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, vis: Option<ast::Visibility>)
  16                    -> AstFragment {
  17     fn mac_placeholder() -> ast::Mac {
  18         ast::Mac {
  19             path: ast::Path { span: DUMMY_SP, segments: Vec::new() },
  20             tts: TokenStream::default().into(),
  21             delim: ast::MacDelimiter::Brace,
  22             span: DUMMY_SP,
  23             prior_type_ascription: None,
  24         }
  25     }
  26
  27     let ident = ast::Ident::invalid();
  28     let attrs = Vec::new();
  29     let generics = ast::Generics::default();
  30     let vis = vis.unwrap_or_else(|| dummy_spanned(ast::VisibilityKind::Inherited));
  31     let span = DUMMY_SP;
  32     let expr_placeholder = || P(ast::Expr {
  33         id, span,
  34         attrs: ThinVec::new(),
  35         kind: ast::ExprKind::Mac(mac_placeholder()),
  36     });
  37     let ty = || P(ast::Ty {
  38         id,
  39         kind: ast::TyKind::Mac(mac_placeholder()),
  40         span,
  41     });
  42     let pat = || P(ast::Pat {
  43         id,
  44         kind: ast::PatKind::Mac(mac_placeholder()),
  45         span,
  46     });
  47
  48     match kind {
  49         AstFragmentKind::Expr => AstFragment::Expr(expr_placeholder()),
  50         AstFragmentKind::OptExpr => AstFragment::OptExpr(Some(expr_placeholder())),
  51         AstFragmentKind::Items => AstFragment::Items(smallvec![P(ast::Item {
  52             id, span, ident, vis, attrs,
  53             kind: ast::ItemKind::Mac(mac_placeholder()),
  54             tokens: None,
  55         })]),
  56         AstFragmentKind::TraitItems => AstFragment::TraitItems(smallvec![ast::TraitItem {
  57             id, span, ident, vis, attrs, generics,
  58             kind: ast::TraitItemKind::Macro(mac_placeholder()),
  59             tokens: None,
  60         }]),
  61         AstFragmentKind::ImplItems => AstFragment::ImplItems(smallvec![ast::ImplItem {
  62             id, span, ident, vis, attrs, generics,
  63             kind: ast::ImplItemKind::Macro(mac_placeholder()),
  64             defaultness: ast::Defaultness::Final,
  65             tokens: None,
  66         }]),
  67         AstFragmentKind::ForeignItems =>
  68             AstFragment::ForeignItems(smallvec![ast::ForeignItem {
  69                 id, span, ident, vis, attrs,
  70                 kind: ast::ForeignItemKind::Macro(mac_placeholder()),
  71             }]),
  72         AstFragmentKind::Pat => AstFragment::Pat(P(ast::Pat {
  73             id, span, kind: ast::PatKind::Mac(mac_placeholder()),
  74         })),
  75         AstFragmentKind::Ty => AstFragment::Ty(P(ast::Ty {
  76             id, span, kind: ast::TyKind::Mac(mac_placeholder()),
  77         })),
  78         AstFragmentKind::Stmts => AstFragment::Stmts(smallvec![{
  79             let mac = P((mac_placeholder(), ast::MacStmtStyle::Braces, ThinVec::new()));
  80             ast::Stmt { id, span, kind: ast::StmtKind::Mac(mac) }
  81         }]),
  82         AstFragmentKind::Arms => AstFragment::Arms(smallvec![
  83             ast::Arm {
  84                 attrs: Default::default(),
  85                 body: expr_placeholder(),
  86                 guard: None,
  87                 id,
  88                 pat: pat(),
  89                 span,
  90                 is_placeholder: true,
  91             }
  92         ]),
  93         AstFragmentKind::Fields => AstFragment::Fields(smallvec![
  94             ast::Field {
  95                 attrs: Default::default(),
  96                 expr: expr_placeholder(),
  97                 id,
  98                 ident,
  99                 is_shorthand: false,
 100                 span,
 101                 is_placeholder: true,
 102             }
 103         ]),
 104         AstFragmentKind::FieldPats => AstFragment::FieldPats(smallvec![
 105             ast::FieldPat {
 106                 attrs: Default::default(),
 107                 id,
 108                 ident,
 109                 is_shorthand: false,
 110                 pat: pat(),
 111                 span,
 112                 is_placeholder: true,
 113             }
 114         ]),
 115         AstFragmentKind::GenericParams => AstFragment::GenericParams(smallvec![{
 116             ast::GenericParam {
 117                 attrs: Default::default(),
 118                 bounds: Default::default(),
 119                 id,
 120                 ident,
 121                 is_placeholder: true,
 122                 kind: ast::GenericParamKind::Lifetime,
 123             }
 124         }]),
 125         AstFragmentKind::Params => AstFragment::Params(smallvec![
 126             ast::Param {
 127                 attrs: Default::default(),
 128                 id,
 129                 pat: pat(),
 130                 span,
 131                 ty: ty(),
 132                 is_placeholder: true,
 133             }
 134         ]),
 135         AstFragmentKind::StructFields => AstFragment::StructFields(smallvec![
 136             ast::StructField {
 137                 attrs: Default::default(),
 138                 id,
 139                 ident: None,
 140                 span,
 141                 ty: ty(),
 142                 vis,
 143                 is_placeholder: true,
 144             }
 145         ]),
 146         AstFragmentKind::Variants => AstFragment::Variants(smallvec![
 147             ast::Variant {
 148                 attrs: Default::default(),
 149                 data: ast::VariantData::Struct(Default::default(), false),
 150                 disr_expr: None,
 151                 id,
 152                 ident,
 153                 span,
 154                 vis,
 155                 is_placeholder: true,
 156             }
 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 {
 170             cx,
 171             expanded_fragments: FxHashMap::default(),
 172             monotonic,
 173         }
 174     }
 175
 176     pub fn add(&mut self, id: ast::NodeId, mut fragment: AstFragment) {
 177         fragment.mut_visit_with(self);
 178         self.expanded_fragments.insert(id, fragment);
 179     }
 180
 181     fn remove(&mut self, id: ast::NodeId) -> AstFragment {
 182         self.expanded_fragments.remove(&id).unwrap()
 183     }
 184 }
 185
 186 impl<'a, 'b> MutVisitor for PlaceholderExpander<'a, 'b> {
 187     fn flat_map_arm(&mut self, arm: ast::Arm) -> SmallVec<[ast::Arm; 1]> {
 188         if arm.is_placeholder {
 189             self.remove(arm.id).make_arms()
 190         } else {
 191             noop_flat_map_arm(arm, self)
 192         }
 193     }
 194
 195     fn flat_map_field(&mut self, field: ast::Field) -> SmallVec<[ast::Field; 1]> {
 196         if field.is_placeholder {
 197             self.remove(field.id).make_fields()
 198         } else {
 199             noop_flat_map_field(field, self)
 200         }
 201     }
 202
 203     fn flat_map_field_pattern(&mut self, fp: ast::FieldPat) -> SmallVec<[ast::FieldPat; 1]> {
 204         if fp.is_placeholder {
 205             self.remove(fp.id).make_field_patterns()
 206         } else {
 207             noop_flat_map_field_pattern(fp, self)
 208         }
 209     }
 210
 211     fn flat_map_generic_param(
 212         &mut self,
 213         param: ast::GenericParam
 214     ) -> SmallVec<[ast::GenericParam; 1]>
 215     {
 216         if param.is_placeholder {
 217             self.remove(param.id).make_generic_params()
 218         } else {
 219             noop_flat_map_generic_param(param, self)
 220         }
 221     }
 222
 223     fn flat_map_param(&mut self, p: ast::Param) -> SmallVec<[ast::Param; 1]> {
 224         if p.is_placeholder {
 225             self.remove(p.id).make_params()
 226         } else {
 227             noop_flat_map_param(p, self)
 228         }
 229     }
 230
 231     fn flat_map_struct_field(&mut self, sf: ast::StructField) -> SmallVec<[ast::StructField; 1]> {
 232         if sf.is_placeholder {
 233             self.remove(sf.id).make_struct_fields()
 234         } else {
 235             noop_flat_map_struct_field(sf, self)
 236         }
 237     }
 238
 239     fn flat_map_variant(&mut self, variant: ast::Variant) -> SmallVec<[ast::Variant; 1]> {
 240         if variant.is_placeholder {
 241             self.remove(variant.id).make_variants()
 242         } else {
 243             noop_flat_map_variant(variant, self)
 244         }
 245     }
 246
 247     fn flat_map_item(&mut self, item: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
 248         match item.kind {
 249             ast::ItemKind::Mac(_) => return self.remove(item.id).make_items(),
 250             ast::ItemKind::MacroDef(_) => return smallvec![item],
 251             _ => {}
 252         }
 253
 254         noop_flat_map_item(item, self)
 255     }
 256
 257     fn flat_map_trait_item(&mut self, item: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> {
 258         match item.kind {
 259             ast::TraitItemKind::Macro(_) => self.remove(item.id).make_trait_items(),
 260             _ => noop_flat_map_trait_item(item, self),
 261         }
 262     }
 263
 264     fn flat_map_impl_item(&mut self, item: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> {
 265         match item.kind {
 266             ast::ImplItemKind::Macro(_) => self.remove(item.id).make_impl_items(),
 267             _ => noop_flat_map_impl_item(item, self),
 268         }
 269     }
 270
 271     fn flat_map_foreign_item(&mut self, item: ast::ForeignItem) -> SmallVec<[ast::ForeignItem; 1]> {
 272         match item.kind {
 273             ast::ForeignItemKind::Macro(_) => 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::Mac(_) => *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::Mac(_) => 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::Mac(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::Mac(_) => *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::Mac(_) => *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::Mac(_) if !self.cx.ecfg.keep_macs => false, // remove macro definitions
 336             _ => true,
 337         });
 338     }
 339
 340     fn visit_mac(&mut self, _mac: &mut ast::Mac) {
 341         // Do nothing.
 342     }
 343 }