Auto merge of #139482 - Zalathar:rollup-h2ht1y6, r=Zalathar

Rollup of 9 pull requests

Successful merges:

 - #139035 (Add new `PatKind::Missing` variants)
 - #139108 (Simplify `thir::PatKind::ExpandedConstant`)
 - #139112 (Implement `super let`)
 - #139365 (Default auto traits: fix perf)
 - #139397 (coverage: Build the CGU's global file table as late as possible)
 - #139455 ( Remove support for `extern "rust-intrinsic"` blocks)
 - #139461 (Stop calling `source_span` query in significant drop order code)
 - #139465 (add sret handling for scalar autodiff)
 - #139466 (Trivial tweaks to stop tracking source span directly)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

crates/hir-ty/src/lib.rs

@@ -400,7 +400,6 @@ pub enum FnAbi {
     Rust,
     RustCall,
     RustCold,
-    RustIntrinsic,
     Stdcall,
     StdcallUnwind,
     System,
@@ -457,7 +456,6 @@ impl FnAbi {
             s if *s == sym::riscv_dash_interrupt_dash_s => FnAbi::RiscvInterruptS,
             s if *s == sym::rust_dash_call => FnAbi::RustCall,
             s if *s == sym::rust_dash_cold => FnAbi::RustCold,
-            s if *s == sym::rust_dash_intrinsic => FnAbi::RustIntrinsic,
             s if *s == sym::Rust => FnAbi::Rust,
             s if *s == sym::stdcall_dash_unwind => FnAbi::StdcallUnwind,
             s if *s == sym::stdcall => FnAbi::Stdcall,
@@ -500,7 +498,6 @@ impl FnAbi {
             FnAbi::Rust => "Rust",
             FnAbi::RustCall => "rust-call",
             FnAbi::RustCold => "rust-cold",
-            FnAbi::RustIntrinsic => "rust-intrinsic",
             FnAbi::Stdcall => "stdcall",
             FnAbi::StdcallUnwind => "stdcall-unwind",
             FnAbi::System => "system",

crates/hir-ty/src/mir/eval/shim.rs

@@ -59,19 +59,7 @@ impl Evaluator<'_> {
 
         let function_data = self.db.function_data(def);
         let attrs = self.db.attrs(def.into());
-        let is_intrinsic = attrs.by_key(&sym::rustc_intrinsic).exists()
-            // Keep this around for a bit until extern "rustc-intrinsic" abis are no longer used
-            || (match &function_data.abi {
-                Some(abi) => *abi == sym::rust_dash_intrinsic,
-                None => match def.lookup(self.db.upcast()).container {
-                    hir_def::ItemContainerId::ExternBlockId(block) => {
-                        let id = block.lookup(self.db.upcast()).id;
-                        id.item_tree(self.db.upcast())[id.value].abi.as_ref()
-                            == Some(&sym::rust_dash_intrinsic)
-                    }
-                    _ => false,
-                },
-            });
+        let is_intrinsic = attrs.by_key(&sym::rustc_intrinsic).exists();
 
         if is_intrinsic {
             return self.exec_intrinsic(

crates/hir-ty/src/utils.rs

@@ -18,7 +18,6 @@ use hir_def::{
     TypeOrConstParamId,
 };
 use hir_expand::name::Name;
-use intern::sym;
 use rustc_abi::TargetDataLayout;
 use rustc_hash::FxHashSet;
 use smallvec::{smallvec, SmallVec};
@@ -303,26 +302,13 @@ pub fn is_fn_unsafe_to_call(
 
     let loc = func.lookup(db.upcast());
     match loc.container {
-        hir_def::ItemContainerId::ExternBlockId(block) => {
-            let id = block.lookup(db.upcast()).id;
-            let is_intrinsic_block =
-                id.item_tree(db.upcast())[id.value].abi.as_ref() == Some(&sym::rust_dash_intrinsic);
-            if is_intrinsic_block {
-                // legacy intrinsics
-                // extern "rust-intrinsic" intrinsics are unsafe unless they have the rustc_safe_intrinsic attribute
-                if db.attrs(func.into()).by_key(&sym::rustc_safe_intrinsic).exists() {
-                    Unsafety::Safe
-                } else {
-                    Unsafety::Unsafe
-                }
+        hir_def::ItemContainerId::ExternBlockId(_block) => {
+            // Function in an `extern` block are always unsafe to call, except when
+            // it is marked as `safe`.
+            if data.is_safe() {
+                Unsafety::Safe
             } else {
-                // Function in an `extern` block are always unsafe to call, except when
-                // it is marked as `safe`.
-                if data.is_safe() {
-                    Unsafety::Safe
-                } else {
-                    Unsafety::Unsafe
-                }
+                Unsafety::Unsafe
             }
         }
         _ => Unsafety::Safe,

crates/ide-completion/src/completions/extern_abi.rs

@@ -36,7 +36,6 @@ const SUPPORTED_CALLING_CONVENTIONS: &[&str] = &[
     "wasm",
     "system",
     "system-unwind",
-    "rust-intrinsic",
     "rust-call",
     "unadjusted",
 ];

crates/ide/src/hover/tests.rs

@@ -6945,9 +6945,8 @@ fn hover_feature() {
             Various intrinsics have native MIR operations that they correspond to. Instead of requiring
             backends to implement both the intrinsic and the MIR operation, the `lower_intrinsics` pass
             will convert the calls to the MIR operation. Backends do not need to know about these intrinsics
-            at all. These intrinsics only make sense without a body, and can either be declared as a "rust-intrinsic"
-            or as a `#[rustc_intrinsic]`. The body is never used, as calls to the intrinsic do not exist
-            anymore after MIR analyses.
+            at all. These intrinsics only make sense without a body, and can be as a `#[rustc_intrinsic]`. 
+            The body is never used, as calls to the intrinsic do not exist anymore after MIR analyses.
 
             ## Intrinsics without fallback logic
 
@@ -6960,29 +6959,6 @@ fn hover_feature() {
             `#[rustc_intrinsic_must_be_overridden]` to the function to ensure that backends don't
             invoke the body.
 
-            ### Legacy extern ABI based intrinsics
-
-            These are imported as if they were FFI functions, with the special
-            `rust-intrinsic` ABI. For example, if one was in a freestanding
-            context, but wished to be able to `transmute` between types, and
-            perform efficient pointer arithmetic, one would import those functions
-            via a declaration like
-
-            ```rust
-            #![feature(intrinsics)]
-            #![allow(internal_features)]
-            # fn main() {}
-
-            extern "rust-intrinsic" {
-                fn transmute<T, U>(x: T) -> U;
-
-                fn arith_offset<T>(dst: *const T, offset: isize) -> *const T;
-            }
-            ```
-
-            As with any other FFI functions, these are by default always `unsafe` to call.
-            You can add `#[rustc_safe_intrinsic]` to the intrinsic to make it safe to call.
-
         "#]],
     )
 }

crates/intern/src/symbol/symbols.rs

@@ -125,7 +125,6 @@ define_symbols! {
     riscv_dash_interrupt_dash_s = "riscv-interrupt-s",
     rust_dash_call = "rust-call",
     rust_dash_cold = "rust-cold",
-    rust_dash_intrinsic = "rust-intrinsic",
     stdcall_dash_unwind = "stdcall-unwind",
     system_dash_unwind = "system-unwind",
     sysv64_dash_unwind = "sysv64-unwind",