2 use crate::config::StripUnconfigured;
4 use crate::hygiene::SyntaxContext;
5 use crate::mbe::macro_rules::annotate_err_with_kind;
6 use crate::module::{mod_dir_path, parse_external_mod, DirOwnership, ParsedExternalMod};
7 use crate::placeholders::{placeholder, PlaceholderExpander};
10 use rustc_ast::mut_visit::*;
11 use rustc_ast::ptr::P;
13 use rustc_ast::tokenstream::TokenStream;
14 use rustc_ast::visit::{self, AssocCtxt, Visitor};
15 use rustc_ast::{AstLike, Block, Inline, ItemKind, MacArgs, MacCall};
16 use rustc_ast::{MacCallStmt, MacStmtStyle, MetaItemKind, ModKind, NestedMetaItem};
17 use rustc_ast::{NodeId, PatKind, Path, StmtKind};
18 use rustc_ast_pretty::pprust;
19 use rustc_attr::is_builtin_attr;
20 use rustc_data_structures::map_in_place::MapInPlace;
21 use rustc_data_structures::stack::ensure_sufficient_stack;
22 use rustc_data_structures::sync::Lrc;
23 use rustc_errors::{Applicability, PResult};
24 use rustc_feature::Features;
25 use rustc_parse::parser::{
26 AttemptLocalParseRecovery, ForceCollect, Parser, RecoverColon, RecoverComma,
28 use rustc_parse::validate_attr;
29 use rustc_session::lint::builtin::{UNUSED_ATTRIBUTES, UNUSED_DOC_COMMENTS};
30 use rustc_session::lint::BuiltinLintDiagnostics;
31 use rustc_session::parse::{feature_err, ParseSess};
32 use rustc_session::Limit;
33 use rustc_span::symbol::{sym, Ident};
34 use rustc_span::{FileName, LocalExpnId, Span};
36 use smallvec::SmallVec;
37 use std::ops::DerefMut;
38 use std::path::PathBuf;
42 macro_rules! ast_fragments {
44 $($Kind:ident($AstTy:ty) {
46 $(one fn $mut_visit_ast:ident; fn $visit_ast:ident;)?
47 $(many fn $flat_map_ast_elt:ident; fn $visit_ast_elt:ident($($args:tt)*);)?
51 /// A fragment of AST that can be produced by a single macro expansion.
52 /// Can also serve as an input and intermediate result for macro expansion operations.
53 pub enum AstFragment {
54 OptExpr(Option<P<ast::Expr>>),
58 /// "Discriminant" of an AST fragment.
59 #[derive(Copy, Clone, PartialEq, Eq)]
60 pub enum AstFragmentKind {
65 impl AstFragmentKind {
66 pub fn name(self) -> &'static str {
68 AstFragmentKind::OptExpr => "expression",
69 $(AstFragmentKind::$Kind => $kind_name,)*
73 fn make_from<'a>(self, result: Box<dyn MacResult + 'a>) -> Option<AstFragment> {
75 AstFragmentKind::OptExpr =>
76 result.make_expr().map(Some).map(AstFragment::OptExpr),
77 $(AstFragmentKind::$Kind => result.$make_ast().map(AstFragment::$Kind),)*
83 pub fn add_placeholders(&mut self, placeholders: &[NodeId]) {
84 if placeholders.is_empty() {
88 $($(AstFragment::$Kind(ast) => ast.extend(placeholders.iter().flat_map(|id| {
89 // We are repeating through arguments with `many`, to do that we have to
90 // mention some macro variable from those arguments even if it's not used.
91 macro _repeating($flat_map_ast_elt) {}
92 placeholder(AstFragmentKind::$Kind, *id, None).$make_ast()
94 _ => panic!("unexpected AST fragment kind")
98 pub fn make_opt_expr(self) -> Option<P<ast::Expr>> {
100 AstFragment::OptExpr(expr) => expr,
101 _ => panic!("AstFragment::make_* called on the wrong kind of fragment"),
105 $(pub fn $make_ast(self) -> $AstTy {
107 AstFragment::$Kind(ast) => ast,
108 _ => panic!("AstFragment::make_* called on the wrong kind of fragment"),
112 pub fn mut_visit_with<F: MutVisitor>(&mut self, vis: &mut F) {
114 AstFragment::OptExpr(opt_expr) => {
115 visit_clobber(opt_expr, |opt_expr| {
116 if let Some(expr) = opt_expr {
117 vis.filter_map_expr(expr)
123 $($(AstFragment::$Kind(ast) => vis.$mut_visit_ast(ast),)?)*
124 $($(AstFragment::$Kind(ast) =>
125 ast.flat_map_in_place(|ast| vis.$flat_map_ast_elt(ast)),)?)*
129 pub fn visit_with<'a, V: Visitor<'a>>(&'a self, visitor: &mut V) {
131 AstFragment::OptExpr(Some(ref expr)) => visitor.visit_expr(expr),
132 AstFragment::OptExpr(None) => {}
133 $($(AstFragment::$Kind(ref ast) => visitor.$visit_ast(ast),)?)*
134 $($(AstFragment::$Kind(ref ast) => for ast_elt in &ast[..] {
135 visitor.$visit_ast_elt(ast_elt, $($args)*);
141 impl<'a> MacResult for crate::mbe::macro_rules::ParserAnyMacro<'a> {
142 $(fn $make_ast(self: Box<crate::mbe::macro_rules::ParserAnyMacro<'a>>)
144 Some(self.make(AstFragmentKind::$Kind).$make_ast())
151 Expr(P<ast::Expr>) { "expression"; one fn visit_expr; fn visit_expr; fn make_expr; }
152 Pat(P<ast::Pat>) { "pattern"; one fn visit_pat; fn visit_pat; fn make_pat; }
153 Ty(P<ast::Ty>) { "type"; one fn visit_ty; fn visit_ty; fn make_ty; }
154 Stmts(SmallVec<[ast::Stmt; 1]>) {
155 "statement"; many fn flat_map_stmt; fn visit_stmt(); fn make_stmts;
157 Items(SmallVec<[P<ast::Item>; 1]>) {
158 "item"; many fn flat_map_item; fn visit_item(); fn make_items;
160 TraitItems(SmallVec<[P<ast::AssocItem>; 1]>) {
162 many fn flat_map_trait_item;
163 fn visit_assoc_item(AssocCtxt::Trait);
166 ImplItems(SmallVec<[P<ast::AssocItem>; 1]>) {
168 many fn flat_map_impl_item;
169 fn visit_assoc_item(AssocCtxt::Impl);
172 ForeignItems(SmallVec<[P<ast::ForeignItem>; 1]>) {
174 many fn flat_map_foreign_item;
175 fn visit_foreign_item();
176 fn make_foreign_items;
178 Arms(SmallVec<[ast::Arm; 1]>) {
179 "match arm"; many fn flat_map_arm; fn visit_arm(); fn make_arms;
181 Fields(SmallVec<[ast::ExprField; 1]>) {
182 "field expression"; many fn flat_map_expr_field; fn visit_expr_field(); fn make_expr_fields;
184 FieldPats(SmallVec<[ast::PatField; 1]>) {
186 many fn flat_map_pat_field;
187 fn visit_pat_field();
190 GenericParams(SmallVec<[ast::GenericParam; 1]>) {
192 many fn flat_map_generic_param;
193 fn visit_generic_param();
194 fn make_generic_params;
196 Params(SmallVec<[ast::Param; 1]>) {
197 "function parameter"; many fn flat_map_param; fn visit_param(); fn make_params;
199 StructFields(SmallVec<[ast::FieldDef; 1]>) {
201 many fn flat_map_field_def;
202 fn visit_field_def();
205 Variants(SmallVec<[ast::Variant; 1]>) {
206 "variant"; many fn flat_map_variant; fn visit_variant(); fn make_variants;
208 Crate(ast::Crate) { "crate"; one fn visit_crate; fn visit_crate; fn make_crate; }
211 pub enum SupportsMacroExpansion {
213 Yes { supports_inner_attrs: bool },
216 impl AstFragmentKind {
217 crate fn dummy(self, span: Span) -> AstFragment {
218 self.make_from(DummyResult::any(span)).expect("couldn't create a dummy AST fragment")
221 pub fn supports_macro_expansion(self) -> SupportsMacroExpansion {
223 AstFragmentKind::OptExpr
224 | AstFragmentKind::Expr
225 | AstFragmentKind::Stmts
226 | AstFragmentKind::Ty
227 | AstFragmentKind::Pat => SupportsMacroExpansion::Yes { supports_inner_attrs: false },
228 AstFragmentKind::Items
229 | AstFragmentKind::TraitItems
230 | AstFragmentKind::ImplItems
231 | AstFragmentKind::ForeignItems
232 | AstFragmentKind::Crate => SupportsMacroExpansion::Yes { supports_inner_attrs: true },
233 AstFragmentKind::Arms
234 | AstFragmentKind::Fields
235 | AstFragmentKind::FieldPats
236 | AstFragmentKind::GenericParams
237 | AstFragmentKind::Params
238 | AstFragmentKind::StructFields
239 | AstFragmentKind::Variants => SupportsMacroExpansion::No,
243 fn expect_from_annotatables<I: IntoIterator<Item = Annotatable>>(
247 let mut items = items.into_iter();
249 AstFragmentKind::Arms => {
250 AstFragment::Arms(items.map(Annotatable::expect_arm).collect())
252 AstFragmentKind::Fields => {
253 AstFragment::Fields(items.map(Annotatable::expect_expr_field).collect())
255 AstFragmentKind::FieldPats => {
256 AstFragment::FieldPats(items.map(Annotatable::expect_pat_field).collect())
258 AstFragmentKind::GenericParams => {
259 AstFragment::GenericParams(items.map(Annotatable::expect_generic_param).collect())
261 AstFragmentKind::Params => {
262 AstFragment::Params(items.map(Annotatable::expect_param).collect())
264 AstFragmentKind::StructFields => {
265 AstFragment::StructFields(items.map(Annotatable::expect_field_def).collect())
267 AstFragmentKind::Variants => {
268 AstFragment::Variants(items.map(Annotatable::expect_variant).collect())
270 AstFragmentKind::Items => {
271 AstFragment::Items(items.map(Annotatable::expect_item).collect())
273 AstFragmentKind::ImplItems => {
274 AstFragment::ImplItems(items.map(Annotatable::expect_impl_item).collect())
276 AstFragmentKind::TraitItems => {
277 AstFragment::TraitItems(items.map(Annotatable::expect_trait_item).collect())
279 AstFragmentKind::ForeignItems => {
280 AstFragment::ForeignItems(items.map(Annotatable::expect_foreign_item).collect())
282 AstFragmentKind::Stmts => {
283 AstFragment::Stmts(items.map(Annotatable::expect_stmt).collect())
285 AstFragmentKind::Expr => AstFragment::Expr(
286 items.next().expect("expected exactly one expression").expect_expr(),
288 AstFragmentKind::OptExpr => {
289 AstFragment::OptExpr(items.next().map(Annotatable::expect_expr))
291 AstFragmentKind::Crate => {
292 AstFragment::Crate(items.next().expect("expected exactly one crate").expect_crate())
294 AstFragmentKind::Pat | AstFragmentKind::Ty => {
295 panic!("patterns and types aren't annotatable")
301 pub struct Invocation {
302 pub kind: InvocationKind,
303 pub fragment_kind: AstFragmentKind,
304 pub expansion_data: ExpansionData,
307 pub enum InvocationKind {
313 attr: ast::Attribute,
314 // Re-insertion position for inert attributes.
317 // Required for resolving derive helper attributes.
326 impl InvocationKind {
327 fn placeholder_visibility(&self) -> Option<ast::Visibility> {
328 // HACK: For unnamed fields placeholders should have the same visibility as the actual
329 // fields because for tuple structs/variants resolve determines visibilities of their
330 // constructor using these field visibilities before attributes on them are are expanded.
331 // The assumption is that the attribute expansion cannot change field visibilities,
332 // and it holds because only inert attributes are supported in this position.
334 InvocationKind::Attr { item: Annotatable::FieldDef(field), .. }
335 | InvocationKind::Derive { item: Annotatable::FieldDef(field), .. }
336 if field.ident.is_none() =>
338 Some(field.vis.clone())
346 pub fn span(&self) -> Span {
348 InvocationKind::Bang { span, .. } => *span,
349 InvocationKind::Attr { attr, .. } => attr.span,
350 InvocationKind::Derive { path, .. } => path.span,
355 pub struct MacroExpander<'a, 'b> {
356 pub cx: &'a mut ExtCtxt<'b>,
357 monotonic: bool, // cf. `cx.monotonic_expander()`
360 impl<'a, 'b> MacroExpander<'a, 'b> {
361 pub fn new(cx: &'a mut ExtCtxt<'b>, monotonic: bool) -> Self {
362 MacroExpander { cx, monotonic }
365 pub fn expand_crate(&mut self, krate: ast::Crate) -> ast::Crate {
366 let file_path = match self.cx.source_map().span_to_filename(krate.span) {
367 FileName::Real(name) => name
369 .expect("attempting to resolve a file path in an external file"),
370 other => PathBuf::from(other.prefer_local().to_string()),
372 let dir_path = file_path.parent().unwrap_or(&file_path).to_owned();
373 self.cx.root_path = dir_path.clone();
374 self.cx.current_expansion.module = Rc::new(ModuleData {
375 mod_path: vec![Ident::from_str(&self.cx.ecfg.crate_name)],
376 file_path_stack: vec![file_path],
379 let krate = self.fully_expand_fragment(AstFragment::Crate(krate)).make_crate();
380 self.cx.trace_macros_diag();
384 // Recursively expand all macro invocations in this AST fragment.
385 pub fn fully_expand_fragment(&mut self, input_fragment: AstFragment) -> AstFragment {
386 let orig_expansion_data = self.cx.current_expansion.clone();
387 let orig_force_mode = self.cx.force_mode;
389 // Collect all macro invocations and replace them with placeholders.
390 let (mut fragment_with_placeholders, mut invocations) =
391 self.collect_invocations(input_fragment, &[]);
393 // Optimization: if we resolve all imports now,
394 // we'll be able to immediately resolve most of imported macros.
395 self.resolve_imports();
397 // Resolve paths in all invocations and produce output expanded fragments for them, but
398 // do not insert them into our input AST fragment yet, only store in `expanded_fragments`.
399 // The output fragments also go through expansion recursively until no invocations are left.
400 // Unresolved macros produce dummy outputs as a recovery measure.
401 invocations.reverse();
402 let mut expanded_fragments = Vec::new();
403 let mut undetermined_invocations = Vec::new();
404 let (mut progress, mut force) = (false, !self.monotonic);
406 let Some((invoc, ext)) = invocations.pop() else {
407 self.resolve_imports();
408 if undetermined_invocations.is_empty() {
411 invocations = mem::take(&mut undetermined_invocations);
412 force = !mem::replace(&mut progress, false);
413 if force && self.monotonic {
414 self.cx.sess.delay_span_bug(
415 invocations.last().unwrap().0.span(),
416 "expansion entered force mode without producing any errors",
422 let ext = match ext {
425 let eager_expansion_root = if self.monotonic {
426 invoc.expansion_data.id
428 orig_expansion_data.id
430 match self.cx.resolver.resolve_macro_invocation(
432 eager_expansion_root,
436 Err(Indeterminate) => {
437 // Cannot resolve, will retry this invocation later.
438 undetermined_invocations.push((invoc, None));
445 let ExpansionData { depth, id: expn_id, .. } = invoc.expansion_data;
446 let depth = depth - orig_expansion_data.depth;
447 self.cx.current_expansion = invoc.expansion_data.clone();
448 self.cx.force_mode = force;
450 let fragment_kind = invoc.fragment_kind;
451 let (expanded_fragment, new_invocations) = match self.expand_invoc(invoc, &ext.kind) {
452 ExpandResult::Ready(fragment) => {
453 let mut derive_invocations = Vec::new();
454 let derive_placeholders = self
457 .take_derive_resolutions(expn_id)
459 derive_invocations.reserve(derives.len());
462 .map(|(path, item, _exts)| {
463 // FIXME: Consider using the derive resolutions (`_exts`)
464 // instead of enqueuing the derives to be resolved again later.
465 let expn_id = LocalExpnId::fresh_empty();
466 derive_invocations.push((
468 kind: InvocationKind::Derive { path, item },
470 expansion_data: ExpansionData {
472 ..self.cx.current_expansion.clone()
477 NodeId::placeholder_from_expn_id(expn_id)
481 .unwrap_or_default();
483 let (fragment, collected_invocations) =
484 self.collect_invocations(fragment, &derive_placeholders);
485 // We choose to expand any derive invocations associated with this macro invocation
486 // *before* any macro invocations collected from the output fragment
487 derive_invocations.extend(collected_invocations);
488 (fragment, derive_invocations)
490 ExpandResult::Retry(invoc) => {
494 "expansion entered force mode but is still stuck",
497 // Cannot expand, will retry this invocation later.
498 undetermined_invocations.push((invoc, Some(ext)));
505 if expanded_fragments.len() < depth {
506 expanded_fragments.push(Vec::new());
508 expanded_fragments[depth - 1].push((expn_id, expanded_fragment));
509 invocations.extend(new_invocations.into_iter().rev());
512 self.cx.current_expansion = orig_expansion_data;
513 self.cx.force_mode = orig_force_mode;
515 // Finally incorporate all the expanded macros into the input AST fragment.
516 let mut placeholder_expander = PlaceholderExpander::default();
517 while let Some(expanded_fragments) = expanded_fragments.pop() {
518 for (expn_id, expanded_fragment) in expanded_fragments.into_iter().rev() {
520 .add(NodeId::placeholder_from_expn_id(expn_id), expanded_fragment);
523 fragment_with_placeholders.mut_visit_with(&mut placeholder_expander);
524 fragment_with_placeholders
527 fn resolve_imports(&mut self) {
529 self.cx.resolver.resolve_imports();
533 /// Collects all macro invocations reachable at this time in this AST fragment, and replace
534 /// them with "placeholders" - dummy macro invocations with specially crafted `NodeId`s.
535 /// Then call into resolver that builds a skeleton ("reduced graph") of the fragment and
536 /// prepares data for resolving paths of macro invocations.
537 fn collect_invocations(
539 mut fragment: AstFragment,
540 extra_placeholders: &[NodeId],
541 ) -> (AstFragment, Vec<(Invocation, Option<Lrc<SyntaxExtension>>)>) {
542 // Resolve `$crate`s in the fragment for pretty-printing.
543 self.cx.resolver.resolve_dollar_crates();
545 let mut invocations = {
546 let mut collector = InvocationCollector {
547 // Non-derive macro invocations cannot see the results of cfg expansion - they
548 // will either be removed along with the item, or invoked before the cfg/cfg_attr
549 // attribute is expanded. Therefore, we don't need to configure the tokens
550 // Derive macros *can* see the results of cfg-expansion - they are handled
551 // specially in `fully_expand_fragment`
552 cfg: StripUnconfigured {
554 features: self.cx.ecfg.features,
555 config_tokens: false,
558 invocations: Vec::new(),
559 monotonic: self.monotonic,
561 fragment.mut_visit_with(&mut collector);
562 fragment.add_placeholders(extra_placeholders);
563 collector.invocations
569 .visit_ast_fragment_with_placeholders(self.cx.current_expansion.id, &fragment);
571 if self.cx.sess.opts.debugging_opts.incremental_relative_spans {
572 for (invoc, _) in invocations.iter_mut() {
573 let expn_id = invoc.expansion_data.id;
574 let parent_def = self.cx.resolver.invocation_parent(expn_id);
575 let span = match &mut invoc.kind {
576 InvocationKind::Bang { ref mut span, .. } => span,
577 InvocationKind::Attr { attr, .. } => &mut attr.span,
578 InvocationKind::Derive { path, .. } => &mut path.span,
580 *span = span.with_parent(Some(parent_def));
585 (fragment, invocations)
588 fn error_recursion_limit_reached(&mut self) {
589 let expn_data = self.cx.current_expansion.id.expn_data();
590 let suggested_limit = match self.cx.ecfg.recursion_limit {
591 Limit(0) => Limit(2),
597 &format!("recursion limit reached while expanding `{}`", expn_data.kind.descr()),
600 "consider increasing the recursion limit by adding a \
601 `#![recursion_limit = \"{}\"]` attribute to your crate (`{}`)",
602 suggested_limit, self.cx.ecfg.crate_name,
605 self.cx.trace_macros_diag();
608 /// A macro's expansion does not fit in this fragment kind.
609 /// For example, a non-type macro in a type position.
610 fn error_wrong_fragment_kind(&mut self, kind: AstFragmentKind, mac: &ast::MacCall, span: Span) {
612 "non-{kind} macro in {kind} position: {path}",
614 path = pprust::path_to_string(&mac.path),
616 self.cx.span_err(span, &msg);
617 self.cx.trace_macros_diag();
623 ext: &SyntaxExtensionKind,
624 ) -> ExpandResult<AstFragment, Invocation> {
625 let recursion_limit =
626 self.cx.reduced_recursion_limit.unwrap_or(self.cx.ecfg.recursion_limit);
627 if !recursion_limit.value_within_limit(self.cx.current_expansion.depth) {
628 if self.cx.reduced_recursion_limit.is_none() {
629 self.error_recursion_limit_reached();
632 // Reduce the recursion limit by half each time it triggers.
633 self.cx.reduced_recursion_limit = Some(recursion_limit / 2);
635 return ExpandResult::Ready(invoc.fragment_kind.dummy(invoc.span()));
638 let (fragment_kind, span) = (invoc.fragment_kind, invoc.span());
639 ExpandResult::Ready(match invoc.kind {
640 InvocationKind::Bang { mac, .. } => match ext {
641 SyntaxExtensionKind::Bang(expander) => {
642 let tok_result = match expander.expand(self.cx, span, mac.args.inner_tokens()) {
643 Err(_) => return ExpandResult::Ready(fragment_kind.dummy(span)),
646 self.parse_ast_fragment(tok_result, fragment_kind, &mac.path, span)
648 SyntaxExtensionKind::LegacyBang(expander) => {
649 let prev = self.cx.current_expansion.prior_type_ascription;
650 self.cx.current_expansion.prior_type_ascription = mac.prior_type_ascription;
651 let tok_result = expander.expand(self.cx, span, mac.args.inner_tokens());
652 let result = if let Some(result) = fragment_kind.make_from(tok_result) {
655 self.error_wrong_fragment_kind(fragment_kind, &mac, span);
656 fragment_kind.dummy(span)
658 self.cx.current_expansion.prior_type_ascription = prev;
663 InvocationKind::Attr { attr, pos, mut item, derives } => match ext {
664 SyntaxExtensionKind::Attr(expander) => {
665 self.gate_proc_macro_input(&item);
666 self.gate_proc_macro_attr_item(span, &item);
667 let tokens = match &item {
668 // FIXME: Collect tokens and use them instead of generating
669 // fake ones. These are unstable, so it needs to be
670 // fixed prior to stabilization
671 // Fake tokens when we are invoking an inner attribute, and
672 // we are invoking it on an out-of-line module or crate.
673 Annotatable::Crate(krate) => rustc_parse::fake_token_stream_for_crate(
674 &self.cx.sess.parse_sess,
677 Annotatable::Item(item_inner)
678 if matches!(attr.style, ast::AttrStyle::Inner)
683 ModKind::Unloaded | ModKind::Loaded(_, Inline::No, _),
687 rustc_parse::fake_token_stream(
688 &self.cx.sess.parse_sess,
689 &item.into_nonterminal(),
692 _ => item.into_tokens(&self.cx.sess.parse_sess),
694 let attr_item = attr.unwrap_normal_item();
695 if let MacArgs::Eq(..) = attr_item.args {
696 self.cx.span_err(span, "key-value macro attributes are not supported");
698 let inner_tokens = attr_item.args.inner_tokens();
699 let tok_result = match expander.expand(self.cx, span, inner_tokens, tokens) {
700 Err(_) => return ExpandResult::Ready(fragment_kind.dummy(span)),
703 self.parse_ast_fragment(tok_result, fragment_kind, &attr_item.path, span)
705 SyntaxExtensionKind::LegacyAttr(expander) => {
706 match validate_attr::parse_meta(&self.cx.sess.parse_sess, &attr) {
708 let items = match expander.expand(self.cx, span, &meta, item) {
709 ExpandResult::Ready(items) => items,
710 ExpandResult::Retry(item) => {
711 // Reassemble the original invocation for retrying.
712 return ExpandResult::Retry(Invocation {
713 kind: InvocationKind::Attr { attr, pos, item, derives },
718 if fragment_kind == AstFragmentKind::Expr && items.is_empty() {
720 "removing an expression is not supported in this position";
721 self.cx.span_err(span, msg);
722 fragment_kind.dummy(span)
724 fragment_kind.expect_from_annotatables(items)
729 fragment_kind.dummy(span)
733 SyntaxExtensionKind::NonMacroAttr => {
734 self.cx.expanded_inert_attrs.mark(&attr);
735 item.visit_attrs(|attrs| attrs.insert(pos, attr));
736 fragment_kind.expect_from_annotatables(iter::once(item))
740 InvocationKind::Derive { path, item } => match ext {
741 SyntaxExtensionKind::Derive(expander)
742 | SyntaxExtensionKind::LegacyDerive(expander) => {
743 if let SyntaxExtensionKind::Derive(..) = ext {
744 self.gate_proc_macro_input(&item);
746 let meta = ast::MetaItem { kind: ast::MetaItemKind::Word, span, path };
747 let items = match expander.expand(self.cx, span, &meta, item) {
748 ExpandResult::Ready(items) => items,
749 ExpandResult::Retry(item) => {
750 // Reassemble the original invocation for retrying.
751 return ExpandResult::Retry(Invocation {
752 kind: InvocationKind::Derive { path: meta.path, item },
757 fragment_kind.expect_from_annotatables(items)
764 fn gate_proc_macro_attr_item(&self, span: Span, item: &Annotatable) {
765 let kind = match item {
767 | Annotatable::TraitItem(_)
768 | Annotatable::ImplItem(_)
769 | Annotatable::ForeignItem(_)
770 | Annotatable::Crate(..) => return,
771 Annotatable::Stmt(stmt) => {
772 // Attributes are stable on item statements,
773 // but unstable on all other kinds of statements
779 Annotatable::Expr(_) => "expressions",
781 | Annotatable::ExprField(..)
782 | Annotatable::PatField(..)
783 | Annotatable::GenericParam(..)
784 | Annotatable::Param(..)
785 | Annotatable::FieldDef(..)
786 | Annotatable::Variant(..) => panic!("unexpected annotatable"),
788 if self.cx.ecfg.proc_macro_hygiene() {
792 &self.cx.sess.parse_sess,
793 sym::proc_macro_hygiene,
795 &format!("custom attributes cannot be applied to {}", kind),
800 fn gate_proc_macro_input(&self, annotatable: &Annotatable) {
801 struct GateProcMacroInput<'a> {
802 parse_sess: &'a ParseSess,
805 impl<'ast, 'a> Visitor<'ast> for GateProcMacroInput<'a> {
806 fn visit_item(&mut self, item: &'ast ast::Item) {
808 ast::ItemKind::Mod(_, mod_kind)
809 if !matches!(mod_kind, ModKind::Loaded(_, Inline::Yes, _)) =>
813 sym::proc_macro_hygiene,
815 "non-inline modules in proc macro input are unstable",
822 visit::walk_item(self, item);
826 if !self.cx.ecfg.proc_macro_hygiene() {
828 .visit_with(&mut GateProcMacroInput { parse_sess: &self.cx.sess.parse_sess });
832 fn parse_ast_fragment(
835 kind: AstFragmentKind,
839 let mut parser = self.cx.new_parser_from_tts(toks);
840 match parse_ast_fragment(&mut parser, kind) {
842 ensure_complete_parse(&mut parser, path, kind.name(), span);
846 if err.span.is_dummy() {
849 annotate_err_with_kind(&mut err, kind, span);
851 self.cx.trace_macros_diag();
858 pub fn parse_ast_fragment<'a>(
859 this: &mut Parser<'a>,
860 kind: AstFragmentKind,
861 ) -> PResult<'a, AstFragment> {
863 AstFragmentKind::Items => {
864 let mut items = SmallVec::new();
865 while let Some(item) = this.parse_item(ForceCollect::No)? {
868 AstFragment::Items(items)
870 AstFragmentKind::TraitItems => {
871 let mut items = SmallVec::new();
872 while let Some(item) = this.parse_trait_item(ForceCollect::No)? {
875 AstFragment::TraitItems(items)
877 AstFragmentKind::ImplItems => {
878 let mut items = SmallVec::new();
879 while let Some(item) = this.parse_impl_item(ForceCollect::No)? {
882 AstFragment::ImplItems(items)
884 AstFragmentKind::ForeignItems => {
885 let mut items = SmallVec::new();
886 while let Some(item) = this.parse_foreign_item(ForceCollect::No)? {
889 AstFragment::ForeignItems(items)
891 AstFragmentKind::Stmts => {
892 let mut stmts = SmallVec::new();
893 // Won't make progress on a `}`.
894 while this.token != token::Eof && this.token != token::CloseDelim(token::Brace) {
895 if let Some(stmt) = this.parse_full_stmt(AttemptLocalParseRecovery::Yes)? {
899 AstFragment::Stmts(stmts)
901 AstFragmentKind::Expr => AstFragment::Expr(this.parse_expr()?),
902 AstFragmentKind::OptExpr => {
903 if this.token != token::Eof {
904 AstFragment::OptExpr(Some(this.parse_expr()?))
906 AstFragment::OptExpr(None)
909 AstFragmentKind::Ty => AstFragment::Ty(this.parse_ty()?),
910 AstFragmentKind::Pat => AstFragment::Pat(this.parse_pat_allow_top_alt(
915 AstFragmentKind::Crate => AstFragment::Crate(this.parse_crate_mod()?),
916 AstFragmentKind::Arms
917 | AstFragmentKind::Fields
918 | AstFragmentKind::FieldPats
919 | AstFragmentKind::GenericParams
920 | AstFragmentKind::Params
921 | AstFragmentKind::StructFields
922 | AstFragmentKind::Variants => panic!("unexpected AST fragment kind"),
926 pub fn ensure_complete_parse<'a>(
927 this: &mut Parser<'a>,
932 if this.token != token::Eof {
933 let token = pprust::token_to_string(&this.token);
934 let msg = format!("macro expansion ignores token `{}` and any following", token);
935 // Avoid emitting backtrace info twice.
936 let def_site_span = this.token.span.with_ctxt(SyntaxContext::root());
937 let mut err = this.struct_span_err(def_site_span, &msg);
938 err.span_label(span, "caused by the macro expansion here");
940 "the usage of `{}!` is likely invalid in {} context",
941 pprust::path_to_string(macro_path),
945 let semi_span = this.sess.source_map().next_point(span);
947 let semi_full_span = semi_span.to(this.sess.source_map().next_point(semi_span));
948 match this.sess.source_map().span_to_snippet(semi_full_span) {
949 Ok(ref snippet) if &snippet[..] != ";" && kind_name == "expression" => {
952 "you might be missing a semicolon here",
954 Applicability::MaybeIncorrect,
963 struct InvocationCollector<'a, 'b> {
964 cx: &'a mut ExtCtxt<'b>,
965 cfg: StripUnconfigured<'a>,
966 invocations: Vec<(Invocation, Option<Lrc<SyntaxExtension>>)>,
970 impl<'a, 'b> InvocationCollector<'a, 'b> {
971 fn collect(&mut self, fragment_kind: AstFragmentKind, kind: InvocationKind) -> AstFragment {
972 let expn_id = LocalExpnId::fresh_empty();
973 let vis = kind.placeholder_visibility();
974 self.invocations.push((
978 expansion_data: ExpansionData {
980 depth: self.cx.current_expansion.depth + 1,
981 ..self.cx.current_expansion.clone()
986 placeholder(fragment_kind, NodeId::placeholder_from_expn_id(expn_id), vis)
989 fn collect_bang(&mut self, mac: ast::MacCall, kind: AstFragmentKind) -> AstFragment {
990 // cache the macro call span so that it can be
991 // easily adjusted for incremental compilation
992 let span = mac.span();
993 self.collect(kind, InvocationKind::Bang { mac, span })
998 (attr, pos, derives): (ast::Attribute, usize, Vec<Path>),
1000 kind: AstFragmentKind,
1002 self.collect(kind, InvocationKind::Attr { attr, pos, item, derives })
1005 /// If `item` is an attribute invocation, remove the attribute and return it together with
1006 /// its position and derives following it. We have to collect the derives in order to resolve
1007 /// legacy derive helpers (helpers written before derives that introduce them).
1010 item: &mut impl AstLike,
1011 ) -> Option<(ast::Attribute, usize, Vec<Path>)> {
1012 let mut attr = None;
1014 item.visit_attrs(|attrs| {
1017 .position(|a| !self.cx.expanded_inert_attrs.is_marked(a) && !is_builtin_attr(a))
1019 let attr = attrs.remove(attr_pos);
1020 let following_derives = attrs[attr_pos..]
1022 .filter(|a| a.has_name(sym::derive))
1023 .flat_map(|a| a.meta_item_list().unwrap_or_default())
1024 .filter_map(|nested_meta| match nested_meta {
1025 NestedMetaItem::MetaItem(ast::MetaItem {
1026 kind: MetaItemKind::Word,
1034 (attr, attr_pos, following_derives)
1044 ) -> Result<(bool, MacCall, Vec<ast::Attribute>), ast::Stmt> {
1046 StmtKind::MacCall(mac) => {
1047 let MacCallStmt { mac, style, attrs, .. } = mac.into_inner();
1048 Ok((style == MacStmtStyle::Semicolon, mac, attrs.into()))
1050 StmtKind::Item(item) if matches!(item.kind, ItemKind::MacCall(..)) => {
1051 match item.into_inner() {
1052 ast::Item { kind: ItemKind::MacCall(mac), attrs, .. } => {
1053 Ok((mac.args.need_semicolon(), mac, attrs))
1055 _ => unreachable!(),
1058 StmtKind::Semi(expr) if matches!(expr.kind, ast::ExprKind::MacCall(..)) => {
1059 match expr.into_inner() {
1060 ast::Expr { kind: ast::ExprKind::MacCall(mac), attrs, .. } => {
1061 Ok((mac.args.need_semicolon(), mac, attrs.into()))
1063 _ => unreachable!(),
1066 StmtKind::Local(..) | StmtKind::Empty | StmtKind::Item(..) | StmtKind::Semi(..) => {
1069 StmtKind::Expr(..) => unreachable!(),
1073 fn configure<T: AstLike>(&mut self, node: T) -> Option<T> {
1074 self.cfg.configure(node)
1077 // Detect use of feature-gated or invalid attributes on macro invocations
1078 // since they will not be detected after macro expansion.
1079 fn check_attributes(&self, attrs: &[ast::Attribute], call: &MacCall) {
1080 let features = self.cx.ecfg.features.unwrap();
1081 let mut attrs = attrs.iter().peekable();
1082 let mut span: Option<Span> = None;
1083 while let Some(attr) = attrs.next() {
1084 rustc_ast_passes::feature_gate::check_attribute(attr, self.cx.sess, features);
1085 validate_attr::check_meta(&self.cx.sess.parse_sess, attr);
1087 let current_span = if let Some(sp) = span { sp.to(attr.span) } else { attr.span };
1088 span = Some(current_span);
1090 if attrs.peek().map_or(false, |next_attr| next_attr.doc_str().is_some()) {
1094 if attr.is_doc_comment() {
1095 self.cx.sess.parse_sess.buffer_lint_with_diagnostic(
1096 &UNUSED_DOC_COMMENTS,
1098 self.cx.current_expansion.lint_node_id,
1099 "unused doc comment",
1100 BuiltinLintDiagnostics::UnusedDocComment(attr.span),
1102 } else if rustc_attr::is_builtin_attr(attr) {
1103 let attr_name = attr.ident().unwrap().name;
1104 // `#[cfg]` and `#[cfg_attr]` are special - they are
1105 // eagerly evaluated.
1106 if attr_name != sym::cfg && attr_name != sym::cfg_attr {
1107 self.cx.sess.parse_sess.buffer_lint_with_diagnostic(
1110 self.cx.current_expansion.lint_node_id,
1111 &format!("unused attribute `{}`", attr_name),
1112 BuiltinLintDiagnostics::UnusedBuiltinAttribute {
1114 macro_name: pprust::path_to_string(&call.path),
1115 invoc_span: call.path.span,
1124 /// Wraps a call to `noop_visit_*` / `noop_flat_map_*`
1125 /// for an AST node that supports attributes
1126 /// (see the `Annotatable` enum)
1127 /// This method assigns a `NodeId`, and sets that `NodeId`
1128 /// as our current 'lint node id'. If a macro call is found
1129 /// inside this AST node, we will use this AST node's `NodeId`
1130 /// to emit lints associated with that macro (allowing
1131 /// `#[allow]` / `#[deny]` to be applied close to
1132 /// the macro invocation).
1134 /// Do *not* call this for a macro AST node
1135 /// (e.g. `ExprKind::MacCall`) - we cannot emit lints
1136 /// at these AST nodes, since they are removed and
1137 /// replaced with the result of macro expansion.
1139 /// All other `NodeId`s are assigned by `visit_id`.
1140 /// * `self` is the 'self' parameter for the current method,
1141 /// * `id` is a mutable reference to the `NodeId` field
1142 /// of the current AST node.
1143 /// * `closure` is a closure that executes the
1144 /// `noop_visit_*` / `noop_flat_map_*` method
1145 /// for the current AST node.
1146 macro_rules! assign_id {
1147 ($self:ident, $id:expr, $closure:expr) => {{
1148 let old_id = $self.cx.current_expansion.lint_node_id;
1149 if $self.monotonic {
1150 debug_assert_eq!(*$id, ast::DUMMY_NODE_ID);
1151 let new_id = $self.cx.resolver.next_node_id();
1153 $self.cx.current_expansion.lint_node_id = new_id;
1155 let ret = ($closure)();
1156 $self.cx.current_expansion.lint_node_id = old_id;
1161 impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
1162 fn visit_crate(&mut self, krate: &mut ast::Crate) {
1163 let span = krate.span;
1165 || ast::Crate { attrs: Vec::new(), items: Vec::new(), span, is_placeholder: None };
1166 let mut fold_crate = |krate: ast::Crate| {
1167 let mut krate = match self.configure(krate) {
1168 Some(krate) => krate,
1169 None => return empty_crate(),
1172 if let Some(attr) = self.take_first_attr(&mut krate) {
1174 .collect_attr(attr, Annotatable::Crate(krate), AstFragmentKind::Crate)
1178 noop_visit_crate(&mut krate, self);
1182 // Cannot use `visit_clobber` here, see the FIXME on it.
1183 *krate = fold_crate(mem::replace(krate, empty_crate()));
1186 fn visit_expr(&mut self, expr: &mut P<ast::Expr>) {
1187 self.cfg.configure_expr(expr);
1188 visit_clobber(expr.deref_mut(), |mut expr| {
1189 if let Some(attr) = self.take_first_attr(&mut expr) {
1190 // Collect the invoc regardless of whether or not attributes are permitted here
1191 // expansion will eat the attribute so it won't error later.
1192 self.cfg.maybe_emit_expr_attr_err(&attr.0);
1194 // AstFragmentKind::Expr requires the macro to emit an expression.
1196 .collect_attr(attr, Annotatable::Expr(P(expr)), AstFragmentKind::Expr)
1201 if let ast::ExprKind::MacCall(mac) = expr.kind {
1202 self.check_attributes(&expr.attrs, &mac);
1203 self.collect_bang(mac, AstFragmentKind::Expr).make_expr().into_inner()
1205 assign_id!(self, &mut expr.id, || {
1206 ensure_sufficient_stack(|| noop_visit_expr(&mut expr, self));
1213 fn flat_map_arm(&mut self, arm: ast::Arm) -> SmallVec<[ast::Arm; 1]> {
1214 let mut arm = configure!(self, arm);
1216 if let Some(attr) = self.take_first_attr(&mut arm) {
1218 .collect_attr(attr, Annotatable::Arm(arm), AstFragmentKind::Arms)
1222 assign_id!(self, &mut arm.id, || noop_flat_map_arm(arm, self))
1225 fn flat_map_expr_field(&mut self, field: ast::ExprField) -> SmallVec<[ast::ExprField; 1]> {
1226 let mut field = configure!(self, field);
1228 if let Some(attr) = self.take_first_attr(&mut field) {
1230 .collect_attr(attr, Annotatable::ExprField(field), AstFragmentKind::Fields)
1231 .make_expr_fields();
1234 assign_id!(self, &mut field.id, || noop_flat_map_expr_field(field, self))
1237 fn flat_map_pat_field(&mut self, fp: ast::PatField) -> SmallVec<[ast::PatField; 1]> {
1238 let mut fp = configure!(self, fp);
1240 if let Some(attr) = self.take_first_attr(&mut fp) {
1242 .collect_attr(attr, Annotatable::PatField(fp), AstFragmentKind::FieldPats)
1246 assign_id!(self, &mut fp.id, || noop_flat_map_pat_field(fp, self))
1249 fn flat_map_param(&mut self, p: ast::Param) -> SmallVec<[ast::Param; 1]> {
1250 let mut p = configure!(self, p);
1252 if let Some(attr) = self.take_first_attr(&mut p) {
1254 .collect_attr(attr, Annotatable::Param(p), AstFragmentKind::Params)
1258 assign_id!(self, &mut p.id, || noop_flat_map_param(p, self))
1261 fn flat_map_field_def(&mut self, sf: ast::FieldDef) -> SmallVec<[ast::FieldDef; 1]> {
1262 let mut sf = configure!(self, sf);
1264 if let Some(attr) = self.take_first_attr(&mut sf) {
1266 .collect_attr(attr, Annotatable::FieldDef(sf), AstFragmentKind::StructFields)
1270 assign_id!(self, &mut sf.id, || noop_flat_map_field_def(sf, self))
1273 fn flat_map_variant(&mut self, variant: ast::Variant) -> SmallVec<[ast::Variant; 1]> {
1274 let mut variant = configure!(self, variant);
1276 if let Some(attr) = self.take_first_attr(&mut variant) {
1278 .collect_attr(attr, Annotatable::Variant(variant), AstFragmentKind::Variants)
1282 assign_id!(self, &mut variant.id, || noop_flat_map_variant(variant, self))
1285 fn filter_map_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
1286 let expr = configure!(self, expr);
1287 expr.filter_map(|mut expr| {
1288 if let Some(attr) = self.take_first_attr(&mut expr) {
1289 self.cfg.maybe_emit_expr_attr_err(&attr.0);
1292 .collect_attr(attr, Annotatable::Expr(P(expr)), AstFragmentKind::OptExpr)
1294 .map(|expr| expr.into_inner());
1297 if let ast::ExprKind::MacCall(mac) = expr.kind {
1298 self.check_attributes(&expr.attrs, &mac);
1299 self.collect_bang(mac, AstFragmentKind::OptExpr)
1301 .map(|expr| expr.into_inner())
1303 assign_id!(self, &mut expr.id, || {
1305 noop_visit_expr(&mut expr, self);
1313 fn visit_pat(&mut self, pat: &mut P<ast::Pat>) {
1315 PatKind::MacCall(_) => {}
1316 _ => return noop_visit_pat(pat, self),
1319 visit_clobber(pat, |mut pat| match mem::replace(&mut pat.kind, PatKind::Wild) {
1320 PatKind::MacCall(mac) => self.collect_bang(mac, AstFragmentKind::Pat).make_pat(),
1321 _ => unreachable!(),
1325 fn flat_map_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> {
1326 let mut stmt = configure!(self, stmt);
1328 // We pull macro invocations (both attributes and fn-like macro calls) out of their
1329 // `StmtKind`s and treat them as statement macro invocations, not as items or expressions.
1330 // FIXME: invocations in semicolon-less expressions positions are expanded as expressions,
1331 // changing that requires some compatibility measures.
1332 let mut stmt = if !stmt.is_expr() {
1333 if let Some(attr) = self.take_first_attr(&mut stmt) {
1335 .collect_attr(attr, Annotatable::Stmt(P(stmt)), AstFragmentKind::Stmts)
1339 match self.take_stmt_bang(stmt) {
1340 Ok((add_semicolon, mac, attrs)) => {
1341 self.check_attributes(&attrs, &mac);
1342 let mut stmts = self.collect_bang(mac, AstFragmentKind::Stmts).make_stmts();
1344 // If this is a macro invocation with a semicolon, then apply that
1345 // semicolon to the final statement produced by expansion.
1347 if let Some(stmt) = stmts.pop() {
1348 stmts.push(stmt.add_trailing_semicolon());
1360 // The only way that we can end up with a `MacCall` expression statement,
1361 // (as opposed to a `StmtKind::MacCall`) is if we have a macro as the
1362 // traiing expression in a block (e.g. `fn foo() { my_macro!() }`).
1363 // Record this information, so that we can report a more specific
1364 // `SEMICOLON_IN_EXPRESSIONS_FROM_MACROS` lint if needed.
1365 // See #78991 for an investigation of treating macros in this position
1366 // as statements, rather than expressions, during parsing.
1367 let res = match &stmt.kind {
1368 StmtKind::Expr(expr)
1369 if matches!(**expr, ast::Expr { kind: ast::ExprKind::MacCall(..), .. }) =>
1371 self.cx.current_expansion.is_trailing_mac = true;
1372 // Don't use `assign_id` for this statement - it may get removed
1373 // entirely due to a `#[cfg]` on the contained expression
1374 noop_flat_map_stmt(stmt, self)
1376 _ => assign_id!(self, &mut stmt.id, || noop_flat_map_stmt(stmt, self)),
1378 self.cx.current_expansion.is_trailing_mac = false;
1382 fn visit_block(&mut self, block: &mut P<Block>) {
1383 let orig_dir_ownership = mem::replace(
1384 &mut self.cx.current_expansion.dir_ownership,
1385 DirOwnership::UnownedViaBlock,
1387 noop_visit_block(block, self);
1388 self.cx.current_expansion.dir_ownership = orig_dir_ownership;
1391 fn flat_map_item(&mut self, item: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
1392 let mut item = configure!(self, item);
1394 if let Some(attr) = self.take_first_attr(&mut item) {
1396 .collect_attr(attr, Annotatable::Item(item), AstFragmentKind::Items)
1400 let mut attrs = mem::take(&mut item.attrs); // We do this to please borrowck.
1401 let ident = item.ident;
1402 let span = item.span;
1405 ast::ItemKind::MacCall(ref mac) => {
1406 self.check_attributes(&attrs, &mac);
1408 item.and_then(|item| match item.kind {
1409 ItemKind::MacCall(mac) => {
1410 self.collect_bang(mac, AstFragmentKind::Items).make_items()
1412 _ => unreachable!(),
1415 ast::ItemKind::Mod(_, ref mut mod_kind) if ident != Ident::empty() => {
1416 let (file_path, dir_path, dir_ownership) = match mod_kind {
1417 ModKind::Loaded(_, inline, _) => {
1418 // Inline `mod foo { ... }`, but we still need to push directories.
1419 let (dir_path, dir_ownership) = mod_dir_path(
1423 &self.cx.current_expansion.module,
1424 self.cx.current_expansion.dir_ownership,
1428 (None, dir_path, dir_ownership)
1430 ModKind::Unloaded => {
1431 // We have an outline `mod foo;` so we need to parse the file.
1432 let old_attrs_len = attrs.len();
1433 let ParsedExternalMod {
1439 } = parse_external_mod(
1443 &self.cx.current_expansion.module,
1444 self.cx.current_expansion.dir_ownership,
1448 if let Some(extern_mod_loaded) = self.cx.extern_mod_loaded {
1449 (attrs, items) = extern_mod_loaded(ident, attrs, items, inner_span);
1452 *mod_kind = ModKind::Loaded(items, Inline::No, inner_span);
1454 if item.attrs.len() > old_attrs_len {
1455 // If we loaded an out-of-line module and added some inner attributes,
1456 // then we need to re-configure it and re-collect attributes for
1457 // resolution and expansion.
1458 item = configure!(self, item);
1460 if let Some(attr) = self.take_first_attr(&mut item) {
1464 Annotatable::Item(item),
1465 AstFragmentKind::Items,
1470 (Some(file_path), dir_path, dir_ownership)
1474 // Set the module info before we flat map.
1475 let mut module = self.cx.current_expansion.module.with_dir_path(dir_path);
1476 module.mod_path.push(ident);
1477 if let Some(file_path) = file_path {
1478 module.file_path_stack.push(file_path);
1482 mem::replace(&mut self.cx.current_expansion.module, Rc::new(module));
1483 let orig_dir_ownership =
1484 mem::replace(&mut self.cx.current_expansion.dir_ownership, dir_ownership);
1486 let result = assign_id!(self, &mut item.id, || noop_flat_map_item(item, self));
1488 // Restore the module info.
1489 self.cx.current_expansion.dir_ownership = orig_dir_ownership;
1490 self.cx.current_expansion.module = orig_module;
1496 // The crate root is special - don't assign an ID to it.
1497 if !(matches!(item.kind, ast::ItemKind::Mod(..)) && ident == Ident::empty()) {
1498 assign_id!(self, &mut item.id, || noop_flat_map_item(item, self))
1500 noop_flat_map_item(item, self)
1506 fn flat_map_trait_item(&mut self, item: P<ast::AssocItem>) -> SmallVec<[P<ast::AssocItem>; 1]> {
1507 let mut item = configure!(self, item);
1509 if let Some(attr) = self.take_first_attr(&mut item) {
1511 .collect_attr(attr, Annotatable::TraitItem(item), AstFragmentKind::TraitItems)
1512 .make_trait_items();
1516 ast::AssocItemKind::MacCall(ref mac) => {
1517 self.check_attributes(&item.attrs, &mac);
1518 item.and_then(|item| match item.kind {
1519 ast::AssocItemKind::MacCall(mac) => {
1520 self.collect_bang(mac, AstFragmentKind::TraitItems).make_trait_items()
1522 _ => unreachable!(),
1526 assign_id!(self, &mut item.id, || noop_flat_map_assoc_item(item, self))
1531 fn flat_map_impl_item(&mut self, item: P<ast::AssocItem>) -> SmallVec<[P<ast::AssocItem>; 1]> {
1532 let mut item = configure!(self, item);
1534 if let Some(attr) = self.take_first_attr(&mut item) {
1536 .collect_attr(attr, Annotatable::ImplItem(item), AstFragmentKind::ImplItems)
1541 ast::AssocItemKind::MacCall(ref mac) => {
1542 self.check_attributes(&item.attrs, &mac);
1543 item.and_then(|item| match item.kind {
1544 ast::AssocItemKind::MacCall(mac) => {
1545 self.collect_bang(mac, AstFragmentKind::ImplItems).make_impl_items()
1547 _ => unreachable!(),
1551 assign_id!(self, &mut item.id, || noop_flat_map_assoc_item(item, self))
1556 fn visit_ty(&mut self, ty: &mut P<ast::Ty>) {
1558 ast::TyKind::MacCall(_) => {}
1559 _ => return noop_visit_ty(ty, self),
1562 visit_clobber(ty, |mut ty| match mem::replace(&mut ty.kind, ast::TyKind::Err) {
1563 ast::TyKind::MacCall(mac) => self.collect_bang(mac, AstFragmentKind::Ty).make_ty(),
1564 _ => unreachable!(),
1568 fn flat_map_foreign_item(
1570 foreign_item: P<ast::ForeignItem>,
1571 ) -> SmallVec<[P<ast::ForeignItem>; 1]> {
1572 let mut foreign_item = configure!(self, foreign_item);
1574 if let Some(attr) = self.take_first_attr(&mut foreign_item) {
1578 Annotatable::ForeignItem(foreign_item),
1579 AstFragmentKind::ForeignItems,
1581 .make_foreign_items();
1584 match foreign_item.kind {
1585 ast::ForeignItemKind::MacCall(ref mac) => {
1586 self.check_attributes(&foreign_item.attrs, &mac);
1587 foreign_item.and_then(|item| match item.kind {
1588 ast::ForeignItemKind::MacCall(mac) => {
1589 self.collect_bang(mac, AstFragmentKind::ForeignItems).make_foreign_items()
1591 _ => unreachable!(),
1595 assign_id!(self, &mut foreign_item.id, || noop_flat_map_foreign_item(
1603 fn flat_map_generic_param(
1605 param: ast::GenericParam,
1606 ) -> SmallVec<[ast::GenericParam; 1]> {
1607 let mut param = configure!(self, param);
1609 if let Some(attr) = self.take_first_attr(&mut param) {
1613 Annotatable::GenericParam(param),
1614 AstFragmentKind::GenericParams,
1616 .make_generic_params();
1619 assign_id!(self, &mut param.id, || noop_flat_map_generic_param(param, self))
1622 fn visit_id(&mut self, id: &mut ast::NodeId) {
1623 // We may have already assigned a `NodeId`
1624 // by calling `assign_id`
1625 if self.monotonic && *id == ast::DUMMY_NODE_ID {
1626 *id = self.cx.resolver.next_node_id();
1631 pub struct ExpansionConfig<'feat> {
1632 pub crate_name: String,
1633 pub features: Option<&'feat Features>,
1634 pub recursion_limit: Limit,
1635 pub trace_mac: bool,
1636 pub should_test: bool, // If false, strip `#[test]` nodes
1637 pub span_debug: bool, // If true, use verbose debugging for `proc_macro::Span`
1638 pub proc_macro_backtrace: bool, // If true, show backtraces for proc-macro panics
1641 impl<'feat> ExpansionConfig<'feat> {
1642 pub fn default(crate_name: String) -> ExpansionConfig<'static> {
1646 recursion_limit: Limit::new(1024),
1650 proc_macro_backtrace: false,
1654 fn proc_macro_hygiene(&self) -> bool {
1655 self.features.map_or(false, |features| features.proc_macro_hygiene)