compiler: plug unsupported ABI leakage from the AST

We elaborate rustc_ast_lowering to prevent unstable, unsupported ABIs
from leaking through the HIR without being checked for target support.
Previously ad-hoc checking on various HIR items required making sure
we check every HIR item which could contain an extern "{abi}" string.
This is a losing proposition compared to gating the lowering itself.

As a consequence, unstable ABI strings will now hard-error instead of
triggering the FCW `unsupported_fn_ptr_calling_conventions`.
This FCW was upgraded to warn in dependencies in Rust 1.87 so it has
become active within a stable Rust version and it was within the
compiler's nightly-feature contract to break this code without warning,
so this breakage has likely had a reasonable amount of foreshadowing.

Author: workingjubilee

compiler/rustc_ast_lowering/src/stability.rs

@@ -1,6 +1,7 @@
 use std::fmt;
 
 use rustc_abi::ExternAbi;
+use rustc_errors::{E0570, struct_span_code_err};
 use rustc_feature::Features;
 use rustc_session::Session;
 use rustc_session::parse::feature_err;
@@ -31,13 +32,28 @@ pub(crate) fn extern_abi_enabled(
 
 #[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();
-        }
+    let Err(unstable) = extern_abi_stability(abi) else { return };
+    // what are we doing here? this is mixing target support with stability?
+    // well, unfortunately we allowed some ABIs to be used via fn pointers and such on stable,
+    // so we can't simply error any time someone uses certain ABIs as we want to let the FCW ride.
+    // however, for a number of *unstable* ABIs, we can simply fix them because they're unstable!
+    // otherwise it's the same idea as checking during lowering at all: because `extern "ABI"` has to
+    // be visible during lowering of some crate, we can easily nail use of certain ABIs before we
+    // get to e.g. attempting to do invalid codegen for the target.
+    if !sess.target.is_abi_supported(unstable.abi) {
+        struct_span_code_err!(
+            sess.dcx(),
+            span,
+            E0570,
+            "`{abi}` is not a supported ABI for the current target",
+        )
+        .emit();
+    }
+    if features.enabled(unstable.feature) || span.allows_unstable(unstable.feature) {
+        return;
     }
+    let explain = unstable.to_string();
+    feature_err(sess, unstable.feature, span, explain).emit();
 }
 
 pub struct UnstableAbi {