fix tests related to attr parsing

Author: jdonszelmann

compiler/rustc_attr_data_structures/src/attributes.rs

@@ -233,7 +233,7 @@ pub enum AttributeKind {
     ProcMacro,
     ProcMacroAttribute,
     ProcMacroDerive,
-    Repr(ThinVec<ReprAttr>),
+    Repr(ThinVec<(ReprAttr, Span)>),
     Stability {
         stability: Stability,
         /// Span of the `#[stable(...)]` or `#[unstable(...)]` attribute

compiler/rustc_attr_parsing/messages.ftl

@@ -66,6 +66,10 @@ attr_parsing_invalid_repr_hint_no_paren =
 attr_parsing_invalid_repr_hint_no_value =
     invalid representation hint: `{$name}` does not take a value
 
+attr_parsing_unrecognized_repr_hint =
+    unrecognized representation hint
+    .help = valid reprs are `Rust` (default), `C`, `align`, `packed`, `transparent`, `simd`, `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`, `isize`, `usize`
+
 attr_parsing_invalid_since =
     'since' must be a Rust version number, such as "1.31.0"
 
@@ -128,3 +132,6 @@ attr_parsing_unused_multiple =
     multiple `{$name}` attributes
     .suggestion = remove this attribute
     .note = attribute also specified here
+
+attr_parsing_repr_ident =
+    meta item in `repr` must be an identifier

compiler/rustc_attr_parsing/src/attributes/repr.rs

@@ -24,22 +24,23 @@ use crate::session_diagnostics::IncorrectReprFormatGenericCause;
 pub(crate) struct ReprGroup;
 
 impl CombineAttributeGroup for ReprGroup {
-    type Item = ReprAttr;
+    type Item = (ReprAttr, Span);
     const PATH: &'static [rustc_span::Symbol] = &[sym::repr];
-    const CONVERT: ConvertFn<ReprAttr> = AttributeKind::Repr;
+    const CONVERT: ConvertFn<Self::Item> = AttributeKind::Repr;
 
     fn extend<'a>(
         cx: &'a AttributeAcceptContext<'a>,
         args: &'a GenericArgParser<'a, rustc_ast::Expr>,
-    ) -> impl IntoIterator<Item = ReprAttr> + 'a {
+    ) -> impl IntoIterator<Item = Self::Item> + 'a {
         let mut reprs = Vec::new();
 
         let Some(list) = args.list() else {
             return reprs;
         };
 
         for param in list.mixed() {
-            reprs.extend(param.meta_item().and_then(|mi| parse_repr(cx, &mi)));
+            let span = param.span();
+            reprs.extend(param.meta_item().and_then(|mi| parse_repr(cx, &mi)).map(|r| (r, span)));
         }
 
         reprs
@@ -266,15 +267,8 @@ fn parse_simple_repr(
     }
 }
 
-// Not a word we recognize. This will be caught and reported by
-// the `check_mod_attrs` pass, but this pass doesn't always run
-// (e.g. if we only pretty-print the source), so we have to gate
-// the `span_delayed_bug` call as follows:
-// TODO: remove this in favor of just reporting the error here if we can...
 fn completely_unknown(cx: &AttributeAcceptContext<'_>, param_span: Span) {
-    if cx.sess().opts.pretty.map_or(true, |pp| pp.needs_analysis()) {
-        cx.dcx().span_delayed_bug(param_span, "unrecognized representation hint");
-    }
+    cx.dcx().emit_err(session_diagnostics::UnrecognizedReprHint { span: param_span });
 }
 
 fn int_type_of_word(s: Symbol) -> Option<IntType> {

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -458,3 +458,18 @@ pub(crate) struct EmptyConfusables {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_repr_ident, code = E0565)]
+pub(crate) struct ReprIdent {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_unrecognized_repr_hint, code = E0552)]
+#[help]
+pub(crate) struct UnrecognizedReprHint {
+    #[primary_span]
+    pub span: Span,
+}

compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs

@@ -35,7 +35,7 @@ pub(crate) fn expand_deriving_coerce_pointee(
     {
         let is_transparent = matches!(
             AttributeParseContext::parse_limited(cx.sess, &aitem.attrs, sym::repr, span),
-            Some(Attribute::Parsed(AttributeKind::Repr(r))) if r.contains(&ReprTransparent)
+            Some(Attribute::Parsed(AttributeKind::Repr(r))) if r.iter().any(|(r, _)| r == &ReprTransparent)
         );
 
         if !is_transparent {

compiler/rustc_builtin_macros/src/deriving/generic/mod.rs

@@ -482,7 +482,7 @@ impl<'a> TraitDef<'a> {
             Annotatable::Item(item) => {
                 let is_packed = matches!(
                     AttributeParseContext::parse_limited(cx.sess, &item.attrs, sym::repr, item.span),
-                    Some(Attribute::Parsed(AttributeKind::Repr(r))) if r.iter().any(|x| matches!(x, ReprPacked(..)))
+                    Some(Attribute::Parsed(AttributeKind::Repr(r))) if r.iter().any(|(x, _)| matches!(x, ReprPacked(..)))
                 );
 
                 let newitem = match &item.kind {

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -107,7 +107,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                 AttributeKind::Repr(reprs) => {
                     codegen_fn_attrs.alignment = reprs
                         .iter()
-                        .find_map(|r| if let ReprAlign(x) = r { Some(*x) } else { None });
+                        .find_map(|(r, _)| if let ReprAlign(x) = r { Some(*x) } else { None });
                 }
 
                 _ => {}

compiler/rustc_hir/src/hir.rs

@@ -1104,7 +1104,9 @@ impl AttributeExt for Attribute {
     fn span(&self) -> Span {
         match &self {
             Attribute::Unparsed(u) => u.span,
-            _ => panic!(),
+            // FIXME: should not be needed anymore when all attrs are parsed
+            Attribute::Parsed(AttributeKind::Deprecation {  span, .. }) => *span,
+            a => panic!("can't get the span of an arbitrary parsed attribute: {a:?}"),
         }
     }
 

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1253,7 +1253,7 @@ pub(super) fn check_packed(tcx: TyCtxt<'_>, sp: Span, def: ty::AdtDef<'_>) {
         if let Some(reprs) =
             attr::find_attr!(tcx.get_all_attrs(def.did()), AttributeKind::Repr(r) => r)
         {
-            for r in reprs {
+            for (r, _) in reprs {
                 if let ReprPacked(pack) = r
                     && let Some(repr_pack) = repr.pack
                     && pack != &repr_pack

compiler/rustc_lint/src/nonstandard_style.rs

@@ -164,7 +164,7 @@ impl EarlyLintPass for NonCamelCaseTypes {
     fn check_item(&mut self, cx: &EarlyContext<'_>, it: &ast::Item) {
         let has_repr_c = matches!(
             AttributeParseContext::parse_limited(cx.sess(), &it.attrs, sym::repr, it.span),
-            Some(Attribute::Parsed(AttributeKind::Repr(r))) if r.contains(&ReprAttr::ReprC)
+            Some(Attribute::Parsed(AttributeKind::Repr(r))) if r.iter().any(|(r, _)| r == &ReprAttr::ReprC)
         );
 
         if has_repr_c {