Migrate extern-flag-fun, incremental-debugger-visualiser and incremental-session-fail run-make tests to rmake.rs

src/tools/run-make-support/src/lib.rs

@@ -271,6 +271,34 @@ pub fn set_host_rpath(cmd: &mut Command) {
     });
 }
 
+/// Read the contents of a file that cannot simply be read by
+/// read_to_string, due to invalid utf8 data, then assert that it contains `expected`.
+#[track_caller]
+pub fn invalid_utf8_contains<P: AsRef<Path>>(path: P, expected: &str) {
+    let buffer = fs_wrapper::read(path.as_ref());
+    if !String::from_utf8_lossy(&buffer).contains(expected) {
+        eprintln!("=== FILE CONTENTS (LOSSY) ===");
+        eprintln!("{}", String::from_utf8_lossy(&buffer));
+        eprintln!("=== SPECIFIED TEXT ===");
+        eprintln!("{}", expected);
+        panic!("specified text was not found in file");
+    }
+}
+
+/// Read the contents of a file that cannot simply be read by
+/// read_to_string, due to invalid utf8 data, then assert that it does not contain `expected`.
+#[track_caller]
+pub fn invalid_utf8_not_contains<P: AsRef<Path>>(path: P, expected: &str) {
+    let buffer = fs_wrapper::read(path.as_ref());
+    if String::from_utf8_lossy(&buffer).contains(expected) {
+        eprintln!("=== FILE CONTENTS (LOSSY) ===");
+        eprintln!("{}", String::from_utf8_lossy(&buffer));
+        eprintln!("=== SPECIFIED TEXT ===");
+        eprintln!("{}", expected);
+        panic!("specified text was unexpectedly found in file");
+    }
+}
+
 /// Copy a directory into another.
 pub fn copy_dir_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) {
     fn copy_dir_all_inner(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {

src/tools/tidy/src/allowed_run_make_makefiles.txt

@@ -43,7 +43,6 @@ run-make/error-writing-dependencies/Makefile
 run-make/export-executable-symbols/Makefile
 run-make/extern-diff-internal-name/Makefile
 run-make/extern-flag-disambiguates/Makefile
-run-make/extern-flag-fun/Makefile
 run-make/extern-flag-pathless/Makefile
 run-make/extern-flag-rename-transitive/Makefile
 run-make/extern-fn-explicit-align/Makefile
@@ -68,8 +67,6 @@ run-make/inaccessible-temp-dir/Makefile
 run-make/include_bytes_deps/Makefile
 run-make/incr-add-rust-src-component/Makefile
 run-make/incr-foreign-head-span/Makefile
-run-make/incremental-debugger-visualizer/Makefile
-run-make/incremental-session-fail/Makefile
 run-make/inline-always-many-cgu/Makefile
 run-make/interdependent-c-libraries/Makefile
 run-make/intrinsic-unreachable/Makefile

tests/run-make/extern-flag-fun/rmake.rs

@@ -0,0 +1,38 @@
+// The --extern flag can override the default crate search of
+// the compiler and directly fetch a given path. There are a few rules
+// to follow: for example, there can't be more than one rlib, the crates must
+// be valid ("no-exist" in this test), and private crates can't be loaded
+// as non-private. This test checks that these rules are enforced.
+// See https://github.com/rust-lang/rust/pull/15319
+
+use run_make_support::{rust_lib_name, rustc};
+
+fn main() {
+    rustc().input("bar.rs").crate_type("rlib").run();
+    // Exactly the same rlib as the first line, only the filename changes.
+    rustc().input("bar.rs").crate_type("rlib").extra_filename("-a").run();
+    rustc().input("bar-alt.rs").crate_type("rlib").run();
+    // The crate must be valid.
+    rustc().input("foo.rs").extern_("bar", "no-exist").run_fail();
+    rustc().input("foo.rs").extern_("bar", "foo.rs").run_fail();
+    // Compilation fails with two different rlibs.
+    rustc()
+        .input("foo.rs")
+        .extern_("bar", rust_lib_name("bar"))
+        .extern_("bar", rust_lib_name("bar-alt"))
+        .run_fail();
+    // Even though this one has seemingly two rlibs, they are one and the same.
+    rustc()
+        .input("foo.rs")
+        .extern_("bar", rust_lib_name("bar"))
+        .extern_("bar", rust_lib_name("bar-a"))
+        .run();
+    rustc().input("foo.rs").extern_("bar", rust_lib_name("bar")).run();
+    // Try to be sneaky and load a private crate from with a non-private name.
+    rustc().input("rustc.rs").arg("-Zforce-unstable-if-unmarked").crate_type("rlib").run();
+    rustc()
+        .input("gated_unstable.rs")
+        .extern_("alloc", rust_lib_name("rustc"))
+        .run_fail()
+        .assert_stderr_contains("rustc_private");
+}

tests/run-make/incremental-debugger-visualizer/rmake.rs

@@ -0,0 +1,56 @@
+// This test ensures that changes to files referenced via #[debugger_visualizer]
+// (in this case, foo.py and foo.natvis) are picked up when compiling incrementally.
+// See https://github.com/rust-lang/rust/pull/111641
+
+use run_make_support::{fs_wrapper, invalid_utf8_contains, invalid_utf8_not_contains, rustc};
+use std::io::Read;
+
+fn main() {
+    fs_wrapper::create_file("foo.py");
+    fs_wrapper::write("foo.py", "GDB script v1");
+    fs_wrapper::create_file("foo.natvis");
+    fs_wrapper::write("foo.natvis", "Natvis v1");
+    rustc()
+        .input("foo.rs")
+        .crate_type("rlib")
+        .emit("metadata")
+        .incremental("incremental")
+        .arg("-Zincremental-verify-ich")
+        .run();
+
+    invalid_utf8_contains("libfoo.rmeta", "GDB script v1");
+    invalid_utf8_contains("libfoo.rmeta", "Natvis v1");
+
+    // Change only the GDB script and check that the change has been picked up
+    fs_wrapper::remove_file("foo.py");
+    fs_wrapper::create_file("foo.py");
+    fs_wrapper::write("foo.py", "GDB script v2");
+    rustc()
+        .input("foo.rs")
+        .crate_type("rlib")
+        .emit("metadata")
+        .incremental("incremental")
+        .arg("-Zincremental-verify-ich")
+        .run();
+
+    invalid_utf8_contains("libfoo.rmeta", "GDB script v2");
+    invalid_utf8_not_contains("libfoo.rmeta", "GDB script v1");
+    invalid_utf8_contains("libfoo.rmeta", "Natvis v1");
+
+    // Now change the Natvis version and check that the change has been picked up
+    fs_wrapper::remove_file("foo.natvis");
+    fs_wrapper::create_file("foo.natvis");
+    fs_wrapper::write("foo.natvis", "Natvis v2");
+    rustc()
+        .input("foo.rs")
+        .crate_type("rlib")
+        .emit("metadata")
+        .incremental("incremental")
+        .arg("-Zincremental-verify-ich")
+        .run();
+
+    invalid_utf8_contains("libfoo.rmeta", "GDB script v2");
+    invalid_utf8_not_contains("libfoo.rmeta", "GDB script v1");
+    invalid_utf8_not_contains("libfoo.rmeta", "Natvis v1");
+    invalid_utf8_contains("libfoo.rmeta", "Natvis v2");
+}

tests/run-make/incremental-session-fail/rmake.rs

@@ -0,0 +1,15 @@
+// Failing to create the directory where output incremental
+// files would be stored used to cause an ICE (Internal Compiler
+// Error). This was patched in #85698, and this test checks that
+// the ensuing compilation failure is not an ICE.
+// See https://github.com/rust-lang/rust/pull/85698
+
+use run_make_support::{fs_wrapper, rustc};
+
+fn main() {
+    fs_wrapper::create_file("session");
+    // rustc should fail to create the session directory here.
+    let out = rustc().input("foo.rs").crate_type("rlib").incremental("session").run_fail();
+    out.assert_stderr_contains("could not create incremental compilation crate directory");
+    out.assert_stderr_not_contains("internal compiler error");
+}