compiletest: dedup revision line logic.

diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs
index 17f2b77dab052b65c97de24da48136ddde73dfc4..02f4d29a2f05f9c43cbee47df46460dc05c46204 100644 (file)
--- a/src/tools/compiletest/src/header.rs
+++ b/src/tools/compiletest/src/header.rs
@@ -535,6 +535,29 @@ pub fn local_pass_mode(&self) -> Option<PassMode> {
     }
 }
 
+pub fn line_directive<'line>(
+    comment: &str,
+    ln: &'line str,
+) -> Option<(Option<&'line str>, &'line str)> {
+    if ln.starts_with(comment) {
+        let ln = ln[comment.len()..].trim_start();
+        if ln.starts_with('[') {
+            // A comment like `//[foo]` is specific to revision `foo`
+            if let Some(close_brace) = ln.find(']') {
+                let lncfg = &ln[1..close_brace];
+
+                Some((Some(lncfg), ln[(close_brace + 1)..].trim_start()))
+            } else {
+                panic!("malformed condition directive: expected `{}[foo]`, found `{}`", comment, ln)
+            }
+        } else {
+            Some((None, ln))
+        }
+    } else {
+        None
+    }
+}
+
 fn iter_header<R: Read>(testfile: &Path, rdr: R, it: &mut dyn FnMut(Option<&str>, &str)) {
     if testfile.is_dir() {
         return;
@@ -557,17 +580,8 @@ fn iter_header<R: Read>(testfile: &Path, rdr: R, it: &mut dyn FnMut(Option<&str>
         let ln = ln.trim();
         if ln.starts_with("fn") || ln.starts_with("mod") {
             return;
-        } else if ln.starts_with(comment) && ln[comment.len()..].trim_start().starts_with('[') {
-            // A comment like `//[foo]` is specific to revision `foo`
-            if let Some(close_brace) = ln.find(']') {
-                let open_brace = ln.find('[').unwrap();
-                let lncfg = &ln[open_brace + 1..close_brace];
-                it(Some(lncfg), ln[(close_brace + 1)..].trim_start());
-            } else {
-                panic!("malformed condition directive: expected `{}[foo]`, found `{}`", comment, ln)
-            }
-        } else if ln.starts_with(comment) {
-            it(None, ln[comment.len()..].trim_start());
+        } else if let Some((lncfg, ln)) = line_directive(comment, ln) {
+            it(lncfg, ln);
         }
     }
 }

diff --git a/src/tools/compiletest/src/runtest/debugger.rs b/src/tools/compiletest/src/runtest/debugger.rs
index 99394c3bfbfe4d122abcb95aa50feac381bee337..379ff0bab408a3120bda8803b9c016a3e216377b 100644 (file)
--- a/src/tools/compiletest/src/runtest/debugger.rs
+++ b/src/tools/compiletest/src/runtest/debugger.rs
@@ -1,4 +1,5 @@
 use crate::common::Config;
+use crate::header::line_directive;
 use crate::runtest::ProcRes;
 
 use std::fs::File;
@@ -32,26 +33,7 @@ pub(super) fn parse_from(
             counter += 1;
             match line {
                 Ok(line) => {
-                    let (line, lnrev) = if line.starts_with("//") {
-                        let line = line[2..].trim_start();
-                        if line.starts_with('[') {
-                            if let Some(close_brace) = line.find(']') {
-                                let open_brace = line.find('[').unwrap();
-                                let lnrev = &line[open_brace + 1..close_brace];
-                                let line = line[(close_brace + 1)..].trim_start();
-                                (line, Some(lnrev))
-                            } else {
-                                panic!(
-                                    "malformed condition direction: expected `//[foo]`, found `{}`",
-                                    line
-                                )
-                            }
-                        } else {
-                            (line, None)
-                        }
-                    } else {
-                        (line.as_str(), None)
-                    };
+                    let (lnrev, line) = line_directive("//", &line).unwrap_or((None, &line));
 
                     // Skip any revision specific directive that doesn't match the current
                     // revision being tested