Update to nightly-2025-07-28.

- `run_fat_lto`, `optimize_fat`, and `autodiff` were merged into
  `run_and_optimize_fat_lto`, and the parameters were changed.
- `run_thin_lto` parameters were changed.
- `codegen` parameters were changed.
- `LtoModuleCodegen` was removed.
- Minor error message changes:
  - Some line number changes in rustc.
  - Some error message wording tweaks.

The LTO changes occurred in rust-lang/rust PR 143388 and PR 144062.

Author: nnethercote

crates/rustc_codegen_spirv/build.rs

@@ -18,9 +18,9 @@ use std::{env, fs, mem};
 /// `cargo publish`. We need to figure out a way to do this properly, but let's hardcode it for now :/
 //const REQUIRED_RUST_TOOLCHAIN: &str = include_str!("../../rust-toolchain.toml");
 const REQUIRED_RUST_TOOLCHAIN: &str = r#"[toolchain]
-channel = "nightly-2025-07-14"
+channel = "nightly-2025-07-28"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = e9182f195b8505c87c4bd055b9f6e114ccda0981"#;
+# commit_hash = f8e355c230c6eb7b78ffce6a92fd81f78c890524"#;
 
 fn rustc_output(arg: &str) -> Result<String, Box<dyn Error>> {
     let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".into());

crates/rustc_codegen_spirv/src/lib.rs

@@ -141,7 +141,7 @@ mod target_feature;
 
 use builder::Builder;
 use codegen_cx::CodegenCx;
-use maybe_pqp_cg_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
+use maybe_pqp_cg_ssa::back::lto::{SerializedModule, ThinModule};
 use maybe_pqp_cg_ssa::back::write::{
     CodegenContext, FatLtoInput, ModuleConfig, OngoingCodegen, TargetMachineFactoryConfig,
 };
@@ -170,7 +170,7 @@ use std::any::Any;
 use std::fs;
 use std::io::Cursor;
 use std::io::Write;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use tracing::{error, warn};
 
@@ -333,7 +333,7 @@ impl WriteBackendMethods for SpirvCodegenBackend {
     type ThinBuffer = SpirvModuleBuffer;
 
     // FIXME(eddyb) reuse the "merge" stage of `crate::linker` for this, or even
-    // delegate to `run_fat_lto` (although `-Zcombine-cgu` is much more niche).
+    // delegate to `run_and_optimize_fat_lto` (although `-Zcombine-cgu` is much more niche).
     fn run_link(
         cgcx: &CodegenContext<Self>,
         diag_handler: DiagCtxtHandle<'_>,
@@ -351,24 +351,29 @@ impl WriteBackendMethods for SpirvCodegenBackend {
     // consider setting `requires_lto = true` in the target specs and moving the
     // entirety of `crate::linker` into this stage (lacking diagnostics may be
     // an issue - it's surprising `CodegenBackend::link` has `Session` at all).
-    fn run_fat_lto(
+    fn run_and_optimize_fat_lto(
         cgcx: &CodegenContext<Self>,
+        _exported_symbols_for_lto: &[String],
+        _each_linked_rlib_for_lto: &[PathBuf],
         _modules: Vec<FatLtoInput<Self>>,
-        _cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
-    ) -> Result<LtoModuleCodegen<Self>, FatalError> {
+        _diff_fncs: Vec<AutoDiffItem>,
+    ) -> Result<ModuleCodegen<Self::Module>, FatalError> {
         assert!(
             cgcx.lto == rustc_session::config::Lto::Fat,
-            "`run_fat_lto` (for `WorkItemResult::NeedsFatLto`) should \
+            "`run_and_optimize_fat_lto` (for `WorkItemResult::NeedsFatLto`) should \
              only be invoked due to `-Clto` (or equivalent)"
         );
         unreachable!("Rust-GPU does not support fat LTO")
     }
 
     fn run_thin_lto(
         cgcx: &CodegenContext<Self>,
+        // FIXME(bjorn3): Limit LTO exports to these symbols
+        _exported_symbols_for_lto: &[String],
+        _each_linked_rlib_for_lto: &[PathBuf], // njn: ?
         modules: Vec<(String, Self::ThinBuffer)>,
         cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
-    ) -> Result<(Vec<LtoModuleCodegen<Self>>, Vec<WorkProduct>), FatalError> {
+    ) -> Result<(Vec<ThinModule<Self>>, Vec<WorkProduct>), FatalError> {
         link::run_thin(cgcx, modules, cached_modules)
     }
 
@@ -409,16 +414,8 @@ impl WriteBackendMethods for SpirvCodegenBackend {
         Ok(module)
     }
 
-    fn optimize_fat(
-        cgcx: &CodegenContext<Self>,
-        module: &mut ModuleCodegen<Self::Module>,
-    ) -> Result<(), FatalError> {
-        Self::optimize_common(cgcx, module)
-    }
-
     fn codegen(
         cgcx: &CodegenContext<Self>,
-        _diag_handler: DiagCtxtHandle<'_>,
         module: ModuleCodegen<Self::Module>,
         _config: &ModuleConfig,
     ) -> Result<CompiledModule, FatalError> {
@@ -457,15 +454,6 @@ impl WriteBackendMethods for SpirvCodegenBackend {
             SpirvModuleBuffer(module.module_llvm.assemble()),
         )
     }
-
-    fn autodiff(
-        _cgcx: &CodegenContext<Self>,
-        _module: &ModuleCodegen<Self::Module>,
-        _diff_fncs: Vec<AutoDiffItem>,
-        _config: &ModuleConfig,
-    ) -> Result<(), FatalError> {
-        unreachable!("Rust-GPU does not support autodiff")
-    }
 }
 
 impl ExtraBackendMethods for SpirvCodegenBackend {

crates/rustc_codegen_spirv/src/link.rs

@@ -8,7 +8,7 @@ use rspirv::binary::Assemble;
 use rspirv::dr::Module;
 use rustc_ast::CRATE_NODE_ID;
 use rustc_codegen_spirv_types::{CompileResult, ModuleResult};
-use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule, ThinShared};
+use rustc_codegen_ssa::back::lto::{SerializedModule, ThinModule, ThinShared};
 use rustc_codegen_ssa::back::write::CodegenContext;
 use rustc_codegen_ssa::{CodegenResults, NativeLib};
 use rustc_data_structures::fx::FxHashSet;
@@ -634,7 +634,7 @@ pub(crate) fn run_thin(
     cgcx: &CodegenContext<SpirvCodegenBackend>,
     modules: Vec<(String, SpirvModuleBuffer)>,
     cached_modules: Vec<(SerializedModule<SpirvModuleBuffer>, WorkProduct)>,
-) -> Result<(Vec<LtoModuleCodegen<SpirvCodegenBackend>>, Vec<WorkProduct>), FatalError> {
+) -> Result<(Vec<ThinModule<SpirvCodegenBackend>>, Vec<WorkProduct>), FatalError> {
     if cgcx.opts.cg.linker_plugin_lto.enabled() {
         unreachable!("We should never reach this case if the LTO step is deferred to the linker");
     }
@@ -668,10 +668,10 @@ pub(crate) fn run_thin(
 
     let mut opt_jobs = vec![];
     for (module_index, _) in shared.module_names.iter().enumerate() {
-        opt_jobs.push(LtoModuleCodegen::Thin(ThinModule {
+        opt_jobs.push(ThinModule {
             shared: shared.clone(),
             idx: module_index,
-        }));
+        });
     }
 
     Ok((opt_jobs, vec![]))

rust-toolchain.toml

@@ -1,7 +1,7 @@
 [toolchain]
-channel = "nightly-2025-07-14"
+channel = "nightly-2025-07-28"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = e9182f195b8505c87c4bd055b9f6e114ccda0981
+# commit_hash = f8e355c230c6eb7b78ffce6a92fd81f78c890524
 
 # Whenever changing the nightly channel, update the commit hash above, and
 # change `REQUIRED_RUST_TOOLCHAIN` in `crates/rustc_codegen_spirv/build.rs` too.

tests/compiletests/ui/dis/ptr_copy.normal.stderr

@@ -1,13 +1,13 @@
 error: cannot memcpy dynamically sized data
-   --> $CORE_SRC/ptr/mod.rs:633:9
+   --> $CORE_SRC/ptr/mod.rs:638:9
     |
-633 |         crate::intrinsics::copy(src, dst, count)
+638 |         crate::intrinsics::copy(src, dst, count)
     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     |
 note: used from within `core::ptr::copy::<f32>`
-   --> $CORE_SRC/ptr/mod.rs:618:21
+   --> $CORE_SRC/ptr/mod.rs:623:21
     |
-618 | pub const unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize) {
+623 | pub const unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize) {
     |                     ^^^^
 note: called by `ptr_copy::copy_via_raw_ptr`
    --> $DIR/ptr_copy.rs:28:18
@@ -28,25 +28,25 @@ note: called by `main`
 error: cannot cast between pointer types
        from `*f32`
          to `*struct () {  }`
-   --> $CORE_SRC/ptr/mod.rs:621:9
+   --> $CORE_SRC/ptr/mod.rs:626:9
     |
-621 | /         ub_checks::assert_unsafe_precondition!(
-622 | |             check_language_ub,
-623 | |             "ptr::copy requires that both pointer arguments are aligned and non-null",
+626 | /         ub_checks::assert_unsafe_precondition!(
+627 | |             check_language_ub,
+628 | |             "ptr::copy requires that both pointer arguments are aligned and non-null",
 ...   |
-631 | |                 && ub_checks::maybe_is_aligned_and_not_null(dst, align, zero_size)
-632 | |         );
+636 | |                 && ub_checks::maybe_is_aligned_and_not_null(dst, align, zero_size)
+637 | |         );
     | |_________^
     |
 note: used from within `core::ptr::copy::<f32>`
-   --> $CORE_SRC/ptr/mod.rs:621:9
+   --> $CORE_SRC/ptr/mod.rs:626:9
     |
-621 | /         ub_checks::assert_unsafe_precondition!(
-622 | |             check_language_ub,
-623 | |             "ptr::copy requires that both pointer arguments are aligned and non-null",
+626 | /         ub_checks::assert_unsafe_precondition!(
+627 | |             check_language_ub,
+628 | |             "ptr::copy requires that both pointer arguments are aligned and non-null",
 ...   |
-631 | |                 && ub_checks::maybe_is_aligned_and_not_null(dst, align, zero_size)
-632 | |         );
+636 | |                 && ub_checks::maybe_is_aligned_and_not_null(dst, align, zero_size)
+637 | |         );
     | |_________^
 note: called by `ptr_copy::copy_via_raw_ptr`
    --> $DIR/ptr_copy.rs:28:18

tests/compiletests/ui/dis/ptr_read.stderr

@@ -2,7 +2,7 @@
 %4 = OpFunctionParameter  %5
 %6 = OpFunctionParameter  %5
 %7 = OpLabel
-OpLine %8 1732 8
+OpLine %8 1737 8
 %9 = OpLoad  %10  %4
 OpLine %11 7 13
 OpStore %6 %9

tests/compiletests/ui/dis/ptr_read_method.stderr

@@ -2,7 +2,7 @@
 %4 = OpFunctionParameter  %5
 %6 = OpFunctionParameter  %5
 %7 = OpLabel
-OpLine %8 1732 8
+OpLine %8 1737 8
 %9 = OpLoad  %10  %4
 OpLine %11 7 13
 OpStore %6 %9

tests/compiletests/ui/dis/ptr_write.stderr

@@ -4,7 +4,7 @@
 %7 = OpLabel
 OpLine %8 7 35
 %9 = OpLoad  %10  %4
-OpLine %11 1932 8
+OpLine %11 1937 8
 OpStore %6 %9
 OpNoLine
 OpReturn

tests/compiletests/ui/dis/ptr_write_method.stderr

@@ -4,7 +4,7 @@
 %7 = OpLabel
 OpLine %8 7 37
 %9 = OpLoad  %10  %4
-OpLine %11 1932 8
+OpLine %11 1937 8
 OpStore %6 %9
 OpNoLine
 OpReturn

tests/compiletests/ui/spirv-attr/invalid-target.stderr

@@ -1030,67 +1030,67 @@ error: attribute is only valid on a function parameter, not on a struct field
 170 |         uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only
     |                                                                   ^^^^^^^^^
 
-error: attribute is only valid on a struct, not on a implementation block
+error: attribute is only valid on a struct, not on a inherent implementation block
    --> $DIR/invalid-target.rs:176:5
     |
 176 |     sampler, block, sampled_image, generic_image_type, // struct-only
     |     ^^^^^^^
 
-error: attribute is only valid on a struct, not on a implementation block
+error: attribute is only valid on a struct, not on a inherent implementation block
    --> $DIR/invalid-target.rs:176:14
     |
 176 |     sampler, block, sampled_image, generic_image_type, // struct-only
     |              ^^^^^
 
-error: attribute is only valid on a struct, not on a implementation block
+error: attribute is only valid on a struct, not on a inherent implementation block
    --> $DIR/invalid-target.rs:176:21
     |
 176 |     sampler, block, sampled_image, generic_image_type, // struct-only
     |                     ^^^^^^^^^^^^^
 
-error: attribute is only valid on a struct, not on a implementation block
+error: attribute is only valid on a struct, not on a inherent implementation block
    --> $DIR/invalid-target.rs:176:36
     |
 176 |     sampler, block, sampled_image, generic_image_type, // struct-only
     |                                    ^^^^^^^^^^^^^^^^^^
 
-error: attribute is only valid on a function, not on a implementation block
+error: attribute is only valid on a function, not on a inherent implementation block
    --> $DIR/invalid-target.rs:177:5
     |
 177 |     vertex, // fn-only
     |     ^^^^^^
 
-error: attribute is only valid on a function parameter, not on a implementation block
+error: attribute is only valid on a function parameter, not on a inherent implementation block
    --> $DIR/invalid-target.rs:178:5
     |
 178 |     uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only
     |     ^^^^^^^
 
-error: attribute is only valid on a function parameter, not on a implementation block
+error: attribute is only valid on a function parameter, not on a inherent implementation block
    --> $DIR/invalid-target.rs:178:14
     |
 178 |     uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only
     |              ^^^^^^^^
 
-error: attribute is only valid on a function parameter, not on a implementation block
+error: attribute is only valid on a function parameter, not on a inherent implementation block
    --> $DIR/invalid-target.rs:178:24
     |
 178 |     uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only
     |                        ^^^^^^^^^^^^^^^^^^
 
-error: attribute is only valid on a function parameter, not on a implementation block
+error: attribute is only valid on a function parameter, not on a inherent implementation block
    --> $DIR/invalid-target.rs:178:44
     |
 178 |     uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only
     |                                            ^^^^^^^^^^^
 
-error: attribute is only valid on a function parameter, not on a implementation block
+error: attribute is only valid on a function parameter, not on a inherent implementation block
    --> $DIR/invalid-target.rs:178:57
     |
 178 |     uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only
     |                                                         ^^^^
 
-error: attribute is only valid on a function parameter, not on a implementation block
+error: attribute is only valid on a function parameter, not on a inherent implementation block
    --> $DIR/invalid-target.rs:178:63
     |
 178 |     uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only
@@ -1228,67 +1228,67 @@ error: attribute is only valid on a function parameter, not on a trait
 205 |     uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only
     |                                                               ^^^^^^^^^
 
-error: attribute is only valid on a struct, not on a implementation block
+error: attribute is only valid on a struct, not on a trait implementation block
    --> $DIR/invalid-target.rs:237:5
     |
 237 |     sampler, block, sampled_image, generic_image_type, // struct-only
     |     ^^^^^^^
 
-error: attribute is only valid on a struct, not on a implementation block
+error: attribute is only valid on a struct, not on a trait implementation block
    --> $DIR/invalid-target.rs:237:14
     |
 237 |     sampler, block, sampled_image, generic_image_type, // struct-only
     |              ^^^^^
 
-error: attribute is only valid on a struct, not on a implementation block
+error: attribute is only valid on a struct, not on a trait implementation block
    --> $DIR/invalid-target.rs:237:21
     |
 237 |     sampler, block, sampled_image, generic_image_type, // struct-only
     |                     ^^^^^^^^^^^^^
 
-error: attribute is only valid on a struct, not on a implementation block
+error: attribute is only valid on a struct, not on a trait implementation block
    --> $DIR/invalid-target.rs:237:36
     |
 237 |     sampler, block, sampled_image, generic_image_type, // struct-only
     |                                    ^^^^^^^^^^^^^^^^^^
 
-error: attribute is only valid on a function, not on a implementation block
+error: attribute is only valid on a function, not on a trait implementation block
    --> $DIR/invalid-target.rs:238:5
     |
 238 |     vertex, // fn-only
     |     ^^^^^^
 
-error: attribute is only valid on a function parameter, not on a implementation block
+error: attribute is only valid on a function parameter, not on a trait implementation block
    --> $DIR/invalid-target.rs:239:5
     |
 239 |     uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only
     |     ^^^^^^^
 
-error: attribute is only valid on a function parameter, not on a implementation block
+error: attribute is only valid on a function parameter, not on a trait implementation block
    --> $DIR/invalid-target.rs:239:14
     |
 239 |     uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only
     |              ^^^^^^^^
 
-error: attribute is only valid on a function parameter, not on a implementation block
+error: attribute is only valid on a function parameter, not on a trait implementation block
    --> $DIR/invalid-target.rs:239:24
     |
 239 |     uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only
     |                        ^^^^^^^^^^^^^^^^^^
 
-error: attribute is only valid on a function parameter, not on a implementation block
+error: attribute is only valid on a function parameter, not on a trait implementation block
    --> $DIR/invalid-target.rs:239:44
     |
 239 |     uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only
     |                                            ^^^^^^^^^^^
 
-error: attribute is only valid on a function parameter, not on a implementation block
+error: attribute is only valid on a function parameter, not on a trait implementation block
    --> $DIR/invalid-target.rs:239:57
     |
 239 |     uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only
     |                                                         ^^^^
 
-error: attribute is only valid on a function parameter, not on a implementation block
+error: attribute is only valid on a function parameter, not on a trait implementation block
    --> $DIR/invalid-target.rs:239:63
     |
 239 |     uniform, position, descriptor_set = 0, binding = 0, flat, invariant, // param-only