]>
Commit | Line | Data |
---|---|---|
dfeec247 XL |
1 | //! The compiler code necessary for `#[derive(RustcDecodable)]`. See encodable.rs for more. |
2 | ||
3 | use crate::deriving::generic::ty::*; | |
4 | use crate::deriving::generic::*; | |
5 | use crate::deriving::pathvec_std; | |
6 | ||
74b04a01 | 7 | use rustc_ast::ptr::P; |
3dfed10e | 8 | use rustc_ast::{self as ast, Expr, MetaItem, Mutability}; |
dfeec247 | 9 | use rustc_expand::base::{Annotatable, ExtCtxt}; |
3dfed10e | 10 | use rustc_span::symbol::{sym, Ident, Symbol}; |
dfeec247 | 11 | use rustc_span::Span; |
dfeec247 XL |
12 | |
13 | pub fn expand_deriving_rustc_decodable( | |
14 | cx: &mut ExtCtxt<'_>, | |
15 | span: Span, | |
16 | mitem: &MetaItem, | |
17 | item: &Annotatable, | |
18 | push: &mut dyn FnMut(Annotatable), | |
19 | ) { | |
3dfed10e XL |
20 | let krate = sym::rustc_serialize; |
21 | let typaram = sym::__D; | |
dfeec247 XL |
22 | |
23 | let trait_def = TraitDef { | |
24 | span, | |
064997fb | 25 | path: Path::new_(vec![krate, sym::Decodable], vec![], PathKind::Global), |
dfeec247 | 26 | additional_bounds: Vec::new(), |
3dfed10e | 27 | generics: Bounds::empty(), |
dfeec247 XL |
28 | supports_unions: false, |
29 | methods: vec![MethodDef { | |
3dfed10e XL |
30 | name: sym::decode, |
31 | generics: Bounds { | |
dfeec247 XL |
32 | bounds: vec![( |
33 | typaram, | |
064997fb | 34 | vec![Path::new_(vec![krate, sym::Decoder], vec![], PathKind::Global)], |
dfeec247 XL |
35 | )], |
36 | }, | |
064997fb FG |
37 | explicit_self: false, |
38 | nonself_args: vec![( | |
39 | Ref(Box::new(Path(Path::new_local(typaram))), Mutability::Mut), | |
3dfed10e | 40 | sym::d, |
dfeec247 | 41 | )], |
064997fb | 42 | ret_ty: Path(Path::new_( |
3dfed10e | 43 | pathvec_std!(result::Result), |
dfeec247 XL |
44 | vec![ |
45 | Box::new(Self_), | |
064997fb | 46 | Box::new(Path(Path::new_(vec![typaram, sym::Error], vec![], PathKind::Local))), |
dfeec247 XL |
47 | ], |
48 | PathKind::Std, | |
49 | )), | |
f2b60f7d | 50 | attributes: ast::AttrVec::new(), |
dfeec247 XL |
51 | unify_fieldless_variants: false, |
52 | combine_substructure: combine_substructure(Box::new(|a, b, c| { | |
53 | decodable_substructure(a, b, c, krate) | |
54 | })), | |
55 | }], | |
56 | associated_types: Vec::new(), | |
57 | }; | |
58 | ||
59 | trait_def.expand(cx, mitem, item, push) | |
60 | } | |
61 | ||
62 | fn decodable_substructure( | |
63 | cx: &mut ExtCtxt<'_>, | |
64 | trait_span: Span, | |
65 | substr: &Substructure<'_>, | |
3dfed10e | 66 | krate: Symbol, |
064997fb FG |
67 | ) -> BlockOrExpr { |
68 | let decoder = substr.nonselflike_args[0].clone(); | |
dfeec247 | 69 | let recurse = vec![ |
3dfed10e XL |
70 | Ident::new(krate, trait_span), |
71 | Ident::new(sym::Decodable, trait_span), | |
72 | Ident::new(sym::decode, trait_span), | |
dfeec247 XL |
73 | ]; |
74 | let exprdecode = cx.expr_path(cx.path_global(trait_span, recurse)); | |
75 | // throw an underscore in front to suppress unused variable warnings | |
3dfed10e | 76 | let blkarg = Ident::new(sym::_d, trait_span); |
dfeec247 XL |
77 | let blkdecoder = cx.expr_ident(trait_span, blkarg); |
78 | ||
064997fb | 79 | let expr = match *substr.fields { |
dfeec247 XL |
80 | StaticStruct(_, ref summary) => { |
81 | let nfields = match *summary { | |
82 | Unnamed(ref fields, _) => fields.len(), | |
83 | Named(ref fields) => fields.len(), | |
84 | }; | |
6a06907d XL |
85 | let fn_read_struct_field_path: Vec<_> = |
86 | cx.def_site_path(&[sym::rustc_serialize, sym::Decoder, sym::read_struct_field]); | |
dfeec247 XL |
87 | |
88 | let path = cx.path_ident(trait_span, substr.type_ident); | |
89 | let result = | |
90 | decode_static_fields(cx, trait_span, path, summary, |cx, span, name, field| { | |
91 | cx.expr_try( | |
92 | span, | |
6a06907d | 93 | cx.expr_call_global( |
dfeec247 | 94 | span, |
6a06907d | 95 | fn_read_struct_field_path.clone(), |
dfeec247 | 96 | vec![ |
6a06907d | 97 | blkdecoder.clone(), |
dfeec247 XL |
98 | cx.expr_str(span, name), |
99 | cx.expr_usize(span, field), | |
100 | exprdecode.clone(), | |
101 | ], | |
102 | ), | |
103 | ) | |
104 | }); | |
105 | let result = cx.expr_ok(trait_span, result); | |
6a06907d XL |
106 | let fn_read_struct_path: Vec<_> = |
107 | cx.def_site_path(&[sym::rustc_serialize, sym::Decoder, sym::read_struct]); | |
108 | ||
109 | cx.expr_call_global( | |
dfeec247 | 110 | trait_span, |
6a06907d | 111 | fn_read_struct_path, |
dfeec247 | 112 | vec![ |
6a06907d | 113 | decoder, |
dfeec247 XL |
114 | cx.expr_str(trait_span, substr.type_ident.name), |
115 | cx.expr_usize(trait_span, nfields), | |
116 | cx.lambda1(trait_span, result, blkarg), | |
117 | ], | |
118 | ) | |
119 | } | |
120 | StaticEnum(_, ref fields) => { | |
3dfed10e | 121 | let variant = Ident::new(sym::i, trait_span); |
dfeec247 XL |
122 | |
123 | let mut arms = Vec::with_capacity(fields.len() + 1); | |
124 | let mut variants = Vec::with_capacity(fields.len()); | |
6a06907d XL |
125 | |
126 | let fn_read_enum_variant_arg_path: Vec<_> = | |
127 | cx.def_site_path(&[sym::rustc_serialize, sym::Decoder, sym::read_enum_variant_arg]); | |
dfeec247 XL |
128 | |
129 | for (i, &(ident, v_span, ref parts)) in fields.iter().enumerate() { | |
130 | variants.push(cx.expr_str(v_span, ident.name)); | |
131 | ||
132 | let path = cx.path(trait_span, vec![substr.type_ident, ident]); | |
133 | let decoded = | |
134 | decode_static_fields(cx, v_span, path, parts, |cx, span, _, field| { | |
135 | let idx = cx.expr_usize(span, field); | |
136 | cx.expr_try( | |
137 | span, | |
6a06907d | 138 | cx.expr_call_global( |
dfeec247 | 139 | span, |
6a06907d XL |
140 | fn_read_enum_variant_arg_path.clone(), |
141 | vec![blkdecoder.clone(), idx, exprdecode.clone()], | |
dfeec247 XL |
142 | ), |
143 | ) | |
144 | }); | |
145 | ||
146 | arms.push(cx.arm(v_span, cx.pat_lit(v_span, cx.expr_usize(v_span, i)), decoded)); | |
147 | } | |
148 | ||
149 | arms.push(cx.arm_unreachable(trait_span)); | |
150 | ||
151 | let result = cx.expr_ok( | |
152 | trait_span, | |
153 | cx.expr_match(trait_span, cx.expr_ident(trait_span, variant), arms), | |
154 | ); | |
155 | let lambda = cx.lambda(trait_span, vec![blkarg, variant], result); | |
064997fb | 156 | let variant_array_ref = cx.expr_array_ref(trait_span, variants); |
6a06907d XL |
157 | let fn_read_enum_variant_path: Vec<_> = |
158 | cx.def_site_path(&[sym::rustc_serialize, sym::Decoder, sym::read_enum_variant]); | |
159 | let result = cx.expr_call_global( | |
dfeec247 | 160 | trait_span, |
6a06907d | 161 | fn_read_enum_variant_path, |
064997fb | 162 | vec![blkdecoder, variant_array_ref, lambda], |
dfeec247 | 163 | ); |
6a06907d XL |
164 | let fn_read_enum_path: Vec<_> = |
165 | cx.def_site_path(&[sym::rustc_serialize, sym::Decoder, sym::read_enum]); | |
166 | ||
167 | cx.expr_call_global( | |
dfeec247 | 168 | trait_span, |
6a06907d | 169 | fn_read_enum_path, |
dfeec247 | 170 | vec![ |
6a06907d | 171 | decoder, |
dfeec247 XL |
172 | cx.expr_str(trait_span, substr.type_ident.name), |
173 | cx.lambda1(trait_span, result, blkarg), | |
174 | ], | |
175 | ) | |
176 | } | |
177 | _ => cx.bug("expected StaticEnum or StaticStruct in derive(Decodable)"), | |
064997fb FG |
178 | }; |
179 | BlockOrExpr::new_expr(expr) | |
dfeec247 XL |
180 | } |
181 | ||
182 | /// Creates a decoder for a single enum variant/struct: | |
183 | /// - `outer_pat_path` is the path to this enum variant/struct | |
184 | /// - `getarg` should retrieve the `usize`-th field with name `@str`. | |
185 | fn decode_static_fields<F>( | |
186 | cx: &mut ExtCtxt<'_>, | |
187 | trait_span: Span, | |
188 | outer_pat_path: ast::Path, | |
189 | fields: &StaticFields, | |
190 | mut getarg: F, | |
191 | ) -> P<Expr> | |
192 | where | |
193 | F: FnMut(&mut ExtCtxt<'_>, Span, Symbol, usize) -> P<Expr>, | |
194 | { | |
195 | match *fields { | |
196 | Unnamed(ref fields, is_tuple) => { | |
197 | let path_expr = cx.expr_path(outer_pat_path); | |
198 | if !is_tuple { | |
199 | path_expr | |
200 | } else { | |
201 | let fields = fields | |
202 | .iter() | |
203 | .enumerate() | |
204 | .map(|(i, &span)| getarg(cx, span, Symbol::intern(&format!("_field{}", i)), i)) | |
205 | .collect(); | |
206 | ||
207 | cx.expr_call(trait_span, path_expr, fields) | |
208 | } | |
209 | } | |
210 | Named(ref fields) => { | |
211 | // use the field's span to get nicer error messages. | |
212 | let fields = fields | |
213 | .iter() | |
214 | .enumerate() | |
215 | .map(|(i, &(ident, span))| { | |
216 | let arg = getarg(cx, span, ident.name, i); | |
217 | cx.field_imm(span, ident, arg) | |
218 | }) | |
219 | .collect(); | |
220 | cx.expr_struct(trait_span, outer_pat_path, fields) | |
221 | } | |
222 | } | |
223 | } |