Check that diagnostics happen in the line that they are annotated for

Author: oli-obk

ui_test/src/comments.rs

@@ -34,6 +34,8 @@ pub(crate) struct ErrorMatch {
     pub matched: String,
     pub revision: Option<String>,
     pub definition_line: usize,
+    /// The line this pattern is expecting to find a message in.
+    pub line: usize,
 }
 
 impl Comments {
@@ -47,9 +49,13 @@ impl Comments {
     pub(crate) fn parse(path: &Path, content: &str) -> Self {
         let mut this = Self::default();
         let error_pattern_regex =
-            Regex::new(r"//(\[(?P<revision>[^\]]+)\])?~[|^]*\s*(ERROR|HELP|WARN)?:?(?P<text>.*)")
+            Regex::new(r"//(\[(?P<revision>[^\]]+)\])?~(?P<offset>\||[\^]+)?\s*(ERROR|HELP|WARN)?:?(?P<text>.*)")
                 .unwrap();
+
+        // The line that a `|` will refer to
+        let mut fallthrough_to = None;
         for (l, line) in content.lines().enumerate() {
+            let l = l + 1; // enumerate starts at 0, but line numbers start at 1
             if let Some(revisions) = line.strip_prefix("// revisions:") {
                 assert_eq!(
                     this.revisions,
@@ -113,7 +119,26 @@ impl Comments {
                 let matched = captures["text"].trim().to_string();
 
                 let revision = captures.name("revision").map(|rev| rev.as_str().to_string());
-                this.error_matches.push(ErrorMatch { matched, revision, definition_line: l });
+
+                let match_line = match captures.name("offset").map(|rev| rev.as_str()) {
+                    Some("|") => fallthrough_to.expect("`//~|` pattern without preceding line"),
+                    Some(pat) => {
+                        debug_assert!(pat.chars().all(|c| c == '^'));
+                        l - pat.len()
+                    }
+                    None => l,
+                };
+
+                fallthrough_to = Some(match_line);
+
+                this.error_matches.push(ErrorMatch {
+                    matched,
+                    revision,
+                    definition_line: l,
+                    line: match_line,
+                });
+            } else {
+                fallthrough_to = None;
             }
         }
         this

ui_test/src/comments/tests.rs

@@ -13,7 +13,7 @@ fn main() {
     ";
     let comments = Comments::parse(Path::new("<dummy>"), s);
     println!("parsed comments: {:#?}", comments);
-    assert_eq!(comments.error_matches[0].definition_line, 4);
+    assert_eq!(comments.error_matches[0].definition_line, 5);
     assert_eq!(comments.error_matches[0].revision, None);
     assert_eq!(
         comments.error_matches[0].matched,

ui_test/src/lib.rs

@@ -266,12 +266,13 @@ fn run_test(
         comments,
     );
     // Check error annotations in the source against output
-    check_annotations(&diagnostics, &mut errors, config, revision, comments);
+    check_annotations(&diagnostics, path, &mut errors, config, revision, comments);
     (miri, errors)
 }
 
 fn check_annotations(
     diagnostics: &Diagnostics,
+    path: &Path,
     errors: &mut Errors,
     config: &Config,
     revision: &str,
@@ -291,7 +292,7 @@ fn check_annotations(
         }
         found_annotation = true;
     }
-    'outer: for &ErrorMatch { ref matched, revision: ref rev, definition_line } in
+    'pattern: for &ErrorMatch { ref matched, revision: ref rev, definition_line, line } in
         &comments.error_matches
     {
         // FIXME: check that the error happens on the marked line
@@ -304,13 +305,16 @@ fn check_annotations(
 
         found_annotation = true;
 
-        for msg in diagnostics
-            .messages
-            .iter()
-            .flat_map(|msg| std::iter::once(msg).chain(msg.children.iter()))
-        {
-            if msg.message.contains(matched) {
-                continue 'outer;
+        for msg in &diagnostics.messages {
+            // Allow any message or child message to match.
+            if let Some(sub_msg) =
+                std::iter::once(msg).chain(&msg.children).find(|msg| msg.message.contains(matched))
+            {
+                // Child messages often don't have spans, so re-use their parents' span (if any)
+                if msg.line(path) == Some(line) || sub_msg.line(path) == Some(line) {
+                    // Actually a match for the expression we looked for, go to the next pattern
+                    continue 'pattern;
+                }
             }
         }
 

ui_test/src/rustc_stderr.rs

@@ -1,18 +1,41 @@
-use std::fmt::Write;
+use std::{
+    fmt::Write,
+    path::{Path, PathBuf},
+};
 
 #[derive(serde::Deserialize, Debug)]
 pub(crate) struct RustcMessage {
     pub(crate) rendered: Option<String>,
     pub(crate) spans: Vec<Span>,
-    pub(crate) level: String,
     pub(crate) message: String,
     pub(crate) children: Vec<RustcMessage>,
 }
 
+impl RustcMessage {
+    pub fn line(&self, file: &Path) -> Option<usize> {
+        self.spans.iter().find_map(|span| span.line(file))
+    }
+}
+
+impl Span {
+    pub fn line(&self, file: &Path) -> Option<usize> {
+        match &self.expansion {
+            None => (self.file_name == file).then_some(self.line_start),
+            Some(expansion) => expansion.span.line(file),
+        }
+    }
+}
+
+#[derive(serde::Deserialize, Debug)]
+pub(crate) struct Expansion {
+    span: Span,
+}
+
 #[derive(serde::Deserialize, Debug)]
 pub(crate) struct Span {
     pub(crate) line_start: usize,
-    pub(crate) is_primary: bool,
+    pub(crate) file_name: PathBuf,
+    pub(crate) expansion: Option<Box<Expansion>>,
 }
 
 #[derive(Debug)]

ui_test/src/tests.rs

@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf};
 
-use crate::rustc_stderr::{Diagnostics, RustcMessage};
+use crate::rustc_stderr::{Diagnostics, RustcMessage, Span};
 
 use super::{check_annotations, Comments, Config, Error, Mode, OutputConflictHandling};
 
@@ -48,13 +48,70 @@ error: aborting due to previous error
             RustcMessage {
                 message:"Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
                 rendered: None,
-                spans: vec![],
-                level: "".to_string(),
+                spans: vec![Span {file_name:PathBuf::from("moobar"), line_start: 4, expansion: None }],
                 children: vec![],
             }
         ]
     };
-    check_annotations(&diagnostics, &mut errors, &config, "", &comments);
+    check_annotations(&diagnostics, Path::new("moobar"), &mut errors, &config, "", &comments);
+    match &errors[..] {
+        [Error::PatternNotFound { .. }] => {}
+        _ => panic!("{:#?}", errors),
+    }
+}
+
+#[test]
+fn find_pattern() {
+    let s = r"
+use std::mem;
+
+fn main() {
+    let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR encountered a dangling reference (address 0x10 is unallocated)
+}
+    ";
+    let comments = Comments::parse(Path::new("<dummy>"), s);
+    let mut errors = vec![];
+    let config = config();
+    let unnormalized_stderr = r"
+error: Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)
+  --> tests/compile-fail/validity/dangling_ref1.rs:6:29
+   |
+LL |     let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR encountered a dangling reference (address 0x10 is unallocated)
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a dangling reference (address 0x10 is unallocated)
+   |
+   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+           
+   = note: inside `main` at tests/compile-fail/validity/dangling_ref1.rs:6:29
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+error: aborting due to previous error
+    ";
+    let diagnostics = Diagnostics { rendered: unnormalized_stderr.to_string(), messages: vec![
+            RustcMessage {
+                message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
+                rendered: None,
+                spans: vec![Span {file_name:PathBuf::from("moobar"), line_start: 5, expansion: None }],
+                children: vec![],
+            }
+        ]
+    };
+    check_annotations(&diagnostics, Path::new("moobar"), &mut errors, &config, "", &comments);
+    match &errors[..] {
+        [] => {}
+        _ => panic!("{:#?}", errors),
+    }
+
+    // only difference to above is a wrong line number
+    let diagnostics = Diagnostics { rendered: unnormalized_stderr.to_string(), messages: vec![
+            RustcMessage {
+                message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
+                rendered: None,
+                spans: vec![Span {file_name:PathBuf::from("moobar"), line_start: 6, expansion: None }],
+                children: vec![],
+            }
+        ]
+    };
+    check_annotations(&diagnostics, Path::new("moobar"), &mut errors, &config, "", &comments);
     match &errors[..] {
         [Error::PatternNotFound { .. }] => {}
         _ => panic!("{:#?}", errors),