Rollup merge of #136603 - workingjubilee:move-abi-versioning-into-ast, r=compiler-errors

compiler: gate `extern "{abi}"` in ast_lowering

I don't believe low-level crates like `rustc_abi` should have to know or care about higher-level concerns like whether the ABI string is stable for users. These implementation details can be made less open to public inspection. This way the code that governs stability is near the code that enforces stability, and compiled together.

It also abstracts away certain error messages instead of constantly repeating them.

A few error messages are simply deleted outright, instead of made uniform, because they are either too dated to be useful or redundant with other diagnostic improvements we could make. These can be pursued in followups: my first concern was making sure there wasn't unnecessary diagnostics-related code in `rustc_abi`, which is not well-positioned to understand what kind of errors are going to be generated based on how it is used.

r? ``@ghost``

62 files changed, 395 insertions, 420 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 2ee2c52b32a..f08a95380c4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3317,7 +3317,6 @@ dependencies = [
  "rand 0.8.5",
  "rand_xoshiro",
  "rustc_data_structures",
- "rustc_feature",
  "rustc_index",
  "rustc_macros",
  "rustc_serialize",
@@ -3379,6 +3378,7 @@ dependencies = [
  "rustc_ast_pretty",
  "rustc_data_structures",
  "rustc_errors",
+ "rustc_feature",
  "rustc_fluent_macro",
  "rustc_hir",
  "rustc_index",
@@ -3683,6 +3683,7 @@ version = "0.0.0"
 dependencies = [
  "ctrlc",
  "libc",
+ "rustc_abi",
  "rustc_ast",
  "rustc_ast_lowering",
  "rustc_ast_passes",
@@ -4337,6 +4338,7 @@ version = "0.0.0"
 dependencies = [
  "rustc_abi",
  "rustc_ast",
+ "rustc_ast_lowering",
  "rustc_ast_pretty",
  "rustc_attr_parsing",
  "rustc_data_structures",
diff --git a/compiler/rustc_abi/Cargo.toml b/compiler/rustc_abi/Cargo.toml
index 3acd25e5461..1013f1d3958 100644
--- a/compiler/rustc_abi/Cargo.toml
+++ b/compiler/rustc_abi/Cargo.toml
@@ -9,7 +9,6 @@ bitflags = "2.4.1"
 rand = { version = "0.8.4", default-features = false, optional = true }
 rand_xoshiro = { version = "0.6.0", optional = true }
 rustc_data_structures = { path = "../rustc_data_structures", optional = true  }
-rustc_feature = { path = "../rustc_feature", optional = true }
 rustc_index = { path = "../rustc_index", default-features = false }
 rustc_macros = { path = "../rustc_macros", optional = true }
 rustc_serialize = { path = "../rustc_serialize", optional = true  }
@@ -24,7 +23,6 @@ default = ["nightly", "randomize"]
 # without depending on rustc_data_structures, rustc_macros and rustc_serialize
 nightly = [
     "dep:rustc_data_structures",
-    "dep:rustc_feature",
     "dep:rustc_macros",
     "dep:rustc_serialize",
     "dep:rustc_span",
diff --git a/compiler/rustc_abi/src/callconv.rs b/compiler/rustc_abi/src/callconv.rs
index daa365bf6e1..9fb70b80c9e 100644
--- a/compiler/rustc_abi/src/callconv.rs
+++ b/compiler/rustc_abi/src/callconv.rs
@@ -1,6 +1,5 @@
 #[cfg(feature = "nightly")]
-use crate::{BackendRepr, FieldsShape, TyAbiInterface, TyAndLayout};
-use crate::{Primitive, Size, Variants};
+use crate::{BackendRepr, FieldsShape, Primitive, Size, TyAbiInterface, TyAndLayout, Variants};
 
 mod reg;
 
diff --git a/compiler/rustc_abi/src/extern_abi.rs b/compiler/rustc_abi/src/extern_abi.rs
index 130834d560f..f3cf7f583ce 100644
--- a/compiler/rustc_abi/src/extern_abi.rs
+++ b/compiler/rustc_abi/src/extern_abi.rs
@@ -1,7 +1,6 @@
 use std::fmt;
 
 use rustc_macros::{Decodable, Encodable, HashStable_Generic};
-use rustc_span::{Span, Symbol, sym};
 
 #[cfg(test)]
 mod tests;
@@ -95,14 +94,14 @@ impl Abi {
 
 #[derive(Copy, Clone)]
 pub struct AbiData {
-    abi: Abi,
+    pub abi: Abi,
 
     /// Name of this ABI as we like it called.
-    name: &'static str,
+    pub name: &'static str,
 }
 
 #[allow(non_upper_case_globals)]
-const AbiDatas: &[AbiData] = &[
+pub const AbiDatas: &[AbiData] = &[
     AbiData { abi: Abi::Rust, name: "Rust" },
     AbiData { abi: Abi::C { unwind: false }, name: "C" },
     AbiData { abi: Abi::C { unwind: true }, name: "C-unwind" },
@@ -142,129 +141,18 @@ const AbiDatas: &[AbiData] = &[
 ];
 
 #[derive(Copy, Clone, Debug)]
-pub enum AbiUnsupported {
-    Unrecognized,
-    Reason { explain: &'static str },
-}
-
+pub struct AbiUnsupported {}
 /// Returns the ABI with the given name (if any).
 pub fn lookup(name: &str) -> Result<Abi, AbiUnsupported> {
-    AbiDatas.iter().find(|abi_data| name == abi_data.name).map(|&x| x.abi).ok_or_else(|| match name {
-        "riscv-interrupt" => AbiUnsupported::Reason {
-            explain: "please use one of riscv-interrupt-m or riscv-interrupt-s for machine- or supervisor-level interrupts, respectively",
-        },
-        "riscv-interrupt-u" => AbiUnsupported::Reason {
-            explain: "user-mode interrupt handlers have been removed from LLVM pending standardization, see: https://reviews.llvm.org/D149314",
-        },
-        "wasm" => AbiUnsupported::Reason {
-            explain: "non-standard wasm ABI is no longer supported",
-        },
-
-        _ => AbiUnsupported::Unrecognized,
-
-    })
-}
-
-pub fn all_names() -> Vec<&'static str> {
-    AbiDatas.iter().map(|d| d.name).collect()
-}
-
-pub fn enabled_names(features: &rustc_feature::Features, span: Span) -> Vec<&'static str> {
     AbiDatas
         .iter()
-        .map(|d| d.name)
-        .filter(|name| is_enabled(features, span, name).is_ok())
-        .collect()
+        .find(|abi_data| name == abi_data.name)
+        .map(|&x| x.abi)
+        .ok_or_else(|| AbiUnsupported {})
 }
 
-pub enum AbiDisabled {
-    Unstable { feature: Symbol, explain: &'static str },
-    Unrecognized,
-}
-
-pub fn is_enabled(
-    features: &rustc_feature::Features,
-    span: Span,
-    name: &str,
-) -> Result<(), AbiDisabled> {
-    let s = is_stable(name);
-    if let Err(AbiDisabled::Unstable { feature, .. }) = s {
-        if features.enabled(feature) || span.allows_unstable(feature) {
-            return Ok(());
-        }
-    }
-    s
-}
-
-/// Returns whether the ABI is stable to use.
-///
-/// Note that there is a separate check determining whether the ABI is even supported
-/// on the current target; see `fn is_abi_supported` in `rustc_target::spec`.
-pub fn is_stable(name: &str) -> Result<(), AbiDisabled> {
-    match name {
-        // Stable
-        "Rust" | "C" | "C-unwind" | "cdecl" | "cdecl-unwind" | "stdcall" | "stdcall-unwind"
-        | "fastcall" | "fastcall-unwind" | "aapcs" | "aapcs-unwind" | "win64" | "win64-unwind"
-        | "sysv64" | "sysv64-unwind" | "system" | "system-unwind" | "efiapi" | "thiscall"
-        | "thiscall-unwind" => Ok(()),
-        "rust-intrinsic" => Err(AbiDisabled::Unstable {
-            feature: sym::intrinsics,
-            explain: "intrinsics are subject to change",
-        }),
-        "vectorcall" => Err(AbiDisabled::Unstable {
-            feature: sym::abi_vectorcall,
-            explain: "vectorcall is experimental and subject to change",
-        }),
-        "vectorcall-unwind" => Err(AbiDisabled::Unstable {
-            feature: sym::abi_vectorcall,
-            explain: "vectorcall-unwind ABI is experimental and subject to change",
-        }),
-        "rust-call" => Err(AbiDisabled::Unstable {
-            feature: sym::unboxed_closures,
-            explain: "rust-call ABI is subject to change",
-        }),
-        "rust-cold" => Err(AbiDisabled::Unstable {
-            feature: sym::rust_cold_cc,
-            explain: "rust-cold is experimental and subject to change",
-        }),
-        "ptx-kernel" => Err(AbiDisabled::Unstable {
-            feature: sym::abi_ptx,
-            explain: "PTX ABIs are experimental and subject to change",
-        }),
-        "unadjusted" => Err(AbiDisabled::Unstable {
-            feature: sym::abi_unadjusted,
-            explain: "unadjusted ABI is an implementation detail and perma-unstable",
-        }),
-        "msp430-interrupt" => Err(AbiDisabled::Unstable {
-            feature: sym::abi_msp430_interrupt,
-            explain: "msp430-interrupt ABI is experimental and subject to change",
-        }),
-        "x86-interrupt" => Err(AbiDisabled::Unstable {
-            feature: sym::abi_x86_interrupt,
-            explain: "x86-interrupt ABI is experimental and subject to change",
-        }),
-        "gpu-kernel" => Err(AbiDisabled::Unstable {
-            feature: sym::abi_gpu_kernel,
-            explain: "gpu-kernel ABI is experimental and subject to change",
-        }),
-        "avr-interrupt" | "avr-non-blocking-interrupt" => Err(AbiDisabled::Unstable {
-            feature: sym::abi_avr_interrupt,
-            explain: "avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change",
-        }),
-        "riscv-interrupt-m" | "riscv-interrupt-s" => Err(AbiDisabled::Unstable {
-            feature: sym::abi_riscv_interrupt,
-            explain: "riscv-interrupt ABIs are experimental and subject to change",
-        }),
-        "C-cmse-nonsecure-call" => Err(AbiDisabled::Unstable {
-            feature: sym::abi_c_cmse_nonsecure_call,
-            explain: "C-cmse-nonsecure-call ABI is experimental and subject to change",
-        }),
-        "C-cmse-nonsecure-entry" => Err(AbiDisabled::Unstable {
-            feature: sym::cmse_nonsecure_entry,
-            explain: "C-cmse-nonsecure-entry ABI is experimental and subject to change",
-        }),
-        _ => Err(AbiDisabled::Unrecognized),
-    }
+pub fn all_names() -> Vec<&'static str> {
+    AbiDatas.iter().map(|d| d.name).collect()
 }
 
 impl Abi {
diff --git a/compiler/rustc_abi/src/extern_abi/tests.rs b/compiler/rustc_abi/src/extern_abi/tests.rs
index 4823058dd69..72c0f183d50 100644
--- a/compiler/rustc_abi/src/extern_abi/tests.rs
+++ b/compiler/rustc_abi/src/extern_abi/tests.rs
@@ -18,7 +18,7 @@ fn lookup_cdecl() {
 #[test]
 fn lookup_baz() {
     let abi = lookup("baz");
-    assert_matches!(abi, Err(AbiUnsupported::Unrecognized));
+    assert_matches!(abi, Err(AbiUnsupported {}));
 }
 
 #[test]
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index fc34b288933..259f1c18ea8 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -66,9 +66,7 @@ mod extern_abi;
 
 pub use callconv::{Heterogeneous, HomogeneousAggregate, Reg, RegKind};
 #[cfg(feature = "nightly")]
-pub use extern_abi::{
-    AbiDisabled, AbiUnsupported, ExternAbi, all_names, enabled_names, is_enabled, is_stable, lookup,
-};
+pub use extern_abi::{AbiDatas, AbiUnsupported, ExternAbi, all_names, lookup};
 #[cfg(feature = "nightly")]
 pub use layout::{FIRST_VARIANT, FieldIdx, Layout, TyAbiInterface, TyAndLayout, VariantIdx};
 pub use layout::{LayoutCalculator, LayoutCalculatorError};
diff --git a/compiler/rustc_ast_lowering/Cargo.toml b/compiler/rustc_ast_lowering/Cargo.toml
index 754f3c1a6e9..ce95f4dfa1b 100644
--- a/compiler/rustc_ast_lowering/Cargo.toml
+++ b/compiler/rustc_ast_lowering/Cargo.toml
@@ -13,6 +13,7 @@ rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
+rustc_feature = { path = "../rustc_feature" }
 rustc_fluent_macro = { path = "../rustc_fluent_macro" }
 rustc_hir = { path = "../rustc_hir" }
 rustc_index = { path = "../rustc_index" }
diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
index f9fe4938ca8..d8b7cb0c322 100644
--- a/compiler/rustc_ast_lowering/src/delegation.rs
+++ b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -41,13 +41,13 @@ use std::iter;
 use ast::visit::Visitor;
 use hir::def::{DefKind, PartialRes, Res};
 use hir::{BodyId, HirId};
+use rustc_abi::ExternAbi;
 use rustc_ast::*;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def_id::DefId;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{Asyncness, ResolverAstLowering};
 use rustc_span::{Ident, Span};
-use rustc_target::spec::abi;
 use {rustc_ast as ast, rustc_hir as hir};
 
 use super::{GenericArgsMode, ImplTraitContext, LoweringContext, ParamMode};
@@ -398,7 +398,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             safety: hir::Safety::Safe.into(),
             constness: hir::Constness::NotConst,
             asyncness: hir::IsAsync::NotAsync,
-            abi: abi::Abi::Rust,
+            abi: ExternAbi::Rust,
         }
     }
 
diff --git a/compiler/rustc_ast_lowering/src/errors.rs b/compiler/rustc_ast_lowering/src/errors.rs
index f727691bf47..9f69387b7b7 100644
--- a/compiler/rustc_ast_lowering/src/errors.rs
+++ b/compiler/rustc_ast_lowering/src/errors.rs
@@ -1,5 +1,5 @@
+use rustc_errors::DiagArgFromDisplay;
 use rustc_errors::codes::*;
-use rustc_errors::{Diag, DiagArgFromDisplay, EmissionGuarantee, SubdiagMessageOp, Subdiagnostic};
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Ident, Span, Symbol};
 
@@ -32,8 +32,6 @@ pub(crate) struct InvalidAbi {
     pub abi: Symbol,
     pub command: String,
     #[subdiagnostic]
-    pub explain: Option<InvalidAbiReason>,
-    #[subdiagnostic]
     pub suggestion: Option<InvalidAbiSuggestion>,
 }
 
@@ -45,19 +43,6 @@ pub(crate) struct TupleStructWithDefault {
     pub span: Span,
 }
 
-pub(crate) struct InvalidAbiReason(pub &'static str);
-
-impl Subdiagnostic for InvalidAbiReason {
-    fn add_to_diag_with<G: EmissionGuarantee, F: SubdiagMessageOp<G>>(
-        self,
-        diag: &mut Diag<'_, G>,
-        _: &F,
-    ) {
-        #[allow(rustc::untranslatable_diagnostic)]
-        diag.note(self.0);
-    }
-}
-
 #[derive(Subdiagnostic)]
 #[suggestion(
     ast_lowering_invalid_abi_suggestion,
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index 7379a3d2cde..75b08e16cdb 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -17,9 +17,9 @@ use thin_vec::ThinVec;
 use tracing::instrument;
 
 use super::errors::{
-    InvalidAbi, InvalidAbiReason, InvalidAbiSuggestion, MisplacedRelaxTraitBound,
-    TupleStructWithDefault,
+    InvalidAbi, InvalidAbiSuggestion, MisplacedRelaxTraitBound, TupleStructWithDefault,
 };
+use super::stability::{enabled_names, gate_unstable_abi};
 use super::{
     AstOwner, FnDeclKind, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
     ResolverAstLoweringExt,
@@ -1479,11 +1479,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    pub(super) fn lower_abi(&mut self, abi: StrLit) -> ExternAbi {
-        rustc_abi::lookup(abi.symbol_unescaped.as_str()).unwrap_or_else(|err| {
-            self.error_on_invalid_abi(abi, err);
+    pub(super) fn lower_abi(&mut self, abi_str: StrLit) -> ExternAbi {
+        let ast::StrLit { symbol_unescaped, span, .. } = abi_str;
+        let extern_abi = rustc_abi::lookup(symbol_unescaped.as_str()).unwrap_or_else(|_| {
+            self.error_on_invalid_abi(abi_str);
             ExternAbi::Rust
-        })
+        });
+        let sess = self.tcx.sess;
+        let features = self.tcx.features();
+        gate_unstable_abi(sess, features, span, extern_abi);
+        extern_abi
     }
 
     pub(super) fn lower_extern(&mut self, ext: Extern) -> ExternAbi {
@@ -1494,8 +1499,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn error_on_invalid_abi(&self, abi: StrLit, err: rustc_abi::AbiUnsupported) {
-        let abi_names = rustc_abi::enabled_names(self.tcx.features(), abi.span)
+    fn error_on_invalid_abi(&self, abi: StrLit) {
+        let abi_names = enabled_names(self.tcx.features(), abi.span)
             .iter()
             .map(|s| Symbol::intern(s))
             .collect::<Vec<_>>();
@@ -1503,10 +1508,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.dcx().emit_err(InvalidAbi {
             abi: abi.symbol_unescaped,
             span: abi.span,
-            explain: match err {
-                rustc_abi::AbiUnsupported::Reason { explain } => Some(InvalidAbiReason(explain)),
-                _ => None,
-            },
             suggestion: suggested_name.map(|suggested_name| InvalidAbiSuggestion {
                 span: abi.span,
                 suggestion: format!("\"{suggested_name}\""),
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 127b7e3684e..3fecb9e9c7e 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -84,6 +84,7 @@ mod index;
 mod item;
 mod pat;
 mod path;
+pub mod stability;
 
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
 
diff --git a/compiler/rustc_ast_lowering/src/stability.rs b/compiler/rustc_ast_lowering/src/stability.rs
new file mode 100644
index 00000000000..e7c166850a4
--- /dev/null
+++ b/compiler/rustc_ast_lowering/src/stability.rs
@@ -0,0 +1,147 @@
+use std::fmt;
+
+use rustc_abi::ExternAbi;
+use rustc_feature::Features;
+use rustc_session::Session;
+use rustc_session::parse::feature_err;
+use rustc_span::symbol::sym;
+use rustc_span::{Span, Symbol};
+
+pub(crate) fn enabled_names(features: &rustc_feature::Features, span: Span) -> Vec<&'static str> {
+    rustc_abi::AbiDatas
+        .iter()
+        .filter(|data| extern_abi_enabled(features, span, data.abi).is_ok())
+        .map(|d| d.name)
+        .collect()
+}
+
+pub(crate) fn extern_abi_enabled(
+    features: &rustc_feature::Features,
+    span: Span,
+    abi: ExternAbi,
+) -> Result<(), UnstableAbi> {
+    extern_abi_stability(abi).or_else(|unstable @ UnstableAbi { feature, .. }| {
+        if features.enabled(feature) || span.allows_unstable(feature) {
+            Ok(())
+        } else {
+            Err(unstable)
+        }
+    })
+}
+
+#[allow(rustc::untranslatable_diagnostic)]
+pub(crate) fn gate_unstable_abi(sess: &Session, features: &Features, span: Span, abi: ExternAbi) {
+    match extern_abi_enabled(features, span, abi) {
+        Ok(_) => (),
+        Err(unstable_abi) => {
+            let explain = unstable_abi.to_string();
+            feature_err(sess, unstable_abi.feature, span, explain).emit();
+        }
+    }
+}
+
+pub struct UnstableAbi {
+    abi: ExternAbi,
+    feature: Symbol,
+    explain: GateReason,
+}
+
+enum GateReason {
+    Experimental,
+    ImplDetail,
+}
+
+impl fmt::Display for UnstableAbi {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self { abi, .. } = self;
+        let name = abi.to_string();
+        let name = name.trim_matches('"');
+        match self.explain {
+            GateReason::Experimental => {
+                write!(f, r#"the extern "{name}" ABI is experimental and subject to change"#)
+            }
+            GateReason::ImplDetail => {
+                write!(
+                    f,
+                    r#"the extern "{name}" ABI is an implementation detail and perma-unstable"#
+                )
+            }
+        }
+    }
+}
+
+pub fn extern_abi_stability(abi: ExternAbi) -> Result<(), UnstableAbi> {
+    match abi {
+        // stable ABIs
+        ExternAbi::Rust
+        | ExternAbi::C { .. }
+        | ExternAbi::Cdecl { .. }
+        | ExternAbi::Stdcall { .. }
+        | ExternAbi::Fastcall { .. }
+        | ExternAbi::Thiscall { .. }
+        | ExternAbi::Aapcs { .. }
+        | ExternAbi::Win64 { .. }
+        | ExternAbi::SysV64 { .. }
+        | ExternAbi::System { .. }
+        | ExternAbi::EfiApi => Ok(()),
+        // implementation details
+        ExternAbi::RustIntrinsic => {
+            Err(UnstableAbi { abi, feature: sym::intrinsics, explain: GateReason::ImplDetail })
+        }
+        ExternAbi::Unadjusted => {
+            Err(UnstableAbi { abi, feature: sym::abi_unadjusted, explain: GateReason::ImplDetail })
+        }
+        // experimental
+        ExternAbi::Vectorcall { .. } => Err(UnstableAbi {
+            abi,
+            feature: sym::abi_vectorcall,
+            explain: GateReason::Experimental,
+        }),
+        ExternAbi::RustCall => Err(UnstableAbi {
+            abi,
+            feature: sym::unboxed_closures,
+            explain: GateReason::Experimental,
+        }),
+        ExternAbi::RustCold => {
+            Err(UnstableAbi { abi, feature: sym::rust_cold_cc, explain: GateReason::Experimental })
+        }
+        ExternAbi::GpuKernel => Err(UnstableAbi {
+            abi,
+            feature: sym::abi_gpu_kernel,
+            explain: GateReason::Experimental,
+        }),
+        ExternAbi::PtxKernel => {
+            Err(UnstableAbi { abi, feature: sym::abi_ptx, explain: GateReason::Experimental })
+        }
+        ExternAbi::Msp430Interrupt => Err(UnstableAbi {
+            abi,
+            feature: sym::abi_msp430_interrupt,
+            explain: GateReason::Experimental,
+        }),
+        ExternAbi::X86Interrupt => Err(UnstableAbi {
+            abi,
+            feature: sym::abi_x86_interrupt,
+            explain: GateReason::Experimental,
+        }),
+        ExternAbi::AvrInterrupt | ExternAbi::AvrNonBlockingInterrupt => Err(UnstableAbi {
+            abi,
+            feature: sym::abi_avr_interrupt,
+            explain: GateReason::Experimental,
+        }),
+        ExternAbi::RiscvInterruptM | ExternAbi::RiscvInterruptS => Err(UnstableAbi {
+            abi,
+            feature: sym::abi_riscv_interrupt,
+            explain: GateReason::Experimental,
+        }),
+        ExternAbi::CCmseNonSecureCall => Err(UnstableAbi {
+            abi,
+            feature: sym::abi_c_cmse_nonsecure_call,
+            explain: GateReason::Experimental,
+        }),
+        ExternAbi::CCmseNonSecureEntry => Err(UnstableAbi {
+            abi,
+            feature: sym::cmse_nonsecure_entry,
+            explain: GateReason::Experimental,
+        }),
+    }
+}
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 0049c5b4823..f9f4035cb22 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -20,6 +20,7 @@ use std::mem;
 use std::ops::{Deref, DerefMut};
 
 use itertools::{Either, Itertools};
+use rustc_abi::ExternAbi;
 use rustc_ast::ptr::P;
 use rustc_ast::visit::{AssocCtxt, BoundKind, FnCtxt, FnKind, Visitor, walk_list};
 use rustc_ast::*;
@@ -35,7 +36,6 @@ use rustc_session::lint::builtin::{
 };
 use rustc_session::lint::{BuiltinLintDiag, LintBuffer};
 use rustc_span::{Ident, Span, kw, sym};
-use rustc_target::spec::abi;
 use thin_vec::thin_vec;
 
 use crate::errors::{self, TildeConstReason};
@@ -723,7 +723,7 @@ impl<'a> AstValidator<'a> {
                 MISSING_ABI,
                 id,
                 span,
-                BuiltinLintDiag::MissingAbi(span, abi::Abi::FALLBACK),
+                BuiltinLintDiag::MissingAbi(span, ExternAbi::FALLBACK),
             )
         }
     }
diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index 13294efdaf6..e5d8013058f 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -1,9 +1,9 @@
 use rustc_ast as ast;
 use rustc_ast::visit::{self, AssocCtxt, FnCtxt, FnKind, Visitor};
 use rustc_ast::{NodeId, PatKind, attr, token};
-use rustc_feature::{AttributeGate, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute, Features, GateIssue};
+use rustc_feature::{AttributeGate, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute, Features};
 use rustc_session::Session;
-use rustc_session::parse::{feature_err, feature_err_issue, feature_warn};
+use rustc_session::parse::{feature_err, feature_warn};
 use rustc_span::source_map::Spanned;
 use rustc_span::{Span, Symbol, sym};
 use thin_vec::ThinVec;
@@ -72,35 +72,6 @@ struct PostExpansionVisitor<'a> {
 }
 
 impl<'a> PostExpansionVisitor<'a> {
-    #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
-    fn check_abi(&self, abi: ast::StrLit) {
-        let ast::StrLit { symbol_unescaped, span, .. } = abi;
-
-        match rustc_abi::is_enabled(self.features, span, symbol_unescaped.as_str()) {
-            Ok(()) => (),
-            Err(rustc_abi::AbiDisabled::Unstable { feature, explain }) => {
-                feature_err_issue(&self.sess, feature, span, GateIssue::Language, explain).emit();
-            }
-            Err(rustc_abi::AbiDisabled::Unrecognized) => {
-                if self.sess.opts.pretty.is_none_or(|ppm| ppm.needs_hir()) {
-                    self.sess.dcx().span_delayed_bug(
-                        span,
-                        format!(
-                            "unrecognized ABI not caught in lowering: {}",
-                            symbol_unescaped.as_str()
-                        ),
-                    );
-                }
-            }
-        }
-    }
-
-    fn check_extern(&self, ext: ast::Extern) {
-        if let ast::Extern::Explicit(abi, _) = ext {
-            self.check_abi(abi);
-        }
-    }
-
     /// Feature gate `impl Trait` inside `type Alias = $type_expr;`.
     fn check_impl_trait(&self, ty: &ast::Ty, in_associated_ty: bool) {
         struct ImplTraitVisitor<'a> {
@@ -223,12 +194,9 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
 
     fn visit_item(&mut self, i: &'a ast::Item) {
         match &i.kind {
-            ast::ItemKind::ForeignMod(foreign_module) => {
-                if let Some(abi) = foreign_module.abi {
-                    self.check_abi(abi);
-                }
+            ast::ItemKind::ForeignMod(_foreign_module) => {
+                // handled during lowering
             }
-
             ast::ItemKind::Struct(..) | ast::ItemKind::Enum(..) | ast::ItemKind::Union(..) => {
                 for attr in attr::filter_by_name(&i.attrs, sym::repr) {
                     for item in attr.meta_item_list().unwrap_or_else(ThinVec::new) {
@@ -315,7 +283,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
         match &ty.kind {
             ast::TyKind::BareFn(bare_fn_ty) => {
                 // Function pointers cannot be `const`
-                self.check_extern(bare_fn_ty.ext);
                 self.check_late_bound_lifetime_defs(&bare_fn_ty.generic_params);
             }
             ast::TyKind::Never => {
@@ -418,9 +385,8 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
     }
 
     fn visit_fn(&mut self, fn_kind: FnKind<'a>, span: Span, _: NodeId) {
-        if let Some(header) = fn_kind.header() {
+        if let Some(_header) = fn_kind.header() {
             // Stability of const fn methods are covered in `visit_assoc_item` below.
-            self.check_extern(header.ext);
         }
 
         if let FnKind::Closure(ast::ClosureBinder::For { generic_params, .. }, ..) = fn_kind {
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 2c38fb5658f..1d8f61806f5 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -1,5 +1,6 @@
 use std::str::FromStr;
 
+use rustc_abi::ExternAbi;
 use rustc_ast::attr::list_contains_name;
 use rustc_ast::expand::autodiff_attrs::{
     AutoDiffAttrs, DiffActivity, DiffMode, valid_input_activity, valid_ret_activity,
@@ -23,7 +24,7 @@ use rustc_middle::ty::{self as ty, TyCtxt};
 use rustc_session::parse::feature_err;
 use rustc_session::{Session, lint};
 use rustc_span::{Ident, Span, sym};
-use rustc_target::spec::{SanitizerSet, abi};
+use rustc_target::spec::SanitizerSet;
 use tracing::debug;
 
 use crate::errors;
@@ -219,7 +220,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
 
                 if !is_closure
                     && let Some(fn_sig) = fn_sig()
-                    && fn_sig.skip_binder().abi() != abi::Abi::Rust
+                    && fn_sig.skip_binder().abi() != ExternAbi::Rust
                 {
                     struct_span_code_err!(
                         tcx.dcx(),
diff --git a/compiler/rustc_driver_impl/Cargo.toml b/compiler/rustc_driver_impl/Cargo.toml
index 07b88e59723..0b45e5786e8 100644
--- a/compiler/rustc_driver_impl/Cargo.toml
+++ b/compiler/rustc_driver_impl/Cargo.toml
@@ -5,6 +5,7 @@ edition = "2021"
 
 [dependencies]
 # tidy-alphabetical-start
+rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_lowering = { path = "../rustc_ast_lowering" }
 rustc_ast_passes = { path = "../rustc_ast_passes" }
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 4c47ce93dd5..6efd11a8c3c 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -747,7 +747,7 @@ fn print_crate_info(
                 }
             }
             CallingConventions => {
-                let mut calling_conventions = rustc_target::spec::abi::all_names();
+                let mut calling_conventions = rustc_abi::all_names();
                 calling_conventions.sort_unstable();
                 println_info!("{}", calling_conventions.join("\n"));
             }
diff --git a/compiler/rustc_passes/Cargo.toml b/compiler/rustc_passes/Cargo.toml
index 2b8a3b9ce23..f592a12ab75 100644
--- a/compiler/rustc_passes/Cargo.toml
+++ b/compiler/rustc_passes/Cargo.toml
@@ -7,6 +7,7 @@ edition = "2021"
 # tidy-alphabetical-start
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
+rustc_ast_lowering = { path = "../rustc_ast_lowering" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
 rustc_attr_parsing = { path = "../rustc_attr_parsing" }
 rustc_data_structures = { path = "../rustc_data_structures" }
diff --git a/compiler/rustc_passes/src/naked_functions.rs b/compiler/rustc_passes/src/naked_functions.rs
index 1e165b22e51..875b6edb58c 100644
--- a/compiler/rustc_passes/src/naked_functions.rs
+++ b/compiler/rustc_passes/src/naked_functions.rs
@@ -1,5 +1,6 @@
 //! Checks validity of naked functions.
 
+use rustc_abi::ExternAbi;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{LocalDefId, LocalModDefId};
@@ -11,7 +12,6 @@ use rustc_middle::span_bug;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::lint::builtin::UNDEFINED_NAKED_FUNCTION_ABI;
 use rustc_span::{Span, sym};
-use rustc_target::spec::abi::Abi;
 
 use crate::errors::{
     NakedAsmOutsideNakedFn, NakedFunctionsAsmBlock, NakedFunctionsMustNakedAsm, NoPatterns,
@@ -61,8 +61,8 @@ fn check_mod_naked_functions(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {
 }
 
 /// Checks that function uses non-Rust ABI.
-fn check_abi(tcx: TyCtxt<'_>, def_id: LocalDefId, abi: Abi) {
-    if abi == Abi::Rust {
+fn check_abi(tcx: TyCtxt<'_>, def_id: LocalDefId, abi: ExternAbi) {
+    if abi == ExternAbi::Rust {
         let hir_id = tcx.local_def_id_to_hir_id(def_id);
         let span = tcx.def_span(def_id);
         tcx.emit_node_span_lint(
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 34f1ca55c78..fd30d0d4867 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -4,6 +4,7 @@
 use std::mem::replace;
 use std::num::NonZero;
 
+use rustc_ast_lowering::stability::extern_abi_stability;
 use rustc_attr_parsing::{
     self as attr, ConstStability, DeprecatedSince, Stability, StabilityLevel, StableSince,
     UnstableReason, VERSION_PLACEHOLDER,
@@ -1027,8 +1028,8 @@ impl<'tcx> Visitor<'tcx> for CheckTraitImplStable<'tcx> {
         if let TyKind::Never = t.kind {
             self.fully_stable = false;
         }
-        if let TyKind::BareFn(f) = t.kind {
-            if rustc_target::spec::abi::is_stable(f.abi.name()).is_err() {
+        if let TyKind::BareFn(function) = t.kind {
+            if extern_abi_stability(function.abi).is_err() {
                 self.fully_stable = false;
             }
         }
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index df1862ec27e..810d8aa8200 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -57,13 +57,6 @@ use crate::spec::crt_objects::CrtObjects;
 
 pub mod crt_objects;
 
-pub mod abi {
-    pub use rustc_abi::{
-        AbiDisabled, AbiUnsupported, ExternAbi as Abi, all_names, enabled_names, is_enabled,
-        is_stable, lookup,
-    };
-}
-
 mod base;
 mod json;
 
diff --git a/tests/incremental/feature_gate.rs b/tests/incremental/feature_gate.rs
index 54c2dbb352e..332cf944b5d 100644
--- a/tests/incremental/feature_gate.rs
+++ b/tests/incremental/feature_gate.rs
@@ -10,4 +10,4 @@ fn main() {
 }
 
 extern "unadjusted" fn foo() {}
-//[cfail2]~^ ERROR: unadjusted ABI is an implementation detail and perma-unstable
+//[cfail2]~^ ERROR: "unadjusted" ABI is an implementation detail and perma-unstable
diff --git a/tests/ui/abi/removed-wasm-abi.rs b/tests/ui/abi/removed-wasm-abi.rs
deleted file mode 100644
index a45e42bfe02..00000000000
--- a/tests/ui/abi/removed-wasm-abi.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-extern "wasm" fn test() {}
-//~^ ERROR invalid ABI: found `wasm`
-
-fn main() {}
diff --git a/tests/ui/abi/riscv-discoverability-guidance.riscv32.stderr b/tests/ui/abi/riscv-discoverability-guidance.riscv32.stderr
index e80411fda34..e1f43347985 100644
--- a/tests/ui/abi/riscv-discoverability-guidance.riscv32.stderr
+++ b/tests/ui/abi/riscv-discoverability-guidance.riscv32.stderr
@@ -8,10 +8,9 @@ LL | extern "riscv-interrupt" fn isr() {}
    |        help: did you mean: `"riscv-interrupt-m"`
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
-   = note: please use one of riscv-interrupt-m or riscv-interrupt-s for machine- or supervisor-level interrupts, respectively
 
 error[E0703]: invalid ABI: found `riscv-interrupt-u`
-  --> $DIR/riscv-discoverability-guidance.rs:23:8
+  --> $DIR/riscv-discoverability-guidance.rs:22:8
    |
 LL | extern "riscv-interrupt-u" fn isr_U() {}
    |        ^^^^^^^^^^^^^^^^^^^
@@ -20,7 +19,6 @@ LL | extern "riscv-interrupt-u" fn isr_U() {}
    |        help: did you mean: `"riscv-interrupt-m"`
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
-   = note: user-mode interrupt handlers have been removed from LLVM pending standardization, see: https://reviews.llvm.org/D149314
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/abi/riscv-discoverability-guidance.riscv64.stderr b/tests/ui/abi/riscv-discoverability-guidance.riscv64.stderr
index e80411fda34..e1f43347985 100644
--- a/tests/ui/abi/riscv-discoverability-guidance.riscv64.stderr
+++ b/tests/ui/abi/riscv-discoverability-guidance.riscv64.stderr
@@ -8,10 +8,9 @@ LL | extern "riscv-interrupt" fn isr() {}
    |        help: did you mean: `"riscv-interrupt-m"`
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
-   = note: please use one of riscv-interrupt-m or riscv-interrupt-s for machine- or supervisor-level interrupts, respectively
 
 error[E0703]: invalid ABI: found `riscv-interrupt-u`
-  --> $DIR/riscv-discoverability-guidance.rs:23:8
+  --> $DIR/riscv-discoverability-guidance.rs:22:8
    |
 LL | extern "riscv-interrupt-u" fn isr_U() {}
    |        ^^^^^^^^^^^^^^^^^^^
@@ -20,7 +19,6 @@ LL | extern "riscv-interrupt-u" fn isr_U() {}
    |        help: did you mean: `"riscv-interrupt-m"`
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
-   = note: user-mode interrupt handlers have been removed from LLVM pending standardization, see: https://reviews.llvm.org/D149314
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/abi/riscv-discoverability-guidance.rs b/tests/ui/abi/riscv-discoverability-guidance.rs
index 1b189d907ba..dec5059b0a7 100644
--- a/tests/ui/abi/riscv-discoverability-guidance.rs
+++ b/tests/ui/abi/riscv-discoverability-guidance.rs
@@ -18,10 +18,8 @@ extern "riscv-interrupt" fn isr() {}
 //~^ ERROR invalid ABI
 //~^^ NOTE invalid ABI
 //~^^^ NOTE invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
-//~^^^^ NOTE please use one of riscv-interrupt-m or riscv-interrupt-s
 
 extern "riscv-interrupt-u" fn isr_U() {}
 //~^ ERROR invalid ABI
 //~^^ NOTE invalid ABI
 //~^^^ NOTE invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
-//~^^^^ NOTE user-mode interrupt handlers have been removed from LLVM pending standardization
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.stderr
index 120d5cc5293..63260b5c78f 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.stderr
@@ -1,4 +1,4 @@
-error[E0658]: C-cmse-nonsecure-call ABI is experimental and subject to change
+error[E0658]: the extern "C-cmse-nonsecure-call" ABI is experimental and subject to change
   --> $DIR/gate_test.rs:5:46
    |
 LL |         core::mem::transmute::<usize, extern "C-cmse-nonsecure-call" fn(i32, i32, i32, i32) -> i32>(
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/gate_test.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/gate_test.stderr
index dabf16cab30..0afbbe647af 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/gate_test.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/gate_test.stderr
@@ -1,4 +1,4 @@
-error[E0658]: C-cmse-nonsecure-entry ABI is experimental and subject to change
+error[E0658]: the extern "C-cmse-nonsecure-entry" ABI is experimental and subject to change
   --> $DIR/gate_test.rs:4:12
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
diff --git a/tests/ui/extern/fictional-abi.rs b/tests/ui/extern/fictional-abi.rs
new file mode 100644
index 00000000000..60b24f8856e
--- /dev/null
+++ b/tests/ui/extern/fictional-abi.rs
@@ -0,0 +1,3 @@
+#![crate_type = "lib"]
+
+pub extern "fictional" fn lol() {} //~ ERROR: invalid ABI
diff --git a/tests/ui/abi/removed-wasm-abi.stderr b/tests/ui/extern/fictional-abi.stderr
index 6007c4e2580..9784a57776f 100644
--- a/tests/ui/abi/removed-wasm-abi.stderr
+++ b/tests/ui/extern/fictional-abi.stderr
@@ -1,11 +1,10 @@
-error[E0703]: invalid ABI: found `wasm`
-  --> $DIR/removed-wasm-abi.rs:1:8
+error[E0703]: invalid ABI: found `fictional`
+  --> $DIR/fictional-abi.rs:3:12
    |
-LL | extern "wasm" fn test() {}
-   |        ^^^^^^ invalid ABI
+LL | pub extern "fictional" fn lol() {}
+   |            ^^^^^^^^^^^ invalid ABI
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
-   = note: non-standard wasm ABI is no longer supported
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.rs b/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.rs
index f37c5335deb..5386628a8e0 100644
--- a/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.rs
+++ b/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.rs
@@ -9,43 +9,43 @@ trait Sized { }
 // feature gate is not used.
 
 extern "avr-non-blocking-interrupt" fn fu() {}
-//~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+//~^ ERROR extern "avr-non-blocking-interrupt" ABI is experimental
 extern "avr-interrupt" fn f() {}
-//~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+//~^ ERROR extern "avr-interrupt" ABI is experimental
 
 trait T {
     extern "avr-interrupt" fn m();
-    //~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+    //~^ ERROR extern "avr-interrupt" ABI is experimental
     extern "avr-non-blocking-interrupt" fn mu();
-    //~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+    //~^ ERROR extern "avr-non-blocking-interrupt" ABI is experimental
 
     extern "avr-interrupt" fn dm() {}
-    //~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+    //~^ ERROR extern "avr-interrupt" ABI is experimental
     extern "avr-non-blocking-interrupt" fn dmu() {}
-    //~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+    //~^ ERROR extern "avr-non-blocking-interrupt" ABI is experimental
 }
 
 struct S;
 impl T for S {
     extern "avr-interrupt" fn m() {}
-    //~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+    //~^ ERROR extern "avr-interrupt" ABI is experimental
     extern "avr-non-blocking-interrupt" fn mu() {}
-    //~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+    //~^ ERROR extern "avr-non-blocking-interrupt" ABI is experimental
 }
 
 impl S {
     extern "avr-interrupt" fn im() {}
-    //~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+    //~^ ERROR extern "avr-interrupt" ABI is experimental
     extern "avr-non-blocking-interrupt" fn imu() {}
-    //~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+    //~^ ERROR extern "avr-non-blocking-interrupt" ABI is experimental
 }
 
 type TA = extern "avr-interrupt" fn();
-//~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+//~^ ERROR extern "avr-interrupt" ABI is experimental
 type TAU = extern "avr-non-blocking-interrupt" fn();
-//~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+//~^ ERROR extern "avr-non-blocking-interrupt" ABI is experimental
 
 extern "avr-interrupt" {}
-//~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+//~^ ERROR extern "avr-interrupt" ABI is experimental
 extern "avr-non-blocking-interrupt" {}
-//~^ ERROR avr-interrupt and avr-non-blocking-interrupt ABIs are experimental
+//~^ ERROR extern "avr-non-blocking-interrupt" ABI is experimental
diff --git a/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.stderr b/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.stderr
index c6786699de1..d9f3c3adc7f 100644
--- a/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.stderr
@@ -1,4 +1,4 @@
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:11:8
    |
 LL | extern "avr-non-blocking-interrupt" fn fu() {}
@@ -8,7 +8,7 @@ LL | extern "avr-non-blocking-interrupt" fn fu() {}
    = help: add `#![feature(abi_avr_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:13:8
    |
 LL | extern "avr-interrupt" fn f() {}
@@ -18,7 +18,7 @@ LL | extern "avr-interrupt" fn f() {}
    = help: add `#![feature(abi_avr_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:17:12
    |
 LL |     extern "avr-interrupt" fn m();
@@ -28,7 +28,7 @@ LL |     extern "avr-interrupt" fn m();
    = help: add `#![feature(abi_avr_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:19:12
    |
 LL |     extern "avr-non-blocking-interrupt" fn mu();
@@ -38,7 +38,7 @@ LL |     extern "avr-non-blocking-interrupt" fn mu();
    = help: add `#![feature(abi_avr_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:22:12
    |
 LL |     extern "avr-interrupt" fn dm() {}
@@ -48,7 +48,7 @@ LL |     extern "avr-interrupt" fn dm() {}
    = help: add `#![feature(abi_avr_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:24:12
    |
 LL |     extern "avr-non-blocking-interrupt" fn dmu() {}
@@ -58,7 +58,7 @@ LL |     extern "avr-non-blocking-interrupt" fn dmu() {}
    = help: add `#![feature(abi_avr_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:30:12
    |
 LL |     extern "avr-interrupt" fn m() {}
@@ -68,7 +68,7 @@ LL |     extern "avr-interrupt" fn m() {}
    = help: add `#![feature(abi_avr_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:32:12
    |
 LL |     extern "avr-non-blocking-interrupt" fn mu() {}
@@ -78,7 +78,7 @@ LL |     extern "avr-non-blocking-interrupt" fn mu() {}
    = help: add `#![feature(abi_avr_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:37:12
    |
 LL |     extern "avr-interrupt" fn im() {}
@@ -88,7 +88,7 @@ LL |     extern "avr-interrupt" fn im() {}
    = help: add `#![feature(abi_avr_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:39:12
    |
 LL |     extern "avr-non-blocking-interrupt" fn imu() {}
@@ -98,7 +98,7 @@ LL |     extern "avr-non-blocking-interrupt" fn imu() {}
    = help: add `#![feature(abi_avr_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:43:18
    |
 LL | type TA = extern "avr-interrupt" fn();
@@ -108,7 +108,7 @@ LL | type TA = extern "avr-interrupt" fn();
    = help: add `#![feature(abi_avr_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:45:19
    |
 LL | type TAU = extern "avr-non-blocking-interrupt" fn();
@@ -118,7 +118,7 @@ LL | type TAU = extern "avr-non-blocking-interrupt" fn();
    = help: add `#![feature(abi_avr_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:48:8
    |
 LL | extern "avr-interrupt" {}
@@ -128,7 +128,7 @@ LL | extern "avr-interrupt" {}
    = help: add `#![feature(abi_avr_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-avr-interrupt.rs:50:8
    |
 LL | extern "avr-non-blocking-interrupt" {}
diff --git a/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.rs b/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.rs
index b0fb4c414d4..bb69a638cee 100644
--- a/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.rs
+++ b/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.rs
@@ -6,29 +6,29 @@
 trait Sized { }
 
 extern "msp430-interrupt" fn f() {}
-//~^ ERROR msp430-interrupt ABI is experimental
+//~^ ERROR "msp430-interrupt" ABI is experimental
 
 trait T {
     extern "msp430-interrupt" fn m();
-    //~^ ERROR msp430-interrupt ABI is experimental
+    //~^ ERROR "msp430-interrupt" ABI is experimental
 
     extern "msp430-interrupt" fn dm() {}
-    //~^ ERROR msp430-interrupt ABI is experimental
+    //~^ ERROR "msp430-interrupt" ABI is experimental
 }
 
 struct S;
 impl T for S {
     extern "msp430-interrupt" fn m() {}
-    //~^ ERROR msp430-interrupt ABI is experimental
+    //~^ ERROR "msp430-interrupt" ABI is experimental
 }
 
 impl S {
     extern "msp430-interrupt" fn im() {}
-    //~^ ERROR msp430-interrupt ABI is experimental
+    //~^ ERROR "msp430-interrupt" ABI is experimental
 }
 
 type TA = extern "msp430-interrupt" fn();
-//~^ ERROR msp430-interrupt ABI is experimental
+//~^ ERROR "msp430-interrupt" ABI is experimental
 
 extern "msp430-interrupt" {}
-//~^ ERROR msp430-interrupt ABI is experimental
+//~^ ERROR "msp430-interrupt" ABI is experimental
diff --git a/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.stderr b/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.stderr
index 5dacc86dcc5..21ddbf7a86d 100644
--- a/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.stderr
@@ -1,4 +1,4 @@
-error[E0658]: msp430-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-msp430-interrupt.rs:8:8
    |
 LL | extern "msp430-interrupt" fn f() {}
@@ -8,7 +8,7 @@ LL | extern "msp430-interrupt" fn f() {}
    = help: add `#![feature(abi_msp430_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: msp430-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-msp430-interrupt.rs:12:12
    |
 LL |     extern "msp430-interrupt" fn m();
@@ -18,7 +18,7 @@ LL |     extern "msp430-interrupt" fn m();
    = help: add `#![feature(abi_msp430_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: msp430-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-msp430-interrupt.rs:15:12
    |
 LL |     extern "msp430-interrupt" fn dm() {}
@@ -28,7 +28,7 @@ LL |     extern "msp430-interrupt" fn dm() {}
    = help: add `#![feature(abi_msp430_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: msp430-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-msp430-interrupt.rs:21:12
    |
 LL |     extern "msp430-interrupt" fn m() {}
@@ -38,7 +38,7 @@ LL |     extern "msp430-interrupt" fn m() {}
    = help: add `#![feature(abi_msp430_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: msp430-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-msp430-interrupt.rs:26:12
    |
 LL |     extern "msp430-interrupt" fn im() {}
@@ -48,7 +48,7 @@ LL |     extern "msp430-interrupt" fn im() {}
    = help: add `#![feature(abi_msp430_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: msp430-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-msp430-interrupt.rs:30:18
    |
 LL | type TA = extern "msp430-interrupt" fn();
@@ -58,7 +58,7 @@ LL | type TA = extern "msp430-interrupt" fn();
    = help: add `#![feature(abi_msp430_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: msp430-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-msp430-interrupt.rs:33:8
    |
 LL | extern "msp430-interrupt" {}
diff --git a/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.rs b/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.rs
index 29820f8877d..6f4989fbd9f 100644
--- a/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.rs
+++ b/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.rs
@@ -9,25 +9,25 @@ trait Sized {}
 // feature gate is not used.
 
 extern "riscv-interrupt-m" fn f() {}
-//~^ ERROR riscv-interrupt ABIs are experimental
+//~^ ERROR "riscv-interrupt-m" ABI is experimental
 extern "riscv-interrupt-s" fn f_s() {}
-//~^ ERROR riscv-interrupt ABIs are experimental
+//~^ ERROR "riscv-interrupt-s" ABI is experimental
 
 trait T {
     extern "riscv-interrupt-m" fn m();
-    //~^ ERROR riscv-interrupt ABIs are experimental
+    //~^ ERROR "riscv-interrupt-m" ABI is experimental
 }
 
 struct S;
 impl T for S {
     extern "riscv-interrupt-m" fn m() {}
-    //~^ ERROR riscv-interrupt ABIs are experimental
+    //~^ ERROR "riscv-interrupt-m" ABI is experimental
 }
 
 impl S {
     extern "riscv-interrupt-m" fn im() {}
-    //~^ ERROR riscv-interrupt ABIs are experimental
+    //~^ ERROR "riscv-interrupt-m" ABI is experimental
 }
 
 type TA = extern "riscv-interrupt-m" fn();
-//~^ ERROR riscv-interrupt ABIs are experimental
+//~^ ERROR "riscv-interrupt-m" ABI is experimental
diff --git a/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.stderr b/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.stderr
index 6b7853a320b..3c9e99aa1b9 100644
--- a/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.stderr
@@ -1,4 +1,4 @@
-error[E0658]: riscv-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "riscv-interrupt-m" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-riscv-interrupt.rs:11:8
    |
 LL | extern "riscv-interrupt-m" fn f() {}
@@ -8,7 +8,7 @@ LL | extern "riscv-interrupt-m" fn f() {}
    = help: add `#![feature(abi_riscv_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: riscv-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "riscv-interrupt-s" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-riscv-interrupt.rs:13:8
    |
 LL | extern "riscv-interrupt-s" fn f_s() {}
@@ -18,7 +18,7 @@ LL | extern "riscv-interrupt-s" fn f_s() {}
    = help: add `#![feature(abi_riscv_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: riscv-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "riscv-interrupt-m" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-riscv-interrupt.rs:17:12
    |
 LL |     extern "riscv-interrupt-m" fn m();
@@ -28,7 +28,7 @@ LL |     extern "riscv-interrupt-m" fn m();
    = help: add `#![feature(abi_riscv_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: riscv-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "riscv-interrupt-m" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-riscv-interrupt.rs:23:12
    |
 LL |     extern "riscv-interrupt-m" fn m() {}
@@ -38,7 +38,7 @@ LL |     extern "riscv-interrupt-m" fn m() {}
    = help: add `#![feature(abi_riscv_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: riscv-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "riscv-interrupt-m" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-riscv-interrupt.rs:28:12
    |
 LL |     extern "riscv-interrupt-m" fn im() {}
@@ -48,7 +48,7 @@ LL |     extern "riscv-interrupt-m" fn im() {}
    = help: add `#![feature(abi_riscv_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: riscv-interrupt ABIs are experimental and subject to change
+error[E0658]: the extern "riscv-interrupt-m" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-riscv-interrupt.rs:32:18
    |
 LL | type TA = extern "riscv-interrupt-m" fn();
diff --git a/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.rs b/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.rs
index 812ca12c7c3..93c59364f10 100644
--- a/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.rs
+++ b/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.rs
@@ -5,24 +5,24 @@
 #[lang="sized"]
 trait Sized { }
 
-extern "x86-interrupt" fn f7() {} //~ ERROR x86-interrupt ABI is experimental
+extern "x86-interrupt" fn f7() {} //~ ERROR "x86-interrupt" ABI is experimental
 trait Tr {
-    extern "x86-interrupt" fn m7(); //~ ERROR x86-interrupt ABI is experimental
-    extern "x86-interrupt" fn dm7() {} //~ ERROR x86-interrupt ABI is experimental
+    extern "x86-interrupt" fn m7(); //~ ERROR "x86-interrupt" ABI is experimental
+    extern "x86-interrupt" fn dm7() {} //~ ERROR "x86-interrupt" ABI is experimental
 }
 
 struct S;
 
 // Methods in trait impl
 impl Tr for S {
-    extern "x86-interrupt" fn m7() {} //~ ERROR x86-interrupt ABI is experimental
+    extern "x86-interrupt" fn m7() {} //~ ERROR "x86-interrupt" ABI is experimental
 }
 
 // Methods in inherent impl
 impl S {
-    extern "x86-interrupt" fn im7() {} //~ ERROR x86-interrupt ABI is experimental
+    extern "x86-interrupt" fn im7() {} //~ ERROR "x86-interrupt" ABI is experimental
 }
 
-type A7 = extern "x86-interrupt" fn(); //~ ERROR x86-interrupt ABI is experimental
+type A7 = extern "x86-interrupt" fn(); //~ ERROR "x86-interrupt" ABI is experimental
 
-extern "x86-interrupt" {} //~ ERROR x86-interrupt ABI is experimental
+extern "x86-interrupt" {} //~ ERROR "x86-interrupt" ABI is experimental
diff --git a/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.stderr b/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.stderr
index 860005cac34..231cf207c86 100644
--- a/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.stderr
@@ -1,4 +1,4 @@
-error[E0658]: x86-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-x86-interrupt.rs:8:8
    |
 LL | extern "x86-interrupt" fn f7() {}
@@ -8,7 +8,7 @@ LL | extern "x86-interrupt" fn f7() {}
    = help: add `#![feature(abi_x86_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: x86-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-x86-interrupt.rs:10:12
    |
 LL |     extern "x86-interrupt" fn m7();
@@ -18,7 +18,7 @@ LL |     extern "x86-interrupt" fn m7();
    = help: add `#![feature(abi_x86_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: x86-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-x86-interrupt.rs:11:12
    |
 LL |     extern "x86-interrupt" fn dm7() {}
@@ -28,7 +28,7 @@ LL |     extern "x86-interrupt" fn dm7() {}
    = help: add `#![feature(abi_x86_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: x86-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-x86-interrupt.rs:18:12
    |
 LL |     extern "x86-interrupt" fn m7() {}
@@ -38,7 +38,7 @@ LL |     extern "x86-interrupt" fn m7() {}
    = help: add `#![feature(abi_x86_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: x86-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-x86-interrupt.rs:23:12
    |
 LL |     extern "x86-interrupt" fn im7() {}
@@ -48,7 +48,7 @@ LL |     extern "x86-interrupt" fn im7() {}
    = help: add `#![feature(abi_x86_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: x86-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-x86-interrupt.rs:26:18
    |
 LL | type A7 = extern "x86-interrupt" fn();
@@ -58,7 +58,7 @@ LL | type A7 = extern "x86-interrupt" fn();
    = help: add `#![feature(abi_x86_interrupt)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: x86-interrupt ABI is experimental and subject to change
+error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-x86-interrupt.rs:28:8
    |
 LL | extern "x86-interrupt" {}
diff --git a/tests/ui/feature-gates/feature-gate-abi.rs b/tests/ui/feature-gates/feature-gate-abi.rs
index 3aa430e736f..7ab05889c20 100644
--- a/tests/ui/feature-gates/feature-gate-abi.rs
+++ b/tests/ui/feature-gates/feature-gate-abi.rs
@@ -11,49 +11,49 @@ trait Sized { }
 trait Tuple { }
 
 // Functions
-extern "rust-intrinsic" fn f1() {} //~ ERROR intrinsics are subject to change
+extern "rust-intrinsic" fn f1() {} //~ ERROR extern "rust-intrinsic" ABI is an implementation detail
                                    //~^ ERROR intrinsic must be in
-extern "rust-intrinsic" fn f2() {} //~ ERROR intrinsics are subject to change
+extern "rust-intrinsic" fn f2() {} //~ ERROR extern "rust-intrinsic" ABI is an implementation detail
                                        //~^ ERROR intrinsic must be in
-extern "rust-call" fn f4(_: ()) {} //~ ERROR rust-call ABI is subject to change
+extern "rust-call" fn f4(_: ()) {} //~ ERROR extern "rust-call" ABI is experimental and subject to change
 
 // Methods in trait definition
 trait Tr {
-    extern "rust-intrinsic" fn m1(); //~ ERROR intrinsics are subject to change
+    extern "rust-intrinsic" fn m1(); //~ ERROR extern "rust-intrinsic" ABI is an implementation detail
                                      //~^ ERROR intrinsic must be in
-    extern "rust-intrinsic" fn m2(); //~ ERROR intrinsics are subject to change
+    extern "rust-intrinsic" fn m2(); //~ ERROR extern "rust-intrinsic" ABI is an implementation detail
                                          //~^ ERROR intrinsic must be in
-    extern "rust-call" fn m4(_: ()); //~ ERROR rust-call ABI is subject to change
+    extern "rust-call" fn m4(_: ()); //~ ERROR extern "rust-call" ABI is experimental and subject to change
 
-    extern "rust-call" fn dm4(_: ()) {} //~ ERROR rust-call ABI is subject to change
+    extern "rust-call" fn dm4(_: ()) {} //~ ERROR extern "rust-call" ABI is experimental and subject to change
 }
 
 struct S;
 
 // Methods in trait impl
 impl Tr for S {
-    extern "rust-intrinsic" fn m1() {} //~ ERROR intrinsics are subject to change
+    extern "rust-intrinsic" fn m1() {} //~ ERROR extern "rust-intrinsic" ABI is an implementation detail
                                        //~^ ERROR intrinsic must be in
-    extern "rust-intrinsic" fn m2() {} //~ ERROR intrinsics are subject to change
+    extern "rust-intrinsic" fn m2() {} //~ ERROR extern "rust-intrinsic" ABI is an implementation detail
                                            //~^ ERROR intrinsic must be in
-    extern "rust-call" fn m4(_: ()) {} //~ ERROR rust-call ABI is subject to change
+    extern "rust-call" fn m4(_: ()) {} //~ ERROR extern "rust-call" ABI is experimental and subject to change
 }
 
 // Methods in inherent impl
 impl S {
-    extern "rust-intrinsic" fn im1() {} //~ ERROR intrinsics are subject to change
+    extern "rust-intrinsic" fn im1() {} //~ ERROR extern "rust-intrinsic" ABI is an implementation detail
                                         //~^ ERROR intrinsic must be in
-    extern "rust-intrinsic" fn im2() {} //~ ERROR intrinsics are subject to change
+    extern "rust-intrinsic" fn im2() {} //~ ERROR extern "rust-intrinsic" ABI is an implementation detail
                                             //~^ ERROR intrinsic must be in
-    extern "rust-call" fn im4(_: ()) {} //~ ERROR rust-call ABI is subject to change
+    extern "rust-call" fn im4(_: ()) {} //~ ERROR extern "rust-call" ABI is experimental and subject to change
 }
 
 // Function pointer types
-type A1 = extern "rust-intrinsic" fn(); //~ ERROR intrinsics are subject to change
-type A2 = extern "rust-intrinsic" fn(); //~ ERROR intrinsics are subject to change
-type A4 = extern "rust-call" fn(_: ()); //~ ERROR rust-call ABI is subject to change
+type A1 = extern "rust-intrinsic" fn(); //~ ERROR extern "rust-intrinsic" ABI is an implementation detail
+type A2 = extern "rust-intrinsic" fn(); //~ ERROR extern "rust-intrinsic" ABI is an implementation detail
+type A4 = extern "rust-call" fn(_: ()); //~ ERROR extern "rust-call" ABI is experimental and subject to change
 
 // Foreign modules
-extern "rust-intrinsic" {} //~ ERROR intrinsics are subject to change
-extern "rust-intrinsic" {} //~ ERROR intrinsics are subject to change
-extern "rust-call" {} //~ ERROR rust-call ABI is subject to change
+extern "rust-intrinsic" {} //~ ERROR extern "rust-intrinsic" ABI is an implementation detail
+extern "rust-intrinsic" {} //~ ERROR extern "rust-intrinsic" ABI is an implementation detail
+extern "rust-call" {} //~ ERROR extern "rust-call" ABI is experimental and subject to change
diff --git a/tests/ui/feature-gates/feature-gate-abi.stderr b/tests/ui/feature-gates/feature-gate-abi.stderr
index dbdfa7b275d..70ec64e5135 100644
--- a/tests/ui/feature-gates/feature-gate-abi.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi.stderr
@@ -1,4 +1,4 @@
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-abi.rs:14:8
    |
 LL | extern "rust-intrinsic" fn f1() {}
@@ -7,7 +7,7 @@ LL | extern "rust-intrinsic" fn f1() {}
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-abi.rs:16:8
    |
 LL | extern "rust-intrinsic" fn f2() {}
@@ -16,7 +16,7 @@ LL | extern "rust-intrinsic" fn f2() {}
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-call ABI is subject to change
+error[E0658]: the extern "rust-call" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:18:8
    |
 LL | extern "rust-call" fn f4(_: ()) {}
@@ -26,7 +26,7 @@ LL | extern "rust-call" fn f4(_: ()) {}
    = help: add `#![feature(unboxed_closures)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-abi.rs:22:12
    |
 LL |     extern "rust-intrinsic" fn m1();
@@ -35,7 +35,7 @@ LL |     extern "rust-intrinsic" fn m1();
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-abi.rs:24:12
    |
 LL |     extern "rust-intrinsic" fn m2();
@@ -44,7 +44,7 @@ LL |     extern "rust-intrinsic" fn m2();
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-call ABI is subject to change
+error[E0658]: the extern "rust-call" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:26:12
    |
 LL |     extern "rust-call" fn m4(_: ());
@@ -54,7 +54,7 @@ LL |     extern "rust-call" fn m4(_: ());
    = help: add `#![feature(unboxed_closures)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-call ABI is subject to change
+error[E0658]: the extern "rust-call" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:28:12
    |
 LL |     extern "rust-call" fn dm4(_: ()) {}
@@ -64,7 +64,7 @@ LL |     extern "rust-call" fn dm4(_: ()) {}
    = help: add `#![feature(unboxed_closures)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-abi.rs:35:12
    |
 LL |     extern "rust-intrinsic" fn m1() {}
@@ -73,7 +73,7 @@ LL |     extern "rust-intrinsic" fn m1() {}
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-abi.rs:37:12
    |
 LL |     extern "rust-intrinsic" fn m2() {}
@@ -82,7 +82,7 @@ LL |     extern "rust-intrinsic" fn m2() {}
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-call ABI is subject to change
+error[E0658]: the extern "rust-call" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:39:12
    |
 LL |     extern "rust-call" fn m4(_: ()) {}
@@ -92,7 +92,7 @@ LL |     extern "rust-call" fn m4(_: ()) {}
    = help: add `#![feature(unboxed_closures)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-abi.rs:44:12
    |
 LL |     extern "rust-intrinsic" fn im1() {}
@@ -101,7 +101,7 @@ LL |     extern "rust-intrinsic" fn im1() {}
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-abi.rs:46:12
    |
 LL |     extern "rust-intrinsic" fn im2() {}
@@ -110,7 +110,7 @@ LL |     extern "rust-intrinsic" fn im2() {}
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-call ABI is subject to change
+error[E0658]: the extern "rust-call" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:48:12
    |
 LL |     extern "rust-call" fn im4(_: ()) {}
@@ -120,7 +120,7 @@ LL |     extern "rust-call" fn im4(_: ()) {}
    = help: add `#![feature(unboxed_closures)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-abi.rs:52:18
    |
 LL | type A1 = extern "rust-intrinsic" fn();
@@ -129,7 +129,7 @@ LL | type A1 = extern "rust-intrinsic" fn();
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-abi.rs:53:18
    |
 LL | type A2 = extern "rust-intrinsic" fn();
@@ -138,7 +138,7 @@ LL | type A2 = extern "rust-intrinsic" fn();
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-call ABI is subject to change
+error[E0658]: the extern "rust-call" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:54:18
    |
 LL | type A4 = extern "rust-call" fn(_: ());
@@ -148,7 +148,7 @@ LL | type A4 = extern "rust-call" fn(_: ());
    = help: add `#![feature(unboxed_closures)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-abi.rs:57:8
    |
 LL | extern "rust-intrinsic" {}
@@ -157,7 +157,7 @@ LL | extern "rust-intrinsic" {}
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-abi.rs:58:8
    |
 LL | extern "rust-intrinsic" {}
@@ -166,7 +166,7 @@ LL | extern "rust-intrinsic" {}
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-call ABI is subject to change
+error[E0658]: the extern "rust-call" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:59:8
    |
 LL | extern "rust-call" {}
diff --git a/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.rs b/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.rs
index 7d39820f086..fb04906dafe 100644
--- a/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.rs
+++ b/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.rs
@@ -10,14 +10,14 @@ trait Sized { }
 trait Tuple { }
 
 // Functions
-extern "gpu-kernel" fn f1(_: ()) {} //~ ERROR gpu-kernel ABI is experimental and subject to change
+extern "gpu-kernel" fn f1(_: ()) {} //~ ERROR "gpu-kernel" ABI is experimental and subject to change
 //~^ ERROR is not a supported ABI
 
 // Methods in trait definition
 trait Tr {
-    extern "gpu-kernel" fn m1(_: ()); //~ ERROR gpu-kernel ABI is experimental and subject to change
+    extern "gpu-kernel" fn m1(_: ()); //~ ERROR "gpu-kernel" ABI is experimental and subject to change
 
-    extern "gpu-kernel" fn dm1(_: ()) {} //~ ERROR gpu-kernel ABI is experimental and subject to change
+    extern "gpu-kernel" fn dm1(_: ()) {} //~ ERROR "gpu-kernel" ABI is experimental and subject to change
     //~^ ERROR is not a supported ABI
 }
 
@@ -25,21 +25,21 @@ struct S;
 
 // Methods in trait impl
 impl Tr for S {
-    extern "gpu-kernel" fn m1(_: ()) {} //~ ERROR gpu-kernel ABI is experimental and subject to change
+    extern "gpu-kernel" fn m1(_: ()) {} //~ ERROR "gpu-kernel" ABI is experimental and subject to change
     //~^ ERROR is not a supported ABI
 }
 
 // Methods in inherent impl
 impl S {
-    extern "gpu-kernel" fn im1(_: ()) {} //~ ERROR gpu-kernel ABI is experimental and subject to change
+    extern "gpu-kernel" fn im1(_: ()) {} //~ ERROR "gpu-kernel" ABI is experimental and subject to change
     //~^ ERROR is not a supported ABI
 }
 
 // Function pointer types
-type A1 = extern "gpu-kernel" fn(_: ()); //~ ERROR gpu-kernel ABI is experimental and subject to change
+type A1 = extern "gpu-kernel" fn(_: ()); //~ ERROR "gpu-kernel" ABI is experimental and subject to change
 //~^ WARN the calling convention "gpu-kernel" is not supported on this target
 //~^^ WARN this was previously accepted by the compiler but is being phased out
 
 // Foreign modules
-extern "gpu-kernel" {} //~ ERROR gpu-kernel ABI is experimental and subject to change
+extern "gpu-kernel" {} //~ ERROR "gpu-kernel" ABI is experimental and subject to change
 //~^ ERROR is not a supported ABI
diff --git a/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.stderr b/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.stderr
index 771c49acb97..b05c16e3d9e 100644
--- a/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.stderr
@@ -1,4 +1,4 @@
-error[E0658]: gpu-kernel ABI is experimental and subject to change
+error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_gpu_kernel.rs:13:8
    |
 LL | extern "gpu-kernel" fn f1(_: ()) {}
@@ -8,7 +8,7 @@ LL | extern "gpu-kernel" fn f1(_: ()) {}
    = help: add `#![feature(abi_gpu_kernel)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: gpu-kernel ABI is experimental and subject to change
+error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_gpu_kernel.rs:18:12
    |
 LL |     extern "gpu-kernel" fn m1(_: ());
@@ -18,7 +18,7 @@ LL |     extern "gpu-kernel" fn m1(_: ());
    = help: add `#![feature(abi_gpu_kernel)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: gpu-kernel ABI is experimental and subject to change
+error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_gpu_kernel.rs:20:12
    |
 LL |     extern "gpu-kernel" fn dm1(_: ()) {}
@@ -28,7 +28,7 @@ LL |     extern "gpu-kernel" fn dm1(_: ()) {}
    = help: add `#![feature(abi_gpu_kernel)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: gpu-kernel ABI is experimental and subject to change
+error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_gpu_kernel.rs:28:12
    |
 LL |     extern "gpu-kernel" fn m1(_: ()) {}
@@ -38,7 +38,7 @@ LL |     extern "gpu-kernel" fn m1(_: ()) {}
    = help: add `#![feature(abi_gpu_kernel)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: gpu-kernel ABI is experimental and subject to change
+error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_gpu_kernel.rs:34:12
    |
 LL |     extern "gpu-kernel" fn im1(_: ()) {}
@@ -48,7 +48,7 @@ LL |     extern "gpu-kernel" fn im1(_: ()) {}
    = help: add `#![feature(abi_gpu_kernel)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: gpu-kernel ABI is experimental and subject to change
+error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_gpu_kernel.rs:39:18
    |
 LL | type A1 = extern "gpu-kernel" fn(_: ());
@@ -58,7 +58,7 @@ LL | type A1 = extern "gpu-kernel" fn(_: ());
    = help: add `#![feature(abi_gpu_kernel)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: gpu-kernel ABI is experimental and subject to change
+error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_gpu_kernel.rs:44:8
    |
 LL | extern "gpu-kernel" {}
diff --git a/tests/ui/feature-gates/feature-gate-abi_ptx.rs b/tests/ui/feature-gates/feature-gate-abi_ptx.rs
index 83f48430281..e742492303a 100644
--- a/tests/ui/feature-gates/feature-gate-abi_ptx.rs
+++ b/tests/ui/feature-gates/feature-gate-abi_ptx.rs
@@ -5,22 +5,22 @@
 #[lang="sized"]
 trait Sized { }
 
-extern "ptx-kernel" fn fu() {} //~ ERROR PTX ABIs are experimental
+extern "ptx-kernel" fn fu() {} //~ ERROR extern "ptx-kernel" ABI is experimental
 
 trait T {
-    extern "ptx-kernel" fn mu(); //~ ERROR PTX ABIs are experimental
-    extern "ptx-kernel" fn dmu() {} //~ ERROR PTX ABIs are experimental
+    extern "ptx-kernel" fn mu(); //~ ERROR extern "ptx-kernel" ABI is experimental
+    extern "ptx-kernel" fn dmu() {} //~ ERROR extern "ptx-kernel" ABI is experimental
 }
 
 struct S;
 impl T for S {
-    extern "ptx-kernel" fn mu() {} //~ ERROR PTX ABIs are experimental
+    extern "ptx-kernel" fn mu() {} //~ ERROR extern "ptx-kernel" ABI is experimental
 }
 
 impl S {
-    extern "ptx-kernel" fn imu() {} //~ ERROR PTX ABIs are experimental
+    extern "ptx-kernel" fn imu() {} //~ ERROR extern "ptx-kernel" ABI is experimental
 }
 
-type TAU = extern "ptx-kernel" fn(); //~ ERROR PTX ABIs are experimental
+type TAU = extern "ptx-kernel" fn(); //~ ERROR extern "ptx-kernel" ABI is experimental
 
-extern "ptx-kernel" {} //~ ERROR PTX ABIs are experimental
+extern "ptx-kernel" {} //~ ERROR extern "ptx-kernel" ABI is experimental
diff --git a/tests/ui/feature-gates/feature-gate-abi_ptx.stderr b/tests/ui/feature-gates/feature-gate-abi_ptx.stderr
index 22b493e577d..d128075919b 100644
--- a/tests/ui/feature-gates/feature-gate-abi_ptx.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi_ptx.stderr
@@ -1,4 +1,4 @@
-error[E0658]: PTX ABIs are experimental and subject to change
+error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_ptx.rs:8:8
    |
 LL | extern "ptx-kernel" fn fu() {}
@@ -8,7 +8,7 @@ LL | extern "ptx-kernel" fn fu() {}
    = help: add `#![feature(abi_ptx)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: PTX ABIs are experimental and subject to change
+error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_ptx.rs:11:12
    |
 LL |     extern "ptx-kernel" fn mu();
@@ -18,7 +18,7 @@ LL |     extern "ptx-kernel" fn mu();
    = help: add `#![feature(abi_ptx)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: PTX ABIs are experimental and subject to change
+error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_ptx.rs:12:12
    |
 LL |     extern "ptx-kernel" fn dmu() {}
@@ -28,7 +28,7 @@ LL |     extern "ptx-kernel" fn dmu() {}
    = help: add `#![feature(abi_ptx)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: PTX ABIs are experimental and subject to change
+error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_ptx.rs:17:12
    |
 LL |     extern "ptx-kernel" fn mu() {}
@@ -38,7 +38,7 @@ LL |     extern "ptx-kernel" fn mu() {}
    = help: add `#![feature(abi_ptx)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: PTX ABIs are experimental and subject to change
+error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_ptx.rs:21:12
    |
 LL |     extern "ptx-kernel" fn imu() {}
@@ -48,7 +48,7 @@ LL |     extern "ptx-kernel" fn imu() {}
    = help: add `#![feature(abi_ptx)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: PTX ABIs are experimental and subject to change
+error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_ptx.rs:24:19
    |
 LL | type TAU = extern "ptx-kernel" fn();
@@ -58,7 +58,7 @@ LL | type TAU = extern "ptx-kernel" fn();
    = help: add `#![feature(abi_ptx)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: PTX ABIs are experimental and subject to change
+error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
   --> $DIR/feature-gate-abi_ptx.rs:26:8
    |
 LL | extern "ptx-kernel" {}
diff --git a/tests/ui/feature-gates/feature-gate-abi_unadjusted.rs b/tests/ui/feature-gates/feature-gate-abi_unadjusted.rs
index 35a7d73288b..1dc6adc0e14 100644
--- a/tests/ui/feature-gates/feature-gate-abi_unadjusted.rs
+++ b/tests/ui/feature-gates/feature-gate-abi_unadjusted.rs
@@ -1,5 +1,5 @@
 extern "unadjusted" fn foo() {
-//~^ ERROR: unadjusted ABI is an implementation detail and perma-unstable
+//~^ ERROR: "unadjusted" ABI is an implementation detail and perma-unstable
 }
 
 fn main() {
diff --git a/tests/ui/feature-gates/feature-gate-abi_unadjusted.stderr b/tests/ui/feature-gates/feature-gate-abi_unadjusted.stderr
index 1d5fb11cd3d..462fb79d557 100644
--- a/tests/ui/feature-gates/feature-gate-abi_unadjusted.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi_unadjusted.stderr
@@ -1,4 +1,4 @@
-error[E0658]: unadjusted ABI is an implementation detail and perma-unstable
+error[E0658]: the extern "unadjusted" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-abi_unadjusted.rs:1:8
    |
 LL | extern "unadjusted" fn foo() {
diff --git a/tests/ui/feature-gates/feature-gate-intrinsics.rs b/tests/ui/feature-gates/feature-gate-intrinsics.rs
index e0dc3cc579d..65806a0223e 100644
--- a/tests/ui/feature-gates/feature-gate-intrinsics.rs
+++ b/tests/ui/feature-gates/feature-gate-intrinsics.rs
@@ -1,8 +1,8 @@
-extern "rust-intrinsic" {   //~ ERROR intrinsics are subject to change
+extern "rust-intrinsic" {   //~ ERROR "rust-intrinsic" ABI is an implementation detail
     fn bar(); //~ ERROR unrecognized intrinsic function: `bar`
 }
 
-extern "rust-intrinsic" fn baz() {} //~ ERROR intrinsics are subject to change
+extern "rust-intrinsic" fn baz() {} //~ ERROR "rust-intrinsic" ABI is an implementation detail
 //~^ ERROR intrinsic must be in
 
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-intrinsics.stderr b/tests/ui/feature-gates/feature-gate-intrinsics.stderr
index 577a620e2d2..97246f05258 100644
--- a/tests/ui/feature-gates/feature-gate-intrinsics.stderr
+++ b/tests/ui/feature-gates/feature-gate-intrinsics.stderr
@@ -1,4 +1,4 @@
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-intrinsics.rs:1:8
    |
 LL | extern "rust-intrinsic" {
@@ -7,7 +7,7 @@ LL | extern "rust-intrinsic" {
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gate-intrinsics.rs:5:8
    |
 LL | extern "rust-intrinsic" fn baz() {}
diff --git a/tests/ui/feature-gates/feature-gate-rust_cold_cc.rs b/tests/ui/feature-gates/feature-gate-rust_cold_cc.rs
index 9ba8e32ac07..4f47eb55b39 100644
--- a/tests/ui/feature-gates/feature-gate-rust_cold_cc.rs
+++ b/tests/ui/feature-gates/feature-gate-rust_cold_cc.rs
@@ -1,21 +1,21 @@
 #![crate_type = "lib"]
 
-extern "rust-cold" fn fu() {} //~ ERROR rust-cold is experimental
+extern "rust-cold" fn fu() {} //~ ERROR "rust-cold" ABI is experimental
 
 trait T {
-    extern "rust-cold" fn mu(); //~ ERROR rust-cold is experimental
-    extern "rust-cold" fn dmu() {} //~ ERROR rust-cold is experimental
+    extern "rust-cold" fn mu(); //~ ERROR "rust-cold" ABI is experimental
+    extern "rust-cold" fn dmu() {} //~ ERROR "rust-cold" ABI is experimental
 }
 
 struct S;
 impl T for S {
-    extern "rust-cold" fn mu() {} //~ ERROR rust-cold is experimental
+    extern "rust-cold" fn mu() {} //~ ERROR "rust-cold" ABI is experimental
 }
 
 impl S {
-    extern "rust-cold" fn imu() {} //~ ERROR rust-cold is experimental
+    extern "rust-cold" fn imu() {} //~ ERROR "rust-cold" ABI is experimental
 }
 
-type TAU = extern "rust-cold" fn(); //~ ERROR rust-cold is experimental
+type TAU = extern "rust-cold" fn(); //~ ERROR "rust-cold" ABI is experimental
 
-extern "rust-cold" {} //~ ERROR rust-cold is experimental
+extern "rust-cold" {} //~ ERROR "rust-cold" ABI is experimental
diff --git a/tests/ui/feature-gates/feature-gate-rust_cold_cc.stderr b/tests/ui/feature-gates/feature-gate-rust_cold_cc.stderr
index eeff9534d52..9547c64f2b2 100644
--- a/tests/ui/feature-gates/feature-gate-rust_cold_cc.stderr
+++ b/tests/ui/feature-gates/feature-gate-rust_cold_cc.stderr
@@ -1,4 +1,4 @@
-error[E0658]: rust-cold is experimental and subject to change
+error[E0658]: the extern "rust-cold" ABI is experimental and subject to change
   --> $DIR/feature-gate-rust_cold_cc.rs:3:8
    |
 LL | extern "rust-cold" fn fu() {}
@@ -8,7 +8,7 @@ LL | extern "rust-cold" fn fu() {}
    = help: add `#![feature(rust_cold_cc)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-cold is experimental and subject to change
+error[E0658]: the extern "rust-cold" ABI is experimental and subject to change
   --> $DIR/feature-gate-rust_cold_cc.rs:6:12
    |
 LL |     extern "rust-cold" fn mu();
@@ -18,7 +18,7 @@ LL |     extern "rust-cold" fn mu();
    = help: add `#![feature(rust_cold_cc)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-cold is experimental and subject to change
+error[E0658]: the extern "rust-cold" ABI is experimental and subject to change
   --> $DIR/feature-gate-rust_cold_cc.rs:7:12
    |
 LL |     extern "rust-cold" fn dmu() {}
@@ -28,7 +28,7 @@ LL |     extern "rust-cold" fn dmu() {}
    = help: add `#![feature(rust_cold_cc)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-cold is experimental and subject to change
+error[E0658]: the extern "rust-cold" ABI is experimental and subject to change
   --> $DIR/feature-gate-rust_cold_cc.rs:12:12
    |
 LL |     extern "rust-cold" fn mu() {}
@@ -38,7 +38,7 @@ LL |     extern "rust-cold" fn mu() {}
    = help: add `#![feature(rust_cold_cc)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-cold is experimental and subject to change
+error[E0658]: the extern "rust-cold" ABI is experimental and subject to change
   --> $DIR/feature-gate-rust_cold_cc.rs:16:12
    |
 LL |     extern "rust-cold" fn imu() {}
@@ -48,7 +48,7 @@ LL |     extern "rust-cold" fn imu() {}
    = help: add `#![feature(rust_cold_cc)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-cold is experimental and subject to change
+error[E0658]: the extern "rust-cold" ABI is experimental and subject to change
   --> $DIR/feature-gate-rust_cold_cc.rs:19:19
    |
 LL | type TAU = extern "rust-cold" fn();
@@ -58,7 +58,7 @@ LL | type TAU = extern "rust-cold" fn();
    = help: add `#![feature(rust_cold_cc)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-cold is experimental and subject to change
+error[E0658]: the extern "rust-cold" ABI is experimental and subject to change
   --> $DIR/feature-gate-rust_cold_cc.rs:21:8
    |
 LL | extern "rust-cold" {}
diff --git a/tests/ui/feature-gates/feature-gate-unboxed-closures-manual-impls.rs b/tests/ui/feature-gates/feature-gate-unboxed-closures-manual-impls.rs
index ff528274c59..7b40c8760e3 100644
--- a/tests/ui/feature-gates/feature-gate-unboxed-closures-manual-impls.rs
+++ b/tests/ui/feature-gates/feature-gate-unboxed-closures-manual-impls.rs
@@ -11,7 +11,7 @@ impl Fn<()> for Foo {
     //~| ERROR manual implementations of `Fn` are experimental
     //~| ERROR expected a `FnMut()` closure, found `Foo`
     extern "rust-call" fn call(self, args: ()) -> () {}
-    //~^ ERROR rust-call ABI is subject to change
+    //~^ ERROR "rust-call" ABI is experimental and subject to change
     //~| ERROR `call` has an incompatible type for trait
 }
 struct Foo1;
@@ -20,7 +20,7 @@ impl FnOnce() for Foo1 {
     //~| ERROR manual implementations of `FnOnce` are experimental
     //~| ERROR not all trait items implemented
     extern "rust-call" fn call_once(self, args: ()) -> () {}
-    //~^ ERROR rust-call ABI is subject to change
+    //~^ ERROR "rust-call" ABI is experimental and subject to change
 }
 struct Bar;
 impl FnMut<()> for Bar {
@@ -28,7 +28,7 @@ impl FnMut<()> for Bar {
     //~| ERROR manual implementations of `FnMut` are experimental
     //~| ERROR expected a `FnOnce()` closure, found `Bar`
     extern "rust-call" fn call_mut(&self, args: ()) -> () {}
-    //~^ ERROR rust-call ABI is subject to change
+    //~^ ERROR "rust-call" ABI is experimental and subject to change
     //~| ERROR incompatible type for trait
 }
 struct Baz;
@@ -37,7 +37,7 @@ impl FnOnce<()> for Baz {
     //~| ERROR manual implementations of `FnOnce` are experimental
     //~| ERROR not all trait items implemented
     extern "rust-call" fn call_once(&self, args: ()) -> () {}
-    //~^ ERROR rust-call ABI is subject to change
+    //~^ ERROR "rust-call" ABI is experimental and subject to change
 }
 
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-unboxed-closures-manual-impls.stderr b/tests/ui/feature-gates/feature-gate-unboxed-closures-manual-impls.stderr
index 584724dfe59..f9d231dc78f 100644
--- a/tests/ui/feature-gates/feature-gate-unboxed-closures-manual-impls.stderr
+++ b/tests/ui/feature-gates/feature-gate-unboxed-closures-manual-impls.stderr
@@ -1,4 +1,4 @@
-error[E0658]: rust-call ABI is subject to change
+error[E0658]: the extern "rust-call" ABI is experimental and subject to change
   --> $DIR/feature-gate-unboxed-closures-manual-impls.rs:13:12
    |
 LL |     extern "rust-call" fn call(self, args: ()) -> () {}
@@ -8,7 +8,7 @@ LL |     extern "rust-call" fn call(self, args: ()) -> () {}
    = help: add `#![feature(unboxed_closures)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-call ABI is subject to change
+error[E0658]: the extern "rust-call" ABI is experimental and subject to change
   --> $DIR/feature-gate-unboxed-closures-manual-impls.rs:22:12
    |
 LL |     extern "rust-call" fn call_once(self, args: ()) -> () {}
@@ -18,7 +18,7 @@ LL |     extern "rust-call" fn call_once(self, args: ()) -> () {}
    = help: add `#![feature(unboxed_closures)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-call ABI is subject to change
+error[E0658]: the extern "rust-call" ABI is experimental and subject to change
   --> $DIR/feature-gate-unboxed-closures-manual-impls.rs:30:12
    |
 LL |     extern "rust-call" fn call_mut(&self, args: ()) -> () {}
@@ -28,7 +28,7 @@ LL |     extern "rust-call" fn call_mut(&self, args: ()) -> () {}
    = help: add `#![feature(unboxed_closures)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: rust-call ABI is subject to change
+error[E0658]: the extern "rust-call" ABI is experimental and subject to change
   --> $DIR/feature-gate-unboxed-closures-manual-impls.rs:39:12
    |
 LL |     extern "rust-call" fn call_once(&self, args: ()) -> () {}
diff --git a/tests/ui/feature-gates/feature-gate-unboxed-closures.rs b/tests/ui/feature-gates/feature-gate-unboxed-closures.rs
index ebc5a2536f6..74cc20c581c 100644
--- a/tests/ui/feature-gates/feature-gate-unboxed-closures.rs
+++ b/tests/ui/feature-gates/feature-gate-unboxed-closures.rs
@@ -10,7 +10,7 @@ impl FnOnce<(u32, u32)> for Test {
     extern "rust-call" fn call_once(self, (a, b): (u32, u32)) -> u32 {
         a + b
     }
-    //~^^^ ERROR rust-call ABI is subject to change
+    //~^^^ ERROR "rust-call" ABI is experimental and subject to change
 }
 
 fn main() {
diff --git a/tests/ui/feature-gates/feature-gate-unboxed-closures.stderr b/tests/ui/feature-gates/feature-gate-unboxed-closures.stderr
index 52c18ec34c5..36932c1f86f 100644
--- a/tests/ui/feature-gates/feature-gate-unboxed-closures.stderr
+++ b/tests/ui/feature-gates/feature-gate-unboxed-closures.stderr
@@ -1,4 +1,4 @@
-error[E0658]: rust-call ABI is subject to change
+error[E0658]: the extern "rust-call" ABI is experimental and subject to change
   --> $DIR/feature-gate-unboxed-closures.rs:10:12
    |
 LL |     extern "rust-call" fn call_once(self, (a, b): (u32, u32)) -> u32 {
diff --git a/tests/ui/feature-gates/feature-gate-vectorcall.rs b/tests/ui/feature-gates/feature-gate-vectorcall.rs
index 73a11a842f3..aafa6a2ed62 100644
--- a/tests/ui/feature-gates/feature-gate-vectorcall.rs
+++ b/tests/ui/feature-gates/feature-gate-vectorcall.rs
@@ -9,23 +9,23 @@ trait Sized { }
 // Test that the "vectorcall" ABI is feature-gated, and cannot be used when
 // the `vectorcall` feature gate is not used.
 
-extern "vectorcall" fn f() {} //~ ERROR vectorcall is experimental
+extern "vectorcall" fn f() {} //~ ERROR "vectorcall" ABI is experimental
 
 trait T {
-    extern "vectorcall" fn m(); //~ ERROR vectorcall is experimental
+    extern "vectorcall" fn m(); //~ ERROR "vectorcall" ABI is experimental
 
-    extern "vectorcall" fn dm() {} //~ ERROR vectorcall is experimental
+    extern "vectorcall" fn dm() {} //~ ERROR "vectorcall" ABI is experimental
 }
 
 struct S;
 impl T for S {
-    extern "vectorcall" fn m() {} //~ ERROR vectorcall is experimental
+    extern "vectorcall" fn m() {} //~ ERROR "vectorcall" ABI is experimental
 }
 
 impl S {
-    extern "vectorcall" fn im() {} //~ ERROR vectorcall is experimental
+    extern "vectorcall" fn im() {} //~ ERROR "vectorcall" ABI is experimental
 }
 
-type TA = extern "vectorcall" fn(); //~ ERROR vectorcall is experimental
+type TA = extern "vectorcall" fn(); //~ ERROR "vectorcall" ABI is experimental
 
-extern "vectorcall" {} //~ ERROR vectorcall is experimental
+extern "vectorcall" {} //~ ERROR "vectorcall" ABI is experimental
diff --git a/tests/ui/feature-gates/feature-gate-vectorcall.stderr b/tests/ui/feature-gates/feature-gate-vectorcall.stderr
index b20e41887b9..8f3f47a3d48 100644
--- a/tests/ui/feature-gates/feature-gate-vectorcall.stderr
+++ b/tests/ui/feature-gates/feature-gate-vectorcall.stderr
@@ -1,4 +1,4 @@
-error[E0658]: vectorcall is experimental and subject to change
+error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
   --> $DIR/feature-gate-vectorcall.rs:12:8
    |
 LL | extern "vectorcall" fn f() {}
@@ -8,7 +8,7 @@ LL | extern "vectorcall" fn f() {}
    = help: add `#![feature(abi_vectorcall)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: vectorcall is experimental and subject to change
+error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
   --> $DIR/feature-gate-vectorcall.rs:15:12
    |
 LL |     extern "vectorcall" fn m();
@@ -18,7 +18,7 @@ LL |     extern "vectorcall" fn m();
    = help: add `#![feature(abi_vectorcall)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: vectorcall is experimental and subject to change
+error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
   --> $DIR/feature-gate-vectorcall.rs:17:12
    |
 LL |     extern "vectorcall" fn dm() {}
@@ -28,7 +28,7 @@ LL |     extern "vectorcall" fn dm() {}
    = help: add `#![feature(abi_vectorcall)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: vectorcall is experimental and subject to change
+error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
   --> $DIR/feature-gate-vectorcall.rs:22:12
    |
 LL |     extern "vectorcall" fn m() {}
@@ -38,7 +38,7 @@ LL |     extern "vectorcall" fn m() {}
    = help: add `#![feature(abi_vectorcall)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: vectorcall is experimental and subject to change
+error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
   --> $DIR/feature-gate-vectorcall.rs:26:12
    |
 LL |     extern "vectorcall" fn im() {}
@@ -48,7 +48,7 @@ LL |     extern "vectorcall" fn im() {}
    = help: add `#![feature(abi_vectorcall)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: vectorcall is experimental and subject to change
+error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
   --> $DIR/feature-gate-vectorcall.rs:29:18
    |
 LL | type TA = extern "vectorcall" fn();
@@ -58,7 +58,7 @@ LL | type TA = extern "vectorcall" fn();
    = help: add `#![feature(abi_vectorcall)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: vectorcall is experimental and subject to change
+error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
   --> $DIR/feature-gate-vectorcall.rs:31:8
    |
 LL | extern "vectorcall" {}
diff --git a/tests/ui/feature-gates/feature-gated-feature-in-macro-arg.rs b/tests/ui/feature-gates/feature-gated-feature-in-macro-arg.rs
index 37b7d52fafc..2328798d74c 100644
--- a/tests/ui/feature-gates/feature-gated-feature-in-macro-arg.rs
+++ b/tests/ui/feature-gates/feature-gated-feature-in-macro-arg.rs
@@ -5,7 +5,7 @@
 fn main() {
     let a = &[1, 2, 3];
     println!("{}", {
-        extern "rust-intrinsic" { //~ ERROR intrinsics are subject to change
+        extern "rust-intrinsic" { //~ ERROR "rust-intrinsic" ABI is an implementation detail
             fn atomic_fence();
         }
         atomic_fence(); //~ ERROR: is unsafe
diff --git a/tests/ui/feature-gates/feature-gated-feature-in-macro-arg.stderr b/tests/ui/feature-gates/feature-gated-feature-in-macro-arg.stderr
index 3dc11b5612c..86f88fdff5f 100644
--- a/tests/ui/feature-gates/feature-gated-feature-in-macro-arg.stderr
+++ b/tests/ui/feature-gates/feature-gated-feature-in-macro-arg.stderr
@@ -1,4 +1,4 @@
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/feature-gated-feature-in-macro-arg.rs:8:16
    |
 LL |         extern "rust-intrinsic" {
diff --git a/tests/ui/intrinsics/incorrect-read_via_copy-defn.rs b/tests/ui/intrinsics/incorrect-read_via_copy-defn.rs
index 66de1f60ed9..5520430e140 100644
--- a/tests/ui/intrinsics/incorrect-read_via_copy-defn.rs
+++ b/tests/ui/intrinsics/incorrect-read_via_copy-defn.rs
@@ -3,5 +3,5 @@ fn main() {
 }
 
 extern "rust-intrinsic" fn read_via_copy() {}
-//~^ ERROR intrinsics are subject to change
+//~^ ERROR "rust-intrinsic" ABI is an implementation detail
 //~| ERROR intrinsic must be in `extern "rust-intrinsic" { ... }` block
diff --git a/tests/ui/intrinsics/incorrect-read_via_copy-defn.stderr b/tests/ui/intrinsics/incorrect-read_via_copy-defn.stderr
index 362ee185b7b..c6682693f74 100644
--- a/tests/ui/intrinsics/incorrect-read_via_copy-defn.stderr
+++ b/tests/ui/intrinsics/incorrect-read_via_copy-defn.stderr
@@ -1,4 +1,4 @@
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/incorrect-read_via_copy-defn.rs:5:8
    |
 LL | extern "rust-intrinsic" fn read_via_copy() {}
diff --git a/tests/ui/intrinsics/incorrect-transmute.rs b/tests/ui/intrinsics/incorrect-transmute.rs
index eed524ae8a8..15d1ab939ed 100644
--- a/tests/ui/intrinsics/incorrect-transmute.rs
+++ b/tests/ui/intrinsics/incorrect-transmute.rs
@@ -3,5 +3,5 @@ fn main() {
 }
 
 extern "rust-intrinsic" fn transmute() {}
-//~^ ERROR intrinsics are subject to change
+//~^ ERROR "rust-intrinsic" ABI is an implementation detail
 //~| ERROR intrinsic must be in `extern "rust-intrinsic" { ... }` block
diff --git a/tests/ui/intrinsics/incorrect-transmute.stderr b/tests/ui/intrinsics/incorrect-transmute.stderr
index 8123f3d71a2..99dfb9847ff 100644
--- a/tests/ui/intrinsics/incorrect-transmute.stderr
+++ b/tests/ui/intrinsics/incorrect-transmute.stderr
@@ -1,4 +1,4 @@
-error[E0658]: intrinsics are subject to change
+error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
   --> $DIR/incorrect-transmute.rs:5:8
    |
 LL | extern "rust-intrinsic" fn transmute() {}