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