rustc_expand/
base.rs

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

rustc_expand/
base.rs
