Rollup of 8 pull requests

compiler/rustc_builtin_macros/messages.ftl

@@ -3,8 +3,6 @@ builtin_macros_alloc_must_statics = allocators must be statics
 
 builtin_macros_asm_attribute_not_supported =
     this attribute is not supported on assembly
-builtin_macros_asm_cfg =
-    the `#[cfg(/* ... */)]` and `#[cfg_attr(/* ... */)]` attributes on assembly are unstable
 
 builtin_macros_asm_clobber_abi = clobber_abi
 builtin_macros_asm_clobber_no_reg = asm with `clobber_abi` must specify explicit registers for outputs

compiler/rustc_builtin_macros/src/asm.rs

@@ -6,14 +6,13 @@ use rustc_expand::base::*;
 use rustc_index::bit_set::GrowableBitSet;
 use rustc_parse::parser::asm::*;
 use rustc_session::lint;
-use rustc_session::parse::feature_err;
 use rustc_span::{ErrorGuaranteed, InnerSpan, Span, Symbol, sym};
 use rustc_target::asm::InlineAsmArch;
 use smallvec::smallvec;
 use {rustc_ast as ast, rustc_parse_format as parse};
 
+use crate::errors;
 use crate::util::{ExprToSpannedString, expr_to_spanned_string};
-use crate::{errors, fluent_generated as fluent};
 
 /// Validated assembly arguments, ready for macro expansion.
 struct ValidatedAsmArgs {
@@ -64,22 +63,13 @@ fn validate_asm_args<'a>(
 
     for arg in args {
         for attr in arg.attributes.0.iter() {
-            match attr.name() {
-                Some(sym::cfg | sym::cfg_attr) => {
-                    if !ecx.ecfg.features.asm_cfg() {
-                        let span = attr.span();
-                        feature_err(ecx.sess, sym::asm_cfg, span, fluent::builtin_macros_asm_cfg)
-                            .emit();
-                    }
-                }
-                _ => {
-                    ecx.dcx().emit_err(errors::AsmAttributeNotSupported { span: attr.span() });
-                }
+            if !matches!(attr.name(), Some(sym::cfg | sym::cfg_attr)) {
+                ecx.dcx().emit_err(errors::AsmAttributeNotSupported { span: attr.span() });
             }
         }
 
         // Skip arguments that are configured out.
-        if ecx.ecfg.features.asm_cfg() && strip_unconfigured.configure(arg.attributes).is_none() {
+        if strip_unconfigured.configure(arg.attributes).is_none() {
             continue;
         }
 

compiler/rustc_feature/src/accepted.rs

@@ -60,6 +60,8 @@ declare_features! (
     (accepted, adx_target_feature, "1.61.0", Some(44839)),
     /// Allows explicit discriminants on non-unit enum variants.
     (accepted, arbitrary_enum_discriminant, "1.66.0", Some(60553)),
+    /// Allows #[cfg(...)] on inline assembly templates and operands.
+    (accepted, asm_cfg, "CURRENT_RUSTC_VERSION", Some(140364)),
     /// Allows using `const` operands in inline assembly.
     (accepted, asm_const, "1.82.0", Some(93332)),
     /// Allows using `label` operands in inline assembly.

compiler/rustc_feature/src/unstable.rs

@@ -382,8 +382,6 @@ declare_features! (
     (unstable, arbitrary_self_types, "1.23.0", Some(44874)),
     /// Allows inherent and trait methods with arbitrary self types that are raw pointers.
     (unstable, arbitrary_self_types_pointers, "1.83.0", Some(44874)),
-    /// Allows #[cfg(...)] on inline assembly templates and operands.
-    (unstable, asm_cfg, "1.89.0", Some(140364)),
     /// Enables experimental inline assembly support for additional architectures.
     (unstable, asm_experimental_arch, "1.58.0", Some(93335)),
     /// Enables experimental register support in inline assembly.

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -1186,14 +1186,21 @@ pub(crate) fn check_static_item<'tcx>(
 ) -> Result<(), ErrorGuaranteed> {
     enter_wf_checking_ctxt(tcx, item_id, |wfcx| {
         let span = tcx.ty_span(item_id);
-        let item_ty = wfcx.deeply_normalize(span, Some(WellFormedLoc::Ty(item_id)), ty);
+        let loc = Some(WellFormedLoc::Ty(item_id));
+        let item_ty = wfcx.deeply_normalize(span, loc, ty);
 
         let is_foreign_item = tcx.is_foreign_item(item_id);
+        let is_structurally_foreign_item = || {
+            let tail = tcx.struct_tail_raw(
+                item_ty,
+                &ObligationCause::dummy(),
+                |ty| wfcx.deeply_normalize(span, loc, ty),
+                || {},
+            );
 
-        let forbid_unsized = !is_foreign_item || {
-            let tail = tcx.struct_tail_for_codegen(item_ty, wfcx.infcx.typing_env(wfcx.param_env));
-            !matches!(tail.kind(), ty::Foreign(_))
+            matches!(tail.kind(), ty::Foreign(_))
         };
+        let forbid_unsized = !(is_foreign_item && is_structurally_foreign_item());
 
         wfcx.register_wf_obligation(span, Some(WellFormedLoc::Ty(item_id)), item_ty.into());
         if forbid_unsized {