src/libsyntax_ext/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 //! ```
   9 //! #[derive(RustcEncodable, RustcDecodable)]
  10 //! struct Node { id: usize }
  11 //! ```
  12 //!
  13 //! would generate two implementations like:
  14 //!
  15 //! ```
  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 //! ```
  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 //! ```
  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::pathvec_std;
  89 use crate::deriving::generic::*;
  90 use crate::deriving::generic::ty::*;
  91
  92 use syntax::ast::{Expr, ExprKind, MetaItem, Mutability};
  93 use syntax_expand::base::{Annotatable, ExtCtxt};
  94 use syntax::ptr::P;
  95 use syntax::symbol::Symbol;
  96 use syntax_pos::Span;
  97
  98 pub fn expand_deriving_rustc_encodable(cx: &mut ExtCtxt<'_>,
  99                                        span: Span,
 100                                        mitem: &MetaItem,
 101                                        item: &Annotatable,
 102                                        push: &mut dyn FnMut(Annotatable)) {
 103     let krate = "rustc_serialize";
 104     let typaram = "__S";
 105
 106     let trait_def = TraitDef {
 107         span,
 108         attributes: Vec::new(),
 109         path: Path::new_(vec![krate, "Encodable"], None, vec![], PathKind::Global),
 110         additional_bounds: Vec::new(),
 111         generics: LifetimeBounds::empty(),
 112         is_unsafe: false,
 113         supports_unions: false,
 114         methods: vec![
 115             MethodDef {
 116                 name: "encode",
 117                 generics: LifetimeBounds {
 118                     lifetimes: Vec::new(),
 119                     bounds: vec![
 120                         (typaram,
 121                          vec![Path::new_(vec![krate, "Encoder"], None, vec![], PathKind::Global)])
 122                     ],
 123                 },
 124                 explicit_self: borrowed_explicit_self(),
 125                 args: vec![(Ptr(Box::new(Literal(Path::new_local(typaram))),
 126                            Borrowed(None, Mutability::Mutable)), "s")],
 127                 ret_ty: Literal(Path::new_(
 128                     pathvec_std!(cx, result::Result),
 129                     None,
 130                     vec![Box::new(Tuple(Vec::new())), Box::new(Literal(Path::new_(
 131                         vec![typaram, "Error"], None, vec![], PathKind::Local
 132                     )))],
 133                     PathKind::Std
 134                 )),
 135                 attributes: Vec::new(),
 136                 is_unsafe: false,
 137                 unify_fieldless_variants: false,
 138                 combine_substructure: combine_substructure(Box::new(|a, b, c| {
 139                     encodable_substructure(a, b, c, krate)
 140                 })),
 141             }
 142         ],
 143         associated_types: Vec::new(),
 144     };
 145
 146     trait_def.expand(cx, mitem, item, push)
 147 }
 148
 149 fn encodable_substructure(cx: &mut ExtCtxt<'_>,
 150                           trait_span: Span,
 151                           substr: &Substructure<'_>,
 152                           krate: &'static str)
 153                           -> P<Expr> {
 154     let encoder = substr.nonself_args[0].clone();
 155     // throw an underscore in front to suppress unused variable warnings
 156     let blkarg = cx.ident_of("_e", trait_span);
 157     let blkencoder = cx.expr_ident(trait_span, blkarg);
 158     let fn_path = cx.expr_path(cx.path_global(trait_span,
 159                                               vec![cx.ident_of(krate, trait_span),
 160                                                    cx.ident_of("Encodable", trait_span),
 161                                                    cx.ident_of("encode", trait_span)]));
 162
 163     return match *substr.fields {
 164         Struct(_, ref fields) => {
 165             let emit_struct_field = cx.ident_of("emit_struct_field", trait_span);
 166             let mut stmts = Vec::new();
 167             for (i, &FieldInfo { name, ref self_, span, .. }) in fields.iter().enumerate() {
 168                 let name = match name {
 169                     Some(id) => id.name,
 170                     None => Symbol::intern(&format!("_field{}", i)),
 171                 };
 172                 let self_ref = cx.expr_addr_of(span, self_.clone());
 173                 let enc = cx.expr_call(span, fn_path.clone(), vec![self_ref, blkencoder.clone()]);
 174                 let lambda = cx.lambda1(span, enc, blkarg);
 175                 let call = cx.expr_method_call(span,
 176                                                blkencoder.clone(),
 177                                                emit_struct_field,
 178                                                vec![cx.expr_str(span, name),
 179                                                     cx.expr_usize(span, i),
 180                                                     lambda]);
 181
 182                 // last call doesn't need a try!
 183                 let last = fields.len() - 1;
 184                 let call = if i != last {
 185                     cx.expr_try(span, call)
 186                 } else {
 187                     cx.expr(span, ExprKind::Ret(Some(call)))
 188                 };
 189
 190                 let stmt = cx.stmt_expr(call);
 191                 stmts.push(stmt);
 192             }
 193
 194             // unit structs have no fields and need to return Ok()
 195             let blk = if stmts.is_empty() {
 196                 let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, vec![]));
 197                 cx.lambda1(trait_span, ok, blkarg)
 198             } else {
 199                 cx.lambda_stmts_1(trait_span, stmts, blkarg)
 200             };
 201
 202             cx.expr_method_call(trait_span,
 203                                 encoder,
 204                                 cx.ident_of("emit_struct", trait_span),
 205                                 vec![cx.expr_str(trait_span, substr.type_ident.name),
 206                                      cx.expr_usize(trait_span, fields.len()),
 207                                      blk])
 208         }
 209
 210         EnumMatching(idx, _, variant, ref fields) => {
 211             // We're not generating an AST that the borrow checker is expecting,
 212             // so we need to generate a unique local variable to take the
 213             // mutable loan out on, otherwise we get conflicts which don't
 214             // actually exist.
 215             let me = cx.stmt_let(trait_span, false, blkarg, encoder);
 216             let encoder = cx.expr_ident(trait_span, blkarg);
 217             let emit_variant_arg = cx.ident_of("emit_enum_variant_arg", trait_span);
 218             let mut stmts = Vec::new();
 219             if !fields.is_empty() {
 220                 let last = fields.len() - 1;
 221                 for (i, &FieldInfo { ref self_, span, .. }) in fields.iter().enumerate() {
 222                     let self_ref = cx.expr_addr_of(span, self_.clone());
 223                     let enc =
 224                         cx.expr_call(span, fn_path.clone(), vec![self_ref, blkencoder.clone()]);
 225                     let lambda = cx.lambda1(span, enc, blkarg);
 226                     let call = cx.expr_method_call(span,
 227                                                    blkencoder.clone(),
 228                                                    emit_variant_arg,
 229                                                    vec![cx.expr_usize(span, i), lambda]);
 230                     let call = if i != last {
 231                         cx.expr_try(span, call)
 232                     } else {
 233                         cx.expr(span, ExprKind::Ret(Some(call)))
 234                     };
 235                     stmts.push(cx.stmt_expr(call));
 236                 }
 237             } else {
 238                 let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, vec![]));
 239                 let ret_ok = cx.expr(trait_span, ExprKind::Ret(Some(ok)));
 240                 stmts.push(cx.stmt_expr(ret_ok));
 241             }
 242
 243             let blk = cx.lambda_stmts_1(trait_span, stmts, blkarg);
 244             let name = cx.expr_str(trait_span, variant.ident.name);
 245             let call = cx.expr_method_call(trait_span,
 246                                            blkencoder,
 247                                            cx.ident_of("emit_enum_variant", trait_span),
 248                                            vec![name,
 249                                                 cx.expr_usize(trait_span, idx),
 250                                                 cx.expr_usize(trait_span, fields.len()),
 251                                                 blk]);
 252             let blk = cx.lambda1(trait_span, call, blkarg);
 253             let ret = cx.expr_method_call(trait_span,
 254                                           encoder,
 255                                           cx.ident_of("emit_enum", trait_span),
 256                                           vec![cx.expr_str(trait_span ,substr.type_ident.name),
 257                                                blk]);
 258             cx.expr_block(cx.block(trait_span, vec![me, cx.stmt_expr(ret)]))
 259         }
 260
 261         _ => cx.bug("expected Struct or EnumMatching in derive(Encodable)"),
 262     };
 263 }