Avoid multiple copies of proc macros ending up in the sysroot

Author: bjorn3

src/bootstrap/src/core/build_steps/compile.rs

@@ -1558,7 +1558,7 @@ impl Step for RustcLink {
         run.never()
     }
 
-    /// Same as `std_link`, only for librustc
+    /// Same as `StdLink`, only for librustc
     fn run(self, builder: &Builder<'_>) {
         let build_compiler = self.build_compiler;
         let sysroot_compiler = self.sysroot_compiler;
@@ -2418,13 +2418,28 @@ pub fn add_to_sysroot(
     t!(fs::create_dir_all(sysroot_dst));
     t!(fs::create_dir_all(sysroot_host_dst));
     t!(fs::create_dir_all(self_contained_dst));
+
+    let mut rustc_crates = HashSet::new();
     for (path, dependency_type) in builder.read_stamp_file(stamp) {
+        let filename = path.file_name().unwrap().to_str().unwrap();
         let dst = match dependency_type {
             DependencyType::Host => sysroot_host_dst,
             DependencyType::Target => sysroot_dst,
             DependencyType::TargetSelfContained => self_contained_dst,
         };
-        builder.copy_link(&path, &dst.join(path.file_name().unwrap()), FileType::Regular);
+        builder.copy_link(&path, &dst.join(filename), FileType::Regular);
+
+        // Check that none of the rustc_* crates have multiple versions. Otherwise using them from
+        // the sysroot would cause ambiguity errors. We do allow rustc_hash however as it is an
+        // external dependency that we build multiple copies of. It is re-exported by
+        // rustc_data_structures, so not being able to use extern crate rustc_hash; is not a big
+        // issue.
+        if !filename.contains("rustc_") || filename.contains("rustc_hash") {
+            continue;
+        }
+        if !rustc_crates.insert(filename.split_once('-').unwrap().0.to_owned()) {
+            panic!("duplicate rustc crate at {}", path.display());
+        }
     }
 }
 
@@ -2511,7 +2526,13 @@ pub fn run_cargo(
             if filename.starts_with(&host_root_dir) {
                 // Unless it's a proc macro used in the compiler
                 if crate_types.iter().any(|t| t == "proc-macro") {
-                    deps.push((filename.to_path_buf(), DependencyType::Host));
+                    // Cargo will compile proc-macros that are part of the rustc workspace twice.
+                    // Once as libmacro-hash.so as build dependency and once as libmacro.so as
+                    // output artifact. Only keep the former to avoid ambiguity when trying to use
+                    // the proc macro from the sysroot.
+                    if filename.file_name().unwrap().to_str().unwrap().contains("-") {
+                        deps.push((filename.to_path_buf(), DependencyType::Host));
+                    }
                 }
                 continue;
             }