compiler/rustc_builtin_macros/src/deriving/encodable.rs

   1 //! The compiler code necessary to implement the `#[derive(RustcEncodable)]`
   2 //! (and `RustcDecodable`, in `decodable.rs`) extension. The idea here is that
   3 //! type-defining items may be tagged with
   4 //! `#[derive(RustcEncodable, RustcDecodable)]`.
   5 //!
   6 //! For example, a type like:
   7 //!
   8 //! ```ignore (old code)
   9 //! #[derive(RustcEncodable, RustcDecodable)]
  10 //! struct Node { id: usize }
  11 //! ```
  12 //!
  13 //! would generate two implementations like:
  14 //!
  15 //! ```ignore (old code)
  16 //! # struct Node { id: usize }
  17 //! impl<S: Encoder<E>, E> Encodable<S, E> for Node {
  18 //!     fn encode(&self, s: &mut S) -> Result<(), E> {
  19 //!         s.emit_struct("Node", 1, |this| {
  20 //!             this.emit_struct_field("id", 0, |this| {
  21 //!                 Encodable::encode(&self.id, this)
  22 //!                 /* this.emit_usize(self.id) can also be used */
  23 //!             })
  24 //!         })
  25 //!     }
  26 //! }
  27 //!
  28 //! impl<D: Decoder<E>, E> Decodable<D, E> for Node {
  29 //!     fn decode(d: &mut D) -> Result<Node, E> {
  30 //!         d.read_struct("Node", 1, |this| {
  31 //!             match this.read_struct_field("id", 0, |this| Decodable::decode(this)) {
  32 //!                 Ok(id) => Ok(Node { id: id }),
  33 //!                 Err(e) => Err(e),
  34 //!             }
  35 //!         })
  36 //!     }
  37 //! }
  38 //! ```
  39 //!
  40 //! Other interesting scenarios are when the item has type parameters or
  41 //! references other non-built-in types. A type definition like:
  42 //!
  43 //! ```ignore (old code)
  44 //! # #[derive(RustcEncodable, RustcDecodable)]
  45 //! # struct Span;
  46 //! #[derive(RustcEncodable, RustcDecodable)]
  47 //! struct Spanned<T> { node: T, span: Span }
  48 //! ```
  49 //!
  50 //! would yield functions like:
  51 //!
  52 //! ```ignore (old code)
  53 //! # #[derive(RustcEncodable, RustcDecodable)]
  54 //! # struct Span;
  55 //! # struct Spanned<T> { node: T, span: Span }
  56 //! impl<
  57 //!     S: Encoder<E>,
  58 //!     E,
  59 //!     T: Encodable<S, E>
  60 //! > Encodable<S, E> for Spanned<T> {
  61 //!     fn encode(&self, s: &mut S) -> Result<(), E> {
  62 //!         s.emit_struct("Spanned", 2, |this| {
  63 //!             this.emit_struct_field("node", 0, |this| self.node.encode(this))
  64 //!                 .unwrap();
  65 //!             this.emit_struct_field("span", 1, |this| self.span.encode(this))
  66 //!         })
  67 //!     }
  68 //! }
  69 //!
  70 //! impl<
  71 //!     D: Decoder<E>,
  72 //!     E,
  73 //!     T: Decodable<D, E>
  74 //! > Decodable<D, E> for Spanned<T> {
  75 //!     fn decode(d: &mut D) -> Result<Spanned<T>, E> {
  76 //!         d.read_struct("Spanned", 2, |this| {
  77 //!             Ok(Spanned {
  78 //!                 node: this.read_struct_field("node", 0, |this| Decodable::decode(this))
  79 //!                     .unwrap(),
  80 //!                 span: this.read_struct_field("span", 1, |this| Decodable::decode(this))
  81 //!                     .unwrap(),
  82 //!             })
  83 //!         })
  84 //!     }
  85 //! }
  86 //! ```
  87
  88 use crate::deriving::generic::ty::*;
  89 use crate::deriving::generic::*;
  90 use crate::deriving::pathvec_std;
  91
  92 use rustc_ast::ptr::P;
  93 use rustc_ast::{Expr, ExprKind, MetaItem, Mutability};
  94 use rustc_expand::base::{Annotatable, ExtCtxt};
  95 use rustc_span::symbol::{sym, Ident, Symbol};
  96 use rustc_span::Span;
  97
  98 pub fn expand_deriving_rustc_encodable(
  99     cx: &mut ExtCtxt<'_>,
 100     span: Span,
 101     mitem: &MetaItem,
 102     item: &Annotatable,
 103     push: &mut dyn FnMut(Annotatable),
 104 ) {
 105     let krate = sym::rustc_serialize;
 106     let typaram = sym::__S;
 107
 108     let trait_def = TraitDef {
 109         span,
 110         attributes: Vec::new(),
 111         path: Path::new_(vec![krate, sym::Encodable], None, vec![], PathKind::Global),
 112         additional_bounds: Vec::new(),
 113         generics: Bounds::empty(),
 114         is_unsafe: false,
 115         supports_unions: false,
 116         methods: vec![MethodDef {
 117             name: sym::encode,
 118             generics: Bounds {
 119                 bounds: vec![(
 120                     typaram,
 121                     vec![Path::new_(vec![krate, sym::Encoder], None, vec![], PathKind::Global)],
 122                 )],
 123             },
 124             explicit_self: borrowed_explicit_self(),
 125             args: vec![(
 126                 Ptr(Box::new(Literal(Path::new_local(typaram))), Borrowed(None, Mutability::Mut)),
 127                 sym::s,
 128             )],
 129             ret_ty: Literal(Path::new_(
 130                 pathvec_std!(result::Result),
 131                 None,
 132                 vec![
 133                     Box::new(Tuple(Vec::new())),
 134                     Box::new(Literal(Path::new_(
 135                         vec![typaram, sym::Error],
 136                         None,
 137                         vec![],
 138                         PathKind::Local,
 139                     ))),
 140                 ],
 141                 PathKind::Std,
 142             )),
 143             attributes: Vec::new(),
 144             is_unsafe: false,
 145             unify_fieldless_variants: false,
 146             combine_substructure: combine_substructure(Box::new(|a, b, c| {
 147                 encodable_substructure(a, b, c, krate)
 148             })),
 149         }],
 150         associated_types: Vec::new(),
 151     };
 152
 153     trait_def.expand(cx, mitem, item, push)
 154 }
 155
 156 fn encodable_substructure(
 157     cx: &mut ExtCtxt<'_>,
 158     trait_span: Span,
 159     substr: &Substructure<'_>,
 160     krate: Symbol,
 161 ) -> P<Expr> {
 162     let encoder = substr.nonself_args[0].clone();
 163     // throw an underscore in front to suppress unused variable warnings
 164     let blkarg = Ident::new(sym::_e, trait_span);
 165     let blkencoder = cx.expr_ident(trait_span, blkarg);
 166     let fn_path = cx.expr_path(cx.path_global(
 167         trait_span,
 168         vec![
 169             Ident::new(krate, trait_span),
 170             Ident::new(sym::Encodable, trait_span),
 171             Ident::new(sym::encode, trait_span),
 172         ],
 173     ));
 174
 175     match *substr.fields {
 176         Struct(_, ref fields) => {
 177             let fn_emit_struct_field_path =
 178                 cx.def_site_path(&[sym::rustc_serialize, sym::Encoder, sym::emit_struct_field]);
 179             let mut stmts = Vec::new();
 180             for (i, &FieldInfo { name, ref self_, span, .. }) in fields.iter().enumerate() {
 181                 let name = match name {
 182                     Some(id) => id.name,
 183                     None => Symbol::intern(&format!("_field{}", i)),
 184                 };
 185                 let self_ref = cx.expr_addr_of(span, self_.clone());
 186                 let enc = cx.expr_call(span, fn_path.clone(), vec![self_ref, blkencoder.clone()]);
 187                 let lambda = cx.lambda1(span, enc, blkarg);
 188                 let call = cx.expr_call_global(
 189                     span,
 190                     fn_emit_struct_field_path.clone(),
 191                     vec![
 192                         blkencoder.clone(),
 193                         cx.expr_str(span, name),
 194                         cx.expr_usize(span, i),
 195                         lambda,
 196                     ],
 197                 );
 198
 199                 // last call doesn't need a try!
 200                 let last = fields.len() - 1;
 201                 let call = if i != last {
 202                     cx.expr_try(span, call)
 203                 } else {
 204                     cx.expr(span, ExprKind::Ret(Some(call)))
 205                 };
 206
 207                 let stmt = cx.stmt_expr(call);
 208                 stmts.push(stmt);
 209             }
 210
 211             // unit structs have no fields and need to return Ok()
 212             let blk = if stmts.is_empty() {
 213                 let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, vec![]));
 214                 cx.lambda1(trait_span, ok, blkarg)
 215             } else {
 216                 cx.lambda_stmts_1(trait_span, stmts, blkarg)
 217             };
 218
 219             let fn_emit_struct_path =
 220                 cx.def_site_path(&[sym::rustc_serialize, sym::Encoder, sym::emit_struct]);
 221
 222             cx.expr_call_global(
 223                 trait_span,
 224                 fn_emit_struct_path,
 225                 vec![
 226                     encoder,
 227                     cx.expr_str(trait_span, substr.type_ident.name),
 228                     cx.expr_usize(trait_span, fields.len()),
 229                     blk,
 230                 ],
 231             )
 232         }
 233
 234         EnumMatching(idx, _, variant, ref fields) => {
 235             // We're not generating an AST that the borrow checker is expecting,
 236             // so we need to generate a unique local variable to take the
 237             // mutable loan out on, otherwise we get conflicts which don't
 238             // actually exist.
 239             let me = cx.stmt_let(trait_span, false, blkarg, encoder);
 240             let encoder = cx.expr_ident(trait_span, blkarg);
 241
 242             let fn_emit_enum_variant_arg_path: Vec<_> =
 243                 cx.def_site_path(&[sym::rustc_serialize, sym::Encoder, sym::emit_enum_variant_arg]);
 244
 245             let mut stmts = Vec::new();
 246             if !fields.is_empty() {
 247                 let last = fields.len() - 1;
 248                 for (i, &FieldInfo { ref self_, span, .. }) in fields.iter().enumerate() {
 249                     let self_ref = cx.expr_addr_of(span, self_.clone());
 250                     let enc =
 251                         cx.expr_call(span, fn_path.clone(), vec![self_ref, blkencoder.clone()]);
 252                     let lambda = cx.lambda1(span, enc, blkarg);
 253
 254                     let call = cx.expr_call_global(
 255                         span,
 256                         fn_emit_enum_variant_arg_path.clone(),
 257                         vec![blkencoder.clone(), cx.expr_usize(span, i), lambda],
 258                     );
 259                     let call = if i != last {
 260                         cx.expr_try(span, call)
 261                     } else {
 262                         cx.expr(span, ExprKind::Ret(Some(call)))
 263                     };
 264                     stmts.push(cx.stmt_expr(call));
 265                 }
 266             } else {
 267                 let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, vec![]));
 268                 let ret_ok = cx.expr(trait_span, ExprKind::Ret(Some(ok)));
 269                 stmts.push(cx.stmt_expr(ret_ok));
 270             }
 271
 272             let blk = cx.lambda_stmts_1(trait_span, stmts, blkarg);
 273             let name = cx.expr_str(trait_span, variant.ident.name);
 274
 275             let fn_emit_enum_variant_path: Vec<_> =
 276                 cx.def_site_path(&[sym::rustc_serialize, sym::Encoder, sym::emit_enum_variant]);
 277
 278             let call = cx.expr_call_global(
 279                 trait_span,
 280                 fn_emit_enum_variant_path,
 281                 vec![
 282                     blkencoder,
 283                     name,
 284                     cx.expr_usize(trait_span, idx),
 285                     cx.expr_usize(trait_span, fields.len()),
 286                     blk,
 287                 ],
 288             );
 289
 290             let blk = cx.lambda1(trait_span, call, blkarg);
 291             let fn_emit_enum_path: Vec<_> =
 292                 cx.def_site_path(&[sym::rustc_serialize, sym::Encoder, sym::emit_enum]);
 293             let ret = cx.expr_call_global(
 294                 trait_span,
 295                 fn_emit_enum_path,
 296                 vec![encoder, cx.expr_str(trait_span, substr.type_ident.name), blk],
 297             );
 298             cx.expr_block(cx.block(trait_span, vec![me, cx.stmt_expr(ret)]))
 299         }
 300
 301         _ => cx.bug("expected Struct or EnumMatching in derive(Encodable)"),
 302     }
 303 }