compiletest: infer needs-target-std for codegen mode tests

A `codegen-llvm` test (and other codegen test mode tests) will now by
default have an inferred `//@ needs-target-std` directive, *unless* the
test explicitly has an `#![no_std]` attribute which disables this
inferred behavior.

- When a test has both `#![no_std]` and `//@ needs-target-std`, the
  explicit `//@ needs-target-std` directive will cause the test to be
  ignored for targets that do not support std still.

This is to make it easier to test out-of-tree targets / custom targets
(and targets not tested in r-l/r CI) without requiring target
maintainers to do a bunch of manual `//@ needs-target-std` busywork.

Author: jieyouxu

src/doc/rustc-dev-guide/src/tests/compiletest.md

@@ -315,6 +315,12 @@ more information.
 
 See also the [assembly tests](#assembly-tests) for a similar set of tests.
 
+By default, codegen tests will infer `//@ needs-target-std` (that the target
+needs to support std), *unless* the `#![no_std]` attribute was specified in the
+test source. You can override this behavior and explicitly write `//@
+needs-target-std` to only run the test when target supports std, even if the
+test is `#![no_std]`.
+
 If you need to work with `#![no_std]` cross-compiling tests, consult the
 [`minicore` test auxiliary](./minicore.md) chapter.
 

src/doc/rustc-dev-guide/src/tests/directives.md

@@ -200,6 +200,8 @@ The following directives will check rustc build settings and target settings:
   on `wasm32-unknown-unknown` target because the target does not support the
   `proc-macro` crate type.
 - `needs-target-std` — ignores if target platform does not have std support.
+  - See also [`#![no_std]` and inferred `needs-target-std` for codegen
+    tests](./compiletest.md#codegen-tests).
 - `ignore-backends` — ignores the listed backends, separated by whitespace characters.
   Please note
   that this directive can be overriden with the `--bypass-ignore-backends=[BACKEND]` command line

src/tools/compiletest/src/directives.rs

@@ -206,7 +206,7 @@ pub(crate) struct TestProps {
     pub add_minicore: bool,
     /// Add these flags to the build of `minicore`.
     pub minicore_compile_flags: Vec<String>,
-    /// Whether line annotatins are required for the given error kind.
+    /// Whether line annotations are required for the given error kind.
     pub dont_require_annotations: HashSet<ErrorKind>,
     /// Whether pretty printers should be disabled in gdb.
     pub disable_gdb_pretty_printers: bool,
@@ -600,6 +600,19 @@ fn iter_directives(
         }
     }
 
+    // Note: affects all codegen test suites under test mode `codegen`, e.g. `codegen-llvm`.
+    //
+    // Codegen tests automatically get `//@ needs-target-std` inferred, unless `#![no_std]`
+    // attribute was explicitly seen. The rationale is basically to avoid having to manually
+    // maintain a bunch of `//@ needs-target-std` directives esp. for targets tested/built
+    // out-of-tree.
+    if mode == TestMode::Codegen && !file_directives.has_explicit_no_std_attribute {
+        let inferred_needs_target_std_line =
+            line_directive(testfile, LineNumber::ZERO, "//@ needs-target-std")
+                .expect("valid `needs-target-std` directive line");
+        it(&inferred_needs_target_std_line);
+    }
+
     for directive_line in &file_directives.lines {
         it(directive_line);
     }

src/tools/compiletest/src/directives/file.rs

@@ -6,20 +6,36 @@ use crate::directives::line::{DirectiveLine, line_directive};
 pub(crate) struct FileDirectives<'a> {
     pub(crate) path: &'a Utf8Path,
     pub(crate) lines: Vec<DirectiveLine<'a>>,
+
+    /// Whether the test source file contains an explicit `#![no_std]` attribute.
+    pub(crate) has_explicit_no_std_attribute: bool,
 }
 
 impl<'a> FileDirectives<'a> {
     pub(crate) fn from_file_contents(path: &'a Utf8Path, file_contents: &'a str) -> Self {
         let mut lines = vec![];
+        let mut has_explicit_no_std_attribute = false;
 
         for (line_number, ln) in LineNumber::enumerate().zip(file_contents.lines()) {
             let ln = ln.trim();
 
+            // Note: obviously, this will not detect `/**/ #![no_std]`, which is okay. Crucially, we
+            // must not accidentally detect a `#![no_std]` in a middle of a comment (which is the
+            // more common scenario).
+            //
+            // This has a false positive possibility with a multiline string literal, where you have
+            // `#![no_std]` as part of a string literal on its own line. But since it should be
+            // *sufficiently* unlikely to occur in practice, I think this is acceptable.
+            if ln.starts_with("#![no_std]") {
+                has_explicit_no_std_attribute = true;
+                continue;
+            }
+
             if let Some(directive_line) = line_directive(path, line_number, ln) {
                 lines.push(directive_line);
             }
         }
 
-        Self { path, lines }
+        Self { path, lines, has_explicit_no_std_attribute }
     }
 }

src/tools/compiletest/src/directives/tests.rs

@@ -105,6 +105,7 @@ fn test_parse_normalize_rule() {
 #[derive(Default)]
 struct ConfigBuilder {
     mode: Option<String>,
+    suite: Option<String>,
     channel: Option<String>,
     edition: Option<Edition>,
     host: Option<String>,
@@ -126,6 +127,11 @@ impl ConfigBuilder {
         self
     }
 
+    fn suite(&mut self, s: &str) -> &mut Self {
+        self.suite = Some(s.to_owned());
+        self
+    }
+
     fn channel(&mut self, s: &str) -> &mut Self {
         self.channel = Some(s.to_owned());
         self
@@ -196,7 +202,8 @@ impl ConfigBuilder {
             "compiletest",
             "--mode",
             self.mode.as_deref().unwrap_or("ui"),
-            "--suite=ui",
+            "--suite",
+            self.suite.as_deref().unwrap_or("ui"),
             "--compile-lib-path=",
             "--run-lib-path=",
             "--python=",
@@ -1019,6 +1026,61 @@ fn test_needs_target_std() {
     assert!(!check_ignore(&config, "//@ needs-target-std"));
 }
 
+#[test]
+fn inferred_needs_target_std() {
+    let config = cfg().mode("codegen").suite("codegen-llvm").target("x86_64-unknown-none").build();
+    // Inferred `needs-target-std` due to no `#![no_std]`.
+    assert!(check_ignore(&config, ""));
+    assert!(check_ignore(&config, "//@ needs-target-std"));
+    assert!(!check_ignore(&config, "#![no_std]"));
+    // Make sure that `//@ needs-target-std` takes precedence.
+    assert!(check_ignore(
+        &config,
+        r#"
+        //@ needs-target-std
+        #![no_std]
+        "#
+    ));
+
+    let config =
+        cfg().mode("codegen").suite("codegen-llvm").target("x86_64-unknown-linux-gnu").build();
+    assert!(!check_ignore(&config, ""));
+    assert!(!check_ignore(&config, "//@ needs-target-std"));
+    assert!(!check_ignore(&config, "#![no_std]"));
+    assert!(!check_ignore(
+        &config,
+        r#"
+        //@ needs-target-std
+        #![no_std]
+        "#
+    ));
+
+    let config = cfg().mode("ui").suite("ui").target("x86_64-unknown-none").build();
+    // The inferred `//@ needs-target-std` is only applicable for mode=codegen tests.
+    assert!(!check_ignore(&config, ""));
+    assert!(check_ignore(&config, "//@ needs-target-std"));
+    assert!(!check_ignore(&config, "#![no_std]"));
+    assert!(check_ignore(
+        &config,
+        r#"
+        //@ needs-target-std
+        #![no_std]
+        "#
+    ));
+
+    let config = cfg().mode("ui").suite("ui").target("x86_64-unknown-linux-gnu").build();
+    assert!(!check_ignore(&config, ""));
+    assert!(!check_ignore(&config, "//@ needs-target-std"));
+    assert!(!check_ignore(&config, "#![no_std]"));
+    assert!(!check_ignore(
+        &config,
+        r#"
+        //@ needs-target-std
+        #![no_std]
+        "#
+    ));
+}
+
 fn parse_edition_range(line: &str) -> Option<EditionRange> {
     let config = cfg().build();