Update cargo submodule

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

@@ -84,7 +84,8 @@ pub use crate::external_deps::rustdoc::{Rustdoc, bare_rustdoc, rustdoc};
 // Path-related helpers.
 pub use crate::path_helpers::{
     build_root, cwd, filename_contains, filename_not_in_denylist, has_extension, has_prefix,
-    has_suffix, not_contains, path, shallow_find_directories, shallow_find_files, source_root,
+    has_suffix, not_contains, path, recursive_find_files, shallow_find_directories,
+    shallow_find_files, source_root,
 };
 // Convenience helpers for running binaries and other commands.
 pub use crate::run::{cmd, run, run_fail, run_with_args};

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

@@ -59,6 +59,30 @@ pub fn shallow_find_files<P: AsRef<Path>, F: Fn(&PathBuf) -> bool>(
     matching_files
 }
 
+/// Browse the directory `path` recursively and return all files which respect the parameters
+/// outlined by `closure`.
+#[track_caller]
+pub fn recursive_find_files<P: AsRef<Path>, F: Fn(&PathBuf) -> bool>(
+    path: P,
+    filter: F,
+) -> Vec<PathBuf> {
+    let mut matching_files = Vec::new();
+    let mut stack = vec![path.as_ref().to_path_buf()];
+    while let Some(dir) = stack.pop() {
+        for entry in rfs::read_dir(dir) {
+            let entry = entry.expect("failed to read directory entry.");
+            let path = entry.path();
+
+            if path.is_dir() {
+                stack.push(path);
+            } else if path.is_file() && filter(&path) {
+                matching_files.push(path);
+            }
+        }
+    }
+    matching_files
+}
+
 /// Browse the directory `path` non-recursively and return all directories which respect the
 /// parameters outlined by `closure`.
 #[track_caller]

tests/run-make-cargo/compiler-builtins/rmake.rs

@@ -19,8 +19,8 @@ use std::collections::HashSet;
 use run_make_support::object::read::Object;
 use run_make_support::object::read::archive::ArchiveFile;
 use run_make_support::object::{ObjectSection, ObjectSymbol, RelocationTarget};
-use run_make_support::rfs::{read, read_dir};
-use run_make_support::{cargo, object, path, target};
+use run_make_support::rfs::read;
+use run_make_support::{cargo, object, path, recursive_find_files, target};
 
 fn main() {
     let target_dir = path("target");
@@ -44,18 +44,14 @@ fn main() {
         .env("LIB", std::env::var("LIB").unwrap_or_default())
         .run();
 
-    let rlibs_path = target_dir.join(target()).join("debug").join("deps");
-    let compiler_builtins_rlib = read_dir(rlibs_path)
-        .find_map(|e| {
-            let path = e.unwrap().path();
-            let file_name = path.file_name().unwrap().to_str().unwrap();
-            if file_name.starts_with("libcompiler_builtins") && file_name.ends_with(".rlib") {
-                Some(path)
-            } else {
-                None
-            }
-        })
-        .unwrap();
+    // The rlib file is emitted as an intermediate build artifacts.
+    // Do not hardcode the path.
+    let mut rlibs = recursive_find_files(&target_dir.join(target()).join("debug"), |path| {
+        let file_name = path.file_name().unwrap().to_str().unwrap();
+        file_name.starts_with("libcompiler_builtins") && file_name.ends_with(".rlib")
+    });
+    assert_eq!(rlibs.len(), 1, "expected exactly one compiler_builtins rlib: {rlibs:?}");
+    let compiler_builtins_rlib = rlibs.pop().unwrap();
 
     // rlib files are archives, where the archive members each a CGU, and we also have one called
     // lib.rmeta which is the encoded metadata. Each of the CGUs is an object file.

tests/run-make-cargo/panic-immediate-abort-codegen/rmake.rs

@@ -5,7 +5,7 @@
 
 #![deny(warnings)]
 
-use run_make_support::{cargo, llvm_filecheck, path, rfs, target};
+use run_make_support::{cargo, llvm_filecheck, path, recursive_find_files, target};
 
 fn main() {
     let target_dir = path("target");
@@ -29,18 +29,14 @@ fn main() {
         .env("LIB", std::env::var("LIB").unwrap_or_default())
         .run();
 
-    let out_dir = target_dir.join(target()).join("release").join("deps");
-    let ir_file = rfs::read_dir(out_dir)
-        .find_map(|e| {
-            let path = e.unwrap().path();
-            let file_name = path.file_name().unwrap().to_str().unwrap();
-            if file_name.starts_with("panic_scenarios") && file_name.ends_with(".ll") {
-                Some(path)
-            } else {
-                None
-            }
-        })
-        .unwrap();
+    // The .ll file is emitted as an intermediate build artifacts.
+    // Do not hardcode the path.
+    let mut ir_files = recursive_find_files(&target_dir.join(target()).join("release"), |path| {
+        let file_name = path.file_name().unwrap().to_str().unwrap();
+        file_name.starts_with("panic_scenarios") && file_name.ends_with(".ll")
+    });
+    assert_eq!(ir_files.len(), 1, "expected exactly one .ll file: {ir_files:?}");
+    let ir_file = ir_files.pop().unwrap();
 
     llvm_filecheck().patterns("lib.rs").input_file(ir_file).run();
 }