src/libsyntax_expand/placeholders.rs

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