rustup: update to nightly-2024-07-20 (~1.81).

Author: eddyb

.cargo/config.toml

@@ -3,6 +3,8 @@ compiletest = "run --release -p compiletests --"
 
 [target.'cfg(all())']
 rustflags = [
+    # FIXME(eddyb) update/review these lints.
+    #
     # BEGIN - Embark standard lints v6 for Rust 1.55+
     # do not change or add/remove here, but one can add exceptions after this section
     # for more info see: <https://github.com/EmbarkStudios/rust-ecosystem/issues/59>
@@ -47,7 +49,6 @@ rustflags = [
     "-Wclippy::match_wild_err_arm",
     "-Wclippy::match_wildcard_for_single_variants",
     "-Wclippy::mem_forget",
-    "-Wclippy::mismatched_target_os",
     "-Wclippy::missing_enforced_import_renames",
     "-Wclippy::mut_mut",
     "-Wclippy::mutex_integer",

crates/rustc_codegen_spirv/build.rs

@@ -15,9 +15,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-2024-06-08"
+channel = "nightly-2024-07-20"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = 804421dff5542c9c7da5c60257b5dbc849719505"#;
+# commit_hash = 9057c3ffec44926d5e149dc13ff3ce1613b69cce"#;
 
 fn rustc_output(arg: &str) -> Result<String, Box<dyn Error>> {
     let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".into());
@@ -189,8 +189,8 @@ mod win {",
                 );
             } else if relative_path == Path::new("src/mir/place.rs") {
                 src = src.replace(
-                    "PlaceValue::alloca(bx, layout.size, layout.align.abi)",
-                    "PlaceValue::new_sized(bx.typed_alloca(bx.cx().backend_type(layout), layout.align.abi), layout.align.abi)",
+                    "Self::alloca_size(bx, layout.size, layout)",
+                    "PlaceValue::new_sized(bx.typed_alloca(bx.cx().backend_type(layout), layout.align.abi), layout.align.abi).with_type(layout)",
                 );
             } else if relative_path == Path::new("src/mir/operand.rs") {
                 src = src.replace("alloca(field.size,", "typed_alloca(llfield_ty,");

crates/rustc_codegen_spirv/src/abi.rs

@@ -867,7 +867,7 @@ fn trans_intrinsic_type<'tcx>(
 
             impl FromScalarInt for u32 {
                 fn from_scalar_int(n: ScalarInt) -> Option<Self> {
-                    n.try_to_u32().ok()
+                    Some(n.try_to_bits(Size::from_bits(32)).ok()?.try_into().unwrap())
                 }
             }
 

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -2020,13 +2020,11 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
             SpirvType::Pointer { .. } => match op {
                 IntEQ => {
                     if self.emit().version().unwrap() > (1, 3) {
-                        let ptr_equal =
-                            self.emit().ptr_equal(b, None, lhs.def(self), rhs.def(self));
-
-                        ptr_equal.map(|result| {
-                            self.zombie_ptr_equal(result, "OpPtrEqual");
-                            result
-                        })
+                        self.emit()
+                            .ptr_equal(b, None, lhs.def(self), rhs.def(self))
+                            .inspect(|&result| {
+                                self.zombie_ptr_equal(result, "OpPtrEqual");
+                            })
                     } else {
                         let int_ty = self.type_usize();
                         let lhs = self
@@ -2039,16 +2037,15 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                             .convert_ptr_to_u(int_ty, None, rhs.def(self))
                             .unwrap();
                         self.zombie_convert_ptr_to_u(rhs);
-                        self.emit().i_not_equal(b, None, lhs, rhs)
+                        self.emit().i_equal(b, None, lhs, rhs)
                     }
                 }
                 IntNE => {
                     if self.emit().version().unwrap() > (1, 3) {
                         self.emit()
                             .ptr_not_equal(b, None, lhs.def(self), rhs.def(self))
-                            .map(|result| {
+                            .inspect(|&result| {
                                 self.zombie_ptr_equal(result, "OpPtrNotEqual");
-                                result
                             })
                     } else {
                         let int_ty = self.type_usize();

crates/rustc_codegen_spirv/src/codegen_cx/constant.rs

@@ -214,7 +214,7 @@ impl<'tcx> ConstMethods<'tcx> for CodegenCx<'tcx> {
         match scalar {
             Scalar::Int(int) => {
                 assert_eq!(int.size(), layout.primitive().size(self));
-                let data = int.assert_uint(int.size());
+                let data = int.to_uint(int.size());
 
                 if let Primitive::Pointer(_) = layout.primitive() {
                     if data == 0 {
@@ -247,8 +247,11 @@ impl<'tcx> ConstMethods<'tcx> for CodegenCx<'tcx> {
                         let value = self.static_addr_of(init, alloc.inner().align, None);
                         (value, AddressSpace::DATA)
                     }
-                    GlobalAlloc::Function(fn_instance) => (
-                        self.get_fn_addr(fn_instance.polymorphize(self.tcx)),
+                    GlobalAlloc::Function {
+                        instance,
+                        unique: _,
+                    } => (
+                        self.get_fn_addr(instance.polymorphize(self.tcx)),
                         self.data_layout().instruction_address_space,
                     ),
                     GlobalAlloc::VTable(vty, trait_ref) => {
@@ -304,7 +307,21 @@ impl<'tcx> ConstMethods<'tcx> for CodegenCx<'tcx> {
         self.def_constant(void_type, SpirvConst::ConstDataFromAlloc(alloc))
     }
 
-    fn const_bitcast(&self, val: Self::Value, ty: Self::Type) -> Self::Value {
+    fn const_ptr_byte_offset(&self, val: Self::Value, offset: Size) -> Self::Value {
+        if offset == Size::ZERO {
+            val
+        } else {
+            // FIXME(eddyb) implement via `OpSpecConstantOp`.
+            // FIXME(eddyb) this zombies the original value without creating a new one.
+            let result = val;
+            self.zombie_no_span(result.def_cx(self), "const_ptr_byte_offset");
+            result
+        }
+    }
+}
+
+impl<'tcx> CodegenCx<'tcx> {
+    pub fn const_bitcast(&self, val: SpirvValue, ty: Word) -> SpirvValue {
         // HACK(eddyb) special-case `const_data_from_alloc` + `static_addr_of`
         // as the old `from_const_alloc` (now `OperandRef::from_const_alloc`).
         if let SpirvValueKind::IllegalConst(_) = val.kind {
@@ -331,20 +348,7 @@ impl<'tcx> ConstMethods<'tcx> for CodegenCx<'tcx> {
             result
         }
     }
-    fn const_ptr_byte_offset(&self, val: Self::Value, offset: Size) -> Self::Value {
-        if offset == Size::ZERO {
-            val
-        } else {
-            // FIXME(eddyb) implement via `OpSpecConstantOp`.
-            // FIXME(eddyb) this zombies the original value without creating a new one.
-            let result = val;
-            self.zombie_no_span(result.def_cx(self), "const_ptr_byte_offset");
-            result
-        }
-    }
-}
 
-impl<'tcx> CodegenCx<'tcx> {
     // This function comes from `ty::layout`'s `layout_of_uncached`,
     // where it's named `scalar_unit`.
     pub fn primitive_to_scalar(&self, value: Primitive) -> abi::Scalar {

crates/rustc_codegen_spirv/src/codegen_cx/mod.rs

@@ -598,12 +598,11 @@ impl CodegenArgs {
 
         let matches_opt_path = |name| matches.opt_str(name).map(PathBuf::from);
         let matches_opt_dump_dir_path = |name| {
-            matches_opt_path(name).map(|path| {
+            matches_opt_path(name).inspect(|path| {
                 if path.is_file() {
-                    std::fs::remove_file(&path).unwrap();
+                    std::fs::remove_file(path).unwrap();
                 }
-                std::fs::create_dir_all(&path).unwrap();
-                path
+                std::fs::create_dir_all(path).unwrap();
             })
         };
         // FIXME(eddyb) should these be handled as `-C linker-args="..."` instead?
@@ -852,10 +851,6 @@ impl<'tcx> MiscMethods<'tcx> for CodegenCx<'tcx> {
         &self.vtables
     }
 
-    fn check_overflow(&self) -> bool {
-        self.tcx.sess.overflow_checks()
-    }
-
     fn get_fn(&self, instance: Instance<'tcx>) -> Self::Function {
         self.get_fn_ext(instance)
     }

crates/rustc_codegen_spirv/src/codegen_cx/type_.rs

@@ -128,9 +128,6 @@ impl<'tcx> CodegenCx<'tcx> {
 }
 
 impl<'tcx> BaseTypeMethods<'tcx> for CodegenCx<'tcx> {
-    fn type_i1(&self) -> Self::Type {
-        SpirvType::Bool.def(DUMMY_SP, self)
-    }
     fn type_i8(&self) -> Self::Type {
         SpirvType::Integer(8, false).def(DUMMY_SP, self)
     }
@@ -179,19 +176,6 @@ impl<'tcx> BaseTypeMethods<'tcx> for CodegenCx<'tcx> {
         }
         .def(DUMMY_SP, self)
     }
-    fn type_struct(&self, els: &[Self::Type], _packed: bool) -> Self::Type {
-        // FIXME(eddyb) use `AccumulateVec`s just like `rustc` itself does.
-        let (field_offsets, size, align) = crate::abi::auto_struct_layout(self, els);
-        SpirvType::Adt {
-            def_id: None,
-            align,
-            size,
-            field_types: els,
-            field_offsets: &field_offsets,
-            field_names: None,
-        }
-        .def(DUMMY_SP, self)
-    }
     fn type_kind(&self, ty: Self::Type) -> TypeKind {
         match self.lookup_type(ty) {
             SpirvType::Void => TypeKind::Void,

crates/rustc_codegen_spirv/src/custom_insts.rs

@@ -43,13 +43,12 @@ lazy_static! {
     ///   achieved by hashing the `SCHEMA` constant from `def_custom_insts!` below
     pub static ref CUSTOM_EXT_INST_SET: String = {
         let schema_hash = {
-            use rustc_data_structures::stable_hasher::StableHasher;
+            use rustc_data_structures::stable_hasher::{Hash128, StableHasher};
             use std::hash::Hash;
 
             let mut hasher = StableHasher::new();
             SCHEMA.hash(&mut hasher);
-            let (lo, hi) = hasher.finalize();
-            (lo as u128) | ((hi as u128) << 64)
+            hasher.finish::<Hash128>().as_u128()
         };
         let version = join_cargo_pkg_version_major_minor_patch!("_");
         format!("{CUSTOM_EXT_INST_SET_PREFIX}{version}.{schema_hash:x}")

crates/rustc_codegen_spirv/src/lib.rs

@@ -1,12 +1,12 @@
 // HACK(eddyb) start of `rustc_codegen_ssa` crate-level attributes (see `build.rs`).
-#![feature(rustdoc_internals)]
 #![allow(internal_features)]
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::untranslatable_diagnostic)]
 #![feature(box_patterns)]
 #![feature(if_let_guard)]
 #![feature(let_chains)]
 #![feature(negative_impls)]
+#![feature(rustdoc_internals)]
 #![feature(strict_provenance)]
 #![feature(try_blocks)]
 // HACK(eddyb) end of `rustc_codegen_ssa` crate-level attributes (see `build.rs`).
@@ -31,7 +31,6 @@
 #![feature(rustc_private)]
 #![feature(assert_matches)]
 #![feature(result_flattening)]
-#![feature(lint_reasons)]
 // crate-specific exceptions:
 #![allow(
     unsafe_code,                // rustc_codegen_ssa requires unsafe functions in traits to be impl'd
@@ -146,13 +145,13 @@ use maybe_pqp_cg_ssa::{CodegenResults, CompiledModule, ModuleCodegen, ModuleKind
 use rspirv::binary::Assemble;
 use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_errors::{DiagCtxt, ErrorGuaranteed, FatalError};
+use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed, FatalError};
 use rustc_metadata::EncodedMetadata;
 use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
 use rustc_middle::mir::mono::{MonoItem, MonoItemData};
 use rustc_middle::mir::pretty::write_mir_pretty;
 use rustc_middle::ty::print::with_no_trimmed_paths;
-use rustc_middle::ty::{self, Instance, InstanceDef, TyCtxt};
+use rustc_middle::ty::{self, Instance, InstanceKind, TyCtxt};
 use rustc_session::config::{self, OutputFilenames, OutputType};
 use rustc_session::Session;
 use rustc_span::symbol::{sym, Symbol};
@@ -168,7 +167,7 @@ fn dump_mir(tcx: TyCtxt<'_>, mono_items: &[(MonoItem<'_>, MonoItemData)], path:
     let mut file = File::create(path).unwrap();
     for &(mono_item, _) in mono_items {
         if let MonoItem::Fn(instance) = mono_item {
-            if matches!(instance.def, InstanceDef::Item(_)) {
+            if matches!(instance.def, InstanceKind::Item(_)) {
                 let mut mir = Cursor::new(Vec::new());
                 if write_mir_pretty(tcx, Some(instance.def_id()), &mut mir).is_ok() {
                     writeln!(file, "{}", String::from_utf8(mir.into_inner()).unwrap()).unwrap();
@@ -184,7 +183,7 @@ fn is_blocklisted_fn<'tcx>(
     instance: Instance<'tcx>,
 ) -> bool {
     // TODO: These sometimes have a constant value of an enum variant with a hole
-    if let InstanceDef::Item(def_id) = instance.def {
+    if let InstanceKind::Item(def_id) = instance.def {
         if let Some(debug_trait_def_id) = tcx.get_diagnostic_item(sym::Debug) {
             // Helper for detecting `<_ as core::fmt::Debug>::fmt` (in impls).
             let is_debug_fmt_method = |def_id| match tcx.opt_associated_item(def_id) {
@@ -328,7 +327,7 @@ impl WriteBackendMethods for SpirvCodegenBackend {
 
     fn run_link(
         _cgcx: &CodegenContext<Self>,
-        _diag_handler: &DiagCtxt,
+        _diag_handler: DiagCtxtHandle<'_>,
         _modules: Vec<ModuleCodegen<Self::Module>>,
     ) -> Result<ModuleCodegen<Self::Module>, FatalError> {
         todo!()
@@ -360,7 +359,7 @@ impl WriteBackendMethods for SpirvCodegenBackend {
 
     unsafe fn optimize(
         _: &CodegenContext<Self>,
-        _: &DiagCtxt,
+        _: DiagCtxtHandle<'_>,
         _: &ModuleCodegen<Self::Module>,
         _: &ModuleConfig,
     ) -> Result<(), FatalError> {
@@ -391,7 +390,7 @@ impl WriteBackendMethods for SpirvCodegenBackend {
 
     unsafe fn codegen(
         cgcx: &CodegenContext<Self>,
-        _diag_handler: &DiagCtxt,
+        _diag_handler: DiagCtxtHandle<'_>,
         module: ModuleCodegen<Self::Module>,
         _config: &ModuleConfig,
     ) -> Result<CompiledModule, FatalError> {
@@ -536,16 +535,13 @@ impl Drop for DumpModuleOnPanic<'_, '_, '_> {
 #[no_mangle]
 pub fn __rustc_codegen_backend() -> Box<dyn CodegenBackend> {
     // Tweak rustc's default ICE panic hook, to direct people to `rust-gpu`.
-    rustc_driver::install_ice_hook(
-        "https://github.com/rust-gpu/rust-gpu/issues/new",
-        |handler| {
-            handler.note(concat!(
-                "`rust-gpu` version `",
-                env!("CARGO_PKG_VERSION"),
-                "`"
-            ));
-        },
-    );
+    rustc_driver::install_ice_hook("https://github.com/rust-gpu/rust-gpu/issues/new", |dcx| {
+        dcx.handle().note(concat!(
+            "`rust-gpu` version `",
+            env!("CARGO_PKG_VERSION"),
+            "`"
+        ));
+    });
 
     Box::new(SpirvCodegenBackend)
 }

crates/rustc_codegen_spirv/src/linker/test.rs

@@ -169,7 +169,9 @@ fn link_with_linker_opts(
 
             // HACK(eddyb) inject `write_diags` into `sess`, to work around
             // the removals in https://github.com/rust-lang/rust/pull/102992.
-            sess.psess.dcx = {
+            sess.psess = {
+                let source_map = sess.psess.clone_source_map();
+
                 let fallback_bundle = {
                     extern crate rustc_error_messages;
                     rustc_error_messages::fallback_fluent_bundle(
@@ -179,10 +181,13 @@ fn link_with_linker_opts(
                 };
                 let emitter =
                     rustc_errors::emitter::HumanEmitter::new(Box::new(buf), fallback_bundle)
-                        .sm(Some(sess.psess.clone_source_map()));
+                        .sm(Some(source_map.clone()));
 
-                rustc_errors::DiagCtxt::new(Box::new(emitter))
-                    .with_flags(sess.opts.unstable_opts.dcx_flags(true))
+                rustc_session::parse::ParseSess::with_dcx(
+                    rustc_errors::DiagCtxt::new(Box::new(emitter))
+                        .with_flags(sess.opts.unstable_opts.dcx_flags(true)),
+                    source_map,
+                )
             };
 
             let res = link(