Rollup merge of rust-lang#134656 - jieyouxu:migrate-incr-add-rust-src…

…-component, r=wesleywiser

Migrate `incr-add-rust-src-component` to rmake

This PR partially supersedes rust-lang#128562, and ports the Makefile-based `tests/run-make/incr-add-rust-src-component` to use rmake.rs infra.

Part of rust-lang#121876.

This run-make test is a regression test for rust-lang#70924. It (tries to) checks that if we add the `rust-src` component in between two incremental compiles, that the compiler doesn't ICE on the second invocation.

- Original issue:rust-lang#70924
- Fix PR: rust-lang#72767
- PR adding this regression test: rust-lang#72952

However, the Makefile version of this used `$SYSROOT/lib/rustlib/src/rust/src/libstd/lib.rs`, but that actually got moved around and reorganized over the years. As of Dec 2024, the `rust-src` component is more like (specific for our purposes):

```
$SYSROOT/lib/rustlib/src/rust/
    library/std/src/lib.rs
    src/
```

However, this run-make test is ancient and it exercises incr-comp system logic. I'm not sure if this test would actually catch the original regression.

This PR was co-authored with `@Oneirical.`

r? incremental

try-job: i686-msvc
try-job: x86_64-mingw-1
try-job: x86_64-msvc
try-job: aarch64-apple

src/tools/tidy/src/allowed_run_make_makefiles.txt

@@ -1,7 +1,6 @@
 run-make/branch-protection-check-IBT/Makefile
 run-make/cat-and-grep-sanity-check/Makefile
 run-make/extern-fn-reachable/Makefile
-run-make/incr-add-rust-src-component/Makefile
 run-make/jobserver-error/Makefile
 run-make/libs-through-symlinks/Makefile
 run-make/split-debuginfo/Makefile

tests/run-make/incr-add-rust-src-component/rmake.rs

@@ -0,0 +1,131 @@
+//! Regression test for rust-lang/rust#70924. Check that if we add the `rust-src` component in
+//! between two incremental compiles, that the compiler doesn't ICE on the second invocation.
+//!
+//! This test uses symbolic links to save testing time.
+//!
+//! The way this test works is that, for every prefix in `root/lib/rustlib/src`, link all of prefix
+//! parent content, then remove the prefix, then loop on the next prefix. This way, we basically
+//! create a copy of the context around `root/lib/rustlib/src`, and can freely add/remove the src
+//! component itself.
+
+//@ ignore-cross-compile
+// Reason: test needs to run.
+
+//@ needs-symlink
+// Reason: test needs symlink to create stub directories and files.
+
+use std::path::Path;
+
+use run_make_support::rfs::read_dir_entries;
+use run_make_support::{bare_rustc, path, rfs, run};
+
+#[derive(Debug, Copy, Clone)]
+struct Symlink<'a, 'b> {
+    src_dir: &'a Path,
+    dst_dir: &'b Path,
+}
+
+fn shallow_symlink_dir<'a, 'b>(Symlink { src_dir, dst_dir }: Symlink<'a, 'b>) {
+    eprintln!(
+        "shallow_symlink_dir: src_dir={} -> dst_dir={}",
+        src_dir.display(),
+        dst_dir.display()
+    );
+
+    read_dir_entries(src_dir, |src_path| {
+        let src_metadata = rfs::symlink_metadata(src_path);
+        let filename = src_path.file_name().unwrap();
+        if src_metadata.is_dir() {
+            rfs::symlink_dir(src_path, dst_dir.join(filename));
+        } else if src_metadata.is_file() {
+            rfs::symlink_file(src_path, dst_dir.join(filename));
+        } else if src_metadata.is_symlink() {
+            rfs::copy_symlink(src_path, dst_dir.join(filename));
+        }
+    });
+}
+
+fn recreate_dir(path: &Path) {
+    rfs::recursive_remove(path);
+    rfs::create_dir(path);
+}
+
+fn main() {
+    let sysroot = bare_rustc().print("sysroot").run().stdout_utf8();
+    let sysroot = sysroot.trim();
+    let sysroot = path(sysroot);
+
+    let incr = path("incr");
+
+    let fakeroot = path("fakeroot");
+    rfs::create_dir(&fakeroot);
+
+    shallow_symlink_dir(Symlink { src_dir: &sysroot, dst_dir: &fakeroot });
+    recreate_dir(&fakeroot.join("lib"));
+
+    shallow_symlink_dir(Symlink { src_dir: &sysroot.join("lib"), dst_dir: &fakeroot.join("lib") });
+    recreate_dir(&fakeroot.join("lib").join("rustlib"));
+
+    shallow_symlink_dir(Symlink {
+        src_dir: &sysroot.join("lib").join("rustlib"),
+        dst_dir: &fakeroot.join("lib").join("rustlib"),
+    });
+    recreate_dir(&fakeroot.join("lib").join("rustlib").join("src"));
+
+    shallow_symlink_dir(Symlink {
+        src_dir: &sysroot.join("lib").join("rustlib").join("src"),
+        dst_dir: &fakeroot.join("lib").join("rustlib").join("src"),
+    });
+
+    rfs::recursive_remove(&fakeroot.join("lib").join("rustlib").join("src").join("rust"));
+
+    let run_incr_rustc = || {
+        bare_rustc()
+            .sysroot(&fakeroot)
+            .arg("-C")
+            .arg(format!("incremental={}", incr.to_str().unwrap()))
+            .input("main.rs")
+            .run();
+    };
+
+    // Run rustc w/ incremental once...
+    run_incr_rustc();
+
+    // NOTE: the Makefile version of this used `$SYSROOT/lib/rustlib/src/rust/src/libstd/lib.rs`,
+    // but that actually got moved around and reorganized over the years. As of Dec 2024, the
+    // rust-src component is more like (specific for our purposes):
+    //
+    // ```
+    // $SYSROOT/lib/rustlib/src/rust/
+    //     library/std/src/lib.rs
+    //     src/
+    // ```
+    rfs::create_dir_all(
+        &fakeroot
+            .join("lib")
+            .join("rustlib")
+            .join("src")
+            .join("rust")
+            .join("library")
+            .join("std")
+            .join("src"),
+    );
+    rfs::write(
+        &fakeroot
+            .join("lib")
+            .join("rustlib")
+            .join("src")
+            .join("rust")
+            .join("library")
+            .join("std")
+            .join("src")
+            .join("lib.rs"),
+        b"",
+    );
+
+    // ... and a second time.
+    run_incr_rustc();
+
+    // Basic sanity check that the compiled binary can run.
+    run("main");
+}