Struct Level

pub struct Level<'a> {
    pub(crate) name: Option<Option<Cow<'a, str>>>,
    pub(crate) level: LevelInner,
}

Severity level for [Title]s and [Message]s

Fields

name: Option<Option<Cow<'a, str>>>

level: LevelInner

Implementations

impl<'a> Level<'a>

Constructors

pub const ERROR: Level<'a> = ERROR

pub const WARNING: Level<'a> = WARNING

pub const INFO: Level<'a> = INFO

pub const NOTE: Level<'a> = NOTE

pub const HELP: Level<'a> = HELP

impl<'a> Level<'a>

pub fn title(self, text: impl Into<Cow<'a, str>>) -> Title<'a>

A text [Element][crate::Element] to start a [Group][crate::Group]

See [Group::with_title][crate::Group::with_title]

Text passed to this function is considered “untrusted input”, as such all text is passed through a normalization function. Pre-styled text is not allowed to be passed to this function.

Example

let input = &[
    Group::with_title(Level::ERROR.title("mismatched types").id("E0308"))
];

pub fn message(self, text: impl Into<Cow<'a, str>>) -> Message<'a>

A text [Element][crate::Element] in a [Group][crate::Group]

Text passed to this function is allowed to be pre-styled, as such all text is considered “trusted input” and has no normalizations applied to it. normalize_untrusted_str can be used to normalize untrusted text before it is passed to this function.

Example

let input = &[
    Group::with_title(Level::ERROR.title("mismatched types").id("E0308"))
        .element(
            Level::NOTE
                .no_name()
                .message("expected reference `&str`\nfound reference `&'static [u8; 0]`"),
        ),
];

impl<'a> Level<'a>

Customize the Level

pub fn with_name(self, name: impl Into<OptionCow<'a>>) -> Level<'a>

Replace the name describing this Level

Text passed to this function is considered “untrusted input”, as such all text is passed through a normalization function. Pre-styled text is not allowed to be passed to this function.

Example

use annotate_snippets::renderer::OutputTheme;
use annotate_snippets::{AnnotationKind, Group, Level, Patch, Renderer, Snippet};

fn main() {
    let source = r#"// Regression test for issue #114529
// Tests that we do not ICE during const eval for a
// break-with-value in contexts where it is illegal

#[allow(while_true)]
fn main() {
    [(); {
        while true {
            break 9; //~ ERROR `break` with value from a `while` loop
        };
        51
    }];

    [(); {
        while let Some(v) = Some(9) {
            break v; //~ ERROR `break` with value from a `while` loop
        };
        51
    }];

    while true {
        break (|| { //~ ERROR `break` with value from a `while` loop
            let local = 9;
        });
    }
}
"#;
    let message = &[
        Group::with_title(
            Level::ERROR
                .title("`break` with value from a `while` loop")
                .id("E0571"),
        )
        .element(
            Snippet::source(source)
                .line_start(1)
                .path("$DIR/issue-114529-illegal-break-with-value.rs")
                .annotation(
                    AnnotationKind::Primary
                        .span(483..581)
                        .label("can only break with a value inside `loop` or breakable block"),
                )
                .annotation(
                    AnnotationKind::Context
                        .span(462..472)
                        .label("you can't `break` with a value in a `while` loop"),
                ),
        ),
        Group::with_title(
            Level::HELP
                .with_name(Some("suggestion"))
                .title("use `break` on its own without a value inside this `while` loop"),
        )
        .element(
            Snippet::source(source)
                .line_start(1)
                .path("$DIR/issue-114529-illegal-break-with-value.rs")
                .patch(Patch::new(483..581, "break")),
        ),
    ];

    let renderer = Renderer::styled().theme(OutputTheme::Unicode);
    anstream::println!("{}", renderer.render(message));
}

pub fn no_name(self) -> Level<'a>

Do not show the Levels name

Example

let source = r#"fn main() {
    let b: &[u8] = include_str!("file.txt");    //~ ERROR mismatched types
    let s: &str = include_bytes!("file.txt");   //~ ERROR mismatched types
}"#;
let input = &[
    Group::with_title(Level::ERROR.title("mismatched types").id("E0308"))
        .element(
            Snippet::source(source)
                .path("$DIR/mismatched-types.rs")
                .annotation(
                    AnnotationKind::Primary
                        .span(105..131)
                        .label("expected `&str`, found `&[u8; 0]`"),
                )
                .annotation(
                    AnnotationKind::Context
                        .span(98..102)
                        .label("expected due to this"),
                ),
        )
        .element(
            Level::NOTE
                .no_name()
                .message("expected reference `&str`\nfound reference `&'static [u8; 0]`"),
        ),
];

Trait Implementations

impl<'a> Clone for Level<'a>

fn clone(&self) -> Level<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Level<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> Ord for Level<'a>

fn cmp(&self, other: &Level<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for Level<'a>

fn eq(&self, other: &Level<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd for Level<'a>

fn partial_cmp(&self, other: &Level<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Eq for Level<'a>

impl<'a> StructuralPartialEq for Level<'a>