src/librustc_expand/placeholders.rs

   1 use crate::base::ExtCtxt;
   2 use crate::expand::{AstFragment, AstFragmentKind};
   3
   4 use rustc_ast as ast;
   5 use rustc_ast::mut_visit::*;
   6 use rustc_ast::ptr::P;
   7 use rustc_span::source_map::{dummy_spanned, DUMMY_SP};
   8 use rustc_span::symbol::Ident;
   9
  10 use smallvec::{smallvec, SmallVec};
  11
  12 use rustc_data_structures::fx::FxHashMap;
  13
  14 pub fn placeholder(
  15     kind: AstFragmentKind,
  16     id: ast::NodeId,
  17     vis: Option<ast::Visibility>,
  18 ) -> AstFragment {
  19     fn mac_placeholder() -> ast::MacCall {
  20         ast::MacCall {
  21             path: ast::Path { span: DUMMY_SP, segments: Vec::new() },
  22             args: P(ast::MacArgs::Empty),
  23             prior_type_ascription: None,
  24         }
  25     }
  26
  27     let ident = Ident::invalid();
  28     let attrs = Vec::new();
  29     let vis = vis.unwrap_or_else(|| dummy_spanned(ast::VisibilityKind::Inherited));
  30     let span = DUMMY_SP;
  31     let expr_placeholder = || {
  32         P(ast::Expr {
  33             id,
  34             span,
  35             attrs: ast::AttrVec::new(),
  36             kind: ast::ExprKind::MacCall(mac_placeholder()),
  37             tokens: None,
  38         })
  39     };
  40     let ty = || P(ast::Ty { id, kind: ast::TyKind::MacCall(mac_placeholder()), span });
  41     let pat = || P(ast::Pat { id, kind: ast::PatKind::MacCall(mac_placeholder()), span });
  42
  43     match kind {
  44         AstFragmentKind::Expr => AstFragment::Expr(expr_placeholder()),
  45         AstFragmentKind::OptExpr => AstFragment::OptExpr(Some(expr_placeholder())),
  46         AstFragmentKind::Items => AstFragment::Items(smallvec![P(ast::Item {
  47             id,
  48             span,
  49             ident,
  50             vis,
  51             attrs,
  52             kind: ast::ItemKind::MacCall(mac_placeholder()),
  53             tokens: None,
  54         })]),
  55         AstFragmentKind::TraitItems => AstFragment::TraitItems(smallvec![P(ast::AssocItem {
  56             id,
  57             span,
  58             ident,
  59             vis,
  60             attrs,
  61             kind: ast::AssocItemKind::MacCall(mac_placeholder()),
  62             tokens: None,
  63         })]),
  64         AstFragmentKind::ImplItems => AstFragment::ImplItems(smallvec![P(ast::AssocItem {
  65             id,
  66             span,
  67             ident,
  68             vis,
  69             attrs,
  70             kind: ast::AssocItemKind::MacCall(mac_placeholder()),
  71             tokens: None,
  72         })]),
  73         AstFragmentKind::ForeignItems => {
  74             AstFragment::ForeignItems(smallvec![P(ast::ForeignItem {
  75                 id,
  76                 span,
  77                 ident,
  78                 vis,
  79                 attrs,
  80                 kind: ast::ForeignItemKind::MacCall(mac_placeholder()),
  81                 tokens: None,
  82             })])
  83         }
  84         AstFragmentKind::Pat => AstFragment::Pat(P(ast::Pat {
  85             id,
  86             span,
  87             kind: ast::PatKind::MacCall(mac_placeholder()),
  88         })),
  89         AstFragmentKind::Ty => {
  90             AstFragment::Ty(P(ast::Ty { id, span, kind: ast::TyKind::MacCall(mac_placeholder()) }))
  91         }
  92         AstFragmentKind::Stmts => AstFragment::Stmts(smallvec![{
  93             let mac = P((mac_placeholder(), ast::MacStmtStyle::Braces, ast::AttrVec::new()));
  94             ast::Stmt { id, span, kind: ast::StmtKind::MacCall(mac) }
  95         }]),
  96         AstFragmentKind::Arms => AstFragment::Arms(smallvec![ast::Arm {
  97             attrs: Default::default(),
  98             body: expr_placeholder(),
  99             guard: None,
 100             id,
 101             pat: pat(),
 102             span,
 103             is_placeholder: true,
 104         }]),
 105         AstFragmentKind::Fields => AstFragment::Fields(smallvec![ast::Field {
 106             attrs: Default::default(),
 107             expr: expr_placeholder(),
 108             id,
 109             ident,
 110             is_shorthand: false,
 111             span,
 112             is_placeholder: true,
 113         }]),
 114         AstFragmentKind::FieldPats => AstFragment::FieldPats(smallvec![ast::FieldPat {
 115             attrs: Default::default(),
 116             id,
 117             ident,
 118             is_shorthand: false,
 119             pat: pat(),
 120             span,
 121             is_placeholder: true,
 122         }]),
 123         AstFragmentKind::GenericParams => AstFragment::GenericParams(smallvec![{
 124             ast::GenericParam {
 125                 attrs: Default::default(),
 126                 bounds: Default::default(),
 127                 id,
 128                 ident,
 129                 is_placeholder: true,
 130                 kind: ast::GenericParamKind::Lifetime,
 131             }
 132         }]),
 133         AstFragmentKind::Params => AstFragment::Params(smallvec![ast::Param {
 134             attrs: Default::default(),
 135             id,
 136             pat: pat(),
 137             span,
 138             ty: ty(),
 139             is_placeholder: true,
 140         }]),
 141         AstFragmentKind::StructFields => AstFragment::StructFields(smallvec![ast::StructField {
 142             attrs: Default::default(),
 143             id,
 144             ident: None,
 145             span,
 146             ty: ty(),
 147             vis,
 148             is_placeholder: true,
 149         }]),
 150         AstFragmentKind::Variants => AstFragment::Variants(smallvec![ast::Variant {
 151             attrs: Default::default(),
 152             data: ast::VariantData::Struct(Default::default(), false),
 153             disr_expr: None,
 154             id,
 155             ident,
 156             span,
 157             vis,
 158             is_placeholder: true,
 159         }]),
 160     }
 161 }
 162
 163 pub struct PlaceholderExpander<'a, 'b> {
 164     expanded_fragments: FxHashMap<ast::NodeId, AstFragment>,
 165     cx: &'a mut ExtCtxt<'b>,
 166     monotonic: bool,
 167 }
 168
 169 impl<'a, 'b> PlaceholderExpander<'a, 'b> {
 170     pub fn new(cx: &'a mut ExtCtxt<'b>, monotonic: bool) -> Self {
 171         PlaceholderExpander { cx, expanded_fragments: FxHashMap::default(), monotonic }
 172     }
 173
 174     pub fn add(&mut self, id: ast::NodeId, mut fragment: AstFragment) {
 175         fragment.mut_visit_with(self);
 176         self.expanded_fragments.insert(id, fragment);
 177     }
 178
 179     fn remove(&mut self, id: ast::NodeId) -> AstFragment {
 180         self.expanded_fragments.remove(&id).unwrap()
 181     }
 182 }
 183
 184 impl<'a, 'b> MutVisitor for PlaceholderExpander<'a, 'b> {
 185     fn flat_map_arm(&mut self, arm: ast::Arm) -> SmallVec<[ast::Arm; 1]> {
 186         if arm.is_placeholder {
 187             self.remove(arm.id).make_arms()
 188         } else {
 189             noop_flat_map_arm(arm, self)
 190         }
 191     }
 192
 193     fn flat_map_field(&mut self, field: ast::Field) -> SmallVec<[ast::Field; 1]> {
 194         if field.is_placeholder {
 195             self.remove(field.id).make_fields()
 196         } else {
 197             noop_flat_map_field(field, self)
 198         }
 199     }
 200
 201     fn flat_map_field_pattern(&mut self, fp: ast::FieldPat) -> SmallVec<[ast::FieldPat; 1]> {
 202         if fp.is_placeholder {
 203             self.remove(fp.id).make_field_patterns()
 204         } else {
 205             noop_flat_map_field_pattern(fp, self)
 206         }
 207     }
 208
 209     fn flat_map_generic_param(
 210         &mut self,
 211         param: ast::GenericParam,
 212     ) -> SmallVec<[ast::GenericParam; 1]> {
 213         if param.is_placeholder {
 214             self.remove(param.id).make_generic_params()
 215         } else {
 216             noop_flat_map_generic_param(param, self)
 217         }
 218     }
 219
 220     fn flat_map_param(&mut self, p: ast::Param) -> SmallVec<[ast::Param; 1]> {
 221         if p.is_placeholder {
 222             self.remove(p.id).make_params()
 223         } else {
 224             noop_flat_map_param(p, self)
 225         }
 226     }
 227
 228     fn flat_map_struct_field(&mut self, sf: ast::StructField) -> SmallVec<[ast::StructField; 1]> {
 229         if sf.is_placeholder {
 230             self.remove(sf.id).make_struct_fields()
 231         } else {
 232             noop_flat_map_struct_field(sf, self)
 233         }
 234     }
 235
 236     fn flat_map_variant(&mut self, variant: ast::Variant) -> SmallVec<[ast::Variant; 1]> {
 237         if variant.is_placeholder {
 238             self.remove(variant.id).make_variants()
 239         } else {
 240             noop_flat_map_variant(variant, self)
 241         }
 242     }
 243
 244     fn flat_map_item(&mut self, item: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
 245         match item.kind {
 246             ast::ItemKind::MacCall(_) => return self.remove(item.id).make_items(),
 247             ast::ItemKind::MacroDef(_) => return smallvec![item],
 248             _ => {}
 249         }
 250
 251         noop_flat_map_item(item, self)
 252     }
 253
 254     fn flat_map_trait_item(&mut self, item: P<ast::AssocItem>) -> SmallVec<[P<ast::AssocItem>; 1]> {
 255         match item.kind {
 256             ast::AssocItemKind::MacCall(_) => self.remove(item.id).make_trait_items(),
 257             _ => noop_flat_map_assoc_item(item, self),
 258         }
 259     }
 260
 261     fn flat_map_impl_item(&mut self, item: P<ast::AssocItem>) -> SmallVec<[P<ast::AssocItem>; 1]> {
 262         match item.kind {
 263             ast::AssocItemKind::MacCall(_) => self.remove(item.id).make_impl_items(),
 264             _ => noop_flat_map_assoc_item(item, self),
 265         }
 266     }
 267
 268     fn flat_map_foreign_item(
 269         &mut self,
 270         item: P<ast::ForeignItem>,
 271     ) -> SmallVec<[P<ast::ForeignItem>; 1]> {
 272         match item.kind {
 273             ast::ForeignItemKind::MacCall(_) => self.remove(item.id).make_foreign_items(),
 274             _ => noop_flat_map_foreign_item(item, self),
 275         }
 276     }
 277
 278     fn visit_expr(&mut self, expr: &mut P<ast::Expr>) {
 279         match expr.kind {
 280             ast::ExprKind::MacCall(_) => *expr = self.remove(expr.id).make_expr(),
 281             _ => noop_visit_expr(expr, self),
 282         }
 283     }
 284
 285     fn filter_map_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
 286         match expr.kind {
 287             ast::ExprKind::MacCall(_) => self.remove(expr.id).make_opt_expr(),
 288             _ => noop_filter_map_expr(expr, self),
 289         }
 290     }
 291
 292     fn flat_map_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> {
 293         let (style, mut stmts) = match stmt.kind {
 294             ast::StmtKind::MacCall(mac) => (mac.1, self.remove(stmt.id).make_stmts()),
 295             _ => return noop_flat_map_stmt(stmt, self),
 296         };
 297
 298         if style == ast::MacStmtStyle::Semicolon {
 299             if let Some(stmt) = stmts.pop() {
 300                 stmts.push(stmt.add_trailing_semicolon());
 301             }
 302         }
 303
 304         stmts
 305     }
 306
 307     fn visit_pat(&mut self, pat: &mut P<ast::Pat>) {
 308         match pat.kind {
 309             ast::PatKind::MacCall(_) => *pat = self.remove(pat.id).make_pat(),
 310             _ => noop_visit_pat(pat, self),
 311         }
 312     }
 313
 314     fn visit_ty(&mut self, ty: &mut P<ast::Ty>) {
 315         match ty.kind {
 316             ast::TyKind::MacCall(_) => *ty = self.remove(ty.id).make_ty(),
 317             _ => noop_visit_ty(ty, self),
 318         }
 319     }
 320
 321     fn visit_block(&mut self, block: &mut P<ast::Block>) {
 322         noop_visit_block(block, self);
 323
 324         for stmt in block.stmts.iter_mut() {
 325             if self.monotonic {
 326                 assert_eq!(stmt.id, ast::DUMMY_NODE_ID);
 327                 stmt.id = self.cx.resolver.next_node_id();
 328             }
 329         }
 330     }
 331
 332     fn visit_mod(&mut self, module: &mut ast::Mod) {
 333         noop_visit_mod(module, self);
 334         module.items.retain(|item| match item.kind {
 335             ast::ItemKind::MacCall(_) if !self.cx.ecfg.keep_macs => false, // remove macro definitions
 336             _ => true,
 337         });
 338     }
 339
 340     fn visit_mac(&mut self, _mac: &mut ast::MacCall) {
 341         // Do nothing.
 342     }
 343 }