]> git.lizzy.rs Git - rust.git/blob - compiler/rustc_expand/src/base.rs
ssa: implement `#[collapse_debuginfo]`
[rust.git] / compiler / rustc_expand / src / base.rs
1 use crate::expand::{self, AstFragment, Invocation};
2 use crate::module::DirOwnership;
3
4 use rustc_ast::attr::MarkedAttrs;
5 use rustc_ast::ptr::P;
6 use rustc_ast::token::{self, Nonterminal};
7 use rustc_ast::tokenstream::TokenStream;
8 use rustc_ast::visit::{AssocCtxt, Visitor};
9 use rustc_ast::{self as ast, AttrVec, Attribute, HasAttrs, Item, NodeId, PatKind};
10 use rustc_attr::{self as attr, Deprecation, Stability};
11 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
12 use rustc_data_structures::sync::{self, Lrc};
13 use rustc_errors::{Applicability, DiagnosticBuilder, ErrorGuaranteed, MultiSpan, PResult};
14 use rustc_lint_defs::builtin::PROC_MACRO_BACK_COMPAT;
15 use rustc_lint_defs::{BufferedEarlyLint, BuiltinLintDiagnostics};
16 use rustc_parse::{self, parser, MACRO_ARGUMENTS};
17 use rustc_session::{parse::ParseSess, Limit, Session, SessionDiagnostic};
18 use rustc_span::def_id::{CrateNum, DefId, LocalDefId};
19 use rustc_span::edition::Edition;
20 use rustc_span::hygiene::{AstPass, ExpnData, ExpnKind, LocalExpnId};
21 use rustc_span::source_map::SourceMap;
22 use rustc_span::symbol::{kw, sym, Ident, Symbol};
23 use rustc_span::{FileName, Span, DUMMY_SP};
24 use smallvec::{smallvec, SmallVec};
25
26 use std::default::Default;
27 use std::iter;
28 use std::path::PathBuf;
29 use std::rc::Rc;
30
31 pub(crate) use rustc_span::hygiene::MacroKind;
32
33 // When adding new variants, make sure to
34 // adjust the `visit_*` / `flat_map_*` calls in `InvocationCollector`
35 // to use `assign_id!`
36 #[derive(Debug, Clone)]
37 pub enum Annotatable {
38     Item(P<ast::Item>),
39     TraitItem(P<ast::AssocItem>),
40     ImplItem(P<ast::AssocItem>),
41     ForeignItem(P<ast::ForeignItem>),
42     Stmt(P<ast::Stmt>),
43     Expr(P<ast::Expr>),
44     Arm(ast::Arm),
45     ExprField(ast::ExprField),
46     PatField(ast::PatField),
47     GenericParam(ast::GenericParam),
48     Param(ast::Param),
49     FieldDef(ast::FieldDef),
50     Variant(ast::Variant),
51     Crate(ast::Crate),
52 }
53
54 impl Annotatable {
55     pub fn span(&self) -> Span {
56         match *self {
57             Annotatable::Item(ref item) => item.span,
58             Annotatable::TraitItem(ref trait_item) => trait_item.span,
59             Annotatable::ImplItem(ref impl_item) => impl_item.span,
60             Annotatable::ForeignItem(ref foreign_item) => foreign_item.span,
61             Annotatable::Stmt(ref stmt) => stmt.span,
62             Annotatable::Expr(ref expr) => expr.span,
63             Annotatable::Arm(ref arm) => arm.span,
64             Annotatable::ExprField(ref field) => field.span,
65             Annotatable::PatField(ref fp) => fp.pat.span,
66             Annotatable::GenericParam(ref gp) => gp.ident.span,
67             Annotatable::Param(ref p) => p.span,
68             Annotatable::FieldDef(ref sf) => sf.span,
69             Annotatable::Variant(ref v) => v.span,
70             Annotatable::Crate(ref c) => c.spans.inner_span,
71         }
72     }
73
74     pub fn visit_attrs(&mut self, f: impl FnOnce(&mut AttrVec)) {
75         match self {
76             Annotatable::Item(item) => item.visit_attrs(f),
77             Annotatable::TraitItem(trait_item) => trait_item.visit_attrs(f),
78             Annotatable::ImplItem(impl_item) => impl_item.visit_attrs(f),
79             Annotatable::ForeignItem(foreign_item) => foreign_item.visit_attrs(f),
80             Annotatable::Stmt(stmt) => stmt.visit_attrs(f),
81             Annotatable::Expr(expr) => expr.visit_attrs(f),
82             Annotatable::Arm(arm) => arm.visit_attrs(f),
83             Annotatable::ExprField(field) => field.visit_attrs(f),
84             Annotatable::PatField(fp) => fp.visit_attrs(f),
85             Annotatable::GenericParam(gp) => gp.visit_attrs(f),
86             Annotatable::Param(p) => p.visit_attrs(f),
87             Annotatable::FieldDef(sf) => sf.visit_attrs(f),
88             Annotatable::Variant(v) => v.visit_attrs(f),
89             Annotatable::Crate(c) => c.visit_attrs(f),
90         }
91     }
92
93     pub fn visit_with<'a, V: Visitor<'a>>(&'a self, visitor: &mut V) {
94         match self {
95             Annotatable::Item(item) => visitor.visit_item(item),
96             Annotatable::TraitItem(item) => visitor.visit_assoc_item(item, AssocCtxt::Trait),
97             Annotatable::ImplItem(item) => visitor.visit_assoc_item(item, AssocCtxt::Impl),
98             Annotatable::ForeignItem(foreign_item) => visitor.visit_foreign_item(foreign_item),
99             Annotatable::Stmt(stmt) => visitor.visit_stmt(stmt),
100             Annotatable::Expr(expr) => visitor.visit_expr(expr),
101             Annotatable::Arm(arm) => visitor.visit_arm(arm),
102             Annotatable::ExprField(field) => visitor.visit_expr_field(field),
103             Annotatable::PatField(fp) => visitor.visit_pat_field(fp),
104             Annotatable::GenericParam(gp) => visitor.visit_generic_param(gp),
105             Annotatable::Param(p) => visitor.visit_param(p),
106             Annotatable::FieldDef(sf) => visitor.visit_field_def(sf),
107             Annotatable::Variant(v) => visitor.visit_variant(v),
108             Annotatable::Crate(c) => visitor.visit_crate(c),
109         }
110     }
111
112     pub fn to_tokens(&self) -> TokenStream {
113         match self {
114             Annotatable::Item(node) => TokenStream::from_ast(node),
115             Annotatable::TraitItem(node) | Annotatable::ImplItem(node) => {
116                 TokenStream::from_ast(node)
117             }
118             Annotatable::ForeignItem(node) => TokenStream::from_ast(node),
119             Annotatable::Stmt(node) => {
120                 assert!(!matches!(node.kind, ast::StmtKind::Empty));
121                 TokenStream::from_ast(node)
122             }
123             Annotatable::Expr(node) => TokenStream::from_ast(node),
124             Annotatable::Arm(..)
125             | Annotatable::ExprField(..)
126             | Annotatable::PatField(..)
127             | Annotatable::GenericParam(..)
128             | Annotatable::Param(..)
129             | Annotatable::FieldDef(..)
130             | Annotatable::Variant(..)
131             | Annotatable::Crate(..) => panic!("unexpected annotatable"),
132         }
133     }
134
135     pub fn expect_item(self) -> P<ast::Item> {
136         match self {
137             Annotatable::Item(i) => i,
138             _ => panic!("expected Item"),
139         }
140     }
141
142     pub fn expect_trait_item(self) -> P<ast::AssocItem> {
143         match self {
144             Annotatable::TraitItem(i) => i,
145             _ => panic!("expected Item"),
146         }
147     }
148
149     pub fn expect_impl_item(self) -> P<ast::AssocItem> {
150         match self {
151             Annotatable::ImplItem(i) => i,
152             _ => panic!("expected Item"),
153         }
154     }
155
156     pub fn expect_foreign_item(self) -> P<ast::ForeignItem> {
157         match self {
158             Annotatable::ForeignItem(i) => i,
159             _ => panic!("expected foreign item"),
160         }
161     }
162
163     pub fn expect_stmt(self) -> ast::Stmt {
164         match self {
165             Annotatable::Stmt(stmt) => stmt.into_inner(),
166             _ => panic!("expected statement"),
167         }
168     }
169
170     pub fn expect_expr(self) -> P<ast::Expr> {
171         match self {
172             Annotatable::Expr(expr) => expr,
173             _ => panic!("expected expression"),
174         }
175     }
176
177     pub fn expect_arm(self) -> ast::Arm {
178         match self {
179             Annotatable::Arm(arm) => arm,
180             _ => panic!("expected match arm"),
181         }
182     }
183
184     pub fn expect_expr_field(self) -> ast::ExprField {
185         match self {
186             Annotatable::ExprField(field) => field,
187             _ => panic!("expected field"),
188         }
189     }
190
191     pub fn expect_pat_field(self) -> ast::PatField {
192         match self {
193             Annotatable::PatField(fp) => fp,
194             _ => panic!("expected field pattern"),
195         }
196     }
197
198     pub fn expect_generic_param(self) -> ast::GenericParam {
199         match self {
200             Annotatable::GenericParam(gp) => gp,
201             _ => panic!("expected generic parameter"),
202         }
203     }
204
205     pub fn expect_param(self) -> ast::Param {
206         match self {
207             Annotatable::Param(param) => param,
208             _ => panic!("expected parameter"),
209         }
210     }
211
212     pub fn expect_field_def(self) -> ast::FieldDef {
213         match self {
214             Annotatable::FieldDef(sf) => sf,
215             _ => panic!("expected struct field"),
216         }
217     }
218
219     pub fn expect_variant(self) -> ast::Variant {
220         match self {
221             Annotatable::Variant(v) => v,
222             _ => panic!("expected variant"),
223         }
224     }
225
226     pub fn expect_crate(self) -> ast::Crate {
227         match self {
228             Annotatable::Crate(krate) => krate,
229             _ => panic!("expected krate"),
230         }
231     }
232 }
233
234 /// Result of an expansion that may need to be retried.
235 /// Consider using this for non-`MultiItemModifier` expanders as well.
236 pub enum ExpandResult<T, U> {
237     /// Expansion produced a result (possibly dummy).
238     Ready(T),
239     /// Expansion could not produce a result and needs to be retried.
240     Retry(U),
241 }
242
243 // `meta_item` is the attribute, and `item` is the item being modified.
244 pub trait MultiItemModifier {
245     fn expand(
246         &self,
247         ecx: &mut ExtCtxt<'_>,
248         span: Span,
249         meta_item: &ast::MetaItem,
250         item: Annotatable,
251     ) -> ExpandResult<Vec<Annotatable>, Annotatable>;
252 }
253
254 impl<F> MultiItemModifier for F
255 where
256     F: Fn(&mut ExtCtxt<'_>, Span, &ast::MetaItem, Annotatable) -> Vec<Annotatable>,
257 {
258     fn expand(
259         &self,
260         ecx: &mut ExtCtxt<'_>,
261         span: Span,
262         meta_item: &ast::MetaItem,
263         item: Annotatable,
264     ) -> ExpandResult<Vec<Annotatable>, Annotatable> {
265         ExpandResult::Ready(self(ecx, span, meta_item, item))
266     }
267 }
268
269 pub trait BangProcMacro {
270     fn expand<'cx>(
271         &self,
272         ecx: &'cx mut ExtCtxt<'_>,
273         span: Span,
274         ts: TokenStream,
275     ) -> Result<TokenStream, ErrorGuaranteed>;
276 }
277
278 impl<F> BangProcMacro for F
279 where
280     F: Fn(TokenStream) -> TokenStream,
281 {
282     fn expand<'cx>(
283         &self,
284         _ecx: &'cx mut ExtCtxt<'_>,
285         _span: Span,
286         ts: TokenStream,
287     ) -> Result<TokenStream, ErrorGuaranteed> {
288         // FIXME setup implicit context in TLS before calling self.
289         Ok(self(ts))
290     }
291 }
292
293 pub trait AttrProcMacro {
294     fn expand<'cx>(
295         &self,
296         ecx: &'cx mut ExtCtxt<'_>,
297         span: Span,
298         annotation: TokenStream,
299         annotated: TokenStream,
300     ) -> Result<TokenStream, ErrorGuaranteed>;
301 }
302
303 impl<F> AttrProcMacro for F
304 where
305     F: Fn(TokenStream, TokenStream) -> TokenStream,
306 {
307     fn expand<'cx>(
308         &self,
309         _ecx: &'cx mut ExtCtxt<'_>,
310         _span: Span,
311         annotation: TokenStream,
312         annotated: TokenStream,
313     ) -> Result<TokenStream, ErrorGuaranteed> {
314         // FIXME setup implicit context in TLS before calling self.
315         Ok(self(annotation, annotated))
316     }
317 }
318
319 /// Represents a thing that maps token trees to Macro Results
320 pub trait TTMacroExpander {
321     fn expand<'cx>(
322         &self,
323         ecx: &'cx mut ExtCtxt<'_>,
324         span: Span,
325         input: TokenStream,
326     ) -> Box<dyn MacResult + 'cx>;
327 }
328
329 pub type MacroExpanderFn =
330     for<'cx> fn(&'cx mut ExtCtxt<'_>, Span, TokenStream) -> Box<dyn MacResult + 'cx>;
331
332 impl<F> TTMacroExpander for F
333 where
334     F: for<'cx> Fn(&'cx mut ExtCtxt<'_>, Span, TokenStream) -> Box<dyn MacResult + 'cx>,
335 {
336     fn expand<'cx>(
337         &self,
338         ecx: &'cx mut ExtCtxt<'_>,
339         span: Span,
340         input: TokenStream,
341     ) -> Box<dyn MacResult + 'cx> {
342         self(ecx, span, input)
343     }
344 }
345
346 // Use a macro because forwarding to a simple function has type system issues
347 macro_rules! make_stmts_default {
348     ($me:expr) => {
349         $me.make_expr().map(|e| {
350             smallvec![ast::Stmt {
351                 id: ast::DUMMY_NODE_ID,
352                 span: e.span,
353                 kind: ast::StmtKind::Expr(e),
354             }]
355         })
356     };
357 }
358
359 /// The result of a macro expansion. The return values of the various
360 /// methods are spliced into the AST at the callsite of the macro.
361 pub trait MacResult {
362     /// Creates an expression.
363     fn make_expr(self: Box<Self>) -> Option<P<ast::Expr>> {
364         None
365     }
366
367     /// Creates zero or more items.
368     fn make_items(self: Box<Self>) -> Option<SmallVec<[P<ast::Item>; 1]>> {
369         None
370     }
371
372     /// Creates zero or more impl items.
373     fn make_impl_items(self: Box<Self>) -> Option<SmallVec<[P<ast::AssocItem>; 1]>> {
374         None
375     }
376
377     /// Creates zero or more trait items.
378     fn make_trait_items(self: Box<Self>) -> Option<SmallVec<[P<ast::AssocItem>; 1]>> {
379         None
380     }
381
382     /// Creates zero or more items in an `extern {}` block
383     fn make_foreign_items(self: Box<Self>) -> Option<SmallVec<[P<ast::ForeignItem>; 1]>> {
384         None
385     }
386
387     /// Creates a pattern.
388     fn make_pat(self: Box<Self>) -> Option<P<ast::Pat>> {
389         None
390     }
391
392     /// Creates zero or more statements.
393     ///
394     /// By default this attempts to create an expression statement,
395     /// returning None if that fails.
396     fn make_stmts(self: Box<Self>) -> Option<SmallVec<[ast::Stmt; 1]>> {
397         make_stmts_default!(self)
398     }
399
400     fn make_ty(self: Box<Self>) -> Option<P<ast::Ty>> {
401         None
402     }
403
404     fn make_arms(self: Box<Self>) -> Option<SmallVec<[ast::Arm; 1]>> {
405         None
406     }
407
408     fn make_expr_fields(self: Box<Self>) -> Option<SmallVec<[ast::ExprField; 1]>> {
409         None
410     }
411
412     fn make_pat_fields(self: Box<Self>) -> Option<SmallVec<[ast::PatField; 1]>> {
413         None
414     }
415
416     fn make_generic_params(self: Box<Self>) -> Option<SmallVec<[ast::GenericParam; 1]>> {
417         None
418     }
419
420     fn make_params(self: Box<Self>) -> Option<SmallVec<[ast::Param; 1]>> {
421         None
422     }
423
424     fn make_field_defs(self: Box<Self>) -> Option<SmallVec<[ast::FieldDef; 1]>> {
425         None
426     }
427
428     fn make_variants(self: Box<Self>) -> Option<SmallVec<[ast::Variant; 1]>> {
429         None
430     }
431
432     fn make_crate(self: Box<Self>) -> Option<ast::Crate> {
433         // Fn-like macros cannot produce a crate.
434         unreachable!()
435     }
436 }
437
438 macro_rules! make_MacEager {
439     ( $( $fld:ident: $t:ty, )* ) => {
440         /// `MacResult` implementation for the common case where you've already
441         /// built each form of AST that you might return.
442         #[derive(Default)]
443         pub struct MacEager {
444             $(
445                 pub $fld: Option<$t>,
446             )*
447         }
448
449         impl MacEager {
450             $(
451                 pub fn $fld(v: $t) -> Box<dyn MacResult> {
452                     Box::new(MacEager {
453                         $fld: Some(v),
454                         ..Default::default()
455                     })
456                 }
457             )*
458         }
459     }
460 }
461
462 make_MacEager! {
463     expr: P<ast::Expr>,
464     pat: P<ast::Pat>,
465     items: SmallVec<[P<ast::Item>; 1]>,
466     impl_items: SmallVec<[P<ast::AssocItem>; 1]>,
467     trait_items: SmallVec<[P<ast::AssocItem>; 1]>,
468     foreign_items: SmallVec<[P<ast::ForeignItem>; 1]>,
469     stmts: SmallVec<[ast::Stmt; 1]>,
470     ty: P<ast::Ty>,
471 }
472
473 impl MacResult for MacEager {
474     fn make_expr(self: Box<Self>) -> Option<P<ast::Expr>> {
475         self.expr
476     }
477
478     fn make_items(self: Box<Self>) -> Option<SmallVec<[P<ast::Item>; 1]>> {
479         self.items
480     }
481
482     fn make_impl_items(self: Box<Self>) -> Option<SmallVec<[P<ast::AssocItem>; 1]>> {
483         self.impl_items
484     }
485
486     fn make_trait_items(self: Box<Self>) -> Option<SmallVec<[P<ast::AssocItem>; 1]>> {
487         self.trait_items
488     }
489
490     fn make_foreign_items(self: Box<Self>) -> Option<SmallVec<[P<ast::ForeignItem>; 1]>> {
491         self.foreign_items
492     }
493
494     fn make_stmts(self: Box<Self>) -> Option<SmallVec<[ast::Stmt; 1]>> {
495         match self.stmts.as_ref().map_or(0, |s| s.len()) {
496             0 => make_stmts_default!(self),
497             _ => self.stmts,
498         }
499     }
500
501     fn make_pat(self: Box<Self>) -> Option<P<ast::Pat>> {
502         if let Some(p) = self.pat {
503             return Some(p);
504         }
505         if let Some(e) = self.expr {
506             if let ast::ExprKind::Lit(_) = e.kind {
507                 return Some(P(ast::Pat {
508                     id: ast::DUMMY_NODE_ID,
509                     span: e.span,
510                     kind: PatKind::Lit(e),
511                     tokens: None,
512                 }));
513             }
514         }
515         None
516     }
517
518     fn make_ty(self: Box<Self>) -> Option<P<ast::Ty>> {
519         self.ty
520     }
521 }
522
523 /// Fill-in macro expansion result, to allow compilation to continue
524 /// after hitting errors.
525 #[derive(Copy, Clone)]
526 pub struct DummyResult {
527     is_error: bool,
528     span: Span,
529 }
530
531 impl DummyResult {
532     /// Creates a default MacResult that can be anything.
533     ///
534     /// Use this as a return value after hitting any errors and
535     /// calling `span_err`.
536     pub fn any(span: Span) -> Box<dyn MacResult + 'static> {
537         Box::new(DummyResult { is_error: true, span })
538     }
539
540     /// Same as `any`, but must be a valid fragment, not error.
541     pub fn any_valid(span: Span) -> Box<dyn MacResult + 'static> {
542         Box::new(DummyResult { is_error: false, span })
543     }
544
545     /// A plain dummy expression.
546     pub fn raw_expr(sp: Span, is_error: bool) -> P<ast::Expr> {
547         P(ast::Expr {
548             id: ast::DUMMY_NODE_ID,
549             kind: if is_error { ast::ExprKind::Err } else { ast::ExprKind::Tup(Vec::new()) },
550             span: sp,
551             attrs: ast::AttrVec::new(),
552             tokens: None,
553         })
554     }
555
556     /// A plain dummy pattern.
557     pub fn raw_pat(sp: Span) -> ast::Pat {
558         ast::Pat { id: ast::DUMMY_NODE_ID, kind: PatKind::Wild, span: sp, tokens: None }
559     }
560
561     /// A plain dummy type.
562     pub fn raw_ty(sp: Span, is_error: bool) -> P<ast::Ty> {
563         P(ast::Ty {
564             id: ast::DUMMY_NODE_ID,
565             kind: if is_error { ast::TyKind::Err } else { ast::TyKind::Tup(Vec::new()) },
566             span: sp,
567             tokens: None,
568         })
569     }
570 }
571
572 impl MacResult for DummyResult {
573     fn make_expr(self: Box<DummyResult>) -> Option<P<ast::Expr>> {
574         Some(DummyResult::raw_expr(self.span, self.is_error))
575     }
576
577     fn make_pat(self: Box<DummyResult>) -> Option<P<ast::Pat>> {
578         Some(P(DummyResult::raw_pat(self.span)))
579     }
580
581     fn make_items(self: Box<DummyResult>) -> Option<SmallVec<[P<ast::Item>; 1]>> {
582         Some(SmallVec::new())
583     }
584
585     fn make_impl_items(self: Box<DummyResult>) -> Option<SmallVec<[P<ast::AssocItem>; 1]>> {
586         Some(SmallVec::new())
587     }
588
589     fn make_trait_items(self: Box<DummyResult>) -> Option<SmallVec<[P<ast::AssocItem>; 1]>> {
590         Some(SmallVec::new())
591     }
592
593     fn make_foreign_items(self: Box<Self>) -> Option<SmallVec<[P<ast::ForeignItem>; 1]>> {
594         Some(SmallVec::new())
595     }
596
597     fn make_stmts(self: Box<DummyResult>) -> Option<SmallVec<[ast::Stmt; 1]>> {
598         Some(smallvec![ast::Stmt {
599             id: ast::DUMMY_NODE_ID,
600             kind: ast::StmtKind::Expr(DummyResult::raw_expr(self.span, self.is_error)),
601             span: self.span,
602         }])
603     }
604
605     fn make_ty(self: Box<DummyResult>) -> Option<P<ast::Ty>> {
606         Some(DummyResult::raw_ty(self.span, self.is_error))
607     }
608
609     fn make_arms(self: Box<DummyResult>) -> Option<SmallVec<[ast::Arm; 1]>> {
610         Some(SmallVec::new())
611     }
612
613     fn make_expr_fields(self: Box<DummyResult>) -> Option<SmallVec<[ast::ExprField; 1]>> {
614         Some(SmallVec::new())
615     }
616
617     fn make_pat_fields(self: Box<DummyResult>) -> Option<SmallVec<[ast::PatField; 1]>> {
618         Some(SmallVec::new())
619     }
620
621     fn make_generic_params(self: Box<DummyResult>) -> Option<SmallVec<[ast::GenericParam; 1]>> {
622         Some(SmallVec::new())
623     }
624
625     fn make_params(self: Box<DummyResult>) -> Option<SmallVec<[ast::Param; 1]>> {
626         Some(SmallVec::new())
627     }
628
629     fn make_field_defs(self: Box<DummyResult>) -> Option<SmallVec<[ast::FieldDef; 1]>> {
630         Some(SmallVec::new())
631     }
632
633     fn make_variants(self: Box<DummyResult>) -> Option<SmallVec<[ast::Variant; 1]>> {
634         Some(SmallVec::new())
635     }
636 }
637
638 /// A syntax extension kind.
639 pub enum SyntaxExtensionKind {
640     /// A token-based function-like macro.
641     Bang(
642         /// An expander with signature TokenStream -> TokenStream.
643         Box<dyn BangProcMacro + sync::Sync + sync::Send>,
644     ),
645
646     /// An AST-based function-like macro.
647     LegacyBang(
648         /// An expander with signature TokenStream -> AST.
649         Box<dyn TTMacroExpander + sync::Sync + sync::Send>,
650     ),
651
652     /// A token-based attribute macro.
653     Attr(
654         /// An expander with signature (TokenStream, TokenStream) -> TokenStream.
655         /// The first TokenSteam is the attribute itself, the second is the annotated item.
656         /// The produced TokenSteam replaces the input TokenSteam.
657         Box<dyn AttrProcMacro + sync::Sync + sync::Send>,
658     ),
659
660     /// An AST-based attribute macro.
661     LegacyAttr(
662         /// An expander with signature (AST, AST) -> AST.
663         /// The first AST fragment is the attribute itself, the second is the annotated item.
664         /// The produced AST fragment replaces the input AST fragment.
665         Box<dyn MultiItemModifier + sync::Sync + sync::Send>,
666     ),
667
668     /// A trivial attribute "macro" that does nothing,
669     /// only keeps the attribute and marks it as inert,
670     /// thus making it ineligible for further expansion.
671     NonMacroAttr,
672
673     /// A token-based derive macro.
674     Derive(
675         /// An expander with signature TokenStream -> TokenStream (not yet).
676         /// The produced TokenSteam is appended to the input TokenSteam.
677         Box<dyn MultiItemModifier + sync::Sync + sync::Send>,
678     ),
679
680     /// An AST-based derive macro.
681     LegacyDerive(
682         /// An expander with signature AST -> AST.
683         /// The produced AST fragment is appended to the input AST fragment.
684         Box<dyn MultiItemModifier + sync::Sync + sync::Send>,
685     ),
686 }
687
688 /// A struct representing a macro definition in "lowered" form ready for expansion.
689 pub struct SyntaxExtension {
690     /// A syntax extension kind.
691     pub kind: SyntaxExtensionKind,
692     /// Span of the macro definition.
693     pub span: Span,
694     /// List of unstable features that are treated as stable inside this macro.
695     pub allow_internal_unstable: Option<Lrc<[Symbol]>>,
696     /// The macro's stability info.
697     pub stability: Option<Stability>,
698     /// The macro's deprecation info.
699     pub deprecation: Option<Deprecation>,
700     /// Names of helper attributes registered by this macro.
701     pub helper_attrs: Vec<Symbol>,
702     /// Edition of the crate in which this macro is defined.
703     pub edition: Edition,
704     /// Built-in macros have a couple of special properties like availability
705     /// in `#[no_implicit_prelude]` modules, so we have to keep this flag.
706     pub builtin_name: Option<Symbol>,
707     /// Suppresses the `unsafe_code` lint for code produced by this macro.
708     pub allow_internal_unsafe: bool,
709     /// Enables the macro helper hack (`ident!(...)` -> `$crate::ident!(...)`) for this macro.
710     pub local_inner_macros: bool,
711     /// Should debuginfo for the macro be collapsed to the outermost expansion site (in other
712     /// words, was the macro definition annotated with `#[collapse_debuginfo]`)?
713     pub collapse_debuginfo: bool,
714 }
715
716 impl SyntaxExtension {
717     /// Returns which kind of macro calls this syntax extension.
718     pub fn macro_kind(&self) -> MacroKind {
719         match self.kind {
720             SyntaxExtensionKind::Bang(..) | SyntaxExtensionKind::LegacyBang(..) => MacroKind::Bang,
721             SyntaxExtensionKind::Attr(..)
722             | SyntaxExtensionKind::LegacyAttr(..)
723             | SyntaxExtensionKind::NonMacroAttr => MacroKind::Attr,
724             SyntaxExtensionKind::Derive(..) | SyntaxExtensionKind::LegacyDerive(..) => {
725                 MacroKind::Derive
726             }
727         }
728     }
729
730     /// Constructs a syntax extension with default properties.
731     pub fn default(kind: SyntaxExtensionKind, edition: Edition) -> SyntaxExtension {
732         SyntaxExtension {
733             span: DUMMY_SP,
734             allow_internal_unstable: None,
735             stability: None,
736             deprecation: None,
737             helper_attrs: Vec::new(),
738             edition,
739             builtin_name: None,
740             kind,
741             allow_internal_unsafe: false,
742             local_inner_macros: false,
743             collapse_debuginfo: false,
744         }
745     }
746
747     /// Constructs a syntax extension with the given properties
748     /// and other properties converted from attributes.
749     pub fn new(
750         sess: &Session,
751         kind: SyntaxExtensionKind,
752         span: Span,
753         helper_attrs: Vec<Symbol>,
754         edition: Edition,
755         name: Symbol,
756         attrs: &[ast::Attribute],
757     ) -> SyntaxExtension {
758         let allow_internal_unstable =
759             attr::allow_internal_unstable(sess, &attrs).collect::<Vec<Symbol>>();
760
761         let allow_internal_unsafe = sess.contains_name(attrs, sym::allow_internal_unsafe);
762         let local_inner_macros = sess
763             .find_by_name(attrs, sym::macro_export)
764             .and_then(|macro_export| macro_export.meta_item_list())
765             .map_or(false, |l| attr::list_contains_name(&l, sym::local_inner_macros));
766         let collapse_debuginfo = sess.contains_name(attrs, sym::collapse_debuginfo);
767         tracing::debug!(?local_inner_macros, ?collapse_debuginfo, ?allow_internal_unsafe);
768
769         let (builtin_name, helper_attrs) = sess
770             .find_by_name(attrs, sym::rustc_builtin_macro)
771             .map(|attr| {
772                 // Override `helper_attrs` passed above if it's a built-in macro,
773                 // marking `proc_macro_derive` macros as built-in is not a realistic use case.
774                 parse_macro_name_and_helper_attrs(sess.diagnostic(), attr, "built-in").map_or_else(
775                     || (Some(name), Vec::new()),
776                     |(name, helper_attrs)| (Some(name), helper_attrs),
777                 )
778             })
779             .unwrap_or_else(|| (None, helper_attrs));
780         let (stability, const_stability, body_stability) = attr::find_stability(&sess, attrs, span);
781         if let Some((_, sp)) = const_stability {
782             sess.parse_sess
783                 .span_diagnostic
784                 .struct_span_err(sp, "macros cannot have const stability attributes")
785                 .span_label(sp, "invalid const stability attribute")
786                 .span_label(
787                     sess.source_map().guess_head_span(span),
788                     "const stability attribute affects this macro",
789                 )
790                 .emit();
791         }
792         if let Some((_, sp)) = body_stability {
793             sess.parse_sess
794                 .span_diagnostic
795                 .struct_span_err(sp, "macros cannot have body stability attributes")
796                 .span_label(sp, "invalid body stability attribute")
797                 .span_label(
798                     sess.source_map().guess_head_span(span),
799                     "body stability attribute affects this macro",
800                 )
801                 .emit();
802         }
803
804         SyntaxExtension {
805             kind,
806             span,
807             allow_internal_unstable: (!allow_internal_unstable.is_empty())
808                 .then(|| allow_internal_unstable.into()),
809             stability: stability.map(|(s, _)| s),
810             deprecation: attr::find_deprecation(&sess, attrs).map(|(d, _)| d),
811             helper_attrs,
812             edition,
813             builtin_name,
814             allow_internal_unsafe,
815             local_inner_macros,
816             collapse_debuginfo,
817         }
818     }
819
820     pub fn dummy_bang(edition: Edition) -> SyntaxExtension {
821         fn expander<'cx>(
822             _: &'cx mut ExtCtxt<'_>,
823             span: Span,
824             _: TokenStream,
825         ) -> Box<dyn MacResult + 'cx> {
826             DummyResult::any(span)
827         }
828         SyntaxExtension::default(SyntaxExtensionKind::LegacyBang(Box::new(expander)), edition)
829     }
830
831     pub fn dummy_derive(edition: Edition) -> SyntaxExtension {
832         fn expander(
833             _: &mut ExtCtxt<'_>,
834             _: Span,
835             _: &ast::MetaItem,
836             _: Annotatable,
837         ) -> Vec<Annotatable> {
838             Vec::new()
839         }
840         SyntaxExtension::default(SyntaxExtensionKind::Derive(Box::new(expander)), edition)
841     }
842
843     pub fn non_macro_attr(edition: Edition) -> SyntaxExtension {
844         SyntaxExtension::default(SyntaxExtensionKind::NonMacroAttr, edition)
845     }
846
847     pub fn expn_data(
848         &self,
849         parent: LocalExpnId,
850         call_site: Span,
851         descr: Symbol,
852         macro_def_id: Option<DefId>,
853         parent_module: Option<DefId>,
854     ) -> ExpnData {
855         ExpnData::new(
856             ExpnKind::Macro(self.macro_kind(), descr),
857             parent.to_expn_id(),
858             call_site,
859             self.span,
860             self.allow_internal_unstable.clone(),
861             self.edition,
862             macro_def_id,
863             parent_module,
864             self.allow_internal_unsafe,
865             self.local_inner_macros,
866             self.collapse_debuginfo,
867         )
868     }
869 }
870
871 /// Error type that denotes indeterminacy.
872 pub struct Indeterminate;
873
874 pub type DeriveResolutions = Vec<(ast::Path, Annotatable, Option<Lrc<SyntaxExtension>>)>;
875
876 pub trait ResolverExpand {
877     fn next_node_id(&mut self) -> NodeId;
878     fn invocation_parent(&self, id: LocalExpnId) -> LocalDefId;
879
880     fn resolve_dollar_crates(&mut self);
881     fn visit_ast_fragment_with_placeholders(
882         &mut self,
883         expn_id: LocalExpnId,
884         fragment: &AstFragment,
885     );
886     fn register_builtin_macro(&mut self, name: Symbol, ext: SyntaxExtensionKind);
887
888     fn expansion_for_ast_pass(
889         &mut self,
890         call_site: Span,
891         pass: AstPass,
892         features: &[Symbol],
893         parent_module_id: Option<NodeId>,
894     ) -> LocalExpnId;
895
896     fn resolve_imports(&mut self);
897
898     fn resolve_macro_invocation(
899         &mut self,
900         invoc: &Invocation,
901         eager_expansion_root: LocalExpnId,
902         force: bool,
903     ) -> Result<Lrc<SyntaxExtension>, Indeterminate>;
904
905     fn record_macro_rule_usage(&mut self, mac_id: NodeId, rule_index: usize);
906
907     fn check_unused_macros(&mut self);
908
909     // Resolver interfaces for specific built-in macros.
910     /// Does `#[derive(...)]` attribute with the given `ExpnId` have built-in `Copy` inside it?
911     fn has_derive_copy(&self, expn_id: LocalExpnId) -> bool;
912     /// Resolve paths inside the `#[derive(...)]` attribute with the given `ExpnId`.
913     fn resolve_derives(
914         &mut self,
915         expn_id: LocalExpnId,
916         force: bool,
917         derive_paths: &dyn Fn() -> DeriveResolutions,
918     ) -> Result<(), Indeterminate>;
919     /// Take resolutions for paths inside the `#[derive(...)]` attribute with the given `ExpnId`
920     /// back from resolver.
921     fn take_derive_resolutions(&mut self, expn_id: LocalExpnId) -> Option<DeriveResolutions>;
922     /// Path resolution logic for `#[cfg_accessible(path)]`.
923     fn cfg_accessible(
924         &mut self,
925         expn_id: LocalExpnId,
926         path: &ast::Path,
927     ) -> Result<bool, Indeterminate>;
928
929     /// Decodes the proc-macro quoted span in the specified crate, with the specified id.
930     /// No caching is performed.
931     fn get_proc_macro_quoted_span(&self, krate: CrateNum, id: usize) -> Span;
932
933     /// The order of items in the HIR is unrelated to the order of
934     /// items in the AST. However, we generate proc macro harnesses
935     /// based on the AST order, and later refer to these harnesses
936     /// from the HIR. This field keeps track of the order in which
937     /// we generated proc macros harnesses, so that we can map
938     /// HIR proc macros items back to their harness items.
939     fn declare_proc_macro(&mut self, id: NodeId);
940
941     /// Tools registered with `#![register_tool]` and used by tool attributes and lints.
942     fn registered_tools(&self) -> &FxHashSet<Ident>;
943 }
944
945 pub trait LintStoreExpand {
946     fn pre_expansion_lint(
947         &self,
948         sess: &Session,
949         registered_tools: &FxHashSet<Ident>,
950         node_id: NodeId,
951         attrs: &[Attribute],
952         items: &[P<Item>],
953         name: &str,
954     );
955 }
956
957 type LintStoreExpandDyn<'a> = Option<&'a (dyn LintStoreExpand + 'a)>;
958
959 #[derive(Clone, Default)]
960 pub struct ModuleData {
961     /// Path to the module starting from the crate name, like `my_crate::foo::bar`.
962     pub mod_path: Vec<Ident>,
963     /// Stack of paths to files loaded by out-of-line module items,
964     /// used to detect and report recursive module inclusions.
965     pub file_path_stack: Vec<PathBuf>,
966     /// Directory to search child module files in,
967     /// often (but not necessarily) the parent of the top file path on the `file_path_stack`.
968     pub dir_path: PathBuf,
969 }
970
971 impl ModuleData {
972     pub fn with_dir_path(&self, dir_path: PathBuf) -> ModuleData {
973         ModuleData {
974             mod_path: self.mod_path.clone(),
975             file_path_stack: self.file_path_stack.clone(),
976             dir_path,
977         }
978     }
979 }
980
981 #[derive(Clone)]
982 pub struct ExpansionData {
983     pub id: LocalExpnId,
984     pub depth: usize,
985     pub module: Rc<ModuleData>,
986     pub dir_ownership: DirOwnership,
987     pub prior_type_ascription: Option<(Span, bool)>,
988     /// Some parent node that is close to this macro call
989     pub lint_node_id: NodeId,
990     pub is_trailing_mac: bool,
991 }
992
993 /// One of these is made during expansion and incrementally updated as we go;
994 /// when a macro expansion occurs, the resulting nodes have the `backtrace()
995 /// -> expn_data` of their expansion context stored into their span.
996 pub struct ExtCtxt<'a> {
997     pub sess: &'a Session,
998     pub ecfg: expand::ExpansionConfig<'a>,
999     pub reduced_recursion_limit: Option<Limit>,
1000     pub root_path: PathBuf,
1001     pub resolver: &'a mut dyn ResolverExpand,
1002     pub current_expansion: ExpansionData,
1003     /// Error recovery mode entered when expansion is stuck
1004     /// (or during eager expansion, but that's a hack).
1005     pub force_mode: bool,
1006     pub expansions: FxIndexMap<Span, Vec<String>>,
1007     /// Used for running pre-expansion lints on freshly loaded modules.
1008     pub(super) lint_store: LintStoreExpandDyn<'a>,
1009     /// Used for storing lints generated during expansion, like `NAMED_ARGUMENTS_USED_POSITIONALLY`
1010     pub buffered_early_lint: Vec<BufferedEarlyLint>,
1011     /// When we 'expand' an inert attribute, we leave it
1012     /// in the AST, but insert it here so that we know
1013     /// not to expand it again.
1014     pub(super) expanded_inert_attrs: MarkedAttrs,
1015 }
1016
1017 impl<'a> ExtCtxt<'a> {
1018     pub fn new(
1019         sess: &'a Session,
1020         ecfg: expand::ExpansionConfig<'a>,
1021         resolver: &'a mut dyn ResolverExpand,
1022         lint_store: LintStoreExpandDyn<'a>,
1023     ) -> ExtCtxt<'a> {
1024         ExtCtxt {
1025             sess,
1026             ecfg,
1027             reduced_recursion_limit: None,
1028             resolver,
1029             lint_store,
1030             root_path: PathBuf::new(),
1031             current_expansion: ExpansionData {
1032                 id: LocalExpnId::ROOT,
1033                 depth: 0,
1034                 module: Default::default(),
1035                 dir_ownership: DirOwnership::Owned { relative: None },
1036                 prior_type_ascription: None,
1037                 lint_node_id: ast::CRATE_NODE_ID,
1038                 is_trailing_mac: false,
1039             },
1040             force_mode: false,
1041             expansions: FxIndexMap::default(),
1042             expanded_inert_attrs: MarkedAttrs::new(),
1043             buffered_early_lint: vec![],
1044         }
1045     }
1046
1047     /// Returns a `Folder` for deeply expanding all macros in an AST node.
1048     pub fn expander<'b>(&'b mut self) -> expand::MacroExpander<'b, 'a> {
1049         expand::MacroExpander::new(self, false)
1050     }
1051
1052     /// Returns a `Folder` that deeply expands all macros and assigns all `NodeId`s in an AST node.
1053     /// Once `NodeId`s are assigned, the node may not be expanded, removed, or otherwise modified.
1054     pub fn monotonic_expander<'b>(&'b mut self) -> expand::MacroExpander<'b, 'a> {
1055         expand::MacroExpander::new(self, true)
1056     }
1057     pub fn new_parser_from_tts(&self, stream: TokenStream) -> parser::Parser<'a> {
1058         rustc_parse::stream_to_parser(&self.sess.parse_sess, stream, MACRO_ARGUMENTS)
1059     }
1060     pub fn source_map(&self) -> &'a SourceMap {
1061         self.sess.parse_sess.source_map()
1062     }
1063     pub fn parse_sess(&self) -> &'a ParseSess {
1064         &self.sess.parse_sess
1065     }
1066     pub fn call_site(&self) -> Span {
1067         self.current_expansion.id.expn_data().call_site
1068     }
1069
1070     /// Returns the current expansion kind's description.
1071     pub(crate) fn expansion_descr(&self) -> String {
1072         let expn_data = self.current_expansion.id.expn_data();
1073         expn_data.kind.descr()
1074     }
1075
1076     /// Equivalent of `Span::def_site` from the proc macro API,
1077     /// except that the location is taken from the span passed as an argument.
1078     pub fn with_def_site_ctxt(&self, span: Span) -> Span {
1079         span.with_def_site_ctxt(self.current_expansion.id.to_expn_id())
1080     }
1081
1082     /// Equivalent of `Span::call_site` from the proc macro API,
1083     /// except that the location is taken from the span passed as an argument.
1084     pub fn with_call_site_ctxt(&self, span: Span) -> Span {
1085         span.with_call_site_ctxt(self.current_expansion.id.to_expn_id())
1086     }
1087
1088     /// Equivalent of `Span::mixed_site` from the proc macro API,
1089     /// except that the location is taken from the span passed as an argument.
1090     pub fn with_mixed_site_ctxt(&self, span: Span) -> Span {
1091         span.with_mixed_site_ctxt(self.current_expansion.id.to_expn_id())
1092     }
1093
1094     /// Returns span for the macro which originally caused the current expansion to happen.
1095     ///
1096     /// Stops backtracing at include! boundary.
1097     pub fn expansion_cause(&self) -> Option<Span> {
1098         self.current_expansion.id.expansion_cause()
1099     }
1100
1101     #[rustc_lint_diagnostics]
1102     pub fn struct_span_err<S: Into<MultiSpan>>(
1103         &self,
1104         sp: S,
1105         msg: &str,
1106     ) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
1107         self.sess.parse_sess.span_diagnostic.struct_span_err(sp, msg)
1108     }
1109
1110     pub fn create_err(
1111         &self,
1112         err: impl SessionDiagnostic<'a>,
1113     ) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
1114         self.sess.create_err(err)
1115     }
1116
1117     pub fn emit_err(&self, err: impl SessionDiagnostic<'a>) -> ErrorGuaranteed {
1118         self.sess.emit_err(err)
1119     }
1120
1121     /// Emit `msg` attached to `sp`, without immediately stopping
1122     /// compilation.
1123     ///
1124     /// Compilation will be stopped in the near future (at the end of
1125     /// the macro expansion phase).
1126     #[rustc_lint_diagnostics]
1127     pub fn span_err<S: Into<MultiSpan>>(&self, sp: S, msg: &str) {
1128         self.sess.parse_sess.span_diagnostic.span_err(sp, msg);
1129     }
1130     #[rustc_lint_diagnostics]
1131     pub fn span_warn<S: Into<MultiSpan>>(&self, sp: S, msg: &str) {
1132         self.sess.parse_sess.span_diagnostic.span_warn(sp, msg);
1133     }
1134     pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> ! {
1135         self.sess.parse_sess.span_diagnostic.span_bug(sp, msg);
1136     }
1137     pub fn trace_macros_diag(&mut self) {
1138         for (sp, notes) in self.expansions.iter() {
1139             let mut db = self.sess.parse_sess.span_diagnostic.span_note_diag(*sp, "trace_macro");
1140             for note in notes {
1141                 db.note(note);
1142             }
1143             db.emit();
1144         }
1145         // Fixme: does this result in errors?
1146         self.expansions.clear();
1147     }
1148     pub fn bug(&self, msg: &str) -> ! {
1149         self.sess.parse_sess.span_diagnostic.bug(msg);
1150     }
1151     pub fn trace_macros(&self) -> bool {
1152         self.ecfg.trace_mac
1153     }
1154     pub fn set_trace_macros(&mut self, x: bool) {
1155         self.ecfg.trace_mac = x
1156     }
1157     pub fn std_path(&self, components: &[Symbol]) -> Vec<Ident> {
1158         let def_site = self.with_def_site_ctxt(DUMMY_SP);
1159         iter::once(Ident::new(kw::DollarCrate, def_site))
1160             .chain(components.iter().map(|&s| Ident::with_dummy_span(s)))
1161             .collect()
1162     }
1163     pub fn def_site_path(&self, components: &[Symbol]) -> Vec<Ident> {
1164         let def_site = self.with_def_site_ctxt(DUMMY_SP);
1165         components.iter().map(|&s| Ident::new(s, def_site)).collect()
1166     }
1167
1168     pub fn check_unused_macros(&mut self) {
1169         self.resolver.check_unused_macros();
1170     }
1171 }
1172
1173 /// Resolves a `path` mentioned inside Rust code, returning an absolute path.
1174 ///
1175 /// This unifies the logic used for resolving `include_X!`.
1176 pub fn resolve_path(
1177     parse_sess: &ParseSess,
1178     path: impl Into<PathBuf>,
1179     span: Span,
1180 ) -> PResult<'_, PathBuf> {
1181     let path = path.into();
1182
1183     // Relative paths are resolved relative to the file in which they are found
1184     // after macro expansion (that is, they are unhygienic).
1185     if !path.is_absolute() {
1186         let callsite = span.source_callsite();
1187         let mut result = match parse_sess.source_map().span_to_filename(callsite) {
1188             FileName::Real(name) => name
1189                 .into_local_path()
1190                 .expect("attempting to resolve a file path in an external file"),
1191             FileName::DocTest(path, _) => path,
1192             other => {
1193                 return Err(parse_sess.span_diagnostic.struct_span_err(
1194                     span,
1195                     &format!(
1196                         "cannot resolve relative path in non-file source `{}`",
1197                         parse_sess.source_map().filename_for_diagnostics(&other)
1198                     ),
1199                 ));
1200             }
1201         };
1202         result.pop();
1203         result.push(path);
1204         Ok(result)
1205     } else {
1206         Ok(path)
1207     }
1208 }
1209
1210 /// Extracts a string literal from the macro expanded version of `expr`,
1211 /// returning a diagnostic error of `err_msg` if `expr` is not a string literal.
1212 /// The returned bool indicates whether an applicable suggestion has already been
1213 /// added to the diagnostic to avoid emitting multiple suggestions. `Err(None)`
1214 /// indicates that an ast error was encountered.
1215 pub fn expr_to_spanned_string<'a>(
1216     cx: &'a mut ExtCtxt<'_>,
1217     expr: P<ast::Expr>,
1218     err_msg: &str,
1219 ) -> Result<(Symbol, ast::StrStyle, Span), Option<(DiagnosticBuilder<'a, ErrorGuaranteed>, bool)>> {
1220     // Perform eager expansion on the expression.
1221     // We want to be able to handle e.g., `concat!("foo", "bar")`.
1222     let expr = cx.expander().fully_expand_fragment(AstFragment::Expr(expr)).make_expr();
1223
1224     Err(match expr.kind {
1225         ast::ExprKind::Lit(ref l) => match l.kind {
1226             ast::LitKind::Str(s, style) => return Ok((s, style, expr.span)),
1227             ast::LitKind::ByteStr(_) => {
1228                 let mut err = cx.struct_span_err(l.span, err_msg);
1229                 err.span_suggestion(
1230                     expr.span.shrink_to_lo(),
1231                     "consider removing the leading `b`",
1232                     "",
1233                     Applicability::MaybeIncorrect,
1234                 );
1235                 Some((err, true))
1236             }
1237             ast::LitKind::Err => None,
1238             _ => Some((cx.struct_span_err(l.span, err_msg), false)),
1239         },
1240         ast::ExprKind::Err => None,
1241         _ => Some((cx.struct_span_err(expr.span, err_msg), false)),
1242     })
1243 }
1244
1245 /// Extracts a string literal from the macro expanded version of `expr`,
1246 /// emitting `err_msg` if `expr` is not a string literal. This does not stop
1247 /// compilation on error, merely emits a non-fatal error and returns `None`.
1248 pub fn expr_to_string(
1249     cx: &mut ExtCtxt<'_>,
1250     expr: P<ast::Expr>,
1251     err_msg: &str,
1252 ) -> Option<(Symbol, ast::StrStyle)> {
1253     expr_to_spanned_string(cx, expr, err_msg)
1254         .map_err(|err| {
1255             err.map(|(mut err, _)| {
1256                 err.emit();
1257             })
1258         })
1259         .ok()
1260         .map(|(symbol, style, _)| (symbol, style))
1261 }
1262
1263 /// Non-fatally assert that `tts` is empty. Note that this function
1264 /// returns even when `tts` is non-empty, macros that *need* to stop
1265 /// compilation should call
1266 /// `cx.parse_sess.span_diagnostic.abort_if_errors()` (this should be
1267 /// done as rarely as possible).
1268 pub fn check_zero_tts(cx: &ExtCtxt<'_>, sp: Span, tts: TokenStream, name: &str) {
1269     if !tts.is_empty() {
1270         cx.span_err(sp, &format!("{} takes no arguments", name));
1271     }
1272 }
1273
1274 /// Parse an expression. On error, emit it, advancing to `Eof`, and return `None`.
1275 pub fn parse_expr(p: &mut parser::Parser<'_>) -> Option<P<ast::Expr>> {
1276     match p.parse_expr() {
1277         Ok(e) => return Some(e),
1278         Err(mut err) => {
1279             err.emit();
1280         }
1281     }
1282     while p.token != token::Eof {
1283         p.bump();
1284     }
1285     None
1286 }
1287
1288 /// Interpreting `tts` as a comma-separated sequence of expressions,
1289 /// expect exactly one string literal, or emit an error and return `None`.
1290 pub fn get_single_str_from_tts(
1291     cx: &mut ExtCtxt<'_>,
1292     sp: Span,
1293     tts: TokenStream,
1294     name: &str,
1295 ) -> Option<Symbol> {
1296     let mut p = cx.new_parser_from_tts(tts);
1297     if p.token == token::Eof {
1298         cx.span_err(sp, &format!("{} takes 1 argument", name));
1299         return None;
1300     }
1301     let ret = parse_expr(&mut p)?;
1302     let _ = p.eat(&token::Comma);
1303
1304     if p.token != token::Eof {
1305         cx.span_err(sp, &format!("{} takes 1 argument", name));
1306     }
1307     expr_to_string(cx, ret, "argument must be a string literal").map(|(s, _)| s)
1308 }
1309
1310 /// Extracts comma-separated expressions from `tts`.
1311 /// On error, emit it, and return `None`.
1312 pub fn get_exprs_from_tts(
1313     cx: &mut ExtCtxt<'_>,
1314     sp: Span,
1315     tts: TokenStream,
1316 ) -> Option<Vec<P<ast::Expr>>> {
1317     let mut p = cx.new_parser_from_tts(tts);
1318     let mut es = Vec::new();
1319     while p.token != token::Eof {
1320         let expr = parse_expr(&mut p)?;
1321
1322         // Perform eager expansion on the expression.
1323         // We want to be able to handle e.g., `concat!("foo", "bar")`.
1324         let expr = cx.expander().fully_expand_fragment(AstFragment::Expr(expr)).make_expr();
1325
1326         es.push(expr);
1327         if p.eat(&token::Comma) {
1328             continue;
1329         }
1330         if p.token != token::Eof {
1331             cx.span_err(sp, "expected token: `,`");
1332             return None;
1333         }
1334     }
1335     Some(es)
1336 }
1337
1338 pub fn parse_macro_name_and_helper_attrs(
1339     diag: &rustc_errors::Handler,
1340     attr: &Attribute,
1341     descr: &str,
1342 ) -> Option<(Symbol, Vec<Symbol>)> {
1343     // Once we've located the `#[proc_macro_derive]` attribute, verify
1344     // that it's of the form `#[proc_macro_derive(Foo)]` or
1345     // `#[proc_macro_derive(Foo, attributes(A, ..))]`
1346     let list = attr.meta_item_list()?;
1347     if list.len() != 1 && list.len() != 2 {
1348         diag.span_err(attr.span, "attribute must have either one or two arguments");
1349         return None;
1350     }
1351     let Some(trait_attr) = list[0].meta_item() else {
1352         diag.span_err(list[0].span(), "not a meta item");
1353         return None;
1354     };
1355     let trait_ident = match trait_attr.ident() {
1356         Some(trait_ident) if trait_attr.is_word() => trait_ident,
1357         _ => {
1358             diag.span_err(trait_attr.span, "must only be one word");
1359             return None;
1360         }
1361     };
1362
1363     if !trait_ident.name.can_be_raw() {
1364         diag.span_err(
1365             trait_attr.span,
1366             &format!("`{}` cannot be a name of {} macro", trait_ident, descr),
1367         );
1368     }
1369
1370     let attributes_attr = list.get(1);
1371     let proc_attrs: Vec<_> = if let Some(attr) = attributes_attr {
1372         if !attr.has_name(sym::attributes) {
1373             diag.span_err(attr.span(), "second argument must be `attributes`");
1374         }
1375         attr.meta_item_list()
1376             .unwrap_or_else(|| {
1377                 diag.span_err(attr.span(), "attribute must be of form: `attributes(foo, bar)`");
1378                 &[]
1379             })
1380             .iter()
1381             .filter_map(|attr| {
1382                 let Some(attr) = attr.meta_item() else {
1383                     diag.span_err(attr.span(), "not a meta item");
1384                     return None;
1385                 };
1386
1387                 let ident = match attr.ident() {
1388                     Some(ident) if attr.is_word() => ident,
1389                     _ => {
1390                         diag.span_err(attr.span, "must only be one word");
1391                         return None;
1392                     }
1393                 };
1394                 if !ident.name.can_be_raw() {
1395                     diag.span_err(
1396                         attr.span,
1397                         &format!("`{}` cannot be a name of derive helper attribute", ident),
1398                     );
1399                 }
1400
1401                 Some(ident.name)
1402             })
1403             .collect()
1404     } else {
1405         Vec::new()
1406     };
1407
1408     Some((trait_ident.name, proc_attrs))
1409 }
1410
1411 /// This nonterminal looks like some specific enums from
1412 /// `proc-macro-hack` and `procedural-masquerade` crates.
1413 /// We need to maintain some special pretty-printing behavior for them due to incorrect
1414 /// asserts in old versions of those crates and their wide use in the ecosystem.
1415 /// See issue #73345 for more details.
1416 /// FIXME(#73933): Remove this eventually.
1417 fn pretty_printing_compatibility_hack(item: &Item, sess: &ParseSess) -> bool {
1418     let name = item.ident.name;
1419     if name == sym::ProceduralMasqueradeDummyType {
1420         if let ast::ItemKind::Enum(enum_def, _) = &item.kind {
1421             if let [variant] = &*enum_def.variants {
1422                 if variant.ident.name == sym::Input {
1423                     sess.buffer_lint_with_diagnostic(
1424                         &PROC_MACRO_BACK_COMPAT,
1425                         item.ident.span,
1426                         ast::CRATE_NODE_ID,
1427                         "using `procedural-masquerade` crate",
1428                         BuiltinLintDiagnostics::ProcMacroBackCompat(
1429                         "The `procedural-masquerade` crate has been unnecessary since Rust 1.30.0. \
1430                         Versions of this crate below 0.1.7 will eventually stop compiling.".to_string())
1431                     );
1432                     return true;
1433                 }
1434             }
1435         }
1436     }
1437     false
1438 }
1439
1440 pub(crate) fn ann_pretty_printing_compatibility_hack(ann: &Annotatable, sess: &ParseSess) -> bool {
1441     let item = match ann {
1442         Annotatable::Item(item) => item,
1443         Annotatable::Stmt(stmt) => match &stmt.kind {
1444             ast::StmtKind::Item(item) => item,
1445             _ => return false,
1446         },
1447         _ => return false,
1448     };
1449     pretty_printing_compatibility_hack(item, sess)
1450 }
1451
1452 pub(crate) fn nt_pretty_printing_compatibility_hack(nt: &Nonterminal, sess: &ParseSess) -> bool {
1453     let item = match nt {
1454         Nonterminal::NtItem(item) => item,
1455         Nonterminal::NtStmt(stmt) => match &stmt.kind {
1456             ast::StmtKind::Item(item) => item,
1457             _ => return false,
1458         },
1459         _ => return false,
1460     };
1461     pretty_printing_compatibility_hack(item, sess)
1462 }