chore(deps): update rust crate annotate-snippets to 0.12.1

Author: Muscraft

Cargo.lock

@@ -18,7 +18,7 @@ homepage = "https://github.com/rust-lang/cargo"
 repository = "https://github.com/rust-lang/cargo"
 
 [workspace.dependencies]
-annotate-snippets = "0.11.5"
+annotate-snippets = { version = "0.12.1", features = ["simd"] }
 anstream = "0.6.20"
 anstyle = "1.0.11"
 anyhow = "1.0.98"

Cargo.toml

@@ -2,7 +2,7 @@ use std::fmt;
 use std::io::IsTerminal;
 use std::io::prelude::*;
 
-use annotate_snippets::{Message, Renderer};
+use annotate_snippets::{Group, Renderer};
 use anstream::AutoStream;
 use anstyle::Style;
 
@@ -406,16 +406,16 @@ impl Shell {
         Ok(())
     }
 
-    /// Prints the passed in [Message] to stderr
-    pub fn print_message(&mut self, message: Message<'_>) -> std::io::Result<()> {
+    /// Prints the passed in &[[`Group`]] to stderr
+    pub fn print_report(&mut self, groups: &[Group<'_>]) -> std::io::Result<()> {
         let term_width = self
             .err_width()
             .diagnostic_terminal_width()
             .unwrap_or(annotate_snippets::renderer::DEFAULT_TERM_WIDTH);
         writeln!(
             self.err(),
             "{}",
-            Renderer::styled().term_width(term_width).render(message)
+            Renderer::styled().term_width(term_width).render(groups)
         )
     }
 }

src/cargo/core/shell.rs

@@ -1,6 +1,6 @@
 use crate::core::{Edition, Feature, Features, Manifest, Package};
 use crate::{CargoResult, GlobalContext};
-use annotate_snippets::{Level, Snippet};
+use annotate_snippets::{AnnotationKind, Group, Level, Snippet};
 use cargo_util_schemas::manifest::{TomlLintLevel, TomlToolLints};
 use pathdiff::diff_paths;
 use std::fmt::Display;
@@ -133,18 +133,16 @@ fn verify_feature_enabled(
             dash_feature_name
         );
 
-        let message = if let Some(span) =
-            get_span(manifest.document(), &["lints", "cargo", lint_name], false)
-        {
-            Level::Error
-                .title(&title)
-                .snippet(
-                    Snippet::source(manifest.contents())
-                        .origin(&manifest_path)
-                        .annotation(Level::Error.span(span).label(&label))
-                        .fold(true),
-                )
-                .footer(Level::Help.title(&help))
+        let mut groups = Vec::new();
+        let mut group = Group::with_title(Level::ERROR.primary_title(title));
+
+        if let Some(span) = get_span(manifest.document(), &["lints", "cargo", lint_name], false) {
+            group = group.element(
+                Snippet::source(manifest.contents())
+                    .path(manifest_path)
+                    .annotation(AnnotationKind::Primary.span(span).label(label)),
+            );
+            group = group.element(Level::HELP.message(help));
         } else {
             let lint_span = get_span(
                 ws_document,
@@ -154,37 +152,37 @@ fn verify_feature_enabled(
             .unwrap_or_else(|| {
                 panic!("could not find `cargo::{lint_name}` in `[lints]`, or `[workspace.lints]` ")
             });
+            group = group.element(
+                Snippet::source(ws_contents)
+                    .path(ws_path)
+                    .annotation(AnnotationKind::Primary.span(lint_span).label(&label)),
+            );
 
-            let inherited_note = if let (Some(inherit_span_key), Some(inherit_span_value)) = (
+            if let (Some(inherit_span_key), Some(inherit_span_value)) = (
                 get_span(manifest.document(), &["lints", "workspace"], false),
                 get_span(manifest.document(), &["lints", "workspace"], true),
             ) {
-                Level::Note.title(&second_title).snippet(
+                let mut temp_group = Group::with_title(Level::NOTE.secondary_title(second_title));
+                std::mem::swap(&mut group, &mut temp_group);
+                groups.push(temp_group);
+
+                group = group.element(
                     Snippet::source(manifest.contents())
-                        .origin(&manifest_path)
+                        .path(manifest_path)
                         .annotation(
-                            Level::Note.span(inherit_span_key.start..inherit_span_value.end),
-                        )
-                        .fold(true),
-                )
+                            AnnotationKind::Context
+                                .span(inherit_span_key.start..inherit_span_value.end),
+                        ),
+                );
             } else {
-                Level::Note.title(&second_title)
+                group = group.element(Level::NOTE.message(second_title));
             };
 
-            Level::Error
-                .title(&title)
-                .snippet(
-                    Snippet::source(ws_contents)
-                        .origin(&ws_path)
-                        .annotation(Level::Error.span(lint_span).label(&label))
-                        .fold(true),
-                )
-                .footer(inherited_note)
-                .footer(Level::Help.title(&help))
+            group = group.element(Level::HELP.message(help));
         };
-
+        groups.push(group);
         *error_count += 1;
-        gctx.shell().print_message(message)?;
+        gctx.shell().print_report(&groups)?;
     }
     Ok(())
 }
@@ -337,12 +335,12 @@ impl LintLevel {
         self == &LintLevel::Forbid || self == &LintLevel::Deny
     }
 
-    pub fn to_diagnostic_level(self) -> Level {
+    pub fn to_diagnostic_level(self) -> Level<'static> {
         match self {
             LintLevel::Allow => unreachable!("allow does not map to a diagnostic level"),
-            LintLevel::Warn => Level::Warning,
-            LintLevel::Deny => Level::Error,
-            LintLevel::Forbid => Level::Error,
+            LintLevel::Warn => Level::WARNING,
+            LintLevel::Deny => Level::ERROR,
+            LintLevel::Forbid => Level::ERROR,
         }
     }
 }
@@ -457,17 +455,15 @@ pub fn check_im_a_teapot(
 
         let key_span = get_span(manifest.document(), &["package", "im-a-teapot"], false).unwrap();
         let value_span = get_span(manifest.document(), &["package", "im-a-teapot"], true).unwrap();
-        let message = level
-            .title(IM_A_TEAPOT.desc)
-            .snippet(
+        let message = &[Group::with_title(level.primary_title(IM_A_TEAPOT.desc))
+            .element(
                 Snippet::source(manifest.contents())
-                    .origin(&manifest_path)
-                    .annotation(level.span(key_span.start..value_span.end))
-                    .fold(true),
+                    .path(&manifest_path)
+                    .annotation(AnnotationKind::Primary.span(key_span.start..value_span.end)),
             )
-            .footer(Level::Note.title(&emitted_reason));
+            .element(Level::NOTE.message(&emitted_reason))];
 
-        gctx.shell().print_message(message)?;
+        gctx.shell().print_report(message)?;
     }
     Ok(())
 }
@@ -535,21 +531,23 @@ fn output_unknown_lints(
         let help =
             matching.map(|(name, kind)| format!("there is a {kind} with a similar name: `{name}`"));
 
-        let mut footers = Vec::new();
-        if emitted_source.is_none() {
-            emitted_source = Some(UNKNOWN_LINTS.emitted_source(lint_level, reason));
-            footers.push(Level::Note.title(emitted_source.as_ref().unwrap()));
-        }
+        let mut groups = Vec::new();
+        let mut group = Group::with_title(level.clone().primary_title(title));
 
-        let mut message = if let Some(span) =
-            get_span(manifest.document(), &["lints", "cargo", lint_name], false)
-        {
-            level.title(&title).snippet(
+        if let Some(span) = get_span(manifest.document(), &["lints", "cargo", lint_name], false) {
+            group = group.element(
                 Snippet::source(manifest.contents())
-                    .origin(&manifest_path)
-                    .annotation(Level::Error.span(span))
-                    .fold(true),
-            )
+                    .path(manifest_path)
+                    .annotation(AnnotationKind::Primary.span(span)),
+            );
+            if emitted_source.is_none() {
+                emitted_source = Some(UNKNOWN_LINTS.emitted_source(lint_level, reason));
+                group = group.element(Level::NOTE.message(emitted_source.as_ref().unwrap()));
+            }
+
+            if let Some(help) = help.as_ref() {
+                group = group.element(Level::HELP.message(help));
+            }
         } else {
             let lint_span = get_span(
                 ws_document,
@@ -560,39 +558,43 @@ fn output_unknown_lints(
                 panic!("could not find `cargo::{lint_name}` in `[lints]`, or `[workspace.lints]` ")
             });
 
-            let inherited_note = if let (Some(inherit_span_key), Some(inherit_span_value)) = (
+            group = group.element(
+                Snippet::source(ws_contents)
+                    .path(ws_path)
+                    .annotation(AnnotationKind::Primary.span(lint_span)),
+            );
+            if emitted_source.is_none() {
+                emitted_source = Some(UNKNOWN_LINTS.emitted_source(lint_level, reason));
+                group = group.element(Level::NOTE.message(emitted_source.as_ref().unwrap()));
+            }
+
+            if let Some(help) = help.as_ref() {
+                group = group.element(Level::HELP.message(help));
+            }
+
+            if let (Some(inherit_span_key), Some(inherit_span_value)) = (
                 get_span(manifest.document(), &["lints", "workspace"], false),
                 get_span(manifest.document(), &["lints", "workspace"], true),
             ) {
-                Level::Note.title(&second_title).snippet(
+                let mut temp_group = Group::with_title(Level::NOTE.secondary_title(second_title));
+                std::mem::swap(&mut group, &mut temp_group);
+                groups.push(temp_group);
+
+                group = group.element(
                     Snippet::source(manifest.contents())
-                        .origin(&manifest_path)
+                        .path(manifest_path)
                         .annotation(
-                            Level::Note.span(inherit_span_key.start..inherit_span_value.end),
-                        )
-                        .fold(true),
-                )
+                            AnnotationKind::Context
+                                .span(inherit_span_key.start..inherit_span_value.end),
+                        ),
+                );
             } else {
-                Level::Note.title(&second_title)
+                group = group.element(Level::NOTE.message(second_title));
             };
-            footers.push(inherited_note);
-
-            level.title(&title).snippet(
-                Snippet::source(ws_contents)
-                    .origin(&ws_path)
-                    .annotation(Level::Error.span(lint_span))
-                    .fold(true),
-            )
         };
 
-        if let Some(help) = help.as_ref() {
-            footers.push(Level::Help.title(help));
-        }
-        for footer in footers {
-            message = message.footer(footer);
-        }
-
-        gctx.shell().print_message(message)?;
+        groups.push(group);
+        gctx.shell().print_report(&groups)?;
     }
 
     Ok(())

src/cargo/util/lints.rs

@@ -1,4 +1,4 @@
-use annotate_snippets::{Level, Snippet};
+use annotate_snippets::{AnnotationKind, Group, Level, Snippet};
 use std::borrow::Cow;
 use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::ffi::OsStr;
@@ -1879,12 +1879,11 @@ fn missing_dep_diagnostic(
         "`{}` is an unused optional dependency since no feature enables it",
         &dep_name
     );
-    let message = Level::Error.title(&title);
-    let snippet = Snippet::source(&contents)
-        .origin(&manifest_path)
-        .fold(true)
-        .annotation(Level::Error.span(feature_value_span.start..feature_value_span.end));
-    let message = if missing_dep.weak_optional {
+    let group = Group::with_title(Level::ERROR.primary_title(&title));
+    let snippet = Snippet::source(contents)
+        .path(manifest_path)
+        .annotation(AnnotationKind::Primary.span(feature_value_span.start..feature_value_span.end));
+    let group = if missing_dep.weak_optional {
         let mut orig_deps = vec![
             (
                 orig_toml.dependencies.as_ref(),
@@ -1920,17 +1919,19 @@ fn missing_dep_diagnostic(
                 .collect::<Vec<_>>();
             let dep_span = get_span(&document, &toml_path, false).unwrap();
 
-            message
-                .snippet(snippet.annotation(Level::Warning.span(dep_span).label(&info_label)))
-                .footer(Level::Help.title(&help))
+            group
+                .element(
+                    snippet.annotation(AnnotationKind::Context.span(dep_span).label(info_label)),
+                )
+                .element(Level::HELP.message(help))
         } else {
-            message.snippet(snippet)
+            group.element(snippet)
         }
     } else {
-        message.snippet(snippet)
+        group.element(snippet)
     };
 
-    if let Err(err) = gctx.shell().print_message(message) {
+    if let Err(err) = gctx.shell().print_report(&[group]) {
         return Err(err.into());
     }
     Err(AlreadyPrintedError::new(anyhow!("").into()).into())
@@ -2792,13 +2793,13 @@ fn emit_diagnostic(
         .unwrap_or_else(|| manifest_file.to_path_buf())
         .display()
         .to_string();
-    let message = Level::Error.title(e.message()).snippet(
+    let group = Group::with_title(Level::ERROR.primary_title(e.message())).element(
         Snippet::source(contents)
-            .origin(&manifest_path)
-            .fold(true)
-            .annotation(Level::Error.span(span)),
+            .path(manifest_path)
+            .annotation(AnnotationKind::Primary.span(span)),
     );
-    if let Err(err) = gctx.shell().print_message(message) {
+
+    if let Err(err) = gctx.shell().print_report(&[group]) {
         return err.into();
     }
     return AlreadyPrintedError::new(e.into()).into();

src/cargo/util/toml/mod.rs

@@ -749,13 +749,12 @@ fn bad_registry_name() {
         .with_status(101)
         .with_stderr_data(str![[r#"
 [ERROR] invalid character ` ` in registry name: `bad name`, characters must be Unicode XID characters (numbers, `-`, `_`, or most letters)
-
-
+       
+       
  --> Cargo.toml:8:17
   |
 8 |                 [dependencies.bar]
   |                 ^^^^^^^^^^^^^^^^^^
-  |
 
 "#]])
         .run();
@@ -1976,13 +1975,12 @@ fn empty_dependency_registry() {
         .with_status(101)
         .with_stderr_data(str![[r#"
 [ERROR] registry name cannot be empty
-
-
+       
+       
  --> Cargo.toml:8:23
   |
 8 |                 bar = { version = "0.1.0", registry = "" }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |
 
 "#]])
         .run();