Move #[naked] attribute check to attribute parsing stage

compiler/rustc_ast_lowering/src/block.rs

@@ -104,7 +104,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         };
         let span = self.lower_span(l.span);
         let source = hir::LocalSource::Normal;
-        self.lower_attrs(hir_id, &l.attrs, l.span, Target::Statement);
+        self.lower_attrs(hir_id, &l.attrs, l.span, Target::Statement, None);
         self.arena.alloc(hir::LetStmt { hir_id, super_, ty, pat, init, els, span, source })
     }
 

compiler/rustc_ast_lowering/src/contract.rs

@@ -350,7 +350,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         ));
 
         let attrs: rustc_ast::AttrVec = thin_vec![self.unreachable_code_attr(span)];
-        self.lower_attrs(contract_check.hir_id, &attrs, span, rustc_hir::Target::Expression);
+        self.lower_attrs(contract_check.hir_id, &attrs, span, rustc_hir::Target::Expression, None);
 
         let ret_block = self.block_all(span, arena_vec![self; ret_stmt], Some(contract_check));
         self.arena.alloc(self.expr_block(self.arena.alloc(ret_block)))

compiler/rustc_ast_lowering/src/expr.rs

@@ -254,7 +254,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
 
         let expr_hir_id = self.lower_node_id(e.id);
-        self.lower_attrs(expr_hir_id, &e.attrs, e.span, Target::from_expr(e));
+        self.lower_attrs(expr_hir_id, &e.attrs, e.span, Target::from_expr(e), None);
 
         let kind = match &e.kind {
             ExprKind::Array(exprs) => hir::ExprKind::Array(self.lower_exprs(exprs)),
@@ -794,7 +794,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let guard = arm.guard.as_ref().map(|guard| self.lower_expr(&guard.cond));
         let hir_id = self.next_id();
         let span = self.lower_span(arm.span);
-        self.lower_attrs(hir_id, &arm.attrs, arm.span, Target::Arm);
+        self.lower_attrs(hir_id, &arm.attrs, arm.span, Target::Arm, None);
         let is_never_pattern = pat.is_never_pattern();
         // We need to lower the body even if it's unneeded for never pattern in match,
         // ensure that we can get HirId for DefId if need (issue #137708).
@@ -1658,7 +1658,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_expr_field(&mut self, f: &ExprField) -> hir::ExprField<'hir> {
         let hir_id = self.lower_node_id(f.id);
-        self.lower_attrs(hir_id, &f.attrs, f.span, Target::ExprField);
+        self.lower_attrs(hir_id, &f.attrs, f.span, Target::ExprField, None);
         hir::ExprField {
             hir_id,
             ident: self.lower_ident(f.ident),
@@ -1925,7 +1925,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         //
         // Also, add the attributes to the outer returned expr node.
         let expr = self.expr_drop_temps_mut(for_span, match_expr);
-        self.lower_attrs(expr.hir_id, &e.attrs, e.span, Target::from_expr(e));
+        self.lower_attrs(expr.hir_id, &e.attrs, e.span, Target::from_expr(e), None);
         expr
     }
 
@@ -1973,7 +1973,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             let val_ident = Ident::with_dummy_span(sym::val);
             let (val_pat, val_pat_nid) = self.pat_ident(span, val_ident);
             let val_expr = self.expr_ident(span, val_ident, val_pat_nid);
-            self.lower_attrs(val_expr.hir_id, &attrs, span, Target::Expression);
+            self.lower_attrs(val_expr.hir_id, &attrs, span, Target::Expression, None);
             let continue_pat = self.pat_cf_continue(unstable_span, val_pat);
             self.arm(continue_pat, val_expr, try_span)
         };
@@ -2015,7 +2015,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let ret_expr = self.checked_return(Some(from_residual_expr));
                 self.arena.alloc(self.expr(try_span, ret_expr))
             };
-            self.lower_attrs(ret_expr.hir_id, &attrs, span, Target::Expression);
+            self.lower_attrs(ret_expr.hir_id, &attrs, span, Target::Expression, None);
 
             let break_pat = self.pat_cf_break(try_span, residual_local);
             self.arm(break_pat, ret_expr, try_span)

compiler/rustc_ast_lowering/src/expr/closure.rs

@@ -19,7 +19,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         closure: &Closure,
     ) -> hir::Expr<'hir> {
         let expr_hir_id = self.lower_node_id(e.id);
-        let attrs = self.lower_attrs(expr_hir_id, &e.attrs, e.span, Target::from_expr(e));
+        let attrs = self.lower_attrs(expr_hir_id, &e.attrs, e.span, Target::from_expr(e), None);
 
         match closure.coroutine_marker {
             Some(coroutine_marker) => self.lower_expr_coroutine_closure_with_move_exprs(

compiler/rustc_ast_lowering/src/item.rs

@@ -1,6 +1,7 @@
 use rustc_abi::ExternAbi;
 use rustc_ast::visit::AssocCtxt;
 use rustc_ast::*;
+use rustc_attr_ir::target::AstTarget;
 use rustc_errors::{E0570, ErrorGuaranteed, struct_span_code_err};
 use rustc_hir::attrs::{AttributeKind, EiiImplResolution};
 use rustc_hir::def::{DefKind, PerNS, Res};
@@ -72,7 +73,7 @@ impl<'hir> ItemLowerer<'_, 'hir> {
         self.with_lctx(CRATE_NODE_ID, |lctx| {
             debug_assert_eq!(lctx.curr_owner.owner_id, CRATE_OWNER_ID);
             let module = lctx.lower_mod(&c.items, &c.spans);
-            lctx.lower_attrs(hir::CRATE_HIR_ID, &c.attrs, c.spans.inner_span, Target::Crate);
+            lctx.lower_attrs(hir::CRATE_HIR_ID, &c.attrs, c.spans.inner_span, Target::Crate, None);
             hir::OwnerNode::Crate(module)
         })
     }
@@ -215,7 +216,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             &i.attrs,
             i.span,
             Target::from_ast_item(i),
-            Some(i),
+            Some(AstTarget::Item(i)),
             &extra_hir_attributes,
         );
 
@@ -733,8 +734,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_foreign_item(&mut self, i: &ForeignItem) -> &'hir hir::ForeignItem<'hir> {
         let owner_id = self.curr_owner.owner_id;
         let hir_id: HirId = owner_id.into();
-        let attrs =
-            self.lower_attrs(hir_id, &i.attrs, i.span, Target::from_foreign_item_kind(&i.kind));
+        let attrs = self.lower_attrs(
+            hir_id,
+            &i.attrs,
+            i.span,
+            Target::from_foreign_item_kind(&i.kind),
+            None,
+        );
         let (ident, kind) = match &i.kind {
             ForeignItemKind::Fn(Fn { sig, ident, generics, define_opaque, .. }) => {
                 let fdec = &sig.decl;
@@ -806,7 +812,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 .emit()
         }
         let hir_id = self.lower_node_id(v.id);
-        self.lower_attrs(hir_id, &v.attrs, v.span, Target::Variant);
+        self.lower_attrs(hir_id, &v.attrs, v.span, Target::Variant, None);
         hir::Variant {
             hir_id,
             def_id: self.local_def_id(v.id),
@@ -893,7 +899,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let ty =
             self.lower_ty_alloc(&f.ty, ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy));
         let hir_id = self.lower_node_id(f.id);
-        self.lower_attrs(hir_id, &f.attrs, f.span, Target::Field);
+        self.lower_attrs(hir_id, &f.attrs, f.span, Target::Field, None);
         hir::FieldDef {
             span: self.lower_span(f.span),
             hir_id,
@@ -921,6 +927,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             &i.attrs,
             i.span,
             Target::from_assoc_item_kind(&i.kind, AssocCtxt::Trait),
+            Some(AstTarget::AssocItem(i)),
         );
 
         let (ident, generics, kind, has_value) = match &i.kind {
@@ -1184,6 +1191,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             &i.attrs,
             i.span,
             Target::from_assoc_item_kind(&i.kind, AssocCtxt::Impl { of_trait: is_in_trait_impl }),
+            Some(AstTarget::AssocItem(i)),
         );
 
         let (ident, (generics, kind)) = match &i.kind {
@@ -1356,7 +1364,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_param(&mut self, param: &Param) -> hir::Param<'hir> {
         let hir_id = self.lower_node_id(param.id);
-        self.lower_attrs(hir_id, &param.attrs, param.span, Target::Param);
+        self.lower_attrs(hir_id, &param.attrs, param.span, Target::Param, None);
         hir::Param {
             hir_id,
             pat: self.lower_pat(&param.pat),
@@ -2052,7 +2060,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> hir::WherePredicate<'hir> {
         let hir_id = self.lower_node_id(pred.id);
         let span = self.lower_span(pred.span);
-        self.lower_attrs(hir_id, &pred.attrs, span, Target::WherePredicate);
+        self.lower_attrs(hir_id, &pred.attrs, span, Target::WherePredicate, None);
         let kind = self.arena.alloc(match &pred.kind {
             WherePredicateKind::BoundPredicate(WhereBoundPredicate {
                 bound_generic_params,

compiler/rustc_ast_lowering/src/lib.rs

@@ -45,6 +45,7 @@ use rustc_ast::mut_visit::{self, MutVisitor};
 use rustc_ast::node_id::NodeMap;
 use rustc_ast::visit::{self, Visitor};
 use rustc_ast::{self as ast, *};
+use rustc_attr_ir::target::AstTarget;
 use rustc_attr_parsing::{AttributeParser, Recovery, ShouldEmit};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::sorted_map::SortedMap;
@@ -1181,8 +1182,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
         attrs: &[Attribute],
         target_span: Span,
         target: Target,
+        ast_target: Option<AstTarget<'_>>,
     ) -> &'hir [hir::Attribute] {
-        self.lower_attrs_with_extra(id, attrs, target_span, target, None, &[])
+        self.lower_attrs_with_extra(id, attrs, target_span, target, ast_target, &[])
     }
 
     fn lower_attrs_with_extra(
@@ -1191,14 +1193,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
         attrs: &[Attribute],
         target_span: Span,
         target: Target,
-        target_item: Option<&ast::Item>,
+        ast_target: Option<AstTarget<'_>>,
         extra_hir_attributes: &[hir::Attribute],
     ) -> &'hir [hir::Attribute] {
         if attrs.is_empty() && extra_hir_attributes.is_empty() {
             &[]
         } else {
             let mut lowered_attrs =
-                self.lower_attrs_vec(attrs, self.lower_span(target_span), id, target, target_item);
+                self.lower_attrs_vec(attrs, self.lower_span(target_span), id, target, ast_target);
             lowered_attrs.extend(extra_hir_attributes.iter().cloned());
 
             assert_eq!(id.owner, self.curr_owner.owner_id);
@@ -1225,14 +1227,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
         target_span: Span,
         target_hir_id: HirId,
         target: Target,
-        target_item: Option<&ast::Item>,
+        ast_target: Option<AstTarget<'_>>,
     ) -> Vec<hir::Attribute> {
         let l = self.span_lowerer();
         self.attribute_parser.parse_attribute_list(
             attrs,
             target_span,
             target,
-            target_item,
+            ast_target,
             |s| l.lower(s),
             |lint_id, span, kind| {
                 self.curr_owner.delayed_lints.push(DelayedLint {
@@ -2304,7 +2306,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             colon_span: param.colon_span.map(|s| self.lower_span(s)),
             source,
         };
-        self.lower_attrs(hir_id, param_attrs, param_span, Target::from(&param));
+        self.lower_attrs(hir_id, param_attrs, param_span, Target::from(&param), None);
         param
     }
 
@@ -2924,7 +2926,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     // FIXME(mgca): This might result in lowering attributes that
                     // then go unused as the `Target::ExprField` is not actually
                     // corresponding to `Node::ExprField`.
-                    self.lower_attrs(hir_id, &f.attrs, f.span, Target::ExprField);
+                    self.lower_attrs(hir_id, &f.attrs, f.span, Target::ExprField, None);
                     let expr = self.lower_expr_to_const_arg_direct(&f.expr, None);
 
                     &*self.arena.alloc(hir::ConstArgExprField {

compiler/rustc_ast_lowering/src/pat.rs

@@ -92,7 +92,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
                     let fs = self.arena.alloc_from_iter(fields.iter().map(|f| {
                         let hir_id = self.lower_node_id(f.id);
-                        self.lower_attrs(hir_id, &f.attrs, f.span, Target::PatField);
+                        self.lower_attrs(hir_id, &f.attrs, f.span, Target::PatField, None);
 
                         hir::PatField {
                             hir_id,

compiler/rustc_attr_ir/src/target.rs

@@ -2,10 +2,19 @@
 
 use std::fmt::{self, Display};
 
+use rustc_abi::ExternAbi;
 pub use rustc_ast::visit::AssocCtxt;
-use rustc_ast::{AssocItemKind, ForeignItemKind, ast};
+use rustc_ast::{AssocItemKind, ForeignItemKind, Item, ast};
 use rustc_macros::StableHash;
 
+// This enum lists all possible types of AST items.
+// FIXME: Currently, this enum only lists `Item` and `AssocItem`, but in the future, be exhaustive.
+#[derive(Clone, Copy, Debug)]
+pub enum AstTarget<'a> {
+    Item(&'a Item),
+    AssocItem(&'a Item<AssocItemKind>),
+}
+
 #[derive(Copy, Clone, PartialEq, Debug, Eq, StableHash)]
 pub enum GenericParamKind {
     Type,
@@ -70,6 +79,48 @@ pub enum Target {
     Break,
 }
 
+impl AstTarget<'_> {
+    pub fn get_abi(&self) -> Option<ExternAbi> {
+        let ext = match self {
+            AstTarget::Item(item) => {
+                let ast::ItemKind::Fn(fn_item) = &item.kind else {
+                    return None;
+                };
+                fn_item.sig.header.ext
+            }
+            AstTarget::AssocItem(assoc_item) => {
+                let ast::AssocItemKind::Fn(fn_item) = &assoc_item.kind else {
+                    return None;
+                };
+                fn_item.sig.header.ext
+            }
+        };
+
+        match ext {
+            ast::Extern::None => Some(ExternAbi::Rust),
+            ast::Extern::Implicit(_) => Some(ExternAbi::FALLBACK),
+            ast::Extern::Explicit(abi, _) => Some(abi.symbol_unescaped.as_str().parse().ok()?),
+        }
+    }
+
+    pub fn get_fn_sig(&self) -> Option<&rustc_ast::ast::FnSig> {
+        match self {
+            AstTarget::Item(item) => {
+                let ast::ItemKind::Fn(fn_item) = &item.kind else {
+                    return None;
+                };
+                Some(&fn_item.sig)
+            }
+            AstTarget::AssocItem(assoc_item) => {
+                let ast::AssocItemKind::Fn(fn_item) = &assoc_item.kind else {
+                    return None;
+                };
+                Some(&fn_item.sig)
+            }
+        }
+    }
+}
+
 impl Display for Target {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", Self::name(*self))

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -8,6 +8,7 @@ use rustc_structures::SanitizerSet;
 
 use super::prelude::*;
 use crate::attributes::AttributeSafety;
+use crate::context::FinalizeCheckFn;
 use crate::diagnostics::{
     EmptyExportName, EmptySection, NakedFunctionIncompatibleAttribute, NullOnExport,
     NullOnObjcClass, NullOnObjcSelector, NullOnSection, ObjcClassExpectedStringLiteral,
@@ -327,6 +328,42 @@ impl AttributeParser for NakedParser {
 
         Some(AttributeKind::Naked(span))
     }
+
+    fn deferred_finalize_check(&self) -> Option<(FinalizeCheckFn, Span)> {
+        Some((
+            |cx, _| match cx.target {
+                Target::Fn
+                | Target::Method(
+                    MethodKind::Trait { body: true } | MethodKind::TraitImpl | MethodKind::Inherent,
+                ) => {
+                    let Some(ast_target) = cx.ast_target else {
+                        panic!("missing AST target for {:?}", cx.target);
+                    };
+
+                    let fn_sig =
+                        ast_target.get_fn_sig().expect("missing fn signature for AST target");
+                    let Some(abi) = ast_target.get_abi() else {
+                        return;
+                    };
+
+                    if abi.is_rustic_abi() && !cx.features().naked_functions_rustic_abi() {
+                        feature_err(
+                            cx.sess(),
+                            sym::naked_functions_rustic_abi,
+                            fn_sig.span,
+                            format!(
+                                "`#[naked]` is currently unstable on `extern \"{}\"` functions",
+                                abi
+                            ),
+                        )
+                        .emit();
+                    }
+                }
+                _ => {}
+            },
+            self.span?,
+        ))
+    }
 }
 
 pub(crate) struct TrackCallerParser;