Struct Group 

pub struct Group<'a> { /* private fields */ }

A Title with supporting context within a Report

Decor is used to visually connect Elements of a Group.

Generally, you will create separate group’s for:

• New Snippets, especially if they need their own AnnotationKind::Primary
• Each logically distinct set of suggestions

Example

use annotate_snippets::{AnnotationKind, Level, Renderer, Snippet, renderer::DecorStyle};
use anstyle::AnsiColor;
use anstyle::Effects;
use anstyle::Style;

fn main() {
    let source = r#"// Make sure "highlighted" code is colored purple

//@ compile-flags: --error-format=human --color=always
//@ edition:2018

use core::pin::Pin;
use core::future::Future;
use core::any::Any;

fn query(_: fn(Box<(dyn Any + Send + '_)>) -> Pin<Box<(
    dyn Future<Output = Result<Box<(dyn Any + 'static)>, String>> + Send + 'static
)>>) {}

fn wrapped_fn<'a>(_: Box<(dyn Any + Send)>) -> Pin<Box<(
    dyn Future<Output = Result<Box<(dyn Any + 'static)>, String>> + Send + 'static
)>> {
    Box::pin(async { Err("nope".into()) })
}

fn main() {
    query(wrapped_fn);
}"#;

    const MAGENTA: Style = AnsiColor::Magenta.on_default().effects(Effects::BOLD);
    let message = format!(
        "expected fn pointer `{MAGENTA}for<'a>{MAGENTA:#} fn(Box<{MAGENTA}(dyn Any + Send + 'a){MAGENTA:#}>) -> Pin<_>`
      found fn item `fn(Box<{MAGENTA}(dyn Any + Send + 'static){MAGENTA:#}>) -> Pin<_> {MAGENTA}{{wrapped_fn}}{MAGENTA:#}`",
    );

    let report = &[
        Level::ERROR
            .primary_title("mismatched types")
            .id("E0308")
            .element(
                Snippet::source(source)
                    .path("$DIR/highlighting.rs")
                    .annotation(
                        AnnotationKind::Primary
                            .span(553..563)
                            .label("one type is more general than the other"),
                    )
                    .annotation(
                        AnnotationKind::Context
                            .span(547..552)
                            .label("arguments to this function are incorrect"),
                    ),
            )
            .element(Level::NOTE.message(&message)),
        Level::NOTE
            .secondary_title("function defined here")
            .element(
                Snippet::source(source)
                    .path("$DIR/highlighting.rs")
                    .annotation(AnnotationKind::Context.span(200..333).label(""))
                    .annotation(AnnotationKind::Primary.span(194..199)),
            ),
    ];

    let renderer = Renderer::styled().decor_style(DecorStyle::Unicode);
    anstream::println!("{}", renderer.render(report));
}

Implementations

impl<'a> Group<'a>

pub fn with_title(title: Title<'a>) -> Self

Create group with a Title, deriving AnnotationKind::Primary from its Level

pub fn with_level(level: Level<'a>) -> Self

Create a title-less group with a primary Level for AnnotationKind::Primary

Example

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

fn main() {
    let source = r#"# Docstring followed by a newline

def foobar(door, bar={}):
    """
    """
"#;

    let report = &[Group::with_level(Level::NOTE)
        .element(
            Snippet::source(source)
                .fold(false)
                .annotation(AnnotationKind::Primary.span(56..58).label("B006")),
        )
        .element(Level::HELP.message("Replace with `None`; initialize within function"))];

    let renderer = Renderer::styled().decor_style(DecorStyle::Unicode);
    anstream::println!("{}", renderer.render(report));
}

pub fn element(self, section: impl Into<Element<'a>>) -> Self

Append an Element that adds context to the Title

pub fn elements( self, sections: impl IntoIterator<Item = impl Into<Element<'a>>>, ) -> Self

Append Elements that adds context to the Title

pub fn is_empty(&self) -> bool

pub fn lineno_offset(self, offset: usize) -> Self

Add an offset used for aligning the header sigil (-->) with the line number separators.

For normal diagnostics this is computed automatically based on the lines to be rendered. This is intended only for use in the formatter, where we don’t render a snippet directly but still want the header to align with the diff.

Trait Implementations

impl<'a> Clone for Group<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Group<'a>

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

Formats the value using the given formatter.