From b93a2dd0efeb00238543fd199ebdb8bb0f96bad7 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sat, 26 Oct 2024 18:51:15 +0300 Subject: [PATCH] expand: Stop using artificial `ast::Item` for macros loaded from metadata --- compiler/rustc_expand/src/mbe/macro_rules.rs | 98 ++++++++----------- compiler/rustc_metadata/src/creader.rs | 4 +- .../src/rmeta/decoder/cstore_impl.rs | 28 ++---- .../rustc_resolve/src/build_reduced_graph.rs | 4 +- compiler/rustc_resolve/src/def_collector.rs | 6 +- compiler/rustc_resolve/src/macros.rs | 40 +++++--- src/librustdoc/clean/inline.rs | 26 ++--- src/librustdoc/html/format.rs | 8 +- 8 files changed, 94 insertions(+), 120 deletions(-) diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs index f40f99b6ea123..fcc90c3ce0dd2 100644 --- a/compiler/rustc_expand/src/mbe/macro_rules.rs +++ b/compiler/rustc_expand/src/mbe/macro_rules.rs @@ -3,12 +3,11 @@ use std::collections::hash_map::Entry; use std::{mem, slice}; use ast::token::IdentIsRaw; -use rustc_ast as ast; use rustc_ast::token::NtPatKind::*; use rustc_ast::token::TokenKind::*; use rustc_ast::token::{self, Delimiter, NonterminalKind, Token, TokenKind}; use rustc_ast::tokenstream::{DelimSpan, TokenStream}; -use rustc_ast::{DUMMY_NODE_ID, NodeId}; +use rustc_ast::{self as ast, DUMMY_NODE_ID, NodeId}; use rustc_ast_pretty::pprust; use rustc_attr::{self as attr, TransparencyError}; use rustc_data_structures::fx::{FxHashMap, FxIndexMap}; @@ -370,34 +369,32 @@ pub(super) fn try_match_macro<'matcher, T: Tracker<'matcher>>( pub fn compile_declarative_macro( sess: &Session, features: &Features, - def: &ast::Item, + macro_def: &ast::MacroDef, + ident: Ident, + attrs: &[ast::Attribute], + span: Span, + node_id: NodeId, edition: Edition, ) -> (SyntaxExtension, Vec<(usize, Span)>) { - debug!("compile_declarative_macro: {:?}", def); let mk_syn_ext = |expander| { SyntaxExtension::new( sess, features, SyntaxExtensionKind::LegacyBang(expander), - def.span, + span, Vec::new(), edition, - def.ident.name, - &def.attrs, - def.id != DUMMY_NODE_ID, + ident.name, + attrs, + node_id != DUMMY_NODE_ID, ) }; let dummy_syn_ext = |guar| (mk_syn_ext(Box::new(DummyExpander(guar))), Vec::new()); let dcx = sess.dcx(); - let lhs_nm = Ident::new(sym::lhs, def.span); - let rhs_nm = Ident::new(sym::rhs, def.span); + let lhs_nm = Ident::new(sym::lhs, span); + let rhs_nm = Ident::new(sym::rhs, span); let tt_spec = Some(NonterminalKind::TT); - - let macro_def = match &def.kind { - ast::ItemKind::MacroDef(def) => def, - _ => unreachable!(), - }; let macro_rules = macro_def.macro_rules; // Parse the macro_rules! invocation @@ -410,25 +407,22 @@ pub fn compile_declarative_macro( let argument_gram = vec![ mbe::TokenTree::Sequence(DelimSpan::dummy(), mbe::SequenceRepetition { tts: vec![ - mbe::TokenTree::MetaVarDecl(def.span, lhs_nm, tt_spec), - mbe::TokenTree::token(token::FatArrow, def.span), - mbe::TokenTree::MetaVarDecl(def.span, rhs_nm, tt_spec), + mbe::TokenTree::MetaVarDecl(span, lhs_nm, tt_spec), + mbe::TokenTree::token(token::FatArrow, span), + mbe::TokenTree::MetaVarDecl(span, rhs_nm, tt_spec), ], - separator: Some(Token::new( - if macro_rules { token::Semi } else { token::Comma }, - def.span, - )), - kleene: mbe::KleeneToken::new(mbe::KleeneOp::OneOrMore, def.span), + separator: Some(Token::new(if macro_rules { token::Semi } else { token::Comma }, span)), + kleene: mbe::KleeneToken::new(mbe::KleeneOp::OneOrMore, span), num_captures: 2, }), // to phase into semicolon-termination instead of semicolon-separation mbe::TokenTree::Sequence(DelimSpan::dummy(), mbe::SequenceRepetition { tts: vec![mbe::TokenTree::token( if macro_rules { token::Semi } else { token::Comma }, - def.span, + span, )], separator: None, - kleene: mbe::KleeneToken::new(mbe::KleeneOp::ZeroOrMore, def.span), + kleene: mbe::KleeneToken::new(mbe::KleeneOp::ZeroOrMore, span), num_captures: 0, }), ]; @@ -460,7 +454,7 @@ pub fn compile_declarative_macro( }; let s = parse_failure_msg(&token, track.get_expected_token()); - let sp = token.span.substitute_dummy(def.span); + let sp = token.span.substitute_dummy(span); let mut err = sess.dcx().struct_span_err(sp, s); err.span_label(sp, msg); annotate_doc_comment(&mut err, sess.source_map(), sp); @@ -468,7 +462,7 @@ pub fn compile_declarative_macro( return dummy_syn_ext(guar); } Error(sp, msg) => { - let guar = sess.dcx().span_err(sp.substitute_dummy(def.span), msg); + let guar = sess.dcx().span_err(sp.substitute_dummy(span), msg); return dummy_syn_ext(guar); } ErrorReported(guar) => { @@ -489,7 +483,7 @@ pub fn compile_declarative_macro( &TokenStream::new(vec![tt.clone()]), true, sess, - def.id, + node_id, features, edition, ) @@ -497,13 +491,13 @@ pub fn compile_declarative_macro( .unwrap(); // We don't handle errors here, the driver will abort // after parsing/expansion. We can report every error in every macro this way. - check_emission(check_lhs_nt_follows(sess, def, &tt)); + check_emission(check_lhs_nt_follows(sess, node_id, &tt)); return tt; } - sess.dcx().span_bug(def.span, "wrong-structured lhs") + sess.dcx().span_bug(span, "wrong-structured lhs") }) .collect::>(), - _ => sess.dcx().span_bug(def.span, "wrong-structured lhs"), + _ => sess.dcx().span_bug(span, "wrong-structured lhs"), }; let rhses = match &argument_map[&MacroRulesNormalizedIdent::new(rhs_nm)] { @@ -515,17 +509,17 @@ pub fn compile_declarative_macro( &TokenStream::new(vec![tt.clone()]), false, sess, - def.id, + node_id, features, edition, ) .pop() .unwrap(); } - sess.dcx().span_bug(def.span, "wrong-structured rhs") + sess.dcx().span_bug(span, "wrong-structured rhs") }) .collect::>(), - _ => sess.dcx().span_bug(def.span, "wrong-structured rhs"), + _ => sess.dcx().span_bug(span, "wrong-structured rhs"), }; for rhs in &rhses { @@ -537,15 +531,9 @@ pub fn compile_declarative_macro( check_emission(check_lhs_no_empty_seq(sess, slice::from_ref(lhs))); } - check_emission(macro_check::check_meta_variables( - &sess.psess, - def.id, - def.span, - &lhses, - &rhses, - )); + check_emission(macro_check::check_meta_variables(&sess.psess, node_id, span, &lhses, &rhses)); - let (transparency, transparency_error) = attr::find_transparency(&def.attrs, macro_rules); + let (transparency, transparency_error) = attr::find_transparency(attrs, macro_rules); match transparency_error { Some(TransparencyError::UnknownTransparency(value, span)) => { dcx.span_err(span, format!("unknown macro transparency: `{value}`")); @@ -564,7 +552,7 @@ pub fn compile_declarative_macro( // Compute the spans of the macro rules for unused rule linting. // Also, we are only interested in non-foreign macros. - let rule_spans = if def.id != DUMMY_NODE_ID { + let rule_spans = if node_id != DUMMY_NODE_ID { lhses .iter() .zip(rhses.iter()) @@ -590,15 +578,15 @@ pub fn compile_declarative_macro( mbe::TokenTree::Delimited(.., delimited) => { mbe::macro_parser::compute_locs(&delimited.tts) } - _ => sess.dcx().span_bug(def.span, "malformed macro lhs"), + _ => sess.dcx().span_bug(span, "malformed macro lhs"), } }) .collect(); let expander = Box::new(MacroRulesMacroExpander { - name: def.ident, - span: def.span, - node_id: def.id, + name: ident, + span, + node_id, transparency, lhses, rhses, @@ -608,13 +596,13 @@ pub fn compile_declarative_macro( fn check_lhs_nt_follows( sess: &Session, - def: &ast::Item, + node_id: NodeId, lhs: &mbe::TokenTree, ) -> Result<(), ErrorGuaranteed> { // lhs is going to be like TokenTree::Delimited(...), where the // entire lhs is those tts. Or, it can be a "bare sequence", not wrapped in parens. if let mbe::TokenTree::Delimited(.., delimited) = lhs { - check_matcher(sess, def, &delimited.tts) + check_matcher(sess, node_id, &delimited.tts) } else { let msg = "invalid macro matcher; matchers must be contained in balanced delimiters"; Err(sess.dcx().span_err(lhs.span(), msg)) @@ -686,12 +674,12 @@ fn check_rhs(sess: &Session, rhs: &mbe::TokenTree) -> Result<(), ErrorGuaranteed fn check_matcher( sess: &Session, - def: &ast::Item, + node_id: NodeId, matcher: &[mbe::TokenTree], ) -> Result<(), ErrorGuaranteed> { let first_sets = FirstSets::new(matcher); let empty_suffix = TokenSet::empty(); - check_matcher_core(sess, def, &first_sets, matcher, &empty_suffix)?; + check_matcher_core(sess, node_id, &first_sets, matcher, &empty_suffix)?; Ok(()) } @@ -1028,7 +1016,7 @@ impl<'tt> TokenSet<'tt> { // see `FirstSets::new`. fn check_matcher_core<'tt>( sess: &Session, - def: &ast::Item, + node_id: NodeId, first_sets: &FirstSets<'tt>, matcher: &'tt [mbe::TokenTree], follow: &TokenSet<'tt>, @@ -1082,7 +1070,7 @@ fn check_matcher_core<'tt>( token::CloseDelim(d.delim), span.close, )); - check_matcher_core(sess, def, first_sets, &d.tts, &my_suffix)?; + check_matcher_core(sess, node_id, first_sets, &d.tts, &my_suffix)?; // don't track non NT tokens last.replace_with_irrelevant(); @@ -1114,7 +1102,7 @@ fn check_matcher_core<'tt>( // At this point, `suffix_first` is built, and // `my_suffix` is some TokenSet that we can use // for checking the interior of `seq_rep`. - let next = check_matcher_core(sess, def, first_sets, &seq_rep.tts, my_suffix)?; + let next = check_matcher_core(sess, node_id, first_sets, &seq_rep.tts, my_suffix)?; if next.maybe_empty { last.add_all(&next); } else { @@ -1144,7 +1132,7 @@ fn check_matcher_core<'tt>( // macro. (See #86567.) // Macros defined in the current crate have a real node id, // whereas macros from an external crate have a dummy id. - if def.id != DUMMY_NODE_ID + if node_id != DUMMY_NODE_ID && matches!(kind, NonterminalKind::Pat(PatParam { inferred: true })) && matches!( next_token, diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs index 8adec7554a834..16623915c4019 100644 --- a/compiler/rustc_metadata/src/creader.rs +++ b/compiler/rustc_metadata/src/creader.rs @@ -28,7 +28,7 @@ use rustc_session::lint::{self, BuiltinLintDiag}; use rustc_session::output::validate_crate_name; use rustc_session::search_paths::PathKind; use rustc_span::edition::Edition; -use rustc_span::symbol::{Symbol, sym}; +use rustc_span::symbol::{Ident, Symbol, sym}; use rustc_span::{DUMMY_SP, Span}; use rustc_target::spec::{PanicStrategy, Target, TargetTriple}; use tracing::{debug, info, trace}; @@ -97,7 +97,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> { } pub enum LoadedMacro { - MacroDef(ast::Item, Edition), + MacroDef { def: MacroDef, ident: Ident, attrs: AttrVec, span: Span, edition: Edition }, ProcMacro(SyntaxExtension), } diff --git a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs index 71c7231a78826..926eb4f6210bd 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs +++ b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs @@ -1,7 +1,6 @@ use std::any::Any; use std::mem; -use rustc_ast as ast; use rustc_attr::Deprecation; use rustc_data_structures::sync::Lrc; use rustc_hir::def::{CtorKind, DefKind, Res}; @@ -592,27 +591,16 @@ impl CStore { let data = self.get_crate_data(id.krate); if data.root.is_proc_macro_crate() { - return LoadedMacro::ProcMacro(data.load_proc_macro(id.index, tcx)); - } - - let span = data.get_span(id.index, sess); - - LoadedMacro::MacroDef( - ast::Item { + LoadedMacro::ProcMacro(data.load_proc_macro(id.index, tcx)) + } else { + LoadedMacro::MacroDef { + def: data.get_macro(id.index, sess), ident: data.item_ident(id.index, sess), - id: ast::DUMMY_NODE_ID, - span, attrs: data.get_item_attrs(id.index, sess).collect(), - kind: ast::ItemKind::MacroDef(data.get_macro(id.index, sess)), - vis: ast::Visibility { - span: span.shrink_to_lo(), - kind: ast::VisibilityKind::Inherited, - tokens: None, - }, - tokens: None, - }, - data.root.edition, - ) + span: data.get_span(id.index, sess), + edition: data.root.edition, + } + } } pub fn def_span_untracked(&self, def_id: DefId, sess: &Session) -> Span { diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs index 031ffaed808bd..bdf940a04b568 100644 --- a/compiler/rustc_resolve/src/build_reduced_graph.rs +++ b/compiler/rustc_resolve/src/build_reduced_graph.rs @@ -177,7 +177,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> { let loaded_macro = self.cstore().load_macro_untracked(def_id, self.tcx); let macro_data = match loaded_macro { - LoadedMacro::MacroDef(item, edition) => self.compile_macro(&item, edition), + LoadedMacro::MacroDef { def, ident, attrs, span, edition } => { + self.compile_macro(&def, ident, &attrs, span, ast::DUMMY_NODE_ID, edition) + } LoadedMacro::ProcMacro(ext) => MacroData::new(Lrc::new(ext)), }; diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs index 0047f2c4b51e9..a825458dc8942 100644 --- a/compiler/rustc_resolve/src/def_collector.rs +++ b/compiler/rustc_resolve/src/def_collector.rs @@ -199,8 +199,10 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> { }, ItemKind::Const(..) => DefKind::Const, ItemKind::Fn(..) | ItemKind::Delegation(..) => DefKind::Fn, - ItemKind::MacroDef(..) => { - let macro_data = self.resolver.compile_macro(i, self.resolver.tcx.sess.edition()); + ItemKind::MacroDef(def) => { + let edition = self.resolver.tcx.sess.edition(); + let macro_data = + self.resolver.compile_macro(def, i.ident, &i.attrs, i.span, i.id, edition); let macro_kind = macro_data.ext.macro_kind(); opt_macro_data = Some(macro_data); DefKind::Macro(macro_kind) diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs index a9ebffea8a10b..1dc27776cb0f5 100644 --- a/compiler/rustc_resolve/src/macros.rs +++ b/compiler/rustc_resolve/src/macros.rs @@ -1122,9 +1122,25 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> { /// Compile the macro into a `SyntaxExtension` and its rule spans. /// /// Possibly replace its expander to a pre-defined one for built-in macros. - pub(crate) fn compile_macro(&mut self, item: &ast::Item, edition: Edition) -> MacroData { - let (mut ext, mut rule_spans) = - compile_declarative_macro(self.tcx.sess, self.tcx.features(), item, edition); + pub(crate) fn compile_macro( + &mut self, + macro_def: &ast::MacroDef, + ident: Ident, + attrs: &[ast::Attribute], + span: Span, + node_id: NodeId, + edition: Edition, + ) -> MacroData { + let (mut ext, mut rule_spans) = compile_declarative_macro( + self.tcx.sess, + self.tcx.features(), + macro_def, + ident, + attrs, + span, + node_id, + edition, + ); if let Some(builtin_name) = ext.builtin_name { // The macro was marked with `#[rustc_builtin_macro]`. @@ -1132,28 +1148,22 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> { // The macro is a built-in, replace its expander function // while still taking everything else from the source code. // If we already loaded this builtin macro, give a better error message than 'no such builtin macro'. - match mem::replace(builtin_macro, BuiltinMacroState::AlreadySeen(item.span)) { + match mem::replace(builtin_macro, BuiltinMacroState::AlreadySeen(span)) { BuiltinMacroState::NotYetSeen(builtin_ext) => { ext.kind = builtin_ext; rule_spans = Vec::new(); } - BuiltinMacroState::AlreadySeen(span) => { - self.dcx().emit_err(errors::AttemptToDefineBuiltinMacroTwice { - span: item.span, - note_span: span, - }); + BuiltinMacroState::AlreadySeen(note_span) => { + self.dcx() + .emit_err(errors::AttemptToDefineBuiltinMacroTwice { span, note_span }); } } } else { - self.dcx().emit_err(errors::CannotFindBuiltinMacroWithName { - span: item.span, - ident: item.ident, - }); + self.dcx().emit_err(errors::CannotFindBuiltinMacroWithName { span, ident }); } } - let ItemKind::MacroDef(def) = &item.kind else { unreachable!() }; - MacroData { ext: Lrc::new(ext), rule_spans, macro_rules: def.macro_rules } + MacroData { ext: Lrc::new(ext), rule_spans, macro_rules: macro_def.macro_rules } } fn path_accessible( diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index e7f921eef7fca..97529e420e3bd 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -248,9 +248,7 @@ pub(crate) fn record_extern_fqn(cx: &mut DocContext<'_>, did: DefId, kind: ItemT // Check to see if it is a macro 2.0 or built-in macro if matches!( CStore::from_tcx(cx.tcx).load_macro_untracked(did, cx.tcx), - LoadedMacro::MacroDef(def, _) - if matches!(&def.kind, ast::ItemKind::MacroDef(ast_def) - if !ast_def.macro_rules) + LoadedMacro::MacroDef { def, .. } if !def.macro_rules ) { once(crate_name).chain(relative).collect() } else { @@ -747,24 +745,12 @@ fn build_macro( is_doc_hidden: bool, ) -> clean::ItemKind { match CStore::from_tcx(cx.tcx).load_macro_untracked(def_id, cx.tcx) { - LoadedMacro::MacroDef(item_def, _) => match macro_kind { + LoadedMacro::MacroDef { def, .. } => match macro_kind { MacroKind::Bang => { - if let ast::ItemKind::MacroDef(ref def) = item_def.kind { - let vis = - cx.tcx.visibility(import_def_id.map(|d| d.to_def_id()).unwrap_or(def_id)); - clean::MacroItem(clean::Macro { - source: utils::display_macro_source( - cx, - name, - def, - def_id, - vis, - is_doc_hidden, - ), - }) - } else { - unreachable!() - } + let vis = cx.tcx.visibility(import_def_id.map(|d| d.to_def_id()).unwrap_or(def_id)); + clean::MacroItem(clean::Macro { + source: utils::display_macro_source(cx, name, &def, def_id, vis, is_doc_hidden), + }) } MacroKind::Derive | MacroKind::Attr => { clean::ProcMacroItem(clean::ProcMacro { kind: macro_kind, helpers: Vec::new() }) diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index ea2f930ab8376..8e8e5c6ade8cb 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -16,6 +16,7 @@ use itertools::Itertools; use rustc_attr::{ConstStability, StabilityLevel, StableSince}; use rustc_data_structures::captures::Captures; use rustc_data_structures::fx::FxHashSet; +use rustc_hir as hir; use rustc_hir::def::DefKind; use rustc_hir::def_id::{DefId, LOCAL_CRATE}; use rustc_metadata::creader::{CStore, LoadedMacro}; @@ -25,7 +26,6 @@ use rustc_span::symbol::kw; use rustc_span::{Symbol, sym}; use rustc_target::spec::abi::Abi; use tracing::{debug, trace}; -use {rustc_ast as ast, rustc_hir as hir}; use super::url_parts_builder::{UrlPartsBuilder, estimate_item_path_byte_length}; use crate::clean::types::ExternalLocation; @@ -554,10 +554,8 @@ fn generate_macro_def_id_path( // Check to see if it is a macro 2.0 or built-in macro. // More information in . let is_macro_2 = match cstore.load_macro_untracked(def_id, tcx) { - LoadedMacro::MacroDef(def, _) => { - // If `ast_def.macro_rules` is `true`, then it's not a macro 2.0. - matches!(&def.kind, ast::ItemKind::MacroDef(ast_def) if !ast_def.macro_rules) - } + // If `def.macro_rules` is `true`, then it's not a macro 2.0. + LoadedMacro::MacroDef { def, .. } => !def.macro_rules, _ => false, };