feat: Update to rustc nightly-2025-06-06

Author: zalanlevai

Cargo.lock

@@ -1,5 +1,5 @@
 [workspace]
-resolver = "2"
+resolver = "3"
 members = [
     "cargo-mutest",
     "mutest-driver",

Cargo.toml

@@ -11,7 +11,7 @@ mutest-driver-cli = { path = "../mutest-driver-cli" }
 mutest-driver = { path = "../mutest-driver" }
 mutest-operators = { path = "../mutest-operators" }
 
-cargo_metadata = "0.18"
+cargo_metadata = "0.20"
 clap = { version = "4", features = ["cargo"] }
 
 [build-dependencies]

cargo-mutest/Cargo.toml

@@ -20,5 +20,5 @@ clap = { version = "4", features = ["cargo"] }
 serde = "1.0"
 serde_json = "1.0"
 
-rand = "0.8"
-rand_seeder = "0.2"
+rand = "0.9"
+rand_seeder = "0.4"

mutest-driver/Cargo.toml

@@ -79,7 +79,7 @@ impl MutationBatchingRandomness {
 
         match self.seed {
             Some(seed) => StdRng::from_seed(seed),
-            None => StdRng::from_entropy(),
+            None => StdRng::from_os_rng(),
         }
     }
 }

mutest-driver/src/config.rs

@@ -13,7 +13,7 @@ use std::path::{Path, PathBuf};
 use std::process::{self, Command};
 
 use mutest_driver::config::{self, Config};
-use mutest_emit::analysis::hir::Unsafety;
+use mutest_emit::analysis::hir::Safety;
 use mutest_emit::codegen::mutation::{Operators, UnsafeTargeting};
 use rustc_hash::FxHashSet;
 use rustc_interface::Config as CompilerConfig;
@@ -97,7 +97,7 @@ pub fn main() {
         args[0] = "rustc".to_string();
 
         process::exit(rustc_driver::catch_with_exit_code(|| {
-            rustc_driver::RunCompiler::new(&args, &mut DefaultCallbacks).run()
+            rustc_driver::run_compiler(&args, &mut DefaultCallbacks)
         }));
     }
 
@@ -111,7 +111,7 @@ pub fn main() {
 
     if normal_rustc || !primary_package || !test_target {
         process::exit(rustc_driver::catch_with_exit_code(|| {
-            rustc_driver::RunCompiler::new(&args, &mut RustcCallbacks { mutest_args }).run()
+            rustc_driver::run_compiler(&args, &mut RustcCallbacks { mutest_args })
         }));
     }
 
@@ -120,7 +120,7 @@ pub fn main() {
         .get_matches_from(mutest_args.as_deref().unwrap_or_default().split(" "));
 
     process::exit(rustc_driver::catch_with_exit_code(|| {
-        let compiler_config = mutest_driver::passes::parse_compiler_args(&args)?.expect("no compiler configuration was generated");
+        let compiler_config = mutest_driver::passes::parse_compiler_args(&args).expect("no compiler configuration was generated");
 
         let early_dcx = EarlyDiagCtxt::new(compiler_config.opts.error_format);
 
@@ -195,8 +195,8 @@ pub fn main() {
 
         let unsafe_targeting = match () {
             _ if mutest_arg_matches.get_flag("safe") => UnsafeTargeting::None,
-            _ if mutest_arg_matches.get_flag("cautious") => UnsafeTargeting::OnlyEnclosing(Unsafety::Unsafe),
-            _ if mutest_arg_matches.get_flag("risky") => UnsafeTargeting::OnlyEnclosing(Unsafety::Normal),
+            _ if mutest_arg_matches.get_flag("cautious") => UnsafeTargeting::OnlyEnclosing(Safety::Unsafe),
+            _ if mutest_arg_matches.get_flag("risky") => UnsafeTargeting::OnlyEnclosing(Safety::Safe),
             _ if mutest_arg_matches.get_flag("unsafe") => UnsafeTargeting::All,
             _ => UnsafeTargeting::None,
         };
@@ -344,7 +344,6 @@ pub fn main() {
             },
         };
 
-        mutest_driver::run(config)?;
-        Ok(())
+        mutest_driver::run(config).unwrap();
     }));
 }

mutest-driver/src/main.rs

@@ -3,12 +3,11 @@ use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 use rustc_feature::UnstableFeatures;
+use rustc_interface::{Linker, create_and_enter_global_ctxt, passes, run_compiler};
 use rustc_interface::interface::Result as CompilerResult;
-use rustc_interface::run_compiler;
 use rustc_lint_defs::Level as LintLevel;
 use rustc_session::EarlyDiagCtxt;
 use rustc_session::config::{ExternEntry, ExternLocation, Externs, Input, OutputFilenames};
-use rustc_session::filesearch;
 use rustc_session::search_paths::SearchPath;
 use rustc_session::utils::CanonicalizedPath;
 
@@ -37,10 +36,10 @@ pub fn run(config: &Config, analysis_pass: &AnalysisPassResult) -> CompilerResul
 
     // The generated crate code relies on the `mutest_runtime` crate (and its dependencies), which must be loaded.
     let early_dcx = EarlyDiagCtxt::new(compiler_config.opts.error_format);
-    let sysroot = filesearch::materialize_sysroot(compiler_config.opts.maybe_sysroot.clone());
+    let sysroot = &compiler_config.opts.sysroot;
     let triple = &compiler_config.opts.target_triple;
-    compiler_config.opts.search_paths.push(SearchPath::from_cli_opt(&sysroot, &triple, &early_dcx, &format!("crate={}", config.mutest_search_path.display()), true));
-    compiler_config.opts.search_paths.push(SearchPath::from_cli_opt(&sysroot, &triple, &early_dcx, &format!("dependency={}", config.mutest_search_path.join("deps").display()), true));
+    compiler_config.opts.search_paths.push(SearchPath::from_cli_opt(sysroot, &triple, &early_dcx, &format!("crate={}", config.mutest_search_path.display()), true));
+    compiler_config.opts.search_paths.push(SearchPath::from_cli_opt(sysroot, &triple, &early_dcx, &format!("dependency={}", config.mutest_search_path.join("deps").display()), true));
     // The externs (paths to dependencies) of the `mutest_runtime` crate are baked into it at compile time.
     // These must be propagated to any crate which depends on it.
     let mut externs = BTreeMap::<String, ExternEntry>::new();
@@ -71,7 +70,7 @@ pub fn run(config: &Config, analysis_pass: &AnalysisPassResult) -> CompilerResul
         let existing_extern = externs.insert(name.to_owned(), ExternEntry {
             location: match path {
                 Some(path) => ExternLocation::ExactPaths(BTreeSet::from([
-                    CanonicalizedPath::new(&config.mutest_search_path.join(path)),
+                    CanonicalizedPath::new(config.mutest_search_path.join(path)),
                 ])),
                 None => ExternLocation::FoundInLibrarySearchDirectories,
             },
@@ -96,24 +95,24 @@ pub fn run(config: &Config, analysis_pass: &AnalysisPassResult) -> CompilerResul
         let sess = &compiler.sess;
         let codegen_backend = &*compiler.codegen_backend;
 
-        let (linker, outputs) = compiler.enter(|queries| {
-            queries.parse()?;
+        let krate = passes::parse(sess);
 
-            let outputs = queries.global_ctxt()?.enter(|tcx| {
-                let _ = tcx.resolver_for_lowering();
+        let (linker, outputs) = create_and_enter_global_ctxt(compiler, krate, |tcx| {
+            let _ = tcx.resolver_for_lowering();
 
-                let outputs = tcx.output_filenames(());
+            passes::write_dep_info(tcx);
 
-                tcx.analysis(())?;
+            passes::write_interface(tcx);
 
-                Ok(outputs.clone())
-            })?;
+            tcx.ensure_ok().analysis(());
 
-            let linker = queries.codegen_and_build_linker()?;
-            Ok((linker, outputs))
-        })?;
+            let outputs = tcx.output_filenames(()).clone();
+            let linker = Linker::codegen_and_build_linker(tcx, &*compiler.codegen_backend);
 
-        linker.link(sess, codegen_backend)?;
+            (linker, outputs)
+        });
+
+        linker.link(sess, codegen_backend);
 
         Ok(CompilationPassResult {
             duration: t_start.elapsed(),

mutest-driver/src/passes/analysis.rs

@@ -1,11 +1,8 @@
 use std::collections::BTreeMap;
 use std::convert::Infallible;
 use std::ops::{ControlFlow, FromResidual, Residual, Try};
-use std::sync::Arc;
-use std::sync::atomic::{self, AtomicBool};
 
 use rustc_interface::Config as CompilerConfig;
-use rustc_interface::interface::Result as CompilerResult;
 use rustc_session::config::{ExternEntry, ExternLocation, Externs, Input};
 use rustc_session::parse::ParseSess;
 use rustc_span::Symbol;
@@ -84,15 +81,16 @@ pub fn copy_compiler_settings(config: &CompilerConfig) -> CompilerConfig {
         output_dir: config.output_dir.clone(),
         ice_file: config.ice_file.clone(),
         file_loader: Some(Box::new(RealFileLoader)),
-        locale_resources: config.locale_resources,
+        locale_resources: config.locale_resources.clone(),
         lint_caps: config.lint_caps.clone(),
         psess_created: None,
         hash_untracked_state: None,
         register_lints: None,
         override_queries: None,
+        extra_symbols: config.extra_symbols.clone(),
         make_codegen_backend: None,
         registry: rustc_driver::diagnostics_registry(),
-        using_internal_features: Arc::new(AtomicBool::new(config.using_internal_features.load(atomic::Ordering::Relaxed))),
+        using_internal_features: config.using_internal_features,
         expanded_args: config.expanded_args.clone(),
     }
 }
@@ -106,19 +104,19 @@ impl rustc_driver::Callbacks for RustcConfigCallbacks {
         self.config = Some(copy_compiler_settings(config));
     }
 
-    fn after_crate_root_parsing<'tcx>(
+    fn after_crate_root_parsing(
         &mut self,
         _compiler: &rustc_interface::interface::Compiler,
-        _queries: &'tcx rustc_interface::Queries<'tcx>,
+        _krate: &mut rustc_ast::Crate,
     ) -> rustc_driver::Compilation {
         rustc_driver::Compilation::Stop
     }
 }
 
-pub fn parse_compiler_args(args: &[String]) -> CompilerResult<Option<CompilerConfig>> {
+pub fn parse_compiler_args(args: &[String]) -> Option<CompilerConfig> {
     let mut callbacks = RustcConfigCallbacks { config: None };
-    rustc_driver::RunCompiler::new(args, &mut callbacks).run()?;
-    Ok(callbacks.config)
+    rustc_driver::run_compiler(args, &mut callbacks);
+    callbacks.config
 }
 
 pub fn track_invocation_fingerprint(parse_sess: &mut ParseSess, invocation_fingerprint: &Option<String>) {
@@ -136,6 +134,12 @@ pub fn base_compiler_config(config: &Config) -> CompilerConfig {
         track_invocation_fingerprint(parse_sess, &invocation_fingerprint);
     }));
 
+    // Register #[cfg(test)] as a valid cfg.
+    // See the rustc change https://github.com/rust-lang/rust/pull/131729, and
+    // the Cargo change https://github.com/rust-lang/cargo/pull/14963
+    // for more details.
+    compiler_config.crate_check_cfg.push("cfg(test)".to_owned());
+
     // Register #[cfg(mutest)] as a valid cfg.
     compiler_config.crate_check_cfg.push("cfg(mutest, values(none()))".to_owned());
     // Enable #[cfg(mutest)].

mutest-driver/src/passes/compilation.rs

@@ -45,9 +45,9 @@ pub fn print_targets<'tcx, 'trg>(tcx: TyCtxt<'tcx>, targets: impl Iterator<Item
 
     // Targets are printed in source span order.
     let mut targets_in_print_order = targets
-        .map(|target| (tcx.hir().span(tcx.local_def_id_to_hir_id(target.def_id)), target))
+        .map(|target| (tcx.hir_span(tcx.local_def_id_to_hir_id(target.def_id)), target))
         .collect::<Vec<_>>();
-    targets_in_print_order.sort_unstable_by_key(|(target_span, _)| *target_span);
+    targets_in_print_order.sort_unstable_by(|(target_a_span, _), (target_b_span, _)| span_diagnostic_ord(*target_a_span, *target_b_span));
 
     let targets_count = targets_in_print_order.len();
 
@@ -127,7 +127,7 @@ pub fn print_call_graph<'tcx, 'trg>(tcx: TyCtxt<'tcx>, tests: &[Test], call_grap
                     .map(|(_, callee)| (callee.display_str(tcx), tcx.def_span(callee.def_id), callee))
                     .collect::<Vec<_>>();
                 callees_in_print_order.sort_unstable_by(|(callee_a_display_str, callee_a_span, _), (callee_b_display_str, callee_b_span, _)| {
-                    Ord::cmp(callee_a_span, callee_b_span).then(Ord::cmp(callee_a_display_str, callee_b_display_str))
+                    span_diagnostic_ord(*callee_a_span, *callee_b_span).then(Ord::cmp(callee_a_display_str, callee_b_display_str))
                 });
 
                 for (callee_display_str, callee_span, callee) in callees_in_print_order {
@@ -150,7 +150,7 @@ pub fn print_call_graph<'tcx, 'trg>(tcx: TyCtxt<'tcx>, tests: &[Test], call_grap
                     .map(|caller| (caller.display_str(tcx), tcx.def_span(caller.def_id), caller))
                     .collect::<Vec<_>>();
                 callers_in_print_order.sort_unstable_by(|(caller_a_display_str, caller_a_span, _), (caller_b_display_str, caller_b_span, _)| {
-                    Ord::cmp(caller_a_span, caller_b_span).then(Ord::cmp(caller_a_display_str, caller_b_display_str))
+                    span_diagnostic_ord(*caller_a_span, *caller_b_span).then(Ord::cmp(caller_a_display_str, caller_b_display_str))
                 });
 
                 for (caller_display_str, caller_span, caller) in callers_in_print_order {
@@ -161,7 +161,7 @@ pub fn print_call_graph<'tcx, 'trg>(tcx: TyCtxt<'tcx>, tests: &[Test], call_grap
                         .map(|(_, callee)| (callee.display_str(tcx), tcx.def_span(callee.def_id), callee))
                         .collect::<Vec<_>>();
                     callees_in_print_order.sort_unstable_by(|(callee_a_display_str, callee_a_span, _), (callee_b_display_str, callee_b_span, _)| {
-                        Ord::cmp(callee_a_span, callee_b_span).then(Ord::cmp(callee_a_display_str, callee_b_display_str))
+                        span_diagnostic_ord(*callee_a_span, *callee_b_span).then(Ord::cmp(callee_a_display_str, callee_b_display_str))
                     });
 
                     for (callee_display_str, callee_span, callee) in callees_in_print_order {