]>
Commit | Line | Data |
---|---|---|
970d7e83 LB |
1 | // Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT |
2 | // file at the top-level directory of this distribution and at | |
3 | // http://rust-lang.org/COPYRIGHT. | |
4 | // | |
5 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or | |
6 | // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
7 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your | |
8 | // option. This file may not be copied, modified, or distributed | |
9 | // except according to those terms. | |
10 | ||
1a4d82fc | 11 | //! The compiler code necessary for `#[derive(Decodable)]`. See encodable.rs for more. |
970d7e83 | 12 | |
1a4d82fc | 13 | use ast; |
d9579d0f | 14 | use ast::{MetaItem, Expr, MutMutable}; |
1a4d82fc | 15 | use codemap::Span; |
d9579d0f | 16 | use ext::base::{ExtCtxt, Annotatable}; |
970d7e83 LB |
17 | use ext::build::AstBuilder; |
18 | use ext::deriving::generic::*; | |
1a4d82fc JJ |
19 | use ext::deriving::generic::ty::*; |
20 | use parse::token::InternedString; | |
21 | use parse::token; | |
22 | use ptr::P; | |
23 | ||
d9579d0f AL |
24 | pub fn expand_deriving_rustc_decodable(cx: &mut ExtCtxt, |
25 | span: Span, | |
26 | mitem: &MetaItem, | |
27 | item: Annotatable, | |
28 | push: &mut FnMut(Annotatable)) | |
1a4d82fc JJ |
29 | { |
30 | expand_deriving_decodable_imp(cx, span, mitem, item, push, "rustc_serialize") | |
31 | } | |
32 | ||
d9579d0f AL |
33 | pub fn expand_deriving_decodable(cx: &mut ExtCtxt, |
34 | span: Span, | |
35 | mitem: &MetaItem, | |
36 | item: Annotatable, | |
37 | push: &mut FnMut(Annotatable)) | |
1a4d82fc JJ |
38 | { |
39 | expand_deriving_decodable_imp(cx, span, mitem, item, push, "serialize") | |
40 | } | |
970d7e83 | 41 | |
d9579d0f AL |
42 | fn expand_deriving_decodable_imp(cx: &mut ExtCtxt, |
43 | span: Span, | |
44 | mitem: &MetaItem, | |
45 | item: Annotatable, | |
46 | push: &mut FnMut(Annotatable), | |
47 | krate: &'static str) | |
1a4d82fc | 48 | { |
85aaf69f SL |
49 | if !cx.use_std { |
50 | // FIXME(#21880): lift this requirement. | |
51 | cx.span_err(span, "this trait cannot be derived with #![no_std]"); | |
52 | return; | |
53 | } | |
54 | ||
970d7e83 | 55 | let trait_def = TraitDef { |
1a4d82fc JJ |
56 | span: span, |
57 | attributes: Vec::new(), | |
58 | path: Path::new_(vec!(krate, "Decodable"), None, vec!(), true), | |
59 | additional_bounds: Vec::new(), | |
60 | generics: LifetimeBounds::empty(), | |
61 | methods: vec!( | |
970d7e83 LB |
62 | MethodDef { |
63 | name: "decode", | |
1a4d82fc JJ |
64 | generics: LifetimeBounds { |
65 | lifetimes: Vec::new(), | |
66 | bounds: vec!(("__D", vec!(Path::new_( | |
67 | vec!(krate, "Decoder"), None, | |
68 | vec!(), true)))) | |
69 | }, | |
970d7e83 | 70 | explicit_self: None, |
d9579d0f | 71 | args: vec!(Ptr(Box::new(Literal(Path::new_local("__D"))), |
1a4d82fc JJ |
72 | Borrowed(None, MutMutable))), |
73 | ret_ty: Literal(Path::new_( | |
85aaf69f | 74 | pathvec_std!(cx, core::result::Result), |
1a4d82fc | 75 | None, |
d9579d0f | 76 | vec!(Box::new(Self_), Box::new(Literal(Path::new_( |
1a4d82fc | 77 | vec!["__D", "Error"], None, vec![], false |
d9579d0f | 78 | )))), |
1a4d82fc JJ |
79 | true |
80 | )), | |
81 | attributes: Vec::new(), | |
c34b1796 | 82 | combine_substructure: combine_substructure(Box::new(|a, b, c| { |
1a4d82fc | 83 | decodable_substructure(a, b, c, krate) |
c34b1796 | 84 | })), |
85aaf69f SL |
85 | } |
86 | ), | |
87 | associated_types: Vec::new(), | |
970d7e83 LB |
88 | }; |
89 | ||
d9579d0f | 90 | trait_def.expand(cx, mitem, &item, push) |
970d7e83 LB |
91 | } |
92 | ||
1a4d82fc JJ |
93 | fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span, |
94 | substr: &Substructure, | |
95 | krate: &str) -> P<Expr> { | |
96 | let decoder = substr.nonself_args[0].clone(); | |
97 | let recurse = vec!(cx.ident_of(krate), | |
970d7e83 | 98 | cx.ident_of("Decodable"), |
1a4d82fc | 99 | cx.ident_of("decode")); |
85aaf69f | 100 | let exprdecode = cx.expr_path(cx.path_global(trait_span, recurse)); |
970d7e83 LB |
101 | // throw an underscore in front to suppress unused variable warnings |
102 | let blkarg = cx.ident_of("_d"); | |
1a4d82fc | 103 | let blkdecoder = cx.expr_ident(trait_span, blkarg); |
970d7e83 LB |
104 | |
105 | return match *substr.fields { | |
106 | StaticStruct(_, ref summary) => { | |
107 | let nfields = match *summary { | |
1a4d82fc JJ |
108 | Unnamed(ref fields) => fields.len(), |
109 | Named(ref fields) => fields.len() | |
970d7e83 LB |
110 | }; |
111 | let read_struct_field = cx.ident_of("read_struct_field"); | |
112 | ||
1a4d82fc JJ |
113 | let path = cx.path_ident(trait_span, substr.type_ident); |
114 | let result = decode_static_fields(cx, | |
115 | trait_span, | |
116 | path, | |
117 | summary, | |
118 | |cx, span, name, field| { | |
119 | cx.expr_try(span, | |
120 | cx.expr_method_call(span, blkdecoder.clone(), read_struct_field, | |
121 | vec!(cx.expr_str(span, name), | |
85aaf69f SL |
122 | cx.expr_usize(span, field), |
123 | exprdecode.clone()))) | |
1a4d82fc JJ |
124 | }); |
125 | let result = cx.expr_ok(trait_span, result); | |
126 | cx.expr_method_call(trait_span, | |
127 | decoder, | |
128 | cx.ident_of("read_struct"), | |
129 | vec!( | |
130 | cx.expr_str(trait_span, token::get_ident(substr.type_ident)), | |
85aaf69f | 131 | cx.expr_usize(trait_span, nfields), |
1a4d82fc JJ |
132 | cx.lambda_expr_1(trait_span, result, blkarg) |
133 | )) | |
970d7e83 LB |
134 | } |
135 | StaticEnum(_, ref fields) => { | |
136 | let variant = cx.ident_of("i"); | |
137 | ||
1a4d82fc JJ |
138 | let mut arms = Vec::new(); |
139 | let mut variants = Vec::new(); | |
970d7e83 LB |
140 | let rvariant_arg = cx.ident_of("read_enum_variant_arg"); |
141 | ||
1a4d82fc JJ |
142 | for (i, &(name, v_span, ref parts)) in fields.iter().enumerate() { |
143 | variants.push(cx.expr_str(v_span, token::get_ident(name))); | |
144 | ||
145 | let path = cx.path(trait_span, vec![substr.type_ident, name]); | |
146 | let decoded = decode_static_fields(cx, | |
147 | v_span, | |
148 | path, | |
149 | parts, | |
150 | |cx, span, _, field| { | |
85aaf69f | 151 | let idx = cx.expr_usize(span, field); |
1a4d82fc JJ |
152 | cx.expr_try(span, |
153 | cx.expr_method_call(span, blkdecoder.clone(), rvariant_arg, | |
85aaf69f | 154 | vec!(idx, exprdecode.clone()))) |
1a4d82fc JJ |
155 | }); |
156 | ||
157 | arms.push(cx.arm(v_span, | |
85aaf69f | 158 | vec!(cx.pat_lit(v_span, cx.expr_usize(v_span, i))), |
970d7e83 LB |
159 | decoded)); |
160 | } | |
161 | ||
1a4d82fc | 162 | arms.push(cx.arm_unreachable(trait_span)); |
970d7e83 | 163 | |
1a4d82fc JJ |
164 | let result = cx.expr_ok(trait_span, |
165 | cx.expr_match(trait_span, | |
166 | cx.expr_ident(trait_span, variant), arms)); | |
167 | let lambda = cx.lambda_expr(trait_span, vec!(blkarg, variant), result); | |
168 | let variant_vec = cx.expr_vec(trait_span, variants); | |
169 | let variant_vec = cx.expr_addr_of(trait_span, variant_vec); | |
170 | let result = cx.expr_method_call(trait_span, blkdecoder, | |
970d7e83 | 171 | cx.ident_of("read_enum_variant"), |
1a4d82fc JJ |
172 | vec!(variant_vec, lambda)); |
173 | cx.expr_method_call(trait_span, | |
174 | decoder, | |
175 | cx.ident_of("read_enum"), | |
176 | vec!( | |
177 | cx.expr_str(trait_span, token::get_ident(substr.type_ident)), | |
178 | cx.lambda_expr_1(trait_span, result, blkarg) | |
179 | )) | |
970d7e83 | 180 | } |
85aaf69f | 181 | _ => cx.bug("expected StaticEnum or StaticStruct in derive(Decodable)") |
970d7e83 LB |
182 | }; |
183 | } | |
1a4d82fc JJ |
184 | |
185 | /// Create a decoder for a single enum variant/struct: | |
186 | /// - `outer_pat_path` is the path to this enum variant/struct | |
85aaf69f | 187 | /// - `getarg` should retrieve the `usize`-th field with name `@str`. |
1a4d82fc JJ |
188 | fn decode_static_fields<F>(cx: &mut ExtCtxt, |
189 | trait_span: Span, | |
190 | outer_pat_path: ast::Path, | |
191 | fields: &StaticFields, | |
192 | mut getarg: F) | |
193 | -> P<Expr> where | |
85aaf69f | 194 | F: FnMut(&mut ExtCtxt, Span, InternedString, usize) -> P<Expr>, |
1a4d82fc JJ |
195 | { |
196 | match *fields { | |
197 | Unnamed(ref fields) => { | |
198 | let path_expr = cx.expr_path(outer_pat_path); | |
199 | if fields.is_empty() { | |
200 | path_expr | |
201 | } else { | |
202 | let fields = fields.iter().enumerate().map(|(i, &span)| { | |
203 | getarg(cx, span, | |
c34b1796 | 204 | token::intern_and_get_ident(&format!("_field{}", i)), |
1a4d82fc JJ |
205 | i) |
206 | }).collect(); | |
207 | ||
208 | cx.expr_call(trait_span, path_expr, fields) | |
209 | } | |
210 | } | |
211 | Named(ref fields) => { | |
212 | // use the field's span to get nicer error messages. | |
213 | let fields = fields.iter().enumerate().map(|(i, &(name, span))| { | |
214 | let arg = getarg(cx, span, token::get_ident(name), i); | |
215 | cx.field_imm(span, name, arg) | |
216 | }).collect(); | |
217 | cx.expr_struct(trait_span, outer_pat_path, fields) | |
218 | } | |
219 | } | |
220 | } |