src/libsyntax/ext/placeholders.rs

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