fix!: Rename AnnotationType to Level

epage · epage · commit b49f9471d920 · 2024-03-11T15:51:42.000-05:00
diff --git a/src/renderer/display_list.rs b/src/renderer/display_list.rs
@@ -649,14 +649,14 @@ pub enum DisplayAnnotationType {
     Help,
 }
 
-impl From<snippet::AnnotationType> for DisplayAnnotationType {
-    fn from(at: snippet::AnnotationType) -> Self {
+impl From<snippet::Level> for DisplayAnnotationType {
+    fn from(at: snippet::Level) -> Self {
         match at {
-            snippet::AnnotationType::Error => DisplayAnnotationType::Error,
-            snippet::AnnotationType::Warning => DisplayAnnotationType::Warning,
-            snippet::AnnotationType::Info => DisplayAnnotationType::Info,
-            snippet::AnnotationType::Note => DisplayAnnotationType::Note,
-            snippet::AnnotationType::Help => DisplayAnnotationType::Help,
+            snippet::Level::Error => DisplayAnnotationType::Error,
+            snippet::Level::Warning => DisplayAnnotationType::Warning,
+            snippet::Level::Info => DisplayAnnotationType::Info,
+            snippet::Level::Note => DisplayAnnotationType::Note,
+            snippet::Level::Help => DisplayAnnotationType::Help,
         }
     }
 }
@@ -736,7 +736,7 @@ fn format_label(
 fn format_title<'a>(title: snippet::Label<'a>, id: Option<&'a str>) -> DisplayLine<'a> {
     DisplayLine::Raw(DisplayRawLine::Annotation {
         annotation: Annotation {
-            annotation_type: DisplayAnnotationType::from(title.annotation_type),
+            annotation_type: DisplayAnnotationType::from(title.level),
             id,
             label: format_label(Some(title.label), Some(DisplayTextStyle::Emphasis)),
         },
@@ -750,7 +750,7 @@ fn format_footer(footer: snippet::Label<'_>) -> Vec<DisplayLine<'_>> {
     for (i, line) in footer.label.lines().enumerate() {
         result.push(DisplayLine::Raw(DisplayRawLine::Annotation {
             annotation: Annotation {
-                annotation_type: DisplayAnnotationType::from(footer.annotation_type),
+                annotation_type: DisplayAnnotationType::from(footer.level),
                 id: None,
                 label: format_label(Some(line), None),
             },
@@ -1010,10 +1010,10 @@ fn format_body(
         // It would be nice to use filter_drain here once it's stable.
         annotations.retain(|annotation| {
             let body_idx = idx + annotation_line_count;
-            let annotation_type = match annotation.annotation_type {
-                snippet::AnnotationType::Error => DisplayAnnotationType::None,
-                snippet::AnnotationType::Warning => DisplayAnnotationType::None,
-                _ => DisplayAnnotationType::from(annotation.annotation_type),
+            let annotation_type = match annotation.level {
+                snippet::Level::Error => DisplayAnnotationType::None,
+                snippet::Level::Warning => DisplayAnnotationType::None,
+                _ => DisplayAnnotationType::from(annotation.level),
             };
             match annotation.range {
                 Range { start, .. } if start > line_end_index => true,
@@ -1036,9 +1036,7 @@ fn format_body(
                                     label: format_label(Some(annotation.label), None),
                                 },
                                 range,
-                                annotation_type: DisplayAnnotationType::from(
-                                    annotation.annotation_type,
-                                ),
+                                annotation_type: DisplayAnnotationType::from(annotation.level),
                                 annotation_part: DisplayAnnotationPart::Standalone,
                             },
                         },
@@ -1059,9 +1057,7 @@ fn format_body(
                         {
                             inline_marks.push(DisplayMark {
                                 mark_type: DisplayMarkType::AnnotationStart,
-                                annotation_type: DisplayAnnotationType::from(
-                                    annotation.annotation_type,
-                                ),
+                                annotation_type: DisplayAnnotationType::from(annotation.level),
                             });
                         }
                     } else {
@@ -1079,9 +1075,7 @@ fn format_body(
                                         label: vec![],
                                     },
                                     range,
-                                    annotation_type: DisplayAnnotationType::from(
-                                        annotation.annotation_type,
-                                    ),
+                                    annotation_type: DisplayAnnotationType::from(annotation.level),
                                     annotation_part: DisplayAnnotationPart::MultilineStart,
                                 },
                             },
@@ -1098,9 +1092,7 @@ fn format_body(
                     {
                         inline_marks.push(DisplayMark {
                             mark_type: DisplayMarkType::AnnotationThrough,
-                            annotation_type: DisplayAnnotationType::from(
-                                annotation.annotation_type,
-                            ),
+                            annotation_type: DisplayAnnotationType::from(annotation.level),
                         });
                     }
                     true
@@ -1117,9 +1109,7 @@ fn format_body(
                     {
                         inline_marks.push(DisplayMark {
                             mark_type: DisplayMarkType::AnnotationThrough,
-                            annotation_type: DisplayAnnotationType::from(
-                                annotation.annotation_type,
-                            ),
+                            annotation_type: DisplayAnnotationType::from(annotation.level),
                         });
                     }
 
@@ -1131,9 +1121,7 @@ fn format_body(
                             lineno: None,
                             inline_marks: vec![DisplayMark {
                                 mark_type: DisplayMarkType::AnnotationThrough,
-                                annotation_type: DisplayAnnotationType::from(
-                                    annotation.annotation_type,
-                                ),
+                                annotation_type: DisplayAnnotationType::from(annotation.level),
                             }],
                             line: DisplaySourceLine::Annotation {
                                 annotation: Annotation {
@@ -1142,9 +1130,7 @@ fn format_body(
                                     label: format_label(Some(annotation.label), None),
                                 },
                                 range,
-                                annotation_type: DisplayAnnotationType::from(
-                                    annotation.annotation_type,
-                                ),
+                                annotation_type: DisplayAnnotationType::from(annotation.level),
                                 annotation_part: DisplayAnnotationPart::MultilineEnd,
                             },
                         },
diff --git a/src/snippet.rs b/src/snippet.rs
@@ -67,35 +67,32 @@ impl<'a> Snippet<'a> {
 }
 
 pub struct Label<'a> {
-    pub(crate) annotation_type: AnnotationType,
+    pub(crate) level: Level,
     pub(crate) label: &'a str,
 }
 
 impl<'a> Label<'a> {
-    pub fn new(annotation_type: AnnotationType, label: &'a str) -> Self {
-        Self {
-            annotation_type,
-            label,
-        }
+    pub fn new(level: Level, label: &'a str) -> Self {
+        Self { level, label }
     }
     pub fn error(label: &'a str) -> Self {
-        Self::new(AnnotationType::Error, label)
+        Self::new(Level::Error, label)
     }
 
     pub fn warning(label: &'a str) -> Self {
-        Self::new(AnnotationType::Warning, label)
+        Self::new(Level::Warning, label)
     }
 
     pub fn info(label: &'a str) -> Self {
-        Self::new(AnnotationType::Info, label)
+        Self::new(Level::Info, label)
     }
 
     pub fn note(label: &'a str) -> Self {
-        Self::new(AnnotationType::Note, label)
+        Self::new(Level::Note, label)
     }
 
     pub fn help(label: &'a str) -> Self {
-        Self::new(AnnotationType::Help, label)
+        Self::new(Level::Help, label)
     }
 
     pub fn label(mut self, label: &'a str) -> Self {
@@ -108,7 +105,7 @@ impl<'a> Label<'a> {
         SourceAnnotation {
             range: span,
             label: self.label,
-            annotation_type: self.annotation_type,
+            level: self.level,
         }
     }
 }
@@ -155,7 +152,7 @@ impl<'a> Slice<'a> {
 
 /// Types of annotations.
 #[derive(Debug, Clone, Copy, PartialEq)]
-pub enum AnnotationType {
+pub enum Level {
     /// Error annotations are displayed using red color and "^" character.
     Error,
     /// Warning annotations are displayed using blue color and "-" character.
@@ -173,5 +170,5 @@ pub struct SourceAnnotation<'a> {
     /// The byte range of the annotation in the `source` string
     pub(crate) range: Range<usize>,
     pub(crate) label: &'a str,
-    pub(crate) annotation_type: AnnotationType,
+    pub(crate) level: Level,
 }
diff --git a/tests/fixtures/deserialize.rs b/tests/fixtures/deserialize.rs
@@ -2,7 +2,7 @@ use serde::{Deserialize, Deserializer, Serialize};
 use std::ops::Range;
 
 use annotate_snippets::{
-    renderer::Margin, AnnotationType, Label, Renderer, Slice, Snippet, SourceAnnotation,
+    renderer::Margin, Label, Level, Renderer, Slice, Snippet, SourceAnnotation,
 };
 
 #[derive(Deserialize)]
@@ -63,8 +63,7 @@ where
         LabelDef<'a>,
     );
 
-    Wrapper::deserialize(deserializer)
-        .map(|Wrapper(label)| Label::new(label.annotation_type, label.label))
+    Wrapper::deserialize(deserializer).map(|Wrapper(label)| Label::new(label.level, label.label))
 }
 
 fn deserialize_labels<'de, D>(deserializer: D) -> Result<Vec<Label<'de>>, D::Error>
@@ -80,7 +79,7 @@ where
 
     let v = Vec::deserialize(deserializer)?;
     Ok(v.into_iter()
-        .map(|Wrapper(a)| Label::new(a.annotation_type, a.label))
+        .map(|Wrapper(a)| Label::new(a.level, a.label))
         .collect())
 }
 
@@ -151,33 +150,33 @@ pub struct SourceAnnotationDef<'a> {
     pub range: Range<usize>,
     #[serde(borrow)]
     pub label: &'a str,
-    #[serde(with = "AnnotationTypeDef")]
-    pub annotation_type: AnnotationType,
+    #[serde(with = "LevelDef")]
+    pub level: Level,
 }
 
 impl<'a> From<SourceAnnotationDef<'a>> for SourceAnnotation<'a> {
     fn from(val: SourceAnnotationDef<'a>) -> Self {
         let SourceAnnotationDef {
             range,
             label,
-            annotation_type,
+            level,
         } = val;
-        Label::new(annotation_type, label).span(range)
+        Label::new(level, label).span(range)
     }
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct LabelDef<'a> {
-    #[serde(with = "AnnotationTypeDef")]
-    pub annotation_type: AnnotationType,
+    #[serde(with = "LevelDef")]
+    pub level: Level,
     #[serde(borrow)]
     pub label: &'a str,
 }
 
 #[allow(dead_code)]
 #[derive(Serialize, Deserialize)]
-#[serde(remote = "AnnotationType")]
-enum AnnotationTypeDef {
+#[serde(remote = "Level")]
+enum LevelDef {
     Error,
     Warning,
     Info,
diff --git a/tests/fixtures/no-color/issue_52.toml b/tests/fixtures/no-color/issue_52.toml
@@ -1,5 +1,5 @@
 [snippet.title]
-annotation_type = "Error"
+level = "Error"
 label = ""
 
 [[snippet.slices]]
@@ -13,5 +13,5 @@ origin = "path/to/error.rs"
 fold = true
 [[snippet.slices.annotations]]
 label = "error here"
-annotation_type = "Warning"
+level = "Warning"
 range = [2,16]
diff --git a/tests/fixtures/no-color/issue_9.toml b/tests/fixtures/no-color/issue_9.toml
@@ -1,28 +1,28 @@
 [snippet.title]
 label = "expected one of `.`, `;`, `?`, or an operator, found `for`"
-annotation_type = "Error"
+level = "Error"
 
 [[snippet.slices]]
 source = "let x = vec![1];"
 line_start = 4
 origin = "/code/rust/src/test/ui/annotate-snippet/suggestion.rs"
 [[snippet.slices.annotations]]
 label = "move occurs because `x` has type `std::vec::Vec<i32>`, which does not implement the `Copy` trait"
-annotation_type = "Warning"
+level = "Warning"
 range = [4, 5]
 
 [[snippet.slices]]
 source = "let y = x;"
 line_start = 7
 [[snippet.slices.annotations]]
 label = "value moved here"
-annotation_type = "Warning"
+level = "Warning"
 range = [8, 9]
 
 [[snippet.slices]]
 source = "x;"
 line_start = 9
 [[snippet.slices.annotations]]
 label = "value used here after move"
-annotation_type = "Error"
+level = "Error"
 range = [0, 1]
diff --git a/tests/fixtures/no-color/multiline_annotation.toml b/tests/fixtures/no-color/multiline_annotation.toml
@@ -28,13 +28,13 @@ origin = "src/format.rs"
 fold = true
 [[snippet.slices.annotations]]
 label = "expected `std::option::Option<std::string::String>` because of return type"
-annotation_type = "Warning"
+level = "Warning"
 range = [5, 19]
 [[snippet.slices.annotations]]
 label = "expected enum `std::option::Option`, found ()"
-annotation_type = "Error"
+level = "Error"
 range = [22, 766]
 
 [snippet]
-title = { annotation_type = "Error", label = "mismatched types" }
+title = { level = "Error", label = "mismatched types" }
 id = "E0308"
diff --git a/tests/fixtures/no-color/multiline_annotation2.toml b/tests/fixtures/no-color/multiline_annotation2.toml
@@ -9,9 +9,9 @@ origin = "src/display_list.rs"
 fold = false
 [[snippet.slices.annotations]]
 label = "missing fields `lineno`, `content`"
-annotation_type = "Error"
+level = "Error"
 range = [31, 128]
 
 [snippet]
-title = { annotation_type = "Error", label = "pattern does not mention fields `lineno`, `content`" }
+title = { level = "Error", label = "pattern does not mention fields `lineno`, `content`" }
 id = "E0027"
diff --git a/tests/fixtures/no-color/multiline_annotation3.toml b/tests/fixtures/no-color/multiline_annotation3.toml
@@ -9,9 +9,9 @@ origin = "foo.txt"
 fold = false
 [[snippet.slices.annotations]]
 label = "this should not be on separate lines"
-annotation_type = "Error"
+level = "Error"
 range = [11, 18]
 
 [snippet]
-title = { annotation_type = "Error", label = "spacing error found" }
+title = { level = "Error", label = "spacing error found" }
 id = "E####"
diff --git a/tests/fixtures/no-color/multiple_annotations.toml b/tests/fixtures/no-color/multiple_annotations.toml
@@ -1,5 +1,5 @@
 [snippet.title]
-annotation_type = "Error"
+level = "Error"
 label = ""
 
 [[snippet.slices]]
@@ -17,13 +17,13 @@ fn add_title_line(result: &mut Vec<String>, main_annotation: Option<&Annotation>
 line_start = 96
 [[snippet.slices.annotations]]
 label = "Variable defined here"
-annotation_type = "Error"
+level = "Error"
 range = [100, 110]
 [[snippet.slices.annotations]]
 label = "Referenced here"
-annotation_type = "Error"
+level = "Error"
 range = [184, 194]
 [[snippet.slices.annotations]]
 label = "Referenced again here"
-annotation_type = "Error"
+level = "Error"
 range = [243, 253]
diff --git a/tests/fixtures/no-color/one_past.toml b/tests/fixtures/no-color/one_past.toml
@@ -1,12 +1,12 @@
 [snippet.title]
 label = "expected `.`, `=`"
-annotation_type = "Error"
+level = "Error"
 
 [[snippet.slices]]
 source = "asdf"
 line_start = 1
 origin = "Cargo.toml"
 [[snippet.slices.annotations]]
 label = ""
-annotation_type = "Error"
+level = "Error"
 range = [4, 5]
diff --git a/tests/fixtures/no-color/simple.toml b/tests/fixtures/no-color/simple.toml
diff --git a/tests/fixtures/no-color/strip_line.toml b/tests/fixtures/no-color/strip_line.toml
diff --git a/tests/fixtures/no-color/strip_line_char.toml b/tests/fixtures/no-color/strip_line_char.toml
diff --git a/tests/fixtures/no-color/strip_line_non_ws.toml b/tests/fixtures/no-color/strip_line_non_ws.toml

Original file line number	Diff line number	Diff line change
`@@ -67,35 +67,32 @@ impl<'a> Snippet<'a> {`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`pub struct Label<'a> {`
`70`		`- pub(crate) annotation_type: AnnotationType,`
	`70`	`+ pub(crate) level: Level,`
`71`	`71`	`pub(crate) label: &'a str,`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`impl<'a> Label<'a> {`
`75`		`- pub fn new(annotation_type: AnnotationType, label: &'a str) -> Self {`
`76`		`- Self {`
`77`		`- annotation_type,`
`78`		`- label,`
`79`		`- }`
	`75`	`+ pub fn new(level: Level, label: &'a str) -> Self {`
	`76`	`+ Self { level, label }`
`80`	`77`	`}`
`81`	`78`	`pub fn error(label: &'a str) -> Self {`
`82`		`- Self::new(AnnotationType::Error, label)`
	`79`	`+ Self::new(Level::Error, label)`
`83`	`80`	`}`
`84`	`81`
`85`	`82`	`pub fn warning(label: &'a str) -> Self {`
`86`		`- Self::new(AnnotationType::Warning, label)`
	`83`	`+ Self::new(Level::Warning, label)`
`87`	`84`	`}`
`88`	`85`
`89`	`86`	`pub fn info(label: &'a str) -> Self {`
`90`		`- Self::new(AnnotationType::Info, label)`
	`87`	`+ Self::new(Level::Info, label)`
`91`	`88`	`}`
`92`	`89`
`93`	`90`	`pub fn note(label: &'a str) -> Self {`
`94`		`- Self::new(AnnotationType::Note, label)`
	`91`	`+ Self::new(Level::Note, label)`
`95`	`92`	`}`
`96`	`93`
`97`	`94`	`pub fn help(label: &'a str) -> Self {`
`98`		`- Self::new(AnnotationType::Help, label)`
	`95`	`+ Self::new(Level::Help, label)`
`99`	`96`	`}`
`100`	`97`
`101`	`98`	`pub fn label(mut self, label: &'a str) -> Self {`
`@@ -108,7 +105,7 @@ impl<'a> Label<'a> {`
`108`	`105`	`SourceAnnotation {`
`109`	`106`	`range: span,`
`110`	`107`	`label: self.label,`
`111`		`- annotation_type: self.annotation_type,`
	`108`	`+ level: self.level,`
`112`	`109`	`}`
`113`	`110`	`}`
`114`	`111`	`}`
`@@ -155,7 +152,7 @@ impl<'a> Slice<'a> {`
`155`	`152`
`156`	`153`	`/// Types of annotations.`
`157`	`154`	`#[derive(Debug, Clone, Copy, PartialEq)]`
`158`		`-pub enum AnnotationType {`
	`155`	`+pub enum Level {`
`159`	`156`	`/// Error annotations are displayed using red color and "^" character.`
`160`	`157`	`Error,`
`161`	`158`	`/// Warning annotations are displayed using blue color and "-" character.`
`@@ -173,5 +170,5 @@ pub struct SourceAnnotation<'a> {`
`173`	`170`	/// The byte range of the annotation in the `source` string
`174`	`171`	`pub(crate) range: Range<usize>,`
`175`	`172`	`pub(crate) label: &'a str,`
`176`		`- pub(crate) annotation_type: AnnotationType,`
	`173`	`+ pub(crate) level: Level,`
`177`	`174`	`}`