Add a ui_test header check in tidy

Author: asquared31415

src/tools/compiletest/src/header.rs

@@ -606,7 +606,7 @@ fn iter_header_extra(
     // Process any extra directives supplied by the caller (e.g. because they
     // are implied by the test mode), with a dummy line number of 0.
     for directive in extra_directives {
-        it(TestComment::new(None, test_common::CommentKind::Compiletest(directive), 0));
+        it(TestComment::new(directive, None, test_common::CommentKind::Compiletest(directive), 0));
     }
 
     test_common::iter_header(testfile, rdr, it);

src/tools/test_common/src/directives.rs

@@ -39,10 +39,26 @@ pub trait NameDirective {
     fn parse_name_negative(&self, comment: &TestComment<'_>) -> bool;
 }
 
+pub trait TestDirective {
+    fn compiletest_name(&self) -> &'static str;
+    fn ui_test_name(&self) -> Option<&'static str>;
+}
+
 macro_rules! name_value_directive {
     ($item:ident, $compiletest_name:literal) => {
         #[derive(Debug, Clone, Copy)]
         pub struct $item;
+
+        impl TestDirective for $item {
+            fn compiletest_name(&self) -> &'static str {
+                $compiletest_name
+            }
+
+            fn ui_test_name(&self) -> Option<&'static str> {
+                None
+            }
+        }
+
         impl NameValueDirective for $item {
             fn parse_name_value<'line>(
                 &self,
@@ -68,6 +84,17 @@ macro_rules! name_value_directive {
     ($item:ident, $compiletest_name:literal, $ui_test_name:literal) => {
         #[derive(Debug, Clone, Copy)]
         pub struct $item;
+
+        impl TestDirective for $item {
+            fn compiletest_name(&self) -> &'static str {
+                $compiletest_name
+            }
+
+            fn ui_test_name(&self) -> Option<&'static str> {
+                Some($ui_test_name)
+            }
+        }
+
         impl NameValueDirective for $item {
             fn parse_name_value<'line>(
                 &self,
@@ -106,6 +133,17 @@ macro_rules! name_directive {
     ($item:ident, $compiletest_name:literal) => {
         #[derive(Debug, Clone, Copy)]
         pub struct $item;
+
+        impl TestDirective for $item {
+            fn compiletest_name(&self) -> &'static str {
+                $compiletest_name
+            }
+
+            fn ui_test_name(&self) -> Option<&'static str> {
+                None
+            }
+        }
+
         impl NameDirective for $item {
             fn parse_name(&self, comment: &TestComment<'_>) -> bool {
                 match comment.comment() {
@@ -134,6 +172,17 @@ macro_rules! name_directive {
     ($item:ident, $compiletest_name:literal, $ui_test_name:literal) => {
         #[derive(Debug, Clone, Copy)]
         pub struct $item;
+
+        impl TestDirective for $item {
+            fn compiletest_name(&self) -> &'static str {
+                $compiletest_name
+            }
+
+            fn ui_test_name(&self) -> Option<&'static str> {
+                Some($ui_test_name)
+            }
+        }
+
         impl NameDirective for $item {
             fn parse_name(&self, comment: &TestComment<'_>) -> bool {
                 match comment.comment() {
@@ -173,6 +222,17 @@ macro_rules! name_val_or_name_directive {
     ($item:ident, $compiletest_name:literal) => {
         #[derive(Debug, Clone, Copy)]
         pub struct $item;
+
+        impl TestDirective for $item {
+            fn compiletest_name(&self) -> &'static str {
+                $compiletest_name
+            }
+
+            fn ui_test_name(&self) -> Option<&'static str> {
+                None
+            }
+        }
+
         impl NameValueDirective for $item {
             fn parse_name_value<'line>(
                 &self,
@@ -222,6 +282,17 @@ macro_rules! name_val_or_name_directive {
     ($item:ident, $compiletest_name:literal, $ui_test_name:literal) => {
         #[derive(Debug, Clone, Copy)]
         pub struct $item;
+
+        impl TestDirective for $item {
+            fn compiletest_name(&self) -> &'static str {
+                $compiletest_name
+            }
+
+            fn ui_test_name(&self) -> Option<&'static str> {
+                Some($ui_test_name)
+            }
+        }
+
         impl NameValueDirective for $item {
             fn parse_name_value<'line>(
                 &self,
@@ -292,7 +363,7 @@ macro_rules! name_val_or_name_directive {
 // Macros are in the form (name, compiletest_name, ui_test_name).
 // If ui_test_name does not exist, ui_test does not support that directive.
 // ========================================================================
-name_value_directive!(ErrorPatternDirective, "error-pattern", "error-in-other-file");
+name_value_directive!(ErrorPatternDirective, "error-in-other-file", "error-pattern");
 name_value_directive!(CompileFlagsDirective, "compile-flags", "compile-flags");
 name_value_directive!(RunFlagsDirective, "run-flags"); // UNUSED IN UI TESTS
 name_value_directive!(PrettyModeDirective, "pretty-mode"); // UNUSED IN UI TESTS

src/tools/test_common/src/lib.rs

@@ -9,28 +9,39 @@ pub struct TestComment<'line> {
     revision: Option<&'line str>,
     comment: CommentKind<'line>,
     line_num: usize,
+    full_line: &'line str,
 }
 
 impl<'line> TestComment<'line> {
-    pub fn new(revision: Option<&'line str>, comment: CommentKind<'line>, line_num: usize) -> Self {
-        Self { revision, comment, line_num }
+    pub const fn new(
+        line: &'line str,
+        revision: Option<&'line str>,
+        comment: CommentKind<'line>,
+        line_num: usize,
+    ) -> Self {
+        Self { revision, comment, line_num, full_line: line }
     }
 
-    pub fn revision(&self) -> Option<&str> {
+    pub const fn revision(&self) -> Option<&str> {
         self.revision
     }
 
-    pub fn comment(&self) -> CommentKind<'_> {
+    pub const fn comment(&self) -> CommentKind<'_> {
         self.comment
     }
 
-    pub fn line_num(&self) -> usize {
+    pub const fn line_num(&self) -> usize {
         self.line_num
     }
 
-    pub fn comment_str(&self) -> &str {
+    pub const fn comment_str(&self) -> &str {
         self.comment.line()
     }
+
+    /// The full line that contains the comment. You almost never want this.
+    pub const fn full_line(&self) -> &str {
+        self.full_line
+    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -44,7 +55,7 @@ pub enum CommentKind<'line> {
 }
 
 impl CommentKind<'_> {
-    pub fn line(&self) -> &str {
+    pub const fn line(&self) -> &str {
         match self {
             CommentKind::Compiletest(line) | CommentKind::UiTest(line) => line,
         }
@@ -61,13 +72,13 @@ pub fn iter_header<R: Read>(testfile: &Path, rdr: R, it: &mut dyn FnMut(TestComm
     let is_rust_file = testfile.extension().is_some_and(|e| e == "rs");
 
     let mut rdr = BufReader::new(rdr);
-    let mut ln = String::new();
+    let mut full_ln = String::new();
     let mut line_num = 0;
 
     loop {
         line_num += 1;
-        ln.clear();
-        if rdr.read_line(&mut ln).unwrap() == 0 {
+        full_ln.clear();
+        if rdr.read_line(&mut full_ln).unwrap() == 0 {
             break;
         }
 
@@ -79,22 +90,33 @@ pub fn iter_header<R: Read>(testfile: &Path, rdr: R, it: &mut dyn FnMut(TestComm
         // Assume that any directives will be found before the first
         // module or function. This doesn't seem to be an optimization
         // with a warm page cache. Maybe with a cold one.
-        let ln = ln.trim();
+        let ln = full_ln.trim();
         if ln.starts_with("fn") || ln.starts_with("mod") {
             return;
         } else if is_rust_file {
             // first try to parse as a ui test comment, then as a compiletest comment
             if let Some((lncfg, ln)) = line_directive(RUST_UI_TEST_COMMENT, ln) {
-                let directive = TestComment::new(lncfg, CommentKind::UiTest(ln), line_num);
+                let directive =
+                    TestComment::new(full_ln.as_str(), lncfg, CommentKind::UiTest(ln), line_num);
                 it(directive);
             } else if let Some((lncfg, ln)) = line_directive(RUST_COMPILETEST_COMMENT, ln) {
-                let directive = TestComment::new(lncfg, CommentKind::Compiletest(ln), line_num);
+                let directive = TestComment::new(
+                    full_ln.as_str(),
+                    lncfg,
+                    CommentKind::Compiletest(ln),
+                    line_num,
+                );
                 it(directive);
             }
         } else {
             // parse a non-rust file that compiletest knows about
             if let Some((lncfg, ln)) = line_directive(NON_RUST_COMMENT, ln) {
-                let directive = TestComment::new(lncfg, CommentKind::Compiletest(ln), line_num);
+                let directive = TestComment::new(
+                    full_ln.as_str(),
+                    lncfg,
+                    CommentKind::Compiletest(ln),
+                    line_num,
+                );
                 it(directive);
             }
         }