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