Update Rust toolchain to nightly-2025-06-23

Author: LegNeato

crates/cust/src/function.rs

@@ -213,7 +213,7 @@ unsafe impl Send for Function<'_> {}
 unsafe impl Sync for Function<'_> {}
 
 impl Function<'_> {
-    pub(crate) fn new(inner: CUfunction, _module: &Module) -> Function {
+    pub(crate) fn new(inner: CUfunction, _module: &Module) -> Function<'_> {
         Function {
             inner,
             module: PhantomData,

crates/cust_raw/build/callbacks.rs

@@ -42,10 +42,7 @@ impl ParseCallbacks for BindgenCallbacks {
         match doxygen_bindgen::transform(&cleaned) {
             Ok(res) => Some(res),
             Err(err) => {
-                println!(
-                    "cargo:warning=Problem processing doxygen comment: {}\n{}",
-                    comment, err
-                );
+                println!("cargo:warning=Problem processing doxygen comment: {comment}\n{err}");
                 None
             }
         }
@@ -184,7 +181,7 @@ impl FunctionRenames {
 
             let expanded = match build.try_expand() {
                 Ok(expanded) => expanded,
-                Err(e) => panic!("Failed to expand macros: {}", e),
+                Err(e) => panic!("Failed to expand macros: {e}"),
             };
             let expanded = str::from_utf8(&expanded).unwrap();
 

crates/cust_raw/build/cuda_sdk.rs

@@ -164,7 +164,7 @@ impl CudaSdk {
         cuda_root: &path::Path,
     ) -> Result<Vec<path::PathBuf>, Box<dyn error::Error>> {
         let (target, triple) = Self::parse_target_triple()?;
-        assert!(triple.len() >= 3, "Invalid target triple: {:?}", triple);
+        assert!(triple.len() >= 3, "Invalid target triple: {triple:?}");
 
         let search_dirs = match [triple[0].as_str(), triple[1].as_str(), triple[2].as_str()] {
             ["x86_64", "pc", "windows"] => {
@@ -248,7 +248,7 @@ impl CudaSdk {
             .ok_or("Cannot find CUDA_VERSION from CUDA header file.")?;
         let version = version
             .parse::<u32>()
-            .map_err(|_| format!("Cannot parse CUDA_VERSION as u32: '{}'", version))?;
+            .map_err(|_| format!("Cannot parse CUDA_VERSION as u32: '{version}'"))?;
         Ok(version)
     }
 
@@ -264,7 +264,7 @@ impl CudaSdk {
             .ok_or("Cannot find CUDART_VERSION from cuda_runtime header file.")?;
         let version = version
             .parse::<u32>()
-            .map_err(|_| format!("Cannot parse CUDART_VERSION as u32: '{}'", version))?;
+            .map_err(|_| format!("Cannot parse CUDART_VERSION as u32: '{version}'"))?;
         Ok(version)
     }
 

crates/cust_raw/build/main.rs

@@ -59,12 +59,12 @@ fn main() {
     let metadata_nvvm_include = env::join_paths(sdk.nvvm_include_paths())
         .map(|s| s.to_string_lossy().to_string())
         .expect("Failed to build metadata for nvvm_include.");
-    println!("cargo::metadata=includes={}", metadata_cuda_include);
-    println!("cargo::metadata=nvvm_includes={}", metadata_nvvm_include);
+    println!("cargo::metadata=includes={metadata_cuda_include}");
+    println!("cargo::metadata=nvvm_includes={metadata_nvvm_include}");
     // Re-run build script conditions.
     println!("cargo::rerun-if-changed=build");
     for e in sdk.related_cuda_envs() {
-        println!("cargo::rerun-if-env-changed={}", e);
+        println!("cargo::rerun-if-env-changed={e}");
     }
 
     create_cuda_driver_bindings(&sdk, &outdir, &manifest_dir);

crates/rustc_codegen_nvvm/build.rs

@@ -26,18 +26,15 @@ fn main() {
 }
 
 fn fail(s: &str) -> ! {
-    println!("\n\n{}\n\n", s);
+    println!("\n\n{s}\n\n");
     std::process::exit(1);
 }
 
 #[track_caller]
 pub fn output(cmd: &mut Command) -> String {
     let output = match cmd.stderr(Stdio::inherit()).output() {
         Ok(status) => status,
-        Err(e) => fail(&format!(
-            "failed to execute command: {:?}\nerror: {}",
-            cmd, e
-        )),
+        Err(e) => fail(&format!("failed to execute command: {cmd:?}\nerror: {e}")),
     };
     assert!(
         output.status.success(),
@@ -56,11 +53,10 @@ fn target_to_llvm_prebuilt(target: &str) -> String {
         // NOTE(RDambrosio016): currently disabled because of weird issues with segfaults and building the C++ shim
         // "x86_64-unknown-linux-gnu" => "linux-x86_64",
         _ => panic!(
-            "Unsupported target with no matching prebuilt LLVM: `{}`, install LLVM and set LLVM_CONFIG",
-            target
+            "Unsupported target with no matching prebuilt LLVM: `{target}`, install LLVM and set LLVM_CONFIG"
         ),
     };
-    format!("{}.tar.xz", base)
+    format!("{base}.tar.xz")
 }
 
 fn find_llvm_config(target: &str) -> PathBuf {
@@ -79,8 +75,7 @@ fn find_llvm_config(target: &str) -> PathBuf {
                 return PathBuf::from(path_to_try);
             }
             println!(
-                "cargo:warning=Prebuilt llvm-config version does not start with {}",
-                REQUIRED_MAJOR_LLVM_VERSION
+                "cargo:warning=Prebuilt llvm-config version does not start with {REQUIRED_MAJOR_LLVM_VERSION}"
             );
         } else {
             println!("cargo:warning=Failed to run prebuilt llvm-config");
@@ -94,7 +89,7 @@ fn find_llvm_config(target: &str) -> PathBuf {
         .unwrap_or_else(|| PREBUILT_LLVM_URL.to_string());
 
     let prebuilt_name = target_to_llvm_prebuilt(target);
-    url = format!("{}{}", url, prebuilt_name);
+    url = format!("{url}{prebuilt_name}");
 
     let out = env::var("OUT_DIR").expect("OUT_DIR was not set");
     let mut easy = Easy::new();
@@ -139,7 +134,7 @@ fn detect_llvm_link() -> (&'static str, &'static str) {
 }
 
 pub fn tracked_env_var_os<K: AsRef<OsStr> + Display>(key: K) -> Option<OsString> {
-    println!("cargo:rerun-if-env-changed={}", key);
+    println!("cargo:rerun-if-env-changed={key}");
     env::var_os(key)
 }
 
@@ -156,13 +151,12 @@ fn rustc_llvm_build() {
     for component in required_components {
         assert!(
             components.contains(component),
-            "require llvm component {} but wasn't found",
-            component
+            "require llvm component {component} but wasn't found"
         );
     }
 
     for component in components.iter() {
-        println!("cargo:rustc-cfg=llvm_component=\"{}\"", component);
+        println!("cargo:rustc-cfg=llvm_component=\"{component}\"");
     }
 
     // Link in our own LLVM shims, compiled with the same flags as LLVM
@@ -255,7 +249,7 @@ fn rustc_llvm_build() {
         } else {
             "dylib"
         };
-        println!("cargo:rustc-link-lib={}={}", kind, name);
+        println!("cargo:rustc-link-lib={kind}={name}");
     }
 
     // Link in the system libraries that LLVM depends on
@@ -272,11 +266,11 @@ fn rustc_llvm_build() {
     cmd.arg(llvm_link_arg).arg("--ldflags");
     for lib in output(&mut cmd).split_whitespace() {
         if let Some(stripped) = lib.strip_prefix("-LIBPATH:") {
-            println!("cargo:rustc-link-search=native={}", stripped);
+            println!("cargo:rustc-link-search=native={stripped}");
         } else if let Some(stripped) = lib.strip_prefix("-l") {
-            println!("cargo:rustc-link-lib={}", stripped);
+            println!("cargo:rustc-link-lib={stripped}");
         } else if let Some(stripped) = lib.strip_prefix("-L") {
-            println!("cargo:rustc-link-search=native={}", stripped);
+            println!("cargo:rustc-link-search=native={stripped}");
         }
     }
 
@@ -288,9 +282,9 @@ fn rustc_llvm_build() {
     if let Some(s) = llvm_linker_flags {
         for lib in s.into_string().unwrap().split_whitespace() {
             if let Some(stripped) = lib.strip_prefix("-l") {
-                println!("cargo:rustc-link-lib={}", stripped);
+                println!("cargo:rustc-link-lib={stripped}");
             } else if let Some(stripped) = lib.strip_prefix("-L") {
-                println!("cargo:rustc-link-search=native={}", stripped);
+                println!("cargo:rustc-link-search=native={stripped}");
             }
         }
     }
@@ -330,14 +324,14 @@ fn rustc_llvm_build() {
                 path.parent().unwrap().display()
             );
             if target.contains("windows") {
-                println!("cargo:rustc-link-lib=static-nobundle={}", stdcppname);
+                println!("cargo:rustc-link-lib=static-nobundle={stdcppname}");
             } else {
-                println!("cargo:rustc-link-lib=static={}", stdcppname);
+                println!("cargo:rustc-link-lib=static={stdcppname}");
             }
         } else if cxxflags.contains("stdlib=libc++") {
             println!("cargo:rustc-link-lib=c++");
         } else {
-            println!("cargo:rustc-link-lib={}", stdcppname);
+            println!("cargo:rustc-link-lib={stdcppname}");
         }
     }
 
@@ -365,6 +359,6 @@ fn link_llvm_system_libs(llvm_config: &Path, components: &[&str]) {
             continue;
         };
 
-        println!("cargo:rustc-link-lib=dylib={}", name);
+        println!("cargo:rustc-link-lib=dylib={name}");
     }
 }

crates/rustc_codegen_nvvm/src/abi.rs

@@ -2,6 +2,7 @@ use std::cmp;
 
 use libc::c_uint;
 use rustc_abi::BackendRepr::Scalar;
+use rustc_abi::CanonAbi;
 use rustc_abi::Size;
 use rustc_abi::{HasDataLayout, Primitive, Reg, RegKind};
 use rustc_codegen_ssa::mir::operand::OperandRef;
@@ -13,7 +14,7 @@ use rustc_middle::ty::layout::LayoutOf;
 pub use rustc_middle::ty::layout::{WIDE_PTR_ADDR, WIDE_PTR_EXTRA};
 use rustc_middle::ty::{Ty, TyCtxt, TyKind};
 use rustc_target::callconv::{
-    ArgAbi, ArgAttribute, ArgAttributes, ArgExtension, CastTarget, Conv, FnAbi, PassMode,
+    ArgAbi, ArgAttribute, ArgAttributes, ArgExtension, CastTarget, FnAbi, PassMode,
 };
 use tracing::trace;
 
@@ -28,7 +29,7 @@ pub(crate) fn readjust_fn_abi<'tcx>(
     fn_abi: &'tcx FnAbi<'tcx, Ty<'tcx>>,
 ) -> &'tcx FnAbi<'tcx, Ty<'tcx>> {
     // dont override anything in the rust abi for now
-    if fn_abi.conv == Conv::Rust {
+    if fn_abi.conv == CanonAbi::Rust {
         return fn_abi;
     }
     let readjust_arg_abi = |arg: &ArgAbi<'tcx, Ty<'tcx>>| {
@@ -260,9 +261,6 @@ impl<'ll, 'tcx> ArgAbiBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
     ) {
         arg_abi.store(self, val, dst)
     }
-    fn arg_memory_ty(&self, arg_abi: &ArgAbi<'tcx, Ty<'tcx>>) -> &'ll Type {
-        arg_abi.memory_ty(self)
-    }
 }
 
 pub(crate) trait FnAbiLlvmExt<'ll, 'tcx> {
@@ -541,7 +539,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
     }
 }
 
-impl<'tcx> AbiBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
+impl<'tcx> AbiBuilderMethods for Builder<'_, '_, 'tcx> {
     fn get_param(&mut self, index: usize) -> Self::Value {
         let val = llvm::get_param(self.llfn(), index as c_uint);
         // trace!("Get param `{:?}`", val);
@@ -551,7 +549,7 @@ impl<'tcx> AbiBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
             // destructure so rustc doesnt complain in the call to transmute_llval
             let Self { cx, llbuilder } = self;
             let map = cx.remapped_integer_args.borrow();
-            if let Some((_, key)) = map.get(llfnty) {
+            if let Some((_, key)) = map.get(&llfnty) {
                 if let Some((_, new_ty)) = key.iter().find(|t| t.0 == index) {
                     trace!("Casting irregular param {:?} to {:?}", val, new_ty);
                     return transmute_llval(llbuilder, cx, val, new_ty);

crates/rustc_codegen_nvvm/src/asm.rs

@@ -224,7 +224,7 @@ impl<'tcx> AsmBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
 
 impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
     fn codegen_global_asm(
-        &self,
+        &mut self,
         template: &[InlineAsmTemplatePiece],
         operands: &[GlobalAsmOperandRef],
         _options: InlineAsmOptions,

crates/rustc_codegen_nvvm/src/attributes.rs

@@ -1,8 +1,8 @@
 use crate::llvm::{self, AttributePlace::*, Value};
 use rustc_ast::{LitKind, MetaItemInner, MetaItemLit};
-use rustc_attr_parsing::{InlineAttr, OptimizeAttr};
+use rustc_attr_data_structures::{InlineAttr, OptimizeAttr};
 use rustc_hir::Attribute;
-use rustc_middle::{bug, middle::codegen_fn_attrs::CodegenFnAttrFlags, ty};
+use rustc_middle::{middle::codegen_fn_attrs::CodegenFnAttrFlags, ty};
 use rustc_session::{Session, config::OptLevel};
 use rustc_span::{Symbol, sym};
 
@@ -16,7 +16,7 @@ fn inline(val: &'_ Value, inline: InlineAttr) {
         Always => llvm::Attribute::AlwaysInline.apply_llfn(Function, val),
         Never => llvm::Attribute::NoInline.apply_llfn(Function, val),
         None => {}
-        Force { .. } => bug!("Force inline should have been inlined away by now"), // TODO: Verify this
+        Force { .. } => llvm::Attribute::AlwaysInline.apply_llfn(Function, val),
     }
 }
 

crates/rustc_codegen_nvvm/src/back.rs

@@ -176,11 +176,11 @@ pub(crate) unsafe fn codegen(
 
     let llmod = unsafe { module.module_llvm.llmod.as_ref().unwrap() };
     let mod_name = module.name.clone();
-    let module_name = Some(&mod_name[..]);
+    let module_name = &mod_name[..];
 
     let out = cgcx
         .output_filenames
-        .temp_path(OutputType::Object, module_name);
+        .temp_path_for_cgu(OutputType::Object, module_name, None);
 
     // nvvm ir *is* llvm ir so emit_ir fits the expectation of llvm ir which is why we
     // implement this. this is copy and pasted straight from rustc_codegen_llvm
@@ -189,9 +189,9 @@ pub(crate) unsafe fn codegen(
         let _timer = cgcx
             .prof
             .generic_activity_with_arg("NVVM_module_codegen_emit_ir", &module.name[..]);
-        let out = cgcx
-            .output_filenames
-            .temp_path(OutputType::LlvmAssembly, module_name);
+        let out =
+            cgcx.output_filenames
+                .temp_path_for_cgu(OutputType::LlvmAssembly, module_name, None);
         let out = out.to_str().unwrap();
 
         let result = unsafe {
@@ -229,6 +229,7 @@ pub(crate) unsafe fn codegen(
         bytecode: None,
         assembly: None,
         llvm_ir: None,
+        links_from_incr_cache: vec![],
     })
 }
 
@@ -254,7 +255,7 @@ pub fn compile_codegen_unit(tcx: TyCtxt<'_>, cgu_name: Symbol) -> (ModuleCodegen
         // Instantiate monomorphizations without filling out definitions yet...
         let llvm_module = LlvmMod::new(cgu_name.as_str());
         {
-            let cx = CodegenCx::new(tcx, cgu, &llvm_module);
+            let mut cx = CodegenCx::new(tcx, cgu, &llvm_module);
 
             let mono_items = cx.codegen_unit.items_in_deterministic_order(cx.tcx);
 
@@ -267,22 +268,27 @@ pub fn compile_codegen_unit(tcx: TyCtxt<'_>, cgu_name: Symbol) -> (ModuleCodegen
                 },
             ) in &mono_items
             {
-                mono_item.predefine::<Builder<'_, '_, '_>>(&cx, linkage, visibility);
+                mono_item.predefine::<Builder<'_, '_, '_>>(
+                    &mut cx,
+                    "mono_item",
+                    linkage,
+                    visibility,
+                );
             }
 
             // ... and now that we have everything pre-defined, fill out those definitions.
-            for &(mono_item, _) in &mono_items {
+            for &(mono_item, mono_item_data) in &mono_items {
                 if let MonoItem::Fn(func) = mono_item {
-                    define_or_override_fn(func, &cx);
+                    define_or_override_fn(func, &mut cx);
                 } else {
-                    mono_item.define::<Builder<'_, '_, '_>>(&cx);
+                    mono_item.define::<Builder<'_, '_, '_>>(&mut cx, "mono_item", mono_item_data);
                 }
             }
 
             // a main function for gpu kernels really makes no sense but
             // codegen it anyways.
             // sanitize attrs are not allowed in nvvm so do nothing further.
-            maybe_create_entry_wrapper::<Builder<'_, '_, '_>>(&cx);
+            maybe_create_entry_wrapper::<Builder<'_, '_, '_>>(&mut cx, cgu);
 
             // Run replace-all-uses-with for statics that need it
             for &(old_g, new_g) in cx.statics_to_rauw.borrow().iter() {
@@ -333,13 +339,8 @@ pub(crate) unsafe fn optimize(
 
     let llmod = unsafe { &*module.module_llvm.llmod };
 
-    let module_name = module.name.clone();
-    let module_name = Some(&module_name[..]);
-
     if config.emit_no_opt_bc {
-        let out = cgcx
-            .output_filenames
-            .temp_path_ext("no-opt.bc", module_name);
+        let out = cgcx.output_filenames.with_extension("no-opt.bc");
         let out = path_to_c_string(&out);
         unsafe { llvm::LLVMWriteBitcodeToFile(llmod, out.as_ptr()) };
     }