compiler/rustc_expand/src/expand.rs

   1 use crate::base::*;
   2 use crate::config::StripUnconfigured;
   3 use crate::configure;
   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};
   8
   9 use rustc_ast as ast;
  10 use rustc_ast::mut_visit::*;
  11 use rustc_ast::ptr::P;
  12 use rustc_ast::token;
  13 use rustc_ast::tokenstream::TokenStream;
  14 use rustc_ast::visit::{self, AssocCtxt, Visitor};
  15 use rustc_ast::{AstLike, Block, Inline, ItemKind, Local, MacArgs, MacCall};
  16 use rustc_ast::{MacCallStmt, MacStmtStyle, MetaItemKind, ModKind, NestedMetaItem};
  17 use rustc_ast::{NodeId, PatKind, Path, StmtKind, Unsafe};
  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, FatalError, PResult};
  24 use rustc_feature::Features;
  25 use rustc_parse::parser::{
  26     AttemptLocalParseRecovery, ForceCollect, Parser, RecoverColon, RecoverComma,
  27 };
  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};
  35
  36 use smallvec::{smallvec, SmallVec};
  37 use std::ops::DerefMut;
  38 use std::path::PathBuf;
  39 use std::rc::Rc;
  40 use std::{iter, mem};
  41
  42 macro_rules! ast_fragments {
  43     (
  44         $($Kind:ident($AstTy:ty) {
  45             $kind_name:expr;
  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)*);)?
  48             fn $make_ast:ident;
  49         })*
  50     ) => {
  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>>),
  55             $($Kind($AstTy),)*
  56         }
  57
  58         /// "Discriminant" of an AST fragment.
  59         #[derive(Copy, Clone, PartialEq, Eq)]
  60         pub enum AstFragmentKind {
  61             OptExpr,
  62             $($Kind,)*
  63         }
  64
  65         impl AstFragmentKind {
  66             pub fn name(self) -> &'static str {
  67                 match self {
  68                     AstFragmentKind::OptExpr => "expression",
  69                     $(AstFragmentKind::$Kind => $kind_name,)*
  70                 }
  71             }
  72
  73             fn make_from<'a>(self, result: Box<dyn MacResult + 'a>) -> Option<AstFragment> {
  74                 match self {
  75                     AstFragmentKind::OptExpr =>
  76                         result.make_expr().map(Some).map(AstFragment::OptExpr),
  77                     $(AstFragmentKind::$Kind => result.$make_ast().map(AstFragment::$Kind),)*
  78                 }
  79             }
  80         }
  81
  82         impl AstFragment {
  83             pub fn add_placeholders(&mut self, placeholders: &[NodeId]) {
  84                 if placeholders.is_empty() {
  85                     return;
  86                 }
  87                 match self {
  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()
  93                     })),)?)*
  94                     _ => panic!("unexpected AST fragment kind")
  95                 }
  96             }
  97
  98             pub fn make_opt_expr(self) -> Option<P<ast::Expr>> {
  99                 match self {
 100                     AstFragment::OptExpr(expr) => expr,
 101                     _ => panic!("AstFragment::make_* called on the wrong kind of fragment"),
 102                 }
 103             }
 104
 105             $(pub fn $make_ast(self) -> $AstTy {
 106                 match self {
 107                     AstFragment::$Kind(ast) => ast,
 108                     _ => panic!("AstFragment::make_* called on the wrong kind of fragment"),
 109                 }
 110             })*
 111
 112             pub fn mut_visit_with<F: MutVisitor>(&mut self, vis: &mut F) {
 113                 match self {
 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)
 118                             } else {
 119                                 None
 120                             }
 121                         });
 122                     }
 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)),)?)*
 126                 }
 127             }
 128
 129             pub fn visit_with<'a, V: Visitor<'a>>(&'a self, visitor: &mut V) {
 130                 match *self {
 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)*);
 136                     })?)*
 137                 }
 138             }
 139         }
 140
 141         impl<'a> MacResult for crate::mbe::macro_rules::ParserAnyMacro<'a> {
 142             $(fn $make_ast(self: Box<crate::mbe::macro_rules::ParserAnyMacro<'a>>)
 143                            -> Option<$AstTy> {
 144                 Some(self.make(AstFragmentKind::$Kind).$make_ast())
 145             })*
 146         }
 147     }
 148 }
 149
 150 ast_fragments! {
 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;
 156     }
 157     Items(SmallVec<[P<ast::Item>; 1]>) {
 158         "item"; many fn flat_map_item; fn visit_item(); fn make_items;
 159     }
 160     TraitItems(SmallVec<[P<ast::AssocItem>; 1]>) {
 161         "trait item";
 162         many fn flat_map_trait_item;
 163         fn visit_assoc_item(AssocCtxt::Trait);
 164         fn make_trait_items;
 165     }
 166     ImplItems(SmallVec<[P<ast::AssocItem>; 1]>) {
 167         "impl item";
 168         many fn flat_map_impl_item;
 169         fn visit_assoc_item(AssocCtxt::Impl);
 170         fn make_impl_items;
 171     }
 172     ForeignItems(SmallVec<[P<ast::ForeignItem>; 1]>) {
 173         "foreign item";
 174         many fn flat_map_foreign_item;
 175         fn visit_foreign_item();
 176         fn make_foreign_items;
 177     }
 178     Arms(SmallVec<[ast::Arm; 1]>) {
 179         "match arm"; many fn flat_map_arm; fn visit_arm(); fn make_arms;
 180     }
 181     Fields(SmallVec<[ast::ExprField; 1]>) {
 182         "field expression"; many fn flat_map_expr_field; fn visit_expr_field(); fn make_expr_fields;
 183     }
 184     FieldPats(SmallVec<[ast::PatField; 1]>) {
 185         "field pattern";
 186         many fn flat_map_pat_field;
 187         fn visit_pat_field();
 188         fn make_pat_fields;
 189     }
 190     GenericParams(SmallVec<[ast::GenericParam; 1]>) {
 191         "generic parameter";
 192         many fn flat_map_generic_param;
 193         fn visit_generic_param();
 194         fn make_generic_params;
 195     }
 196     Params(SmallVec<[ast::Param; 1]>) {
 197         "function parameter"; many fn flat_map_param; fn visit_param(); fn make_params;
 198     }
 199     StructFields(SmallVec<[ast::FieldDef; 1]>) {
 200         "field";
 201         many fn flat_map_field_def;
 202         fn visit_field_def();
 203         fn make_field_defs;
 204     }
 205     Variants(SmallVec<[ast::Variant; 1]>) {
 206         "variant"; many fn flat_map_variant; fn visit_variant(); fn make_variants;
 207     }
 208 }
 209
 210 pub enum SupportsMacroExpansion {
 211     No,
 212     Yes { supports_inner_attrs: bool },
 213 }
 214
 215 impl AstFragmentKind {
 216     crate fn dummy(self, span: Span) -> AstFragment {
 217         self.make_from(DummyResult::any(span)).expect("couldn't create a dummy AST fragment")
 218     }
 219
 220     pub fn supports_macro_expansion(self) -> SupportsMacroExpansion {
 221         match self {
 222             AstFragmentKind::OptExpr
 223             | AstFragmentKind::Expr
 224             | AstFragmentKind::Stmts
 225             | AstFragmentKind::Ty
 226             | AstFragmentKind::Pat => SupportsMacroExpansion::Yes { supports_inner_attrs: false },
 227             AstFragmentKind::Items
 228             | AstFragmentKind::TraitItems
 229             | AstFragmentKind::ImplItems
 230             | AstFragmentKind::ForeignItems => {
 231                 SupportsMacroExpansion::Yes { supports_inner_attrs: true }
 232             }
 233             AstFragmentKind::Arms
 234             | AstFragmentKind::Fields
 235             | AstFragmentKind::FieldPats
 236             | AstFragmentKind::GenericParams
 237             | AstFragmentKind::Params
 238             | AstFragmentKind::StructFields
 239             | AstFragmentKind::Variants => SupportsMacroExpansion::No,
 240         }
 241     }
 242
 243     fn expect_from_annotatables<I: IntoIterator<Item = Annotatable>>(
 244         self,
 245         items: I,
 246     ) -> AstFragment {
 247         let mut items = items.into_iter();
 248         match self {
 249             AstFragmentKind::Arms => {
 250                 AstFragment::Arms(items.map(Annotatable::expect_arm).collect())
 251             }
 252             AstFragmentKind::Fields => {
 253                 AstFragment::Fields(items.map(Annotatable::expect_expr_field).collect())
 254             }
 255             AstFragmentKind::FieldPats => {
 256                 AstFragment::FieldPats(items.map(Annotatable::expect_pat_field).collect())
 257             }
 258             AstFragmentKind::GenericParams => {
 259                 AstFragment::GenericParams(items.map(Annotatable::expect_generic_param).collect())
 260             }
 261             AstFragmentKind::Params => {
 262                 AstFragment::Params(items.map(Annotatable::expect_param).collect())
 263             }
 264             AstFragmentKind::StructFields => {
 265                 AstFragment::StructFields(items.map(Annotatable::expect_field_def).collect())
 266             }
 267             AstFragmentKind::Variants => {
 268                 AstFragment::Variants(items.map(Annotatable::expect_variant).collect())
 269             }
 270             AstFragmentKind::Items => {
 271                 AstFragment::Items(items.map(Annotatable::expect_item).collect())
 272             }
 273             AstFragmentKind::ImplItems => {
 274                 AstFragment::ImplItems(items.map(Annotatable::expect_impl_item).collect())
 275             }
 276             AstFragmentKind::TraitItems => {
 277                 AstFragment::TraitItems(items.map(Annotatable::expect_trait_item).collect())
 278             }
 279             AstFragmentKind::ForeignItems => {
 280                 AstFragment::ForeignItems(items.map(Annotatable::expect_foreign_item).collect())
 281             }
 282             AstFragmentKind::Stmts => {
 283                 AstFragment::Stmts(items.map(Annotatable::expect_stmt).collect())
 284             }
 285             AstFragmentKind::Expr => AstFragment::Expr(
 286                 items.next().expect("expected exactly one expression").expect_expr(),
 287             ),
 288             AstFragmentKind::OptExpr => {
 289                 AstFragment::OptExpr(items.next().map(Annotatable::expect_expr))
 290             }
 291             AstFragmentKind::Pat | AstFragmentKind::Ty => {
 292                 panic!("patterns and types aren't annotatable")
 293             }
 294         }
 295     }
 296 }
 297
 298 pub struct Invocation {
 299     pub kind: InvocationKind,
 300     pub fragment_kind: AstFragmentKind,
 301     pub expansion_data: ExpansionData,
 302 }
 303
 304 pub enum InvocationKind {
 305     Bang {
 306         mac: ast::MacCall,
 307         span: Span,
 308     },
 309     Attr {
 310         attr: ast::Attribute,
 311         // Re-insertion position for inert attributes.
 312         pos: usize,
 313         item: Annotatable,
 314         // Required for resolving derive helper attributes.
 315         derives: Vec<Path>,
 316     },
 317     Derive {
 318         path: Path,
 319         item: Annotatable,
 320     },
 321 }
 322
 323 impl InvocationKind {
 324     fn placeholder_visibility(&self) -> Option<ast::Visibility> {
 325         // HACK: For unnamed fields placeholders should have the same visibility as the actual
 326         // fields because for tuple structs/variants resolve determines visibilities of their
 327         // constructor using these field visibilities before attributes on them are are expanded.
 328         // The assumption is that the attribute expansion cannot change field visibilities,
 329         // and it holds because only inert attributes are supported in this position.
 330         match self {
 331             InvocationKind::Attr { item: Annotatable::FieldDef(field), .. }
 332             | InvocationKind::Derive { item: Annotatable::FieldDef(field), .. }
 333                 if field.ident.is_none() =>
 334             {
 335                 Some(field.vis.clone())
 336             }
 337             _ => None,
 338         }
 339     }
 340 }
 341
 342 impl Invocation {
 343     pub fn span(&self) -> Span {
 344         match &self.kind {
 345             InvocationKind::Bang { span, .. } => *span,
 346             InvocationKind::Attr { attr, .. } => attr.span,
 347             InvocationKind::Derive { path, .. } => path.span,
 348         }
 349     }
 350 }
 351
 352 pub struct MacroExpander<'a, 'b> {
 353     pub cx: &'a mut ExtCtxt<'b>,
 354     monotonic: bool, // cf. `cx.monotonic_expander()`
 355 }
 356
 357 impl<'a, 'b> MacroExpander<'a, 'b> {
 358     pub fn new(cx: &'a mut ExtCtxt<'b>, monotonic: bool) -> Self {
 359         MacroExpander { cx, monotonic }
 360     }
 361
 362     // FIXME: Avoid visiting the crate as a `Mod` item,
 363     // make crate a first class expansion target instead.
 364     pub fn expand_crate(&mut self, mut krate: ast::Crate) -> ast::Crate {
 365         let file_path = match self.cx.source_map().span_to_filename(krate.span) {
 366             FileName::Real(name) => name
 367                 .into_local_path()
 368                 .expect("attempting to resolve a file path in an external file"),
 369             other => PathBuf::from(other.prefer_local().to_string()),
 370         };
 371         let dir_path = file_path.parent().unwrap_or(&file_path).to_owned();
 372         self.cx.root_path = dir_path.clone();
 373         self.cx.current_expansion.module = Rc::new(ModuleData {
 374             mod_path: vec![Ident::from_str(&self.cx.ecfg.crate_name)],
 375             file_path_stack: vec![file_path],
 376             dir_path,
 377         });
 378
 379         let krate_item = AstFragment::Items(smallvec![P(ast::Item {
 380             attrs: krate.attrs,
 381             span: krate.span,
 382             kind: ast::ItemKind::Mod(
 383                 Unsafe::No,
 384                 ModKind::Loaded(krate.items, Inline::Yes, krate.span)
 385             ),
 386             ident: Ident::invalid(),
 387             id: ast::DUMMY_NODE_ID,
 388             vis: ast::Visibility {
 389                 span: krate.span.shrink_to_lo(),
 390                 kind: ast::VisibilityKind::Public,
 391                 tokens: None,
 392             },
 393             tokens: None,
 394         })]);
 395
 396         match self.fully_expand_fragment(krate_item).make_items().pop().map(P::into_inner) {
 397             Some(ast::Item {
 398                 attrs,
 399                 kind: ast::ItemKind::Mod(_, ModKind::Loaded(items, ..)),
 400                 ..
 401             }) => {
 402                 krate.attrs = attrs;
 403                 krate.items = items;
 404             }
 405             None => {
 406                 // Resolution failed so we return an empty expansion
 407                 krate.attrs = vec![];
 408                 krate.items = vec![];
 409             }
 410             Some(ast::Item { span, kind, .. }) => {
 411                 krate.attrs = vec![];
 412                 krate.items = vec![];
 413                 self.cx.span_err(
 414                     span,
 415                     &format!(
 416                         "expected crate top-level item to be a module after macro expansion, found {} {}",
 417                         kind.article(), kind.descr()
 418                     ),
 419                 );
 420                 // FIXME: this workaround issue #84569
 421                 FatalError.raise();
 422             }
 423         };
 424         self.cx.trace_macros_diag();
 425         krate
 426     }
 427
 428     // Recursively expand all macro invocations in this AST fragment.
 429     pub fn fully_expand_fragment(&mut self, input_fragment: AstFragment) -> AstFragment {
 430         let orig_expansion_data = self.cx.current_expansion.clone();
 431         let orig_force_mode = self.cx.force_mode;
 432
 433         // Collect all macro invocations and replace them with placeholders.
 434         let (mut fragment_with_placeholders, mut invocations) =
 435             self.collect_invocations(input_fragment, &[]);
 436
 437         // Optimization: if we resolve all imports now,
 438         // we'll be able to immediately resolve most of imported macros.
 439         self.resolve_imports();
 440
 441         // Resolve paths in all invocations and produce output expanded fragments for them, but
 442         // do not insert them into our input AST fragment yet, only store in `expanded_fragments`.
 443         // The output fragments also go through expansion recursively until no invocations are left.
 444         // Unresolved macros produce dummy outputs as a recovery measure.
 445         invocations.reverse();
 446         let mut expanded_fragments = Vec::new();
 447         let mut undetermined_invocations = Vec::new();
 448         let (mut progress, mut force) = (false, !self.monotonic);
 449         loop {
 450             let (invoc, ext) = if let Some(invoc) = invocations.pop() {
 451                 invoc
 452             } else {
 453                 self.resolve_imports();
 454                 if undetermined_invocations.is_empty() {
 455                     break;
 456                 }
 457                 invocations = mem::take(&mut undetermined_invocations);
 458                 force = !mem::replace(&mut progress, false);
 459                 if force && self.monotonic {
 460                     self.cx.sess.delay_span_bug(
 461                         invocations.last().unwrap().0.span(),
 462                         "expansion entered force mode without producing any errors",
 463                     );
 464                 }
 465                 continue;
 466             };
 467
 468             let ext = match ext {
 469                 Some(ext) => ext,
 470                 None => {
 471                     let eager_expansion_root = if self.monotonic {
 472                         invoc.expansion_data.id
 473                     } else {
 474                         orig_expansion_data.id
 475                     };
 476                     match self.cx.resolver.resolve_macro_invocation(
 477                         &invoc,
 478                         eager_expansion_root,
 479                         force,
 480                     ) {
 481                         Ok(ext) => ext,
 482                         Err(Indeterminate) => {
 483                             // Cannot resolve, will retry this invocation later.
 484                             undetermined_invocations.push((invoc, None));
 485                             continue;
 486                         }
 487                     }
 488                 }
 489             };
 490
 491             let ExpansionData { depth, id: expn_id, .. } = invoc.expansion_data;
 492             let depth = depth - orig_expansion_data.depth;
 493             self.cx.current_expansion = invoc.expansion_data.clone();
 494             self.cx.force_mode = force;
 495
 496             let fragment_kind = invoc.fragment_kind;
 497             let (expanded_fragment, new_invocations) = match self.expand_invoc(invoc, &ext.kind) {
 498                 ExpandResult::Ready(fragment) => {
 499                     let mut derive_invocations = Vec::new();
 500                     let derive_placeholders = self
 501                         .cx
 502                         .resolver
 503                         .take_derive_resolutions(expn_id)
 504                         .map(|derives| {
 505                             derive_invocations.reserve(derives.len());
 506                             derives
 507                                 .into_iter()
 508                                 .map(|(path, item, _exts)| {
 509                                     // FIXME: Consider using the derive resolutions (`_exts`)
 510                                     // instead of enqueuing the derives to be resolved again later.
 511                                     let expn_id = LocalExpnId::fresh_empty();
 512                                     derive_invocations.push((
 513                                         Invocation {
 514                                             kind: InvocationKind::Derive { path, item },
 515                                             fragment_kind,
 516                                             expansion_data: ExpansionData {
 517                                                 id: expn_id,
 518                                                 ..self.cx.current_expansion.clone()
 519                                             },
 520                                         },
 521                                         None,
 522                                     ));
 523                                     NodeId::placeholder_from_expn_id(expn_id)
 524                                 })
 525                                 .collect::<Vec<_>>()
 526                         })
 527                         .unwrap_or_default();
 528
 529                     let (fragment, collected_invocations) =
 530                         self.collect_invocations(fragment, &derive_placeholders);
 531                     // We choose to expand any derive invocations associated with this macro invocation
 532                     // *before* any macro invocations collected from the output fragment
 533                     derive_invocations.extend(collected_invocations);
 534                     (fragment, derive_invocations)
 535                 }
 536                 ExpandResult::Retry(invoc) => {
 537                     if force {
 538                         self.cx.span_bug(
 539                             invoc.span(),
 540                             "expansion entered force mode but is still stuck",
 541                         );
 542                     } else {
 543                         // Cannot expand, will retry this invocation later.
 544                         undetermined_invocations.push((invoc, Some(ext)));
 545                         continue;
 546                     }
 547                 }
 548             };
 549
 550             progress = true;
 551             if expanded_fragments.len() < depth {
 552                 expanded_fragments.push(Vec::new());
 553             }
 554             expanded_fragments[depth - 1].push((expn_id, expanded_fragment));
 555             invocations.extend(new_invocations.into_iter().rev());
 556         }
 557
 558         self.cx.current_expansion = orig_expansion_data;
 559         self.cx.force_mode = orig_force_mode;
 560
 561         // Finally incorporate all the expanded macros into the input AST fragment.
 562         let mut placeholder_expander = PlaceholderExpander::new(self.cx, self.monotonic);
 563         while let Some(expanded_fragments) = expanded_fragments.pop() {
 564             for (expn_id, expanded_fragment) in expanded_fragments.into_iter().rev() {
 565                 placeholder_expander
 566                     .add(NodeId::placeholder_from_expn_id(expn_id), expanded_fragment);
 567             }
 568         }
 569         fragment_with_placeholders.mut_visit_with(&mut placeholder_expander);
 570         fragment_with_placeholders
 571     }
 572
 573     fn resolve_imports(&mut self) {
 574         if self.monotonic {
 575             self.cx.resolver.resolve_imports();
 576         }
 577     }
 578
 579     /// Collects all macro invocations reachable at this time in this AST fragment, and replace
 580     /// them with "placeholders" - dummy macro invocations with specially crafted `NodeId`s.
 581     /// Then call into resolver that builds a skeleton ("reduced graph") of the fragment and
 582     /// prepares data for resolving paths of macro invocations.
 583     fn collect_invocations(
 584         &mut self,
 585         mut fragment: AstFragment,
 586         extra_placeholders: &[NodeId],
 587     ) -> (AstFragment, Vec<(Invocation, Option<Lrc<SyntaxExtension>>)>) {
 588         // Resolve `$crate`s in the fragment for pretty-printing.
 589         self.cx.resolver.resolve_dollar_crates();
 590
 591         let invocations = {
 592             let mut collector = InvocationCollector {
 593                 // Non-derive macro invocations cannot see the results of cfg expansion - they
 594                 // will either be removed along with the item, or invoked before the cfg/cfg_attr
 595                 // attribute is expanded. Therefore, we don't need to configure the tokens
 596                 // Derive macros *can* see the results of cfg-expansion - they are handled
 597                 // specially in `fully_expand_fragment`
 598                 cfg: StripUnconfigured {
 599                     sess: &self.cx.sess,
 600                     features: self.cx.ecfg.features,
 601                     config_tokens: false,
 602                 },
 603                 cx: self.cx,
 604                 invocations: Vec::new(),
 605                 monotonic: self.monotonic,
 606             };
 607             fragment.mut_visit_with(&mut collector);
 608             fragment.add_placeholders(extra_placeholders);
 609             collector.invocations
 610         };
 611
 612         if self.monotonic {
 613             self.cx
 614                 .resolver
 615                 .visit_ast_fragment_with_placeholders(self.cx.current_expansion.id, &fragment);
 616         }
 617
 618         (fragment, invocations)
 619     }
 620
 621     fn error_recursion_limit_reached(&mut self) {
 622         let expn_data = self.cx.current_expansion.id.expn_data();
 623         let suggested_limit = self.cx.ecfg.recursion_limit * 2;
 624         self.cx
 625             .struct_span_err(
 626                 expn_data.call_site,
 627                 &format!("recursion limit reached while expanding `{}`", expn_data.kind.descr()),
 628             )
 629             .help(&format!(
 630                 "consider adding a `#![recursion_limit=\"{}\"]` attribute to your crate (`{}`)",
 631                 suggested_limit, self.cx.ecfg.crate_name,
 632             ))
 633             .emit();
 634         self.cx.trace_macros_diag();
 635     }
 636
 637     /// A macro's expansion does not fit in this fragment kind.
 638     /// For example, a non-type macro in a type position.
 639     fn error_wrong_fragment_kind(&mut self, kind: AstFragmentKind, mac: &ast::MacCall, span: Span) {
 640         let msg = format!(
 641             "non-{kind} macro in {kind} position: {path}",
 642             kind = kind.name(),
 643             path = pprust::path_to_string(&mac.path),
 644         );
 645         self.cx.span_err(span, &msg);
 646         self.cx.trace_macros_diag();
 647     }
 648
 649     fn expand_invoc(
 650         &mut self,
 651         invoc: Invocation,
 652         ext: &SyntaxExtensionKind,
 653     ) -> ExpandResult<AstFragment, Invocation> {
 654         let recursion_limit =
 655             self.cx.reduced_recursion_limit.unwrap_or(self.cx.ecfg.recursion_limit);
 656         if !recursion_limit.value_within_limit(self.cx.current_expansion.depth) {
 657             if self.cx.reduced_recursion_limit.is_none() {
 658                 self.error_recursion_limit_reached();
 659             }
 660
 661             // Reduce the recursion limit by half each time it triggers.
 662             self.cx.reduced_recursion_limit = Some(recursion_limit / 2);
 663
 664             return ExpandResult::Ready(invoc.fragment_kind.dummy(invoc.span()));
 665         }
 666
 667         let (fragment_kind, span) = (invoc.fragment_kind, invoc.span());
 668         ExpandResult::Ready(match invoc.kind {
 669             InvocationKind::Bang { mac, .. } => match ext {
 670                 SyntaxExtensionKind::Bang(expander) => {
 671                     let tok_result = match expander.expand(self.cx, span, mac.args.inner_tokens()) {
 672                         Err(_) => return ExpandResult::Ready(fragment_kind.dummy(span)),
 673                         Ok(ts) => ts,
 674                     };
 675                     self.parse_ast_fragment(tok_result, fragment_kind, &mac.path, span)
 676                 }
 677                 SyntaxExtensionKind::LegacyBang(expander) => {
 678                     let prev = self.cx.current_expansion.prior_type_ascription;
 679                     self.cx.current_expansion.prior_type_ascription = mac.prior_type_ascription;
 680                     let tok_result = expander.expand(self.cx, span, mac.args.inner_tokens());
 681                     let result = if let Some(result) = fragment_kind.make_from(tok_result) {
 682                         result
 683                     } else {
 684                         self.error_wrong_fragment_kind(fragment_kind, &mac, span);
 685                         fragment_kind.dummy(span)
 686                     };
 687                     self.cx.current_expansion.prior_type_ascription = prev;
 688                     result
 689                 }
 690                 _ => unreachable!(),
 691             },
 692             InvocationKind::Attr { attr, pos, mut item, derives } => match ext {
 693                 SyntaxExtensionKind::Attr(expander) => {
 694                     self.gate_proc_macro_input(&item);
 695                     self.gate_proc_macro_attr_item(span, &item);
 696                     let mut fake_tokens = false;
 697                     if let Annotatable::Item(item_inner) = &item {
 698                         if let ItemKind::Mod(_, mod_kind) = &item_inner.kind {
 699                             // FIXME: Collect tokens and use them instead of generating
 700                             // fake ones. These are unstable, so it needs to be
 701                             // fixed prior to stabilization
 702                             // Fake tokens when we are invoking an inner attribute, and:
 703                             fake_tokens = matches!(attr.style, ast::AttrStyle::Inner) &&
 704                                 // We are invoking an attribute on the crate root, or an outline
 705                                 // module
 706                                 (item_inner.ident.name.is_empty() || !matches!(mod_kind, ast::ModKind::Loaded(_, Inline::Yes, _)));
 707                         }
 708                     }
 709                     let tokens = if fake_tokens {
 710                         rustc_parse::fake_token_stream(
 711                             &self.cx.sess.parse_sess,
 712                             &item.into_nonterminal(),
 713                         )
 714                     } else {
 715                         item.into_tokens(&self.cx.sess.parse_sess)
 716                     };
 717                     let attr_item = attr.unwrap_normal_item();
 718                     if let MacArgs::Eq(..) = attr_item.args {
 719                         self.cx.span_err(span, "key-value macro attributes are not supported");
 720                     }
 721                     let inner_tokens = attr_item.args.inner_tokens();
 722                     let tok_result = match expander.expand(self.cx, span, inner_tokens, tokens) {
 723                         Err(_) => return ExpandResult::Ready(fragment_kind.dummy(span)),
 724                         Ok(ts) => ts,
 725                     };
 726                     self.parse_ast_fragment(tok_result, fragment_kind, &attr_item.path, span)
 727                 }
 728                 SyntaxExtensionKind::LegacyAttr(expander) => {
 729                     match validate_attr::parse_meta(&self.cx.sess.parse_sess, &attr) {
 730                         Ok(meta) => {
 731                             let items = match expander.expand(self.cx, span, &meta, item) {
 732                                 ExpandResult::Ready(items) => items,
 733                                 ExpandResult::Retry(item) => {
 734                                     // Reassemble the original invocation for retrying.
 735                                     return ExpandResult::Retry(Invocation {
 736                                         kind: InvocationKind::Attr { attr, pos, item, derives },
 737                                         ..invoc
 738                                     });
 739                                 }
 740                             };
 741                             if fragment_kind == AstFragmentKind::Expr && items.is_empty() {
 742                                 let msg =
 743                                     "removing an expression is not supported in this position";
 744                                 self.cx.span_err(span, msg);
 745                                 fragment_kind.dummy(span)
 746                             } else {
 747                                 fragment_kind.expect_from_annotatables(items)
 748                             }
 749                         }
 750                         Err(mut err) => {
 751                             err.emit();
 752                             fragment_kind.dummy(span)
 753                         }
 754                     }
 755                 }
 756                 SyntaxExtensionKind::NonMacroAttr { mark_used } => {
 757                     self.cx.expanded_inert_attrs.mark(&attr);
 758                     if *mark_used {
 759                         self.cx.sess.mark_attr_used(&attr);
 760                     }
 761                     item.visit_attrs(|attrs| attrs.insert(pos, attr));
 762                     fragment_kind.expect_from_annotatables(iter::once(item))
 763                 }
 764                 _ => unreachable!(),
 765             },
 766             InvocationKind::Derive { path, item } => match ext {
 767                 SyntaxExtensionKind::Derive(expander)
 768                 | SyntaxExtensionKind::LegacyDerive(expander) => {
 769                     if let SyntaxExtensionKind::Derive(..) = ext {
 770                         self.gate_proc_macro_input(&item);
 771                     }
 772                     let meta = ast::MetaItem { kind: ast::MetaItemKind::Word, span, path };
 773                     let items = match expander.expand(self.cx, span, &meta, item) {
 774                         ExpandResult::Ready(items) => items,
 775                         ExpandResult::Retry(item) => {
 776                             // Reassemble the original invocation for retrying.
 777                             return ExpandResult::Retry(Invocation {
 778                                 kind: InvocationKind::Derive { path: meta.path, item },
 779                                 ..invoc
 780                             });
 781                         }
 782                     };
 783                     fragment_kind.expect_from_annotatables(items)
 784                 }
 785                 _ => unreachable!(),
 786             },
 787         })
 788     }
 789
 790     fn gate_proc_macro_attr_item(&self, span: Span, item: &Annotatable) {
 791         let kind = match item {
 792             Annotatable::Item(_)
 793             | Annotatable::TraitItem(_)
 794             | Annotatable::ImplItem(_)
 795             | Annotatable::ForeignItem(_) => return,
 796             Annotatable::Stmt(stmt) => {
 797                 // Attributes are stable on item statements,
 798                 // but unstable on all other kinds of statements
 799                 if stmt.is_item() {
 800                     return;
 801                 }
 802                 "statements"
 803             }
 804             Annotatable::Expr(_) => "expressions",
 805             Annotatable::Arm(..)
 806             | Annotatable::ExprField(..)
 807             | Annotatable::PatField(..)
 808             | Annotatable::GenericParam(..)
 809             | Annotatable::Param(..)
 810             | Annotatable::FieldDef(..)
 811             | Annotatable::Variant(..) => panic!("unexpected annotatable"),
 812         };
 813         if self.cx.ecfg.proc_macro_hygiene() {
 814             return;
 815         }
 816         feature_err(
 817             &self.cx.sess.parse_sess,
 818             sym::proc_macro_hygiene,
 819             span,
 820             &format!("custom attributes cannot be applied to {}", kind),
 821         )
 822         .emit();
 823     }
 824
 825     fn gate_proc_macro_input(&self, annotatable: &Annotatable) {
 826         struct GateProcMacroInput<'a> {
 827             parse_sess: &'a ParseSess,
 828         }
 829
 830         impl<'ast, 'a> Visitor<'ast> for GateProcMacroInput<'a> {
 831             fn visit_item(&mut self, item: &'ast ast::Item) {
 832                 match &item.kind {
 833                     ast::ItemKind::Mod(_, mod_kind)
 834                         if !matches!(mod_kind, ModKind::Loaded(_, Inline::Yes, _)) =>
 835                     {
 836                         feature_err(
 837                             self.parse_sess,
 838                             sym::proc_macro_hygiene,
 839                             item.span,
 840                             "non-inline modules in proc macro input are unstable",
 841                         )
 842                         .emit();
 843                     }
 844                     _ => {}
 845                 }
 846
 847                 visit::walk_item(self, item);
 848             }
 849         }
 850
 851         if !self.cx.ecfg.proc_macro_hygiene() {
 852             annotatable
 853                 .visit_with(&mut GateProcMacroInput { parse_sess: &self.cx.sess.parse_sess });
 854         }
 855     }
 856
 857     fn parse_ast_fragment(
 858         &mut self,
 859         toks: TokenStream,
 860         kind: AstFragmentKind,
 861         path: &Path,
 862         span: Span,
 863     ) -> AstFragment {
 864         let mut parser = self.cx.new_parser_from_tts(toks);
 865         match parse_ast_fragment(&mut parser, kind) {
 866             Ok(fragment) => {
 867                 ensure_complete_parse(&mut parser, path, kind.name(), span);
 868                 fragment
 869             }
 870             Err(mut err) => {
 871                 if err.span.is_dummy() {
 872                     err.set_span(span);
 873                 }
 874                 annotate_err_with_kind(&mut err, kind, span);
 875                 err.emit();
 876                 self.cx.trace_macros_diag();
 877                 kind.dummy(span)
 878             }
 879         }
 880     }
 881 }
 882
 883 pub fn parse_ast_fragment<'a>(
 884     this: &mut Parser<'a>,
 885     kind: AstFragmentKind,
 886 ) -> PResult<'a, AstFragment> {
 887     Ok(match kind {
 888         AstFragmentKind::Items => {
 889             let mut items = SmallVec::new();
 890             while let Some(item) = this.parse_item(ForceCollect::No)? {
 891                 items.push(item);
 892             }
 893             AstFragment::Items(items)
 894         }
 895         AstFragmentKind::TraitItems => {
 896             let mut items = SmallVec::new();
 897             while let Some(item) = this.parse_trait_item(ForceCollect::No)? {
 898                 items.extend(item);
 899             }
 900             AstFragment::TraitItems(items)
 901         }
 902         AstFragmentKind::ImplItems => {
 903             let mut items = SmallVec::new();
 904             while let Some(item) = this.parse_impl_item(ForceCollect::No)? {
 905                 items.extend(item);
 906             }
 907             AstFragment::ImplItems(items)
 908         }
 909         AstFragmentKind::ForeignItems => {
 910             let mut items = SmallVec::new();
 911             while let Some(item) = this.parse_foreign_item(ForceCollect::No)? {
 912                 items.extend(item);
 913             }
 914             AstFragment::ForeignItems(items)
 915         }
 916         AstFragmentKind::Stmts => {
 917             let mut stmts = SmallVec::new();
 918             // Won't make progress on a `}`.
 919             while this.token != token::Eof && this.token != token::CloseDelim(token::Brace) {
 920                 if let Some(stmt) = this.parse_full_stmt(AttemptLocalParseRecovery::Yes)? {
 921                     stmts.push(stmt);
 922                 }
 923             }
 924             AstFragment::Stmts(stmts)
 925         }
 926         AstFragmentKind::Expr => AstFragment::Expr(this.parse_expr()?),
 927         AstFragmentKind::OptExpr => {
 928             if this.token != token::Eof {
 929                 AstFragment::OptExpr(Some(this.parse_expr()?))
 930             } else {
 931                 AstFragment::OptExpr(None)
 932             }
 933         }
 934         AstFragmentKind::Ty => AstFragment::Ty(this.parse_ty()?),
 935         AstFragmentKind::Pat => AstFragment::Pat(this.parse_pat_allow_top_alt(
 936             None,
 937             RecoverComma::No,
 938             RecoverColon::Yes,
 939         )?),
 940         AstFragmentKind::Arms
 941         | AstFragmentKind::Fields
 942         | AstFragmentKind::FieldPats
 943         | AstFragmentKind::GenericParams
 944         | AstFragmentKind::Params
 945         | AstFragmentKind::StructFields
 946         | AstFragmentKind::Variants => panic!("unexpected AST fragment kind"),
 947     })
 948 }
 949
 950 pub fn ensure_complete_parse<'a>(
 951     this: &mut Parser<'a>,
 952     macro_path: &Path,
 953     kind_name: &str,
 954     span: Span,
 955 ) {
 956     if this.token != token::Eof {
 957         let token = pprust::token_to_string(&this.token);
 958         let msg = format!("macro expansion ignores token `{}` and any following", token);
 959         // Avoid emitting backtrace info twice.
 960         let def_site_span = this.token.span.with_ctxt(SyntaxContext::root());
 961         let mut err = this.struct_span_err(def_site_span, &msg);
 962         err.span_label(span, "caused by the macro expansion here");
 963         let msg = format!(
 964             "the usage of `{}!` is likely invalid in {} context",
 965             pprust::path_to_string(macro_path),
 966             kind_name,
 967         );
 968         err.note(&msg);
 969         let semi_span = this.sess.source_map().next_point(span);
 970
 971         let semi_full_span = semi_span.to(this.sess.source_map().next_point(semi_span));
 972         match this.sess.source_map().span_to_snippet(semi_full_span) {
 973             Ok(ref snippet) if &snippet[..] != ";" && kind_name == "expression" => {
 974                 err.span_suggestion(
 975                     semi_span,
 976                     "you might be missing a semicolon here",
 977                     ";".to_owned(),
 978                     Applicability::MaybeIncorrect,
 979                 );
 980             }
 981             _ => {}
 982         }
 983         err.emit();
 984     }
 985 }
 986
 987 struct InvocationCollector<'a, 'b> {
 988     cx: &'a mut ExtCtxt<'b>,
 989     cfg: StripUnconfigured<'a>,
 990     invocations: Vec<(Invocation, Option<Lrc<SyntaxExtension>>)>,
 991     monotonic: bool,
 992 }
 993
 994 impl<'a, 'b> InvocationCollector<'a, 'b> {
 995     fn collect(&mut self, fragment_kind: AstFragmentKind, kind: InvocationKind) -> AstFragment {
 996         let expn_id = LocalExpnId::fresh_empty();
 997         let vis = kind.placeholder_visibility();
 998         self.invocations.push((
 999             Invocation {
1000                 kind,
1001                 fragment_kind,
1002                 expansion_data: ExpansionData {
1003                     id: expn_id,
1004                     depth: self.cx.current_expansion.depth + 1,
1005                     ..self.cx.current_expansion.clone()
1006                 },
1007             },
1008             None,
1009         ));
1010         placeholder(fragment_kind, NodeId::placeholder_from_expn_id(expn_id), vis)
1011     }
1012
1013     fn collect_bang(
1014         &mut self,
1015         mac: ast::MacCall,
1016         span: Span,
1017         kind: AstFragmentKind,
1018     ) -> AstFragment {
1019         self.collect(kind, InvocationKind::Bang { mac, span })
1020     }
1021
1022     fn collect_attr(
1023         &mut self,
1024         (attr, pos, derives): (ast::Attribute, usize, Vec<Path>),
1025         item: Annotatable,
1026         kind: AstFragmentKind,
1027     ) -> AstFragment {
1028         self.collect(kind, InvocationKind::Attr { attr, pos, item, derives })
1029     }
1030
1031     /// If `item` is an attribute invocation, remove the attribute and return it together with
1032     /// its position and derives following it. We have to collect the derives in order to resolve
1033     /// legacy derive helpers (helpers written before derives that introduce them).
1034     fn take_first_attr(
1035         &mut self,
1036         item: &mut impl AstLike,
1037     ) -> Option<(ast::Attribute, usize, Vec<Path>)> {
1038         let mut attr = None;
1039
1040         item.visit_attrs(|attrs| {
1041             attr = attrs
1042                 .iter()
1043                 .position(|a| !self.cx.expanded_inert_attrs.is_marked(a) && !is_builtin_attr(a))
1044                 .map(|attr_pos| {
1045                     let attr = attrs.remove(attr_pos);
1046                     let following_derives = attrs[attr_pos..]
1047                         .iter()
1048                         .filter(|a| a.has_name(sym::derive))
1049                         .flat_map(|a| a.meta_item_list().unwrap_or_default())
1050                         .filter_map(|nested_meta| match nested_meta {
1051                             NestedMetaItem::MetaItem(ast::MetaItem {
1052                                 kind: MetaItemKind::Word,
1053                                 path,
1054                                 ..
1055                             }) => Some(path),
1056                             _ => None,
1057                         })
1058                         .collect();
1059
1060                     (attr, attr_pos, following_derives)
1061                 })
1062         });
1063
1064         attr
1065     }
1066
1067     fn configure<T: AstLike>(&mut self, node: T) -> Option<T> {
1068         self.cfg.configure(node)
1069     }
1070
1071     // Detect use of feature-gated or invalid attributes on macro invocations
1072     // since they will not be detected after macro expansion.
1073     fn check_attributes(&mut self, attrs: &[ast::Attribute], call: &MacCall) {
1074         let features = self.cx.ecfg.features.unwrap();
1075         let mut attrs = attrs.iter().peekable();
1076         let mut span: Option<Span> = None;
1077         while let Some(attr) = attrs.next() {
1078             rustc_ast_passes::feature_gate::check_attribute(attr, self.cx.sess, features);
1079             validate_attr::check_meta(&self.cx.sess.parse_sess, attr);
1080
1081             let current_span = if let Some(sp) = span { sp.to(attr.span) } else { attr.span };
1082             span = Some(current_span);
1083
1084             if attrs.peek().map_or(false, |next_attr| next_attr.doc_str().is_some()) {
1085                 continue;
1086             }
1087
1088             if attr.is_doc_comment() {
1089                 self.cx.sess.parse_sess.buffer_lint_with_diagnostic(
1090                     &UNUSED_DOC_COMMENTS,
1091                     current_span,
1092                     self.cx.current_expansion.lint_node_id,
1093                     "unused doc comment",
1094                     BuiltinLintDiagnostics::UnusedDocComment(attr.span),
1095                 );
1096             } else if rustc_attr::is_builtin_attr(attr) {
1097                 let attr_name = attr.ident().unwrap().name;
1098                 // `#[cfg]` and `#[cfg_attr]` are special - they are
1099                 // eagerly evaluated.
1100                 if attr_name != sym::cfg && attr_name != sym::cfg_attr {
1101                     self.cx.sess.parse_sess.buffer_lint_with_diagnostic(
1102                         &UNUSED_ATTRIBUTES,
1103                         attr.span,
1104                         self.cx.current_expansion.lint_node_id,
1105                         &format!("unused attribute `{}`", attr_name),
1106                         BuiltinLintDiagnostics::UnusedBuiltinAttribute {
1107                             attr_name,
1108                             macro_name: pprust::path_to_string(&call.path),
1109                             invoc_span: call.path.span,
1110                         },
1111                     );
1112                 }
1113             }
1114         }
1115     }
1116 }
1117
1118 /// Wraps a call to `noop_visit_*` / `noop_flat_map_*`
1119 /// for an AST node that supports attributes
1120 /// (see the `Annotatable` enum)
1121 /// This method assigns a `NodeId`, and sets that `NodeId`
1122 /// as our current 'lint node id'. If a macro call is found
1123 /// inside this AST node, we will use this AST node's `NodeId`
1124 /// to emit lints associated with that macro (allowing
1125 /// `#[allow]` / `#[deny]` to be applied close to
1126 /// the macro invocation).
1127 ///
1128 /// Do *not* call this for a macro AST node
1129 /// (e.g. `ExprKind::MacCall`) - we cannot emit lints
1130 /// at these AST nodes, since they are removed and
1131 /// replaced with the result of macro expansion.
1132 ///
1133 /// All other `NodeId`s are assigned by `visit_id`.
1134 /// * `self` is the 'self' parameter for the current method,
1135 /// * `id` is a mutable reference to the `NodeId` field
1136 ///    of the current AST node.
1137 /// * `closure` is a closure that executes the
1138 ///   `noop_visit_*` / `noop_flat_map_*` method
1139 ///   for the current AST node.
1140 macro_rules! assign_id {
1141     ($self:ident, $id:expr, $closure:expr) => {{
1142         let old_id = $self.cx.current_expansion.lint_node_id;
1143         if $self.monotonic {
1144             debug_assert_eq!(*$id, ast::DUMMY_NODE_ID);
1145             let new_id = $self.cx.resolver.next_node_id();
1146             *$id = new_id;
1147             $self.cx.current_expansion.lint_node_id = new_id;
1148         }
1149         let ret = ($closure)();
1150         $self.cx.current_expansion.lint_node_id = old_id;
1151         ret
1152     }};
1153 }
1154
1155 impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
1156     fn visit_expr(&mut self, expr: &mut P<ast::Expr>) {
1157         self.cfg.configure_expr(expr);
1158         visit_clobber(expr.deref_mut(), |mut expr| {
1159             if let Some(attr) = self.take_first_attr(&mut expr) {
1160                 // Collect the invoc regardless of whether or not attributes are permitted here
1161                 // expansion will eat the attribute so it won't error later.
1162                 self.cfg.maybe_emit_expr_attr_err(&attr.0);
1163
1164                 // AstFragmentKind::Expr requires the macro to emit an expression.
1165                 return self
1166                     .collect_attr(attr, Annotatable::Expr(P(expr)), AstFragmentKind::Expr)
1167                     .make_expr()
1168                     .into_inner();
1169             }
1170
1171             if let ast::ExprKind::MacCall(mac) = expr.kind {
1172                 self.check_attributes(&expr.attrs, &mac);
1173                 self.collect_bang(mac, expr.span, AstFragmentKind::Expr).make_expr().into_inner()
1174             } else {
1175                 assign_id!(self, &mut expr.id, || {
1176                     ensure_sufficient_stack(|| noop_visit_expr(&mut expr, self));
1177                 });
1178                 expr
1179             }
1180         });
1181     }
1182
1183     // This is needed in order to set `lint_node_id` for `let` statements
1184     fn visit_local(&mut self, local: &mut P<Local>) {
1185         assign_id!(self, &mut local.id, || noop_visit_local(local, self));
1186     }
1187
1188     fn flat_map_arm(&mut self, arm: ast::Arm) -> SmallVec<[ast::Arm; 1]> {
1189         let mut arm = configure!(self, arm);
1190
1191         if let Some(attr) = self.take_first_attr(&mut arm) {
1192             return self
1193                 .collect_attr(attr, Annotatable::Arm(arm), AstFragmentKind::Arms)
1194                 .make_arms();
1195         }
1196
1197         assign_id!(self, &mut arm.id, || noop_flat_map_arm(arm, self))
1198     }
1199
1200     fn flat_map_expr_field(&mut self, field: ast::ExprField) -> SmallVec<[ast::ExprField; 1]> {
1201         let mut field = configure!(self, field);
1202
1203         if let Some(attr) = self.take_first_attr(&mut field) {
1204             return self
1205                 .collect_attr(attr, Annotatable::ExprField(field), AstFragmentKind::Fields)
1206                 .make_expr_fields();
1207         }
1208
1209         assign_id!(self, &mut field.id, || noop_flat_map_expr_field(field, self))
1210     }
1211
1212     fn flat_map_pat_field(&mut self, fp: ast::PatField) -> SmallVec<[ast::PatField; 1]> {
1213         let mut fp = configure!(self, fp);
1214
1215         if let Some(attr) = self.take_first_attr(&mut fp) {
1216             return self
1217                 .collect_attr(attr, Annotatable::PatField(fp), AstFragmentKind::FieldPats)
1218                 .make_pat_fields();
1219         }
1220
1221         assign_id!(self, &mut fp.id, || noop_flat_map_pat_field(fp, self))
1222     }
1223
1224     fn flat_map_param(&mut self, p: ast::Param) -> SmallVec<[ast::Param; 1]> {
1225         let mut p = configure!(self, p);
1226
1227         if let Some(attr) = self.take_first_attr(&mut p) {
1228             return self
1229                 .collect_attr(attr, Annotatable::Param(p), AstFragmentKind::Params)
1230                 .make_params();
1231         }
1232
1233         assign_id!(self, &mut p.id, || noop_flat_map_param(p, self))
1234     }
1235
1236     fn flat_map_field_def(&mut self, sf: ast::FieldDef) -> SmallVec<[ast::FieldDef; 1]> {
1237         let mut sf = configure!(self, sf);
1238
1239         if let Some(attr) = self.take_first_attr(&mut sf) {
1240             return self
1241                 .collect_attr(attr, Annotatable::FieldDef(sf), AstFragmentKind::StructFields)
1242                 .make_field_defs();
1243         }
1244
1245         assign_id!(self, &mut sf.id, || noop_flat_map_field_def(sf, self))
1246     }
1247
1248     fn flat_map_variant(&mut self, variant: ast::Variant) -> SmallVec<[ast::Variant; 1]> {
1249         let mut variant = configure!(self, variant);
1250
1251         if let Some(attr) = self.take_first_attr(&mut variant) {
1252             return self
1253                 .collect_attr(attr, Annotatable::Variant(variant), AstFragmentKind::Variants)
1254                 .make_variants();
1255         }
1256
1257         assign_id!(self, &mut variant.id, || noop_flat_map_variant(variant, self))
1258     }
1259
1260     fn filter_map_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
1261         let expr = configure!(self, expr);
1262         expr.filter_map(|mut expr| {
1263             if let Some(attr) = self.take_first_attr(&mut expr) {
1264                 self.cfg.maybe_emit_expr_attr_err(&attr.0);
1265
1266                 return self
1267                     .collect_attr(attr, Annotatable::Expr(P(expr)), AstFragmentKind::OptExpr)
1268                     .make_opt_expr()
1269                     .map(|expr| expr.into_inner());
1270             }
1271
1272             if let ast::ExprKind::MacCall(mac) = expr.kind {
1273                 self.check_attributes(&expr.attrs, &mac);
1274                 self.collect_bang(mac, expr.span, AstFragmentKind::OptExpr)
1275                     .make_opt_expr()
1276                     .map(|expr| expr.into_inner())
1277             } else {
1278                 assign_id!(self, &mut expr.id, || {
1279                     Some({
1280                         noop_visit_expr(&mut expr, self);
1281                         expr
1282                     })
1283                 })
1284             }
1285         })
1286     }
1287
1288     fn visit_pat(&mut self, pat: &mut P<ast::Pat>) {
1289         match pat.kind {
1290             PatKind::MacCall(_) => {}
1291             _ => return noop_visit_pat(pat, self),
1292         }
1293
1294         visit_clobber(pat, |mut pat| match mem::replace(&mut pat.kind, PatKind::Wild) {
1295             PatKind::MacCall(mac) => {
1296                 self.collect_bang(mac, pat.span, AstFragmentKind::Pat).make_pat()
1297             }
1298             _ => unreachable!(),
1299         });
1300     }
1301
1302     fn flat_map_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> {
1303         let mut stmt = configure!(self, stmt);
1304
1305         // we'll expand attributes on expressions separately
1306         if !stmt.is_expr() {
1307             if let Some(attr) = self.take_first_attr(&mut stmt) {
1308                 return self
1309                     .collect_attr(attr, Annotatable::Stmt(P(stmt)), AstFragmentKind::Stmts)
1310                     .make_stmts();
1311             }
1312         }
1313
1314         if let StmtKind::MacCall(mac) = stmt.kind {
1315             let MacCallStmt { mac, style, attrs, tokens: _ } = mac.into_inner();
1316             self.check_attributes(&attrs, &mac);
1317             let mut placeholder =
1318                 self.collect_bang(mac, stmt.span, AstFragmentKind::Stmts).make_stmts();
1319
1320             // If this is a macro invocation with a semicolon, then apply that
1321             // semicolon to the final statement produced by expansion.
1322             if style == MacStmtStyle::Semicolon {
1323                 if let Some(stmt) = placeholder.pop() {
1324                     placeholder.push(stmt.add_trailing_semicolon());
1325                 }
1326             }
1327
1328             return placeholder;
1329         }
1330
1331         // The only way that we can end up with a `MacCall` expression statement,
1332         // (as opposed to a `StmtKind::MacCall`) is if we have a macro as the
1333         // traiing expression in a block (e.g. `fn foo() { my_macro!() }`).
1334         // Record this information, so that we can report a more specific
1335         // `SEMICOLON_IN_EXPRESSIONS_FROM_MACROS` lint if needed.
1336         // See #78991 for an investigation of treating macros in this position
1337         // as statements, rather than expressions, during parsing.
1338         if let StmtKind::Expr(expr) = &stmt.kind {
1339             if matches!(**expr, ast::Expr { kind: ast::ExprKind::MacCall(..), .. }) {
1340                 self.cx.current_expansion.is_trailing_mac = true;
1341             }
1342         }
1343
1344         // The placeholder expander gives ids to statements, so we avoid folding the id here.
1345         // We don't use `assign_id!` - it will be called when we visit statement's contents
1346         // (e.g. an expression, item, or local)
1347         let ast::Stmt { id, kind, span } = stmt;
1348         let res = noop_flat_map_stmt_kind(kind, self)
1349             .into_iter()
1350             .map(|kind| ast::Stmt { id, kind, span })
1351             .collect();
1352
1353         self.cx.current_expansion.is_trailing_mac = false;
1354         res
1355     }
1356
1357     fn visit_block(&mut self, block: &mut P<Block>) {
1358         let orig_dir_ownership = mem::replace(
1359             &mut self.cx.current_expansion.dir_ownership,
1360             DirOwnership::UnownedViaBlock,
1361         );
1362         noop_visit_block(block, self);
1363         self.cx.current_expansion.dir_ownership = orig_dir_ownership;
1364     }
1365
1366     fn flat_map_item(&mut self, item: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
1367         let mut item = configure!(self, item);
1368
1369         if let Some(attr) = self.take_first_attr(&mut item) {
1370             return self
1371                 .collect_attr(attr, Annotatable::Item(item), AstFragmentKind::Items)
1372                 .make_items();
1373         }
1374
1375         let mut attrs = mem::take(&mut item.attrs); // We do this to please borrowck.
1376         let ident = item.ident;
1377         let span = item.span;
1378
1379         match item.kind {
1380             ast::ItemKind::MacCall(ref mac) => {
1381                 self.check_attributes(&attrs, &mac);
1382                 item.attrs = attrs;
1383                 item.and_then(|item| match item.kind {
1384                     ItemKind::MacCall(mac) => {
1385                         self.collect_bang(mac, span, AstFragmentKind::Items).make_items()
1386                     }
1387                     _ => unreachable!(),
1388                 })
1389             }
1390             ast::ItemKind::Mod(_, ref mut mod_kind) if ident != Ident::invalid() => {
1391                 let (file_path, dir_path, dir_ownership) = match mod_kind {
1392                     ModKind::Loaded(_, inline, _) => {
1393                         // Inline `mod foo { ... }`, but we still need to push directories.
1394                         let (dir_path, dir_ownership) = mod_dir_path(
1395                             &self.cx.sess,
1396                             ident,
1397                             &attrs,
1398                             &self.cx.current_expansion.module,
1399                             self.cx.current_expansion.dir_ownership,
1400                             *inline,
1401                         );
1402                         item.attrs = attrs;
1403                         (None, dir_path, dir_ownership)
1404                     }
1405                     ModKind::Unloaded => {
1406                         // We have an outline `mod foo;` so we need to parse the file.
1407                         let old_attrs_len = attrs.len();
1408                         let ParsedExternalMod {
1409                             mut items,
1410                             inner_span,
1411                             file_path,
1412                             dir_path,
1413                             dir_ownership,
1414                         } = parse_external_mod(
1415                             &self.cx.sess,
1416                             ident,
1417                             span,
1418                             &self.cx.current_expansion.module,
1419                             self.cx.current_expansion.dir_ownership,
1420                             &mut attrs,
1421                         );
1422
1423                         if let Some(extern_mod_loaded) = self.cx.extern_mod_loaded {
1424                             (attrs, items) = extern_mod_loaded(ident, attrs, items, inner_span);
1425                         }
1426
1427                         *mod_kind = ModKind::Loaded(items, Inline::No, inner_span);
1428                         item.attrs = attrs;
1429                         if item.attrs.len() > old_attrs_len {
1430                             // If we loaded an out-of-line module and added some inner attributes,
1431                             // then we need to re-configure it and re-collect attributes for
1432                             // resolution and expansion.
1433                             item = configure!(self, item);
1434
1435                             if let Some(attr) = self.take_first_attr(&mut item) {
1436                                 return self
1437                                     .collect_attr(
1438                                         attr,
1439                                         Annotatable::Item(item),
1440                                         AstFragmentKind::Items,
1441                                     )
1442                                     .make_items();
1443                             }
1444                         }
1445                         (Some(file_path), dir_path, dir_ownership)
1446                     }
1447                 };
1448
1449                 // Set the module info before we flat map.
1450                 let mut module = self.cx.current_expansion.module.with_dir_path(dir_path);
1451                 module.mod_path.push(ident);
1452                 if let Some(file_path) = file_path {
1453                     module.file_path_stack.push(file_path);
1454                 }
1455
1456                 let orig_module =
1457                     mem::replace(&mut self.cx.current_expansion.module, Rc::new(module));
1458                 let orig_dir_ownership =
1459                     mem::replace(&mut self.cx.current_expansion.dir_ownership, dir_ownership);
1460
1461                 let result = assign_id!(self, &mut item.id, || noop_flat_map_item(item, self));
1462
1463                 // Restore the module info.
1464                 self.cx.current_expansion.dir_ownership = orig_dir_ownership;
1465                 self.cx.current_expansion.module = orig_module;
1466
1467                 result
1468             }
1469             _ => {
1470                 item.attrs = attrs;
1471                 // The crate root is special - don't assign an ID to it.
1472                 if !(matches!(item.kind, ast::ItemKind::Mod(..)) && ident == Ident::invalid()) {
1473                     assign_id!(self, &mut item.id, || noop_flat_map_item(item, self))
1474                 } else {
1475                     noop_flat_map_item(item, self)
1476                 }
1477             }
1478         }
1479     }
1480
1481     fn flat_map_trait_item(&mut self, item: P<ast::AssocItem>) -> SmallVec<[P<ast::AssocItem>; 1]> {
1482         let mut item = configure!(self, item);
1483
1484         if let Some(attr) = self.take_first_attr(&mut item) {
1485             return self
1486                 .collect_attr(attr, Annotatable::TraitItem(item), AstFragmentKind::TraitItems)
1487                 .make_trait_items();
1488         }
1489
1490         match item.kind {
1491             ast::AssocItemKind::MacCall(ref mac) => {
1492                 self.check_attributes(&item.attrs, &mac);
1493                 item.and_then(|item| match item.kind {
1494                     ast::AssocItemKind::MacCall(mac) => self
1495                         .collect_bang(mac, item.span, AstFragmentKind::TraitItems)
1496                         .make_trait_items(),
1497                     _ => unreachable!(),
1498                 })
1499             }
1500             _ => {
1501                 assign_id!(self, &mut item.id, || noop_flat_map_assoc_item(item, self))
1502             }
1503         }
1504     }
1505
1506     fn flat_map_impl_item(&mut self, item: P<ast::AssocItem>) -> SmallVec<[P<ast::AssocItem>; 1]> {
1507         let mut item = configure!(self, item);
1508
1509         if let Some(attr) = self.take_first_attr(&mut item) {
1510             return self
1511                 .collect_attr(attr, Annotatable::ImplItem(item), AstFragmentKind::ImplItems)
1512                 .make_impl_items();
1513         }
1514
1515         match item.kind {
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) => self
1520                         .collect_bang(mac, item.span, AstFragmentKind::ImplItems)
1521                         .make_impl_items(),
1522                     _ => unreachable!(),
1523                 })
1524             }
1525             _ => {
1526                 assign_id!(self, &mut item.id, || noop_flat_map_assoc_item(item, self))
1527             }
1528         }
1529     }
1530
1531     fn visit_ty(&mut self, ty: &mut P<ast::Ty>) {
1532         match ty.kind {
1533             ast::TyKind::MacCall(_) => {}
1534             _ => return noop_visit_ty(ty, self),
1535         };
1536
1537         visit_clobber(ty, |mut ty| match mem::replace(&mut ty.kind, ast::TyKind::Err) {
1538             ast::TyKind::MacCall(mac) => {
1539                 self.collect_bang(mac, ty.span, AstFragmentKind::Ty).make_ty()
1540             }
1541             _ => unreachable!(),
1542         });
1543     }
1544
1545     fn flat_map_foreign_item(
1546         &mut self,
1547         foreign_item: P<ast::ForeignItem>,
1548     ) -> SmallVec<[P<ast::ForeignItem>; 1]> {
1549         let mut foreign_item = configure!(self, foreign_item);
1550
1551         if let Some(attr) = self.take_first_attr(&mut foreign_item) {
1552             return self
1553                 .collect_attr(
1554                     attr,
1555                     Annotatable::ForeignItem(foreign_item),
1556                     AstFragmentKind::ForeignItems,
1557                 )
1558                 .make_foreign_items();
1559         }
1560
1561         match foreign_item.kind {
1562             ast::ForeignItemKind::MacCall(ref mac) => {
1563                 self.check_attributes(&foreign_item.attrs, &mac);
1564                 foreign_item.and_then(|item| match item.kind {
1565                     ast::ForeignItemKind::MacCall(mac) => self
1566                         .collect_bang(mac, item.span, AstFragmentKind::ForeignItems)
1567                         .make_foreign_items(),
1568                     _ => unreachable!(),
1569                 })
1570             }
1571             _ => {
1572                 assign_id!(self, &mut foreign_item.id, || noop_flat_map_foreign_item(
1573                     foreign_item,
1574                     self
1575                 ))
1576             }
1577         }
1578     }
1579
1580     fn flat_map_generic_param(
1581         &mut self,
1582         param: ast::GenericParam,
1583     ) -> SmallVec<[ast::GenericParam; 1]> {
1584         let mut param = configure!(self, param);
1585
1586         if let Some(attr) = self.take_first_attr(&mut param) {
1587             return self
1588                 .collect_attr(
1589                     attr,
1590                     Annotatable::GenericParam(param),
1591                     AstFragmentKind::GenericParams,
1592                 )
1593                 .make_generic_params();
1594         }
1595
1596         assign_id!(self, &mut param.id, || noop_flat_map_generic_param(param, self))
1597     }
1598
1599     fn visit_id(&mut self, id: &mut ast::NodeId) {
1600         // We may have already assigned a `NodeId`
1601         // by calling `assign_id`
1602         if self.monotonic && *id == ast::DUMMY_NODE_ID {
1603             *id = self.cx.resolver.next_node_id();
1604         }
1605     }
1606 }
1607
1608 pub struct ExpansionConfig<'feat> {
1609     pub crate_name: String,
1610     pub features: Option<&'feat Features>,
1611     pub recursion_limit: Limit,
1612     pub trace_mac: bool,
1613     pub should_test: bool,          // If false, strip `#[test]` nodes
1614     pub span_debug: bool,           // If true, use verbose debugging for `proc_macro::Span`
1615     pub proc_macro_backtrace: bool, // If true, show backtraces for proc-macro panics
1616 }
1617
1618 impl<'feat> ExpansionConfig<'feat> {
1619     pub fn default(crate_name: String) -> ExpansionConfig<'static> {
1620         ExpansionConfig {
1621             crate_name,
1622             features: None,
1623             recursion_limit: Limit::new(1024),
1624             trace_mac: false,
1625             should_test: false,
1626             span_debug: false,
1627             proc_macro_backtrace: false,
1628         }
1629     }
1630
1631     fn proc_macro_hygiene(&self) -> bool {
1632         self.features.map_or(false, |features| features.proc_macro_hygiene)
1633     }
1634 }