Port #[macro_export] to the new attribute parsing infrastructure

Co-authored-by: Anne Stijns <anstijns@gmail.com>

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs

@@ -1,3 +1,4 @@
+use rustc_ast::AttrStyle;
 use rustc_errors::DiagArgValue;
 use rustc_hir::attrs::MacroUseArgs;
 
@@ -133,3 +134,65 @@ impl<S: Stage> NoArgsAttributeParser<S> for AllowInternalUnsafeParser {
  ]);
  const CREATE: fn(Span) -> AttributeKind = |span| AttributeKind::AllowInternalUnsafe(span);
 }
+
+pub(crate) struct MacroExportParser;
+
+impl<S: Stage> SingleAttributeParser<S> for MacroExportParser {
+ const PATH: &[Symbol] = &[sym::macro_export];
+ const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
+ const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+ const TEMPLATE: AttributeTemplate = template!(Word, List: &["local_inner_macros"]);
+ const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[
+ Allow(Target::MacroDef),
+ Error(Target::WherePredicate),
+ Error(Target::Crate),
+ ]);
+
+ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+ let suggestions = || {
+ <Self as SingleAttributeParser<S>>::TEMPLATE
+ .suggestions(AttrStyle::Inner, "macro_export")
+ };
+ let local_inner_macros = match args {
+ ArgParser::NoArgs => false,
+ ArgParser::List(list) => {
+ let Some(l) = list.single() else {
+ let span = cx.attr_span;
+ cx.emit_lint(
+ AttributeLintKind::InvalidMacroExportArguments {
+ suggestions: suggestions(),
+ },
+ span,
+ );
+ return None;
+ };
+ match l.meta_item().and_then(|i| i.path().word_sym()) {
+ Some(sym::local_inner_macros) => true,
+ _ => {
+ let span = cx.attr_span;
+ cx.emit_lint(
+ AttributeLintKind::InvalidMacroExportArguments {
+ suggestions: suggestions(),
+ },
+ span,
+ );
+ return None;
+ }
+ }
+ }
+ ArgParser::NameValue(_) => {
+ let span = cx.attr_span;
+ let suggestions = suggestions();
+ cx.emit_err(IllFormedAttributeInputLint {
+ num_suggestions: suggestions.len(),
+ suggestions: DiagArgValue::StrListSepByAnd(
+ suggestions.into_iter().map(|s| format!("`{s}`").into()).collect(),
+ ),
+ span,
+ });
+ return None;
+ }
+ };
+ Some(AttributeKind::MacroExport { span: cx.attr_span, local_inner_macros })
+ }
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -40,7 +40,7 @@ use crate::attributes::lint_helpers::{
 };
 use crate::attributes::loop_match::{ConstContinueParser, LoopMatchParser};
 use crate::attributes::macro_attrs::{
- AllowInternalUnsafeParser, MacroEscapeParser, MacroUseParser,
+ AllowInternalUnsafeParser, MacroEscapeParser, MacroExportParser, MacroUseParser,
 };
 use crate::attributes::must_use::MustUseParser;
 use crate::attributes::no_implicit_prelude::NoImplicitPreludeParser;
@@ -183,6 +183,7 @@ attribute_parsers!(
  Single<LinkOrdinalParser>,
  Single<LinkSectionParser>,
  Single<LinkageParser>,
+ Single<MacroExportParser>,
  Single<MoveSizeLimitParser>,
  Single<MustUseParser>,
  Single<ObjcClassParser>,

compiler/rustc_attr_parsing/src/lints.rs

@@ -31,6 +31,18 @@ pub fn emit_attribute_lint<L: LintEmitter>(lint: &AttributeLint<L::Id>, lint_emi
  },
  );
  }
+ AttributeLintKind::InvalidMacroExportArguments { suggestions } => lint_emitter
+ .emit_node_span_lint(
+ rustc_session::lint::builtin::INVALID_MACRO_EXPORT_ARGUMENTS,
+ *id,
+ *span,
+ session_diagnostics::IllFormedAttributeInput {
+ num_suggestions: suggestions.len(),
+ suggestions: DiagArgValue::StrListSepByAnd(
+ suggestions.into_iter().map(|s| format!("`{s}`").into()).collect(),
+ ),
+ },
+ ),
  AttributeLintKind::EmptyAttribute { first_span } => lint_emitter.emit_node_span_lint(
  rustc_session::lint::builtin::UNUSED_ATTRIBUTES,
  *id,

compiler/rustc_expand/src/base.rs

@@ -942,9 +942,9 @@ impl SyntaxExtension {
  .unwrap_or_default();
  let allow_internal_unsafe = find_attr!(attrs, AttributeKind::AllowInternalUnsafe(_));
 
- let local_inner_macros = ast::attr::find_by_name(attrs, sym::macro_export)
- .and_then(|macro_export| macro_export.meta_item_list())
- .is_some_and(|l| ast::attr::list_contains_name(&l, sym::local_inner_macros));
+ let local_inner_macros =
+ *find_attr!(attrs, AttributeKind::MacroExport {local_inner_macros: l, ..} => l)
+  .unwrap_or(&false);
  let collapse_debuginfo = Self::get_collapse_debuginfo(sess, attrs, !is_local);
  tracing::debug!(?name, ?local_inner_macros, ?collapse_debuginfo, ?allow_internal_unsafe);
 

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -551,6 +551,9 @@ pub enum AttributeKind {
  /// Represents `#[macro_escape]`.
  MacroEscape(Span),
 
+ /// Represents [`#[macro_export]`](https://doc.rust-lang.org/reference/macros-by-example.html#r-macro.decl.scope.path).
+ MacroExport { span: Span, local_inner_macros: bool },
+
  /// Represents `#[rustc_macro_transparency]`.
  MacroTransparency(Transparency),
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -56,6 +56,7 @@ impl AttributeKind {
  Linkage(..) => No,
  LoopMatch(..) => No,
  MacroEscape(..) => No,
+ MacroExport { .. } => Yes,
  MacroTransparency(..) => Yes,
  MacroUse { .. } => No,
  Marker(..) => No,

compiler/rustc_hir/src/lints.rs

@@ -31,9 +31,34 @@ pub struct AttributeLint<Id> {
 
 #[derive(Clone, Debug, HashStable_Generic)]
 pub enum AttributeLintKind {
- UnusedDuplicate { this: Span, other: Span, warning: bool },
- IllFormedAttributeInput { suggestions: Vec<String> },
- EmptyAttribute { first_span: Span },
- InvalidTarget { name: AttrPath, target: Target, applied: Vec<String>, only: &'static str },
- InvalidStyle { name: AttrPath, is_used_as_inner: bool, target: Target, target_span: Span },
+ UnusedDuplicate {
+ this: Span,
+ other: Span,
+ warning: bool,
+ },
+ IllFormedAttributeInput {
+ suggestions: Vec<String>,
+ },
+ EmptyAttribute {
+ first_span: Span,
+ },
+
+ /// Copy of `IllFormedAttributeInput`
+ /// specifically for the `invalid_macro_export_arguments` lint until that is removed,
+ /// see <https://github.com/rust-lang/rust/pull/143857#issuecomment-3079175663>
+ InvalidMacroExportArguments {
+ suggestions: Vec<String>,
+ },
+ InvalidTarget {
+ name: AttrPath,
+ target: Target,
+ applied: Vec<String>,
+ only: &'static str,
+ },
+ InvalidStyle {
+ name: AttrPath,
+ is_used_as_inner: bool,
+ target: Target,
+ target_span: Span,
+ },
 }

compiler/rustc_lint/src/non_local_def.rs

@@ -1,11 +1,12 @@
 use rustc_errors::MultiSpan;
+use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{self, Visitor, VisitorExt};
-use rustc_hir::{Body, HirId, Item, ItemKind, Node, Path, TyKind};
+use rustc_hir::{Body, HirId, Item, ItemKind, Node, Path, TyKind, find_attr};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::{declare_lint, impl_lint_pass};
 use rustc_span::def_id::{DefId, LOCAL_CRATE};
-use rustc_span::{ExpnKind, Span, kw, sym};
+use rustc_span::{ExpnKind, Span, kw};
 
 use crate::lints::{NonLocalDefinitionsCargoUpdateNote, NonLocalDefinitionsDiag};
 use crate::{LateContext, LateLintPass, LintContext, fluent_generated as fluent};
@@ -241,7 +242,10 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
  )
  }
  ItemKind::Macro(_, _macro, _kinds)
- if cx.tcx.has_attr(item.owner_id.def_id, sym::macro_export) =>
+ if find_attr!(
+ cx.tcx.get_all_attrs(item.owner_id.def_id),
+ AttributeKind::MacroExport { .. }
+ ) =>
  {
  cx.emit_span_lint(
  NON_LOCAL_DEFINITIONS,

compiler/rustc_lint_defs/src/builtin.rs

@@ -4191,8 +4191,13 @@ declare_lint! {
  /// You can't have multiple arguments in a `#[macro_export(..)]`, or mention arguments other than `local_inner_macros`.
  ///
  pub INVALID_MACRO_EXPORT_ARGUMENTS,
- Warn,
+ Deny,
  "\"invalid_parameter\" isn't a valid argument for `#[macro_export]`",
+ @future_incompatible = FutureIncompatibleInfo {
+ reason: FutureIncompatibilityReason::FutureReleaseError,
+ reference: "issue #57571 <https://github.com/rust-lang/rust/issues/57571>",
+ report_in_deps: true,
+ };
 }
 
 declare_lint! {

compiler/rustc_passes/messages.ftl

@@ -349,10 +349,6 @@ passes_invalid_attr_at_crate_level =
 passes_invalid_attr_at_crate_level_item =
  the inner attribute doesn't annotate this {$kind}
 
-passes_invalid_macro_export_arguments = invalid `#[macro_export]` argument
-
-passes_invalid_macro_export_arguments_too_many_items = `#[macro_export]` can only take 1 or 0 arguments
-
 passes_lang_item_fn = {$name ->
  [panic_impl] `#[panic_handler]`
  *[other] `{$name}` lang item
@@ -392,9 +388,6 @@ passes_loop_match_attr =
  `#[loop_match]` should be applied to a loop
  .label = not a loop
 
-passes_macro_export =
- `#[macro_export]` only has an effect on macro definitions
-
 passes_macro_export_on_decl_macro =
  `#[macro_export]` has no effect on declarative macro definitions
  .note = declarative macros follow the same exporting rules as regular items