compiletest: Add LineNo newtype to avoid +1 magic here and there

Start small and only use it in `debugger.rs` for now. If it works well
we can incrementally increase usage as time passes.

Author: Enselic

src/tools/compiletest/src/lib.rs

@@ -12,6 +12,7 @@ mod edition;
 mod errors;
 mod executor;
 mod json;
+mod line_no;
 mod output_capture;
 mod panic_hook;
 mod raise_fd_limit;

src/tools/compiletest/src/line_no.rs

@@ -0,0 +1,15 @@
+/// A line number in a file. Internally the first line has index 0.
+/// But when displayed, the first line is 1.
+pub struct LineNo(usize);
+
+impl LineNo {
+    pub fn from_zero_based(zero_based: usize) -> Self {
+        LineNo(zero_based)
+    }
+}
+
+impl std::fmt::Display for LineNo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0 + 1)
+    }
+}

src/tools/compiletest/src/runtest/debugger.rs

@@ -4,16 +4,17 @@ use std::io::{BufRead, BufReader};
 
 use camino::{Utf8Path, Utf8PathBuf};
 
+use crate::line_no::LineNo;
 use crate::runtest::ProcRes;
 
 /// Representation of information to invoke a debugger and check its output
 pub(super) struct DebuggerCommands {
     /// Commands for the debuuger
     pub commands: Vec<String>,
     /// Lines to insert breakpoints at
-    pub breakpoint_lines: Vec<usize>,
+    pub breakpoint_lines: Vec<LineNo>,
     /// Contains the source line number to check and the line itself
-    check_lines: Vec<(usize, String)>,
+    check_lines: Vec<(LineNo, String)>,
     /// Source file name
     file: Utf8PathBuf,
 }
@@ -26,15 +27,13 @@ impl DebuggerCommands {
         let mut breakpoint_lines = vec![];
         let mut commands = vec![];
         let mut check_lines = vec![];
-        let mut counter = 0;
         let reader = BufReader::new(File::open(file.as_std_path()).unwrap());
         for (line_no, line) in reader.lines().enumerate() {
-            counter += 1;
             let line = line.map_err(|e| format!("Error while parsing debugger commands: {}", e))?;
 
             // Breakpoints appear on lines with actual code, typically at the end of the line.
             if line.contains("#break") {
-                breakpoint_lines.push(counter);
+                breakpoint_lines.push(LineNo::from_zero_based(line_no));
                 continue;
             }
 
@@ -46,7 +45,7 @@ impl DebuggerCommands {
                 commands.push(command);
             }
             if let Some(pattern) = parse_name_value(&line, &check_directive) {
-                check_lines.push((line_no, pattern));
+                check_lines.push((LineNo::from_zero_based(line_no), pattern));
             }
         }
 
@@ -88,15 +87,14 @@ impl DebuggerCommands {
             );
 
             for (src_lineno, err_line) in missing {
-                write!(msg, "\n    ({fname}:{num}) `{err_line}`", num = src_lineno + 1).unwrap();
+                write!(msg, "\n    ({fname}:{src_lineno}) `{err_line}`").unwrap();
             }
 
             if !found.is_empty() {
                 let init = "\nthe following subset of check directive(s) was found successfully:";
                 msg.push_str(init);
                 for (src_lineno, found_line) in found {
-                    write!(msg, "\n    ({fname}:{num}) `{found_line}`", num = src_lineno + 1)
-                        .unwrap();
+                    write!(msg, "\n    ({fname}:{src_lineno}) `{found_line}`").unwrap();
                 }
             }