Auto merge of rust-lang#133925 - folkertdev:improve-repr-warnings, r=<try>

disallow `repr()` on invalid items

fixes rust-lang#129606

Disallows `repr()` (so a repr with no arguments) on items where that won't ever make sense.

Also this generates an error when `repr` is used on a trait method and the `fn_align` feature is not enabled. Looks like that was missed here:

https://github.com/rust-lang/rust/pull/110313/files

Which first accepts the align attribute on trait methods.

r? `@compiler-errors`

Author: bors

compiler/rustc_passes/src/check_attr.rs

@@ -1791,6 +1791,34 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         let mut is_simd = false;
         let mut is_transparent = false;
 
+        // catch `repr()` with no arguments, applied to an item (i.e. not `#![repr()]`)
+        if hints.is_empty() && item.is_some() {
+            for attr in attrs.iter().filter(|attr| attr.has_name(sym::repr)) {
+                match target {
+                    Target::Struct | Target::Union | Target::Enum => {}
+                    Target::Fn | Target::Method(_) => {
+                        feature_err(
+                            &self.tcx.sess,
+                            sym::fn_align,
+                            attr.span,
+                            fluent::passes_repr_align_function,
+                        )
+                        .emit();
+                    }
+                    _ => {
+                        self.dcx().emit_err(
+                            errors::AttrApplication::StructEnumFunctionMethodUnion {
+                                hint_span: attr.span,
+                                span,
+                            },
+                        );
+                    }
+                }
+            }
+
+            return;
+        }
+
         for hint in &hints {
             if !hint.is_meta_item() {
                 self.dcx().emit_err(errors::ReprIdent { span: hint.span() });
@@ -1823,24 +1851,19 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     }
                 }
                 sym::align => {
-                    if let (Target::Fn | Target::Method(MethodKind::Inherent), false) =
-                        (target, self.tcx.features().fn_align())
-                    {
-                        feature_err(
-                            &self.tcx.sess,
-                            sym::fn_align,
-                            hint.span(),
-                            fluent::passes_repr_align_function,
-                        )
-                        .emit();
-                    }
-
                     match target {
-                        Target::Struct
-                        | Target::Union
-                        | Target::Enum
-                        | Target::Fn
-                        | Target::Method(_) => {}
+                        Target::Struct | Target::Union | Target::Enum => {}
+                        Target::Fn | Target::Method(_) => {
+                            if !self.tcx.features().fn_align() {
+                                feature_err(
+                                    &self.tcx.sess,
+                                    sym::fn_align,
+                                    hint.span(),
+                                    fluent::passes_repr_align_function,
+                                )
+                                .emit();
+                            }
+                        }
                         _ => {
                             self.dcx().emit_err(
                                 errors::AttrApplication::StructEnumFunctionMethodUnion {

tests/ui/repr/attr-usage-repr.rs

@@ -16,18 +16,39 @@ struct SSimd([f64; 2]);
 struct SInt(f64, f64);
 
 #[repr(C)]
-enum EExtern { A, B }
+enum EExtern {
+    A,
+    B,
+}
 
 #[repr(align(8))]
-enum EAlign { A, B }
+enum EAlign {
+    A,
+    B,
+}
 
 #[repr(packed)] //~ ERROR: attribute should be applied to a struct
-enum EPacked { A, B }
+enum EPacked {
+    A,
+    B,
+}
 
 #[repr(simd)] //~ ERROR: attribute should be applied to a struct
-enum ESimd { A, B }
+enum ESimd {
+    A,
+    B,
+}
 
 #[repr(i8)]
-enum EInt { A, B }
+enum EInt {
+    A,
+    B,
+}
+
+#[repr()] //~ attribute should be applied to a struct, enum, function, associated function, or union [E0517]
+type SirThisIsAType = i32;
+
+#[repr()]
+struct EmptyReprArgumentList(i32);
 
 fn main() {}

tests/ui/repr/attr-usage-repr.stderr

@@ -15,21 +15,35 @@ LL | struct SInt(f64, f64);
    | ---------------------- not an enum
 
 error[E0517]: attribute should be applied to a struct or union
-  --> $DIR/attr-usage-repr.rs:24:8
+  --> $DIR/attr-usage-repr.rs:30:8
    |
-LL | #[repr(packed)]
-   |        ^^^^^^
-LL | enum EPacked { A, B }
-   | --------------------- not a struct or union
+LL |   #[repr(packed)]
+   |          ^^^^^^
+LL | / enum EPacked {
+LL | |     A,
+LL | |     B,
+LL | | }
+   | |_- not a struct or union
 
 error[E0517]: attribute should be applied to a struct
-  --> $DIR/attr-usage-repr.rs:27:8
+  --> $DIR/attr-usage-repr.rs:36:8
    |
-LL | #[repr(simd)]
-   |        ^^^^
-LL | enum ESimd { A, B }
-   | ------------------- not a struct
+LL |   #[repr(simd)]
+   |          ^^^^
+LL | / enum ESimd {
+LL | |     A,
+LL | |     B,
+LL | | }
+   | |_- not a struct
 
-error: aborting due to 4 previous errors
+error[E0517]: attribute should be applied to a struct, enum, function, associated function, or union
+  --> $DIR/attr-usage-repr.rs:48:1
+   |
+LL | #[repr()]
+   | ^^^^^^^^^
+LL | type SirThisIsAType = i32;
+   | -------------------------- not a struct, enum, function, associated function, or union
+
+error: aborting due to 5 previous errors
 
 For more information about this error, try `rustc --explain E0517`.