Rollup of 14 pull requests

compiler/rustc_ast/src/ast.rs

@@ -3514,7 +3514,7 @@ pub enum SyntheticAttr {
     /// because they are not needed.
     ///
     /// The attribute is used by some clippy lints.
-    CfgAttrTrace,
+    CfgAttrTrace(CfgEntry),
 }
 
 impl AttrItem {

compiler/rustc_ast/src/attr/mod.rs

@@ -106,7 +106,7 @@ impl AttributeExt for Attribute {
         use SyntheticAttr::*;
         match &self.kind {
             AttrKind::Normal(normal) => normal.item.name(),
-            AttrKind::Synthetic(CfgTrace(_) | CfgAttrTrace) => None,
+            AttrKind::Synthetic(CfgTrace(_) | CfgAttrTrace(_)) => None,
             AttrKind::DocComment(..) => None,
         }
     }
@@ -117,7 +117,7 @@ impl AttributeExt for Attribute {
             AttrKind::Normal(normal) => {
                 Some(normal.item.path.segments.iter().map(|i| i.ident.name).collect())
             }
-            AttrKind::Synthetic(CfgTrace(_) | CfgAttrTrace) => None,
+            AttrKind::Synthetic(CfgTrace(_) | CfgAttrTrace(_)) => None,
             AttrKind::DocComment(_, _) => None,
         }
     }

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -525,7 +525,7 @@ impl<'a> AstValidator<'a> {
                         [sym::allow, sym::deny, sym::expect, sym::forbid, sym::splat, sym::warn];
                     !attr.has_any_name(&arr) && rustc_attr_parsing::is_builtin_attr(&normal.item)
                 }
-                AttrKind::Synthetic(CfgTrace(_) | CfgAttrTrace) => false,
+                AttrKind::Synthetic(CfgTrace(_) | CfgAttrTrace(_)) => false,
                 AttrKind::DocComment(..) => true,
             })
             .for_each(|attr| {
@@ -1202,6 +1202,48 @@ impl<'a> AstValidator<'a> {
         self.visit_vis(vis);
         self.visit_ident(ident);
     }
+
+    // Check EII implementation attributes against an allowlist.
+    fn check_eii_impl_attrs(&self, attrs: &[Attribute], eii_impls: &[EiiImpl]) {
+        if eii_impls.is_empty() {
+            return;
+        }
+
+        let allowed_attrs: &[Symbol] = &[
+            sym::allow,
+            sym::warn,
+            sym::deny,
+            sym::forbid,
+            sym::expect,
+            sym::doc,
+            sym::inline,
+            sym::cold,
+            sym::optimize,
+            sym::coverage,
+            sym::sanitize,
+            sym::must_use,
+            sym::deprecated,
+        ];
+
+        for attr in attrs {
+            let AttrKind::Normal(normal) = &attr.kind else {
+                continue;
+            };
+            if attr.has_any_name(allowed_attrs) {
+                continue;
+            }
+
+            let attr_name = pprust::path_to_string(&normal.item.path);
+            for eii_impl in eii_impls {
+                self.dcx().emit_err(diagnostics::EiiImplAttributeNotSupported {
+                    attr_span: attr.span,
+                    attr_name: &attr_name,
+                    eii_span: eii_impl.span,
+                    eii_name: pprust::path_to_string(&eii_impl.eii_macro_path),
+                });
+            }
+        }
+    }
 }
 
 /// Checks that generic parameters are in the correct order,
@@ -1391,6 +1433,7 @@ impl Visitor<'_> for AstValidator<'_> {
                 for EiiImpl { eii_macro_path, .. } in eii_impls {
                     self.visit_path(eii_macro_path);
                 }
+                self.check_eii_impl_attrs(&item.attrs, eii_impls);
 
                 let is_intrinsic = item.attrs.iter().any(|a| a.has_name(sym::rustc_intrinsic));
                 if body.is_none() && !is_intrinsic && !self.is_sdylib_interface {
@@ -1566,8 +1609,9 @@ impl Visitor<'_> for AstValidator<'_> {
 
                 visit::walk_item(self, item);
             }
-            ItemKind::Static(StaticItem { expr, safety, .. }) => {
+            ItemKind::Static(StaticItem { expr, safety, eii_impls, .. }) => {
                 self.check_item_safety(item.span, *safety);
+                self.check_eii_impl_attrs(&item.attrs, eii_impls);
                 if matches!(safety, Safety::Unsafe(_)) {
                     self.dcx().emit_err(diagnostics::UnsafeStatic { span: item.span });
                 }

compiler/rustc_ast_passes/src/diagnostics.rs

@@ -189,6 +189,17 @@ pub(crate) struct FnParamForbiddenAttr {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("`#[{$eii_name}]` is not allowed to have `#[{$attr_name}]`")]
+pub(crate) struct EiiImplAttributeNotSupported<'a> {
+    #[primary_span]
+    pub attr_span: Span,
+    pub attr_name: &'a str,
+    pub eii_name: String,
+    #[label("`#[{$eii_name}]` is not allowed to have `#[{$attr_name}]`")]
+    pub eii_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag("`self` parameter is only allowed in associated functions")]
 #[note("associated functions are those in `impl` or `trait` definitions")]

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -665,7 +665,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
     fn print_attribute_inline(&mut self, attr: &ast::Attribute, is_inline: bool) -> bool {
         use ast::SyntheticAttr::*;
         match attr.kind {
-            AttrKind::Synthetic(CfgTrace(_) | CfgAttrTrace) => {
+            AttrKind::Synthetic(CfgTrace(_) | CfgAttrTrace(_)) => {
                 // These are internal synthetic attributes with no syntax, so avoid printing them
                 // to keep the printed code reasonably parse-able.
                 return false;

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -353,12 +353,13 @@ pub fn parse_cfg_attr(
             {
                 (dspan.entire(), AttributeParseErrorReason::ExpectedAtLeastOneArgument)
             } else {
-                (cfg_attr.span, AttributeParseErrorReason::ExpectedList)
+                (cfg_attr.get_normal_item().span, AttributeParseErrorReason::ExpectedList)
             };
 
             sess.dcx().emit_err(AttributeParseError {
                 span,
                 attr_span: cfg_attr.span,
+                inner_span: cfg_attr.get_normal_item().span,
                 template: CFG_ATTR_TEMPLATE,
                 path: AttrPath::from_ast(&cfg_attr.get_normal_item().path, identity),
                 description: ParsedDescription::Attribute,

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -127,7 +127,7 @@ impl SingleAttributeParser for PatternComplexityLimitParser {
     const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
     const STABILITY: AttributeStability = unstable!(
         rustc_attrs,
-        "the `#[pattern_complexity_limit]` attribute is used for rustc unit tests"
+        "the `pattern_complexity_limit` attribute is used for rustc unit tests"
     );
 
     fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {

compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unimplemented.rs

@@ -38,7 +38,7 @@ impl AttributeParser for OnUnimplementedParser {
             template!(List: &[r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#]),
             unstable!(
                 rustc_attrs,
-                "see `#[diagnostic::on_unimplemented]` for the stable equivalent of this attribute"
+                "see the `diagnostic::on_unimplemented` attribute for the stable equivalent of this attribute"
             ),
             |this, cx, args| {
                 this.parse(cx, args, Mode::RustcOnUnimplemented);

compiler/rustc_attr_parsing/src/attributes/dummy.rs

@@ -15,7 +15,7 @@ impl SingleAttributeParser for RustcDummyParser {
     const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::ManuallyChecked;
     const TEMPLATE: AttributeTemplate = template!(Word); // Anything, really
     const STABILITY: AttributeStability =
-        unstable!(rustc_attrs, "the `#[rustc_dummy]` attribute is used for rustc unit tests");
+        unstable!(rustc_attrs, "the `rustc_dummy` attribute is used for rustc unit tests");
 
     fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {
         args.ignore_args();

compiler/rustc_attr_parsing/src/attributes/inline.rs

@@ -70,8 +70,10 @@ impl SingleAttributeParser for RustcForceInlineParser {
         Allow(Target::Fn),
         Allow(Target::Method(MethodKind::Inherent)),
     ]);
-    const STABILITY: AttributeStability =
-        unstable!(rustc_attrs, "`#[rustc_force_inline]` forces a free function to be inlined");
+    const STABILITY: AttributeStability = unstable!(
+        rustc_attrs,
+        "the `rustc_force_inline` attribute forces a free function to be inlined"
+    );
     const TEMPLATE: AttributeTemplate = template!(Word, List: &["reason"], NameValueStr: "reason");
 
     fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {

compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs

@@ -261,10 +261,8 @@ impl NoArgsAttributeParser for RustcDumpVariancesParser {
         Allow(Target::Struct),
         Allow(Target::Union),
     ]);
-    const STABILITY: AttributeStability = unstable!(
-        rustc_attrs,
-        "the `#[rustc_dump_variances]` attribute is used for rustc unit tests"
-    );
+    const STABILITY: AttributeStability =
+        unstable!(rustc_attrs, "the `rustc_dump_variances` attribute is used for rustc unit tests");
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpVariances;
 }
 

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -24,7 +24,7 @@ impl NoArgsAttributeParser for RustcMainParser {
     const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
     const STABILITY: AttributeStability = unstable!(
         rustc_attrs,
-        "the `#[rustc_main]` attribute is used internally to specify test entry point function"
+        "the `rustc_main` attribute is used internally to specify test entry point function"
     );
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcMain;
 }
@@ -36,7 +36,7 @@ impl SingleAttributeParser for RustcMustImplementOneOfParser {
     const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[Allow(Target::Trait)]);
     const STABILITY: AttributeStability = unstable!(
         rustc_attrs,
-        "the `#[rustc_must_implement_one_of]` attribute is used to change minimal complete definition of a trait. Its syntax and semantics are highly experimental and will be subject to change before stabilization"
+        "the `rustc_must_implement_one_of` attribute is used to change minimal complete definition of a trait. Its syntax and semantics are highly experimental and will be subject to change before stabilization"
     );
     const TEMPLATE: AttributeTemplate = template!(List: &["function1, function2, ..."]);
     fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {
@@ -734,7 +734,7 @@ impl NoArgsAttributeParser for RustcNonConstTraitMethodParser {
     ]);
     const STABILITY: AttributeStability = unstable!(
         rustc_attrs,
-        "`#[rustc_non_const_trait_method]` should only used by the standard library to mark trait methods as non-const to allow large traits an easier transition to const"
+        "the `rustc_non_const_trait_method` attribute should only be used by the standard library to mark trait methods as non-const to allow large traits an easier transition to const"
     );
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcNonConstTraitMethod;
 }
@@ -1018,7 +1018,7 @@ impl SingleAttributeParser for RustcDiagnosticItemParser {
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
     const STABILITY: AttributeStability = unstable!(
         rustc_attrs,
-        "the `#[rustc_diagnostic_item]` attribute allows the compiler to reference types from the standard library for diagnostic purposes"
+        "the `rustc_diagnostic_item` attribute allows the compiler to reference types from the standard library for diagnostic purposes"
     );
 
     fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {
@@ -1041,7 +1041,7 @@ impl NoArgsAttributeParser for RustcDoNotConstCheckParser {
     ]);
     const STABILITY: AttributeStability = unstable!(
         rustc_attrs,
-        "`#[rustc_do_not_const_check]` skips const-check for this function's body"
+        "the `rustc_do_not_const_check` attribute skips const-check for this function's body"
     );
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDoNotConstCheck;
 }
@@ -1053,7 +1053,7 @@ impl NoArgsAttributeParser for RustcNonnullOptimizationGuaranteedParser {
     const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[Allow(Target::Struct)]);
     const STABILITY: AttributeStability = unstable!(
         rustc_attrs,
-        "the `#[rustc_nonnull_optimization_guaranteed]` attribute is just used to document guaranteed niche optimizations in the standard library",
+        "the `rustc_nonnull_optimization_guaranteed` attribute is just used to document guaranteed niche optimizations in the standard library",
         "the compiler does not even check whether the type indeed is being non-null-optimized; it is your responsibility to ensure that the attribute is only used on types that are optimized"
     );
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcNonnullOptimizationGuaranteed;
@@ -1108,7 +1108,7 @@ impl SingleAttributeParser for RustcDocPrimitiveParser {
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "primitive name");
     const STABILITY: AttributeStability = unstable!(
         rustc_attrs,
-        "the `#[rustc_doc_primitive]` attribute is used by the standard library to provide a way to generate documentation for primitive types"
+        "the `rustc_doc_primitive` attribute is used by the standard library to provide a way to generate documentation for primitive types"
     );
 
     fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {
@@ -1154,7 +1154,7 @@ impl NoArgsAttributeParser for RustcCanonicalSymbolParser {
         AllowedTargets::AllowList(&[Allow(Target::ForeignFn)]);
     const STABILITY: AttributeStability = unstable!(
         rustc_attrs,
-        "the `#[rustc_canonical_symbol]` attribute registers a function's symbol to be linted against \
+        "the `rustc_canonical_symbol` attribute registers a function's symbol to be linted against \
         by the `invalid_runtime_symbol_definitions` and `suspicious_runtime_symbol_definitions` \
         lints"
     );

compiler/rustc_attr_parsing/src/attributes/splat.rs

@@ -10,7 +10,6 @@ pub(crate) struct SplatParser;
 impl NoArgsAttributeParser for SplatParser {
     const PATH: &[Symbol] = &[sym::splat];
     const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[Allow(Target::Param)]);
-    const STABILITY: AttributeStability =
-        unstable!(splat, "the `#[splat]` attribute is experimental");
+    const STABILITY: AttributeStability = unstable!(splat, "the `splat` attribute is experimental");
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::Splat;
 }

compiler/rustc_attr_parsing/src/context.rs

@@ -916,7 +916,7 @@ pub(crate) struct AttributeDiagnosticContext<'a, 'f, 'sess> {
 impl<'a, 'f, 'sess: 'f> AttributeDiagnosticContext<'a, 'f, 'sess> {
     fn emit_parse_error(
         &mut self,
-        span: Span,
+        mut span: Span,
         reason: AttributeParseErrorReason<'_>,
     ) -> ErrorGuaranteed {
         let suggestions = if self.custom_suggestions.is_empty() {
@@ -925,9 +925,16 @@ impl<'a, 'f, 'sess: 'f> AttributeDiagnosticContext<'a, 'f, 'sess> {
             AttributeParseErrorSuggestions::CreatedByParser(mem::take(&mut self.custom_suggestions))
         };
 
+        // If the span is the full attribute (including the `#[`/`]` delimiters) shrink it to
+        // exclude those delimiters, because that's what we want in error messages.
+        if span == self.attr_span {
+            span = self.inner_span;
+        }
+
         self.emit_err(AttributeParseError {
             span,
             attr_span: self.attr_span,
+            inner_span: self.inner_span,
             template: *self.template,
             path: self.attr_path.clone(),
             description: self.parsed_description,

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -372,17 +372,18 @@ pub(crate) struct EmptyConfusables {
 }
 
 #[derive(Diagnostic)]
-#[help("`#[{$name}{$attribute_args}]` can {$only}be applied to {$applied}")]
-#[diag("`#[{$name}{$attribute_args}]` attribute cannot be used on {$target}")]
+#[help("the `{$name}{$attribute_args}` attribute can {$only}be applied to {$applied}")]
+#[diag("the `{$name}{$attribute_args}` attribute cannot be used on {$target}")]
 pub(crate) struct InvalidTarget {
     #[primary_span]
+    pub span: Span,
     #[suggestion(
         "remove the attribute",
         code = "",
         applicability = "machine-applicable",
         style = "tool-only"
     )]
-    pub span: Span,
+    pub attr_span: Span,
     pub name: AttrPath,
     pub target: &'static str,
     pub applied: DiagArgValue,
@@ -509,6 +510,7 @@ pub enum ParsedDescription {
 pub(crate) struct AttributeParseError<'a> {
     pub(crate) span: Span,
     pub(crate) attr_span: Span,
+    pub(crate) inner_span: Span,
     pub(crate) template: AttributeTemplate,
     pub(crate) path: AttrPath,
     pub(crate) description: ParsedDescription,
@@ -652,7 +654,7 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> {
         let description = self.description();
 
         let mut diag = Diag::new(dcx, level, format!("malformed `{name}` {description} input"));
-        diag.span(self.attr_span);
+        diag.span(self.inner_span);
         diag.code(E0539);
         match &self.reason {
             AttributeParseErrorReason::ExpectedStringLiteral { byte_string } => {
@@ -727,8 +729,9 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> {
                 diag.code(E0565);
             }
             AttributeParseErrorReason::ExpectedNameValue(None) => {
-                // If the span is the entire attribute, the suggestion we add below this match already contains enough information
-                if self.span != self.attr_span {
+                // If the span is the entire attribute inner, the suggestion we add below this
+                // match already contains enough information.
+                if self.span != self.inner_span {
                     diag.span_label(self.span, "expected this to be of the form `... = \"...\"`");
                 }
             }