src/librustc_expand/placeholders.rs

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