src/libsyntax_ext/deriving/mod.rs

   1 //! The compiler code necessary to implement the `#[derive]` extensions.
   2
   3 use syntax::ast::{self, MetaItem};
   4 use syntax::ext::base::{Annotatable, ExtCtxt, MultiItemModifier};
   5 use syntax::ext::build::AstBuilder;
   6 use syntax::ptr::P;
   7 use syntax::symbol::{Symbol, sym};
   8 use syntax_pos::Span;
   9
  10 macro path_local($x:ident) {
  11     generic::ty::Path::new_local(stringify!($x))
  12 }
  13
  14 macro pathvec_std($cx:expr, $($rest:ident)::+) {{
  15     vec![ $( stringify!($rest) ),+ ]
  16 }}
  17
  18 macro path_std($($x:tt)*) {
  19     generic::ty::Path::new( pathvec_std!( $($x)* ) )
  20 }
  21
  22 pub mod bounds;
  23 pub mod clone;
  24 pub mod encodable;
  25 pub mod decodable;
  26 pub mod hash;
  27 pub mod debug;
  28 pub mod default;
  29 pub mod custom;
  30
  31 #[path="cmp/partial_eq.rs"]
  32 pub mod partial_eq;
  33 #[path="cmp/eq.rs"]
  34 pub mod eq;
  35 #[path="cmp/partial_ord.rs"]
  36 pub mod partial_ord;
  37 #[path="cmp/ord.rs"]
  38 pub mod ord;
  39
  40 pub mod generic;
  41
  42 crate struct BuiltinDerive(
  43     crate fn(&mut ExtCtxt<'_>, Span, &MetaItem, &Annotatable, &mut dyn FnMut(Annotatable))
  44 );
  45
  46 impl MultiItemModifier for BuiltinDerive {
  47     fn expand(&self,
  48               ecx: &mut ExtCtxt<'_>,
  49               span: Span,
  50               meta_item: &MetaItem,
  51               item: Annotatable)
  52               -> Vec<Annotatable> {
  53         let mut items = Vec::new();
  54         (self.0)(ecx, span, meta_item, &item, &mut |a| items.push(a));
  55         items
  56     }
  57 }
  58
  59 /// Construct a name for the inner type parameter that can't collide with any type parameters of
  60 /// the item. This is achieved by starting with a base and then concatenating the names of all
  61 /// other type parameters.
  62 // FIXME(aburka): use real hygiene when that becomes possible
  63 fn hygienic_type_parameter(item: &Annotatable, base: &str) -> String {
  64     let mut typaram = String::from(base);
  65     if let Annotatable::Item(ref item) = *item {
  66         match item.node {
  67             ast::ItemKind::Struct(_, ast::Generics { ref params, .. }) |
  68             ast::ItemKind::Enum(_, ast::Generics { ref params, .. }) => {
  69                 for param in params {
  70                     match param.kind {
  71                         ast::GenericParamKind::Type { .. } => {
  72                             typaram.push_str(&param.ident.as_str());
  73                         }
  74                         _ => {}
  75                     }
  76                 }
  77             }
  78
  79             _ => {}
  80         }
  81     }
  82
  83     typaram
  84 }
  85
  86 /// Constructs an expression that calls an intrinsic
  87 fn call_intrinsic(cx: &ExtCtxt<'_>,
  88                   span: Span,
  89                   intrinsic: &str,
  90                   args: Vec<P<ast::Expr>>)
  91                   -> P<ast::Expr> {
  92     let span = span.with_ctxt(cx.backtrace());
  93     let path = cx.std_path(&[sym::intrinsics, Symbol::intern(intrinsic)]);
  94     let call = cx.expr_call_global(span, path, args);
  95
  96     cx.expr_block(P(ast::Block {
  97         stmts: vec![cx.stmt_expr(call)],
  98         id: ast::DUMMY_NODE_ID,
  99         rules: ast::BlockCheckMode::Unsafe(ast::CompilerGenerated),
 100         span,
 101     }))
 102 }