Refactor: Extract expected diags in separate step

Author: LeonMatthes

internal/compiler/tests/syntax_tests.rs

@@ -21,6 +21,7 @@
 
 use i_slint_compiler::diagnostics::{BuildDiagnostics, Diagnostic, DiagnosticLevel};
 use i_slint_compiler::ComponentSelection;
+use std::ops::Range;
 use std::path::{Path, PathBuf};
 
 #[test]
@@ -96,36 +97,16 @@ fn process_file(path: &std::path::Path, update: bool) -> std::io::Result<bool> {
     )
 }
 
-fn process_diagnostics(
-    compile_diagnostics: &BuildDiagnostics,
-    path: &Path,
-    source: &str,
-    _silent: bool,
-    update: bool,
-) -> std::io::Result<bool> {
-    let mut success = true;
-
-    let path = canonical(path);
-
-    let mut diags = compile_diagnostics
-        .iter()
-        .filter(|d| {
-            canonical(
-                d.source_file()
-                    .unwrap_or_else(|| panic!("{path:?}: Error without a source file {d:?}",)),
-            ) == path
-        })
-        .collect::<Vec<_>>();
-
-    let lines = source
-        .bytes()
-        .enumerate()
-        .filter_map(|(i, c)| if c == b'\n' { Some(i) } else { None })
-        .collect::<Vec<usize>>();
-
-    let diag_copy = diags.clone();
-    let mut captures = Vec::new();
+struct ExpectedDiagnostic {
+    start: usize,
+    end: Option<usize>,
+    level: DiagnosticLevel,
+    message: String,
+    comment_range: Range<usize>,
+}
 
+fn extract_expected_diags(source: &str) -> Vec<ExpectedDiagnostic> {
+    let mut expected = Vec::new();
     // Find expected errors in the file. The first caret (^) points to the expected column. The number of
     // carets refers to the number of lines to go back. This is useful when one line of code produces multiple
     // errors or warnings.
@@ -137,9 +118,7 @@ fn process_diagnostics(
         let warning_or_error = m.get(2).unwrap().as_str();
         let expected_message =
             m.get(3).unwrap().as_str().replace('↵', "\n").replace('📂', env!("CARGO_MANIFEST_DIR"));
-        if update {
-            captures.push(m.get(0).unwrap().range());
-        }
+        let comment_range = m.get(0).unwrap().range();
 
         let mut line_counter = 0;
         let mut line_offset = source[..line_begin_offset].rfind('\n').unwrap_or(0);
@@ -161,6 +140,54 @@ fn process_diagnostics(
             _ => panic!("Unsupported diagnostic level {warning_or_error}"),
         };
 
+        expected.push(ExpectedDiagnostic {
+            start: offset,
+            end: None,
+            level: expected_diag_level,
+            message: expected_message,
+            comment_range,
+        });
+    }
+    expected
+}
+
+fn process_diagnostics(
+    compile_diagnostics: &BuildDiagnostics,
+    path: &Path,
+    source: &str,
+    _silent: bool,
+    update: bool,
+) -> std::io::Result<bool> {
+    let mut success = true;
+
+    let path = canonical(path);
+
+    let mut diags = compile_diagnostics
+        .iter()
+        .filter(|d| {
+            canonical(
+                d.source_file()
+                    .unwrap_or_else(|| panic!("{path:?}: Error without a source file {d:?}",)),
+            ) == path
+        })
+        .collect::<Vec<_>>();
+
+    let lines = source
+        .bytes()
+        .enumerate()
+        .filter_map(|(i, c)| if c == b'\n' { Some(i) } else { None })
+        .collect::<Vec<usize>>();
+
+    let diag_copy = diags.clone();
+
+    let expected = extract_expected_diags(source);
+    let captures: Vec<_> =
+        expected.iter().map(|expected| &expected.comment_range).cloned().collect();
+
+    // Find expected errors in the file. The first caret (^) points to the expected column. The number of
+    // carets refers to the number of lines to go back. This is useful when one line of code produces multiple
+    // errors or warnings.
+    for expected in expected {
         fn compare_message(message: &str, expected_message: &str) -> bool {
             if message == expected_message {
                 return true;
@@ -175,17 +202,22 @@ fn process_diagnostics(
 
         match diags.iter().position(|e| {
             let (l, c) = e.line_column();
-            let o = lines.get(l.wrapping_sub(2)).unwrap_or(&0) + c;
-            o == offset
-                && compare_message(e.message(), &expected_message)
-                && e.level() == expected_diag_level
+            let diag_start = lines.get(l.wrapping_sub(2)).unwrap_or(&0) + c;
+            diag_start == expected.start
+                && compare_message(e.message(), &expected.message)
+                && e.level() == expected.level
         }) {
             Some(idx) => {
                 diags.remove(idx);
             }
             None => {
                 success = false;
-                println!("{path:?}: {warning_or_error} not found at offset {offset}: {expected_message:?}");
+                println!(
+                    "{path:?}: {level:?} not found at offset {offset}: {message:?}",
+                    level = expected.level,
+                    offset = expected.start,
+                    message = expected.message
+                );
             }
         }
     }