Consolidate checking for attributes not compatible with #[naked]

Currently #[inline] and #[track_caller] are incompatible with #[naked],
and there are more such attributes on the way.

In preparation for this, consolidate the existing checks into a central
location so that they can all be handled together.

In addition, clean up the wording of the existing error messages.

Author: bstrie

compiler/rustc_error_codes/src/error_codes/E0736.md

@@ -1,14 +1,23 @@
-`#[track_caller]` and `#[naked]` cannot both be applied to the same function.
+Functions marked with the `#[naked]` attribute are restricted in what other
+code generation attributes they may be marked with.
+
+The following code generation attributes are incompatible with `#[naked]`:
+
+  * `#[inline]`
+  * `#[track_caller]`
 
 Erroneous code example:
 
 ```compile_fail,E0736
+#[inline]
 #[naked]
-#[track_caller]
 fn foo() {}
 ```
 
-This is primarily due to ABI incompatibilities between the two attributes.
-See [RFC 2091] for details on this and other limitations.
+These incompatibilities are due to the fact that naked functions impose
+deliberately strict restrictions regarding the code that the compiler is
+allowed to produce for this function.
+
+See [the reference page for codegen attributes] for more information.
 
-[RFC 2091]: https://github.com/rust-lang/rfcs/blob/master/text/2091-inline-semantic.md
+[the reference page for codegen attributes]: https://doc.rust-lang.org/reference/attributes/codegen.html

compiler/rustc_error_codes/src/error_codes/E0739.md

@@ -1,4 +1,4 @@
-`#[track_caller]` can not be applied on struct.
+`#[track_caller]` must be applied to a function.
 
 Erroneous code example:
 

compiler/rustc_passes/src/check_attr.rs

@@ -80,51 +80,49 @@ impl CheckAttrVisitor<'_> {
                     self.check_rustc_must_implement_one_of(attr, span, target)
                 }
                 sym::target_feature => self.check_target_feature(hir_id, attr, span, target),
-                sym::track_caller => {
-                    self.check_track_caller(hir_id, attr.span, attrs, span, target)
-                }
+                sym::track_caller => self.check_track_caller(hir_id, attr, span, target),
                 sym::doc => self.check_doc_attrs(
                     attr,
                     hir_id,
                     target,
                     &mut specified_inline,
                     &mut doc_aliases,
                 ),
-                sym::no_link => self.check_no_link(hir_id, &attr, span, target),
-                sym::export_name => self.check_export_name(hir_id, &attr, span, target),
+                sym::no_link => self.check_no_link(hir_id, attr, span, target),
+                sym::export_name => self.check_export_name(hir_id, attr, span, target),
                 sym::rustc_layout_scalar_valid_range_start
                 | sym::rustc_layout_scalar_valid_range_end => {
-                    self.check_rustc_layout_scalar_valid_range(&attr, span, target)
+                    self.check_rustc_layout_scalar_valid_range(attr, span, target)
                 }
                 sym::allow_internal_unstable => {
-                    self.check_allow_internal_unstable(hir_id, &attr, span, target, &attrs)
+                    self.check_allow_internal_unstable(hir_id, attr, span, target, attrs)
                 }
                 sym::rustc_allow_const_fn_unstable => {
-                    self.check_rustc_allow_const_fn_unstable(hir_id, &attr, span, target)
+                    self.check_rustc_allow_const_fn_unstable(hir_id, attr, span, target)
                 }
-                sym::naked => self.check_naked(hir_id, attr, span, target),
+                sym::naked => self.check_naked(hir_id, attr, span, target, attrs),
                 sym::rustc_legacy_const_generics => {
-                    self.check_rustc_legacy_const_generics(&attr, span, target, item)
+                    self.check_rustc_legacy_const_generics(attr, span, target, item)
                 }
                 sym::rustc_lint_query_instability => {
-                    self.check_rustc_lint_query_instability(&attr, span, target)
+                    self.check_rustc_lint_query_instability(attr, span, target)
                 }
                 sym::rustc_clean
                 | sym::rustc_dirty
                 | sym::rustc_if_this_changed
-                | sym::rustc_then_this_would_need => self.check_rustc_dirty_clean(&attr),
+                | sym::rustc_then_this_would_need => self.check_rustc_dirty_clean(attr),
                 sym::cmse_nonsecure_entry => self.check_cmse_nonsecure_entry(attr, span, target),
                 sym::default_method_body_is_const => {
                     self.check_default_method_body_is_const(attr, span, target)
                 }
-                sym::must_not_suspend => self.check_must_not_suspend(&attr, span, target),
-                sym::must_use => self.check_must_use(hir_id, &attr, span, target),
-                sym::rustc_pass_by_value => self.check_pass_by_value(&attr, span, target),
+                sym::must_not_suspend => self.check_must_not_suspend(attr, span, target),
+                sym::must_use => self.check_must_use(hir_id, attr, span, target),
+                sym::rustc_pass_by_value => self.check_pass_by_value(attr, span, target),
                 sym::rustc_const_unstable
                 | sym::rustc_const_stable
                 | sym::unstable
                 | sym::stable
-                | sym::rustc_promotable => self.check_stability_promotable(&attr, span, target),
+                | sym::rustc_promotable => self.check_stability_promotable(attr, span, target),
                 _ => true,
             };
             is_valid &= attr_is_valid;
@@ -338,7 +336,27 @@ impl CheckAttrVisitor<'_> {
     }
 
     /// Checks if `#[naked]` is applied to a function definition.
-    fn check_naked(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
+    fn check_naked(
+        &self,
+        hir_id: HirId,
+        attr: &Attribute,
+        span: Span,
+        target: Target,
+        attrs: &[Attribute],
+    ) -> bool {
+        for any_attr in attrs {
+            if any_attr.has_name(sym::track_caller) || any_attr.has_name(sym::inline) {
+                struct_span_err!(
+                    self.tcx.sess,
+                    any_attr.span,
+                    E0736,
+                    "cannot use additional code generation attributes with `#[naked]`",
+                )
+                .emit();
+                return false;
+            }
+        }
+
         match target {
             Target::Fn
             | Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent) => true,
@@ -383,41 +401,28 @@ impl CheckAttrVisitor<'_> {
         }
     }
 
-    /// Checks if a `#[track_caller]` is applied to a non-naked function. Returns `true` if valid.
+    /// Checks if a `#[track_caller]` is applied to a function. Returns `true` if valid.
     fn check_track_caller(
         &self,
         hir_id: HirId,
-        attr_span: Span,
-        attrs: &[Attribute],
+        attr: &Attribute,
         span: Span,
         target: Target,
     ) -> bool {
         match target {
-            _ if attrs.iter().any(|attr| attr.has_name(sym::naked)) => {
-                struct_span_err!(
-                    self.tcx.sess,
-                    attr_span,
-                    E0736,
-                    "cannot use `#[track_caller]` with `#[naked]`",
-                )
-                .emit();
-                false
-            }
             Target::Fn | Target::Method(..) | Target::ForeignFn | Target::Closure => true,
             // FIXME(#80564): We permit struct fields, match arms and macro defs to have an
             // `#[track_caller]` attribute with just a lint, because we previously
             // erroneously allowed it and some crates used it accidentally, to to be compatible
             // with crates depending on them, we can't throw an error here.
             Target::Field | Target::Arm | Target::MacroDef => {
-                for attr in attrs {
-                    self.inline_attr_str_error_with_macro_def(hir_id, attr, "track_caller");
-                }
+                self.inline_attr_str_error_with_macro_def(hir_id, attr, "track_caller");
                 true
             }
             _ => {
                 struct_span_err!(
                     self.tcx.sess,
-                    attr_span,
+                    attr.span,
                     E0739,
                     "attribute should be applied to function"
                 )

compiler/rustc_passes/src/naked_functions.rs

@@ -1,6 +1,6 @@
 //! Checks validity of naked functions.
 
-use rustc_ast::{Attribute, InlineAsmOptions};
+use rustc_ast::InlineAsmOptions;
 use rustc_errors::struct_span_err;
 use rustc_hir as hir;
 use rustc_hir::def_id::LocalDefId;
@@ -65,18 +65,10 @@ impl<'tcx> Visitor<'tcx> for CheckNakedFunctions<'tcx> {
             check_no_patterns(self.tcx, body.params);
             check_no_parameters_use(self.tcx, body);
             check_asm(self.tcx, body, span);
-            check_inline(self.tcx, attrs);
         }
     }
 }
 
-/// Check that the function isn't inlined.
-fn check_inline(tcx: TyCtxt<'_>, attrs: &[Attribute]) {
-    for attr in attrs.iter().filter(|attr| attr.has_name(sym::inline)) {
-        tcx.sess.struct_span_err(attr.span, "naked functions cannot be inlined").emit();
-    }
-}
-
 /// Checks that function uses non-Rust ABI.
 fn check_abi(tcx: TyCtxt<'_>, hir_id: HirId, abi: Abi, fn_ident_span: Span) {
     if abi == Abi::Rust {

src/test/ui/asm/naked-functions-inline.rs

@@ -0,0 +1,32 @@
+// needs-asm-support
+
+#![feature(naked_functions)]
+#![crate_type = "lib"]
+
+use std::arch::asm;
+
+#[naked]
+pub unsafe extern "C" fn inline_none() {
+    asm!("", options(noreturn));
+}
+
+#[naked]
+#[inline]
+//~^ ERROR cannot use additional code generation attributes with `#[naked]`
+pub unsafe extern "C" fn inline_hint() {
+    asm!("", options(noreturn));
+}
+
+#[naked]
+#[inline(always)]
+//~^ ERROR cannot use additional code generation attributes with `#[naked]`
+pub unsafe extern "C" fn inline_always() {
+    asm!("", options(noreturn));
+}
+
+#[naked]
+#[inline(never)]
+//~^ ERROR cannot use additional code generation attributes with `#[naked]`
+pub unsafe extern "C" fn inline_never() {
+    asm!("", options(noreturn));
+}

src/test/ui/asm/naked-functions-inline.stderr

@@ -0,0 +1,21 @@
+error[E0736]: cannot use additional code generation attributes with `#[naked]`
+  --> $DIR/naked-functions-inline.rs:14:1
+   |
+LL | #[inline]
+   | ^^^^^^^^^
+
+error[E0736]: cannot use additional code generation attributes with `#[naked]`
+  --> $DIR/naked-functions-inline.rs:21:1
+   |
+LL | #[inline(always)]
+   | ^^^^^^^^^^^^^^^^^
+
+error[E0736]: cannot use additional code generation attributes with `#[naked]`
+  --> $DIR/naked-functions-inline.rs:28:1
+   |
+LL | #[inline(never)]
+   | ^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0736`.

src/test/ui/asm/naked-functions.rs

@@ -160,40 +160,3 @@ pub unsafe extern "C" fn valid_c() {
 pub unsafe extern "C" fn valid_att_syntax() {
     asm!("", options(noreturn, att_syntax));
 }
-
-#[naked]
-pub unsafe extern "C" fn inline_none() {
-    asm!("", options(noreturn));
-}
-
-#[naked]
-#[inline]
-//~^ ERROR naked functions cannot be inlined
-pub unsafe extern "C" fn inline_hint() {
-    asm!("", options(noreturn));
-}
-
-#[naked]
-#[inline(always)]
-//~^ ERROR naked functions cannot be inlined
-pub unsafe extern "C" fn inline_always() {
-    asm!("", options(noreturn));
-}
-
-#[naked]
-#[inline(never)]
-//~^ ERROR naked functions cannot be inlined
-pub unsafe extern "C" fn inline_never() {
-    asm!("", options(noreturn));
-}
-
-#[naked]
-#[inline]
-//~^ ERROR naked functions cannot be inlined
-#[inline(always)]
-//~^ ERROR naked functions cannot be inlined
-#[inline(never)]
-//~^ ERROR naked functions cannot be inlined
-pub unsafe extern "C" fn inline_all() {
-    asm!("", options(noreturn));
-}

src/test/ui/asm/naked-functions.stderr

@@ -219,42 +219,6 @@ warning: Rust ABI is unsupported in naked functions
 LL | pub unsafe fn rust_abi() {
    |               ^^^^^^^^
 
-error: naked functions cannot be inlined
-  --> $DIR/naked-functions.rs:170:1
-   |
-LL | #[inline]
-   | ^^^^^^^^^
-
-error: naked functions cannot be inlined
-  --> $DIR/naked-functions.rs:177:1
-   |
-LL | #[inline(always)]
-   | ^^^^^^^^^^^^^^^^^
-
-error: naked functions cannot be inlined
-  --> $DIR/naked-functions.rs:184:1
-   |
-LL | #[inline(never)]
-   | ^^^^^^^^^^^^^^^^
-
-error: naked functions cannot be inlined
-  --> $DIR/naked-functions.rs:191:1
-   |
-LL | #[inline]
-   | ^^^^^^^^^
-
-error: naked functions cannot be inlined
-  --> $DIR/naked-functions.rs:193:1
-   |
-LL | #[inline(always)]
-   | ^^^^^^^^^^^^^^^^^
-
-error: naked functions cannot be inlined
-  --> $DIR/naked-functions.rs:195:1
-   |
-LL | #[inline(never)]
-   | ^^^^^^^^^^^^^^^^
-
-error: aborting due to 30 previous errors; 2 warnings emitted
+error: aborting due to 24 previous errors; 2 warnings emitted
 
 For more information about this error, try `rustc --explain E0787`.

src/test/ui/rfc-2091-track-caller/error-with-naked.rs

@@ -3,7 +3,7 @@
 
 use std::arch::asm;
 
-#[track_caller] //~ ERROR cannot use `#[track_caller]` with `#[naked]`
+#[track_caller] //~ ERROR cannot use additional code generation attributes with `#[naked]`
 #[naked]
 extern "C" fn f() {
     asm!("", options(noreturn));
@@ -12,7 +12,7 @@ extern "C" fn f() {
 struct S;
 
 impl S {
-    #[track_caller] //~ ERROR cannot use `#[track_caller]` with `#[naked]`
+    #[track_caller] //~ ERROR cannot use additional code generation attributes with `#[naked]`
     #[naked]
     extern "C" fn g() {
         asm!("", options(noreturn));

src/test/ui/rfc-2091-track-caller/error-with-naked.stderr

@@ -1,10 +1,10 @@
-error[E0736]: cannot use `#[track_caller]` with `#[naked]`
+error[E0736]: cannot use additional code generation attributes with `#[naked]`
   --> $DIR/error-with-naked.rs:6:1
    |
 LL | #[track_caller]
    | ^^^^^^^^^^^^^^^
 
-error[E0736]: cannot use `#[track_caller]` with `#[naked]`
+error[E0736]: cannot use additional code generation attributes with `#[naked]`
   --> $DIR/error-with-naked.rs:15:5
    |
 LL |     #[track_caller]