Revert "Allow specifying alignment for functions"

This reverts commit 448d076 to address
issue 85713 on beta.

Author: pnkfelix

compiler/rustc_attr/src/builtin.rs

@@ -862,6 +862,18 @@ pub fn find_repr_attrs(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
         if let Some(items) = attr.meta_item_list() {
             sess.mark_attr_used(attr);
             for item in items {
+                if !item.is_meta_item() {
+                    handle_errors(
+                        &sess.parse_sess,
+                        item.span(),
+                        AttrError::UnsupportedLiteral(
+                            "meta item in `repr` must be an identifier",
+                            false,
+                        ),
+                    );
+                    continue;
+                }
+
                 let mut recognised = false;
                 if item.is_word() {
                     let hint = match item.name_or_empty() {
@@ -878,6 +890,23 @@ pub fn find_repr_attrs(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
                         acc.push(h);
                     }
                 } else if let Some((name, value)) = item.name_value_literal() {
+                    let parse_alignment = |node: &ast::LitKind| -> Result<u32, &'static str> {
+                        if let ast::LitKind::Int(literal, ast::LitIntType::Unsuffixed) = node {
+                            if literal.is_power_of_two() {
+                                // rustc_middle::ty::layout::Align restricts align to <= 2^29
+                                if *literal <= 1 << 29 {
+                                    Ok(*literal as u32)
+                                } else {
+                                    Err("larger than 2^29")
+                                }
+                            } else {
+                                Err("not a power of two")
+                            }
+                        } else {
+                            Err("not an unsuffixed integer")
+                        }
+                    };
+
                     let mut literal_error = None;
                     if name == sym::align {
                         recognised = true;
@@ -937,7 +966,13 @@ pub fn find_repr_attrs(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
                 }
                 if !recognised {
                     // Not a word we recognize
-                    diagnostic.delay_span_bug(item.span(), "unrecognized representation hint");
+                    struct_span_err!(
+                        diagnostic,
+                        item.span(),
+                        E0552,
+                        "unrecognized representation hint"
+                    )
+                    .emit();
                 }
             }
         }
@@ -1045,16 +1080,3 @@ fn allow_unstable<'a>(
         name
     })
 }
-
-pub fn parse_alignment(node: &ast::LitKind) -> Result<u32, &'static str> {
-    if let ast::LitKind::Int(literal, ast::LitIntType::Unsuffixed) = node {
-        if literal.is_power_of_two() {
-            // rustc_middle::ty::layout::Align restricts align to <= 2^29
-            if *literal <= 1 << 29 { Ok(*literal as u32) } else { Err("larger than 2^29") }
-        } else {
-            Err("not a power of two")
-        }
-    } else {
-        Err("not an unsuffixed integer")
-    }
-}

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -281,9 +281,6 @@ pub fn from_fn_attrs(cx: &CodegenCx<'ll, 'tcx>, llfn: &'ll Value, instance: ty::
     if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::CMSE_NONSECURE_ENTRY) {
         llvm::AddFunctionAttrString(llfn, Function, cstr!("cmse_nonsecure_entry"));
     }
-    if let Some(align) = codegen_fn_attrs.alignment {
-        llvm::set_alignment(llfn, align as usize);
-    }
     sanitize(cx, codegen_fn_attrs.no_sanitize, llfn);
 
     // Always annotate functions with the target-cpu they are compiled for.

compiler/rustc_feature/src/active.rs

@@ -637,9 +637,6 @@ declare_features! (
     /// Allows `extern "C-unwind" fn` to enable unwinding across ABI boundaries.
     (active, c_unwind, "1.52.0", Some(74990), None),
 
-    /// Allows using `#[repr(align(...))]` on function items
-    (active, fn_align, "1.53.0", Some(82232), None),
-
     /// Allows `extern "wasm" fn`
     (active, wasm_abi, "1.53.0", Some(83788), None),
 

compiler/rustc_middle/src/middle/codegen_fn_attrs.rs

@@ -38,9 +38,6 @@ pub struct CodegenFnAttrs {
     /// be generated against a specific instruction set. Only usable on architectures which allow
     /// switching between multiple instruction sets.
     pub instruction_set: Option<InstructionSetAttr>,
-    /// The `#[repr(align(...))]` attribute. Indicates the value of which the function should be
-    /// aligned to.
-    pub alignment: Option<u32>,
 }
 
 bitflags! {
@@ -110,7 +107,6 @@ impl CodegenFnAttrs {
             link_section: None,
             no_sanitize: SanitizerSet::empty(),
             instruction_set: None,
-            alignment: None,
         }
     }
 

compiler/rustc_passes/src/check_attr.rs

@@ -1120,41 +1120,17 @@ impl CheckAttrVisitor<'tcx> {
         let mut is_transparent = false;
 
         for hint in &hints {
-            if !hint.is_meta_item() {
-                struct_span_err!(
-                    self.tcx.sess,
-                    hint.span(),
-                    E0565,
-                    "meta item in `repr` must be an identifier"
-                )
-                .emit();
-                continue;
-            }
-
             let (article, allowed_targets) = match hint.name_or_empty() {
-                sym::C => {
-                    is_c = true;
+                _ if !matches!(target, Target::Struct | Target::Enum | Target::Union) => {
+                    ("a", "struct, enum, or union")
+                }
+                name @ sym::C | name @ sym::align => {
+                    is_c |= name == sym::C;
                     match target {
                         Target::Struct | Target::Union | Target::Enum => continue,
                         _ => ("a", "struct, enum, or union"),
                     }
                 }
-                sym::align => {
-                    if let (Target::Fn, true) = (target, !self.tcx.features().fn_align) {
-                        feature_err(
-                            &self.tcx.sess.parse_sess,
-                            sym::fn_align,
-                            hint.span(),
-                            "`repr(align)` attributes on functions are unstable",
-                        )
-                        .emit();
-                    }
-
-                    match target {
-                        Target::Struct | Target::Union | Target::Enum | Target::Fn => continue,
-                        _ => ("a", "struct, enum, function, or union"),
-                    }
-                }
                 sym::packed => {
                     if target != Target::Struct && target != Target::Union {
                         ("a", "struct or union")
@@ -1211,17 +1187,7 @@ impl CheckAttrVisitor<'tcx> {
                         continue;
                     }
                 }
-                _ => {
-                    struct_span_err!(
-                        self.tcx.sess,
-                        hint.span(),
-                        E0552,
-                        "unrecognized representation hint"
-                    )
-                    .emit();
-
-                    continue;
-                }
+                _ => continue,
             };
 
             struct_span_err!(

compiler/rustc_span/src/symbol.rs

@@ -563,7 +563,6 @@ symbols! {
         fmt,
         fmt_internals,
         fmul_fast,
-        fn_align,
         fn_must_use,
         fn_mut,
         fn_once,

compiler/rustc_typeck/src/collect.rs

@@ -15,8 +15,6 @@
 //! At present, however, we do run collection across all items in the
 //! crate as a kind of pass. This should eventually be factored away.
 
-// ignore-tidy-filelength
-
 use crate::astconv::{AstConv, SizedByDefault};
 use crate::bounds::Bounds;
 use crate::check::intrinsic::intrinsic_operation_unsafety;
@@ -2903,36 +2901,6 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, id: DefId) -> CodegenFnAttrs {
                     None
                 }
             };
-        } else if tcx.sess.check_name(attr, sym::repr) {
-            codegen_fn_attrs.alignment = match attr.meta_item_list() {
-                Some(items) => match items.as_slice() {
-                    [item] => match item.name_value_literal() {
-                        Some((sym::align, literal)) => {
-                            let alignment = rustc_attr::parse_alignment(&literal.kind);
-
-                            match alignment {
-                                Ok(align) => Some(align),
-                                Err(msg) => {
-                                    struct_span_err!(
-                                        tcx.sess.diagnostic(),
-                                        attr.span,
-                                        E0589,
-                                        "invalid `repr(align)` attribute: {}",
-                                        msg
-                                    )
-                                    .emit();
-
-                                    None
-                                }
-                            }
-                        }
-                        _ => None,
-                    },
-                    [] => None,
-                    _ => None,
-                },
-                None => None,
-            };
         }
     }
 

src/test/codegen/align-fn.rs

@@ -3,6 +3,7 @@
 macro_rules! pass_nonterminal {
     ($n:expr) => {
         #[repr(align($n))] //~ ERROR expected unsuffixed literal or identifier, found `n!()`
+                           //~| ERROR unrecognized representation hint
         struct S;
     };
 }

src/test/ui/attributes/nonterminal-expansion.rs

@@ -9,5 +9,17 @@ LL | pass_nonterminal!(n!());
    |
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error[E0552]: unrecognized representation hint
+  --> $DIR/nonterminal-expansion.rs:5:16
+   |
+LL |         #[repr(align($n))]
+   |                ^^^^^^^^^
+...
+LL | pass_nonterminal!(n!());
+   | ------------------------ in this macro invocation
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 2 previous errors
 
+For more information about this error, try `rustc --explain E0552`.

src/test/ui/attributes/nonterminal-expansion.stderr

@@ -1,5 +1,6 @@
 // repr currently doesn't support literals
 #[repr("C")] //~ ERROR E0565
-struct A {}
+             //~| ERROR E0565
+struct A {  }
 
-fn main() {}
+fn main() {  }

src/test/ui/error-codes/E0565.rs

@@ -4,6 +4,12 @@ error[E0565]: meta item in `repr` must be an identifier
 LL | #[repr("C")]
    |        ^^^
 
-error: aborting due to previous error
+error[E0565]: meta item in `repr` must be an identifier
+  --> $DIR/E0565.rs:2:8
+   |
+LL | #[repr("C")]
+   |        ^^^
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0565`.

src/test/ui/error-codes/E0565.stderr

@@ -13,13 +13,13 @@ fn main() {
 
     #[repr(nothing)]
     let _x = 0;
-    //~^^ ERROR E0552
+    //~^^ ERROR attribute should be applied to a struct, enum, or union
 
     #[repr(something_not_real)]
     loop {
         ()
     };
-    //~^^^^ ERROR E0552
+    //~^^^^ ERROR attribute should be applied to a struct, enum, or union
 
     #[repr]
     let _y = "123";

src/test/ui/feature-gates/feature-gate-fn_align.rs

@@ -26,17 +26,23 @@ LL |     #[inline(XYZ)]
 LL |     let _b = 4;
    |     ----------- not a function or closure
 
-error[E0552]: unrecognized representation hint
+error[E0517]: attribute should be applied to a struct, enum, or union
   --> $DIR/issue-43988.rs:14:12
    |
 LL |     #[repr(nothing)]
    |            ^^^^^^^
+LL |     let _x = 0;
+   |     ----------- not a struct, enum, or union
 
-error[E0552]: unrecognized representation hint
+error[E0517]: attribute should be applied to a struct, enum, or union
   --> $DIR/issue-43988.rs:18:12
    |
-LL |     #[repr(something_not_real)]
-   |            ^^^^^^^^^^^^^^^^^^
+LL |       #[repr(something_not_real)]
+   |              ^^^^^^^^^^^^^^^^^^
+LL | /     loop {
+LL | |         ()
+LL | |     };
+   | |_____- not a struct, enum, or union
 
 error[E0518]: attribute should be applied to function or closure
   --> $DIR/issue-43988.rs:30:5
@@ -48,5 +54,5 @@ LL |     foo();
 
 error: aborting due to 7 previous errors
 
-Some errors have detailed explanations: E0518, E0552.
-For more information about an error, try `rustc --explain E0518`.
+Some errors have detailed explanations: E0517, E0518.
+For more information about an error, try `rustc --explain E0517`.

src/test/ui/feature-gates/feature-gate-fn_align.stderr

@@ -2,7 +2,7 @@ struct Test;
 
 enum Foo {
     #[repr(u8)]
-    //~^ ERROR attribute should be applied to an enum
+    //~^ ERROR attribute should be applied to a struct, enum, or union
     Variant,
 }
 

src/test/ui/issues/issue-43988.rs

@@ -1,11 +1,11 @@
-error[E0517]: attribute should be applied to an enum
+error[E0517]: attribute should be applied to a struct, enum, or union
   --> $DIR/repr-disallow-on-variant.rs:4:12
    |
 LL |     #[repr(u8)]
    |            ^^
 LL |
 LL |     Variant,
-   |     ------- not an enum
+   |     ------- not a struct, enum, or union
 
 error: aborting due to previous error