1 use proc_macro2::TokenStream;
5 pub fn type_decodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
6 let decoder_ty = quote! { __D };
7 if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") {
8 s.add_impl_generic(parse_quote! { 'tcx });
10 s.add_impl_generic(parse_quote! {#decoder_ty: ::rustc_middle::ty::codec::TyDecoder<'tcx>});
11 s.add_bounds(synstructure::AddBounds::Generics);
13 decodable_body(s, decoder_ty)
16 pub fn meta_decodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
17 if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") {
18 s.add_impl_generic(parse_quote! { 'tcx });
20 s.add_impl_generic(parse_quote! { '__a });
21 let decoder_ty = quote! { DecodeContext<'__a, 'tcx> };
22 s.add_bounds(synstructure::AddBounds::Generics);
24 decodable_body(s, decoder_ty)
27 pub fn decodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
28 let decoder_ty = quote! { __D };
29 s.add_impl_generic(parse_quote! {#decoder_ty: ::rustc_serialize::Decoder});
30 s.add_bounds(synstructure::AddBounds::Generics);
32 decodable_body(s, decoder_ty)
36 s: synstructure::Structure<'_>,
37 decoder_ty: TokenStream,
38 ) -> proc_macro2::TokenStream {
39 if let syn::Data::Union(_) = s.ast().data {
40 panic!("cannot derive on union")
42 let ty_name = s.ast().ident.to_string();
43 let decode_body = match s.variants() {
45 let construct = vi.construct(|field, index| decode_field(field, index, true));
46 let n_fields = vi.ast().fields.len();
48 ::rustc_serialize::Decoder::read_struct(
52 |__decoder| { ::std::result::Result::Ok(#construct) },
57 let match_inner: TokenStream = variants
61 let construct = vi.construct(|field, index| decode_field(field, index, false));
62 quote! { #idx => { ::std::result::Result::Ok(#construct) } }
65 let names: TokenStream = variants
68 let variant_name = vi.ast().ident.to_string();
69 quote!(#variant_name,)
72 let message = format!(
73 "invalid enum variant tag while decoding `{}`, expected 0..{}",
78 ::rustc_serialize::Decoder::read_enum(
82 ::rustc_serialize::Decoder::read_enum_variant(
85 |__decoder, __variant_idx| {
88 _ => return ::std::result::Result::Err(
89 ::rustc_serialize::Decoder::error(__decoder, #message)),
99 quote!(::rustc_serialize::Decodable<#decoder_ty>),
102 __decoder: &mut #decoder_ty,
103 ) -> ::std::result::Result<Self, <#decoder_ty as ::rustc_serialize::Decoder>::Error> {
110 fn decode_field(field: &syn::Field, index: usize, is_struct: bool) -> proc_macro2::TokenStream {
111 let decode_inner_method = if let syn::Type::Reference(_) = field.ty {
112 quote! { ::rustc_middle::ty::codec::RefDecodable::decode }
114 quote! { ::rustc_serialize::Decodable::decode }
116 let (decode_method, opt_field_name) = if is_struct {
117 let field_name = field.ident.as_ref().map_or_else(|| index.to_string(), |i| i.to_string());
119 proc_macro2::Ident::new("read_struct_field", proc_macro2::Span::call_site()),
120 quote! { #field_name, },
124 proc_macro2::Ident::new("read_enum_variant_arg", proc_macro2::Span::call_site()),
130 match ::rustc_serialize::Decoder::#decode_method(
131 __decoder, #opt_field_name #index, #decode_inner_method) {
132 ::std::result::Result::Ok(__res) => __res,
133 ::std::result::Result::Err(__err) => return ::std::result::Result::Err(__err),
138 pub fn type_encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
139 if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") {
140 s.add_impl_generic(parse_quote! {'tcx});
142 let encoder_ty = quote! { __E };
143 s.add_impl_generic(parse_quote! {#encoder_ty: ::rustc_middle::ty::codec::TyEncoder<'tcx>});
144 s.add_bounds(synstructure::AddBounds::Generics);
146 encodable_body(s, encoder_ty, false)
149 pub fn meta_encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
150 if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") {
151 s.add_impl_generic(parse_quote! {'tcx});
153 s.add_impl_generic(parse_quote! { '__a });
154 let encoder_ty = quote! { EncodeContext<'__a, 'tcx> };
155 s.add_bounds(synstructure::AddBounds::Generics);
157 encodable_body(s, encoder_ty, true)
160 pub fn encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
161 let encoder_ty = quote! { __E };
162 s.add_impl_generic(parse_quote! { #encoder_ty: ::rustc_serialize::Encoder});
163 s.add_bounds(synstructure::AddBounds::Generics);
165 encodable_body(s, encoder_ty, false)
169 mut s: synstructure::Structure<'_>,
170 encoder_ty: TokenStream,
171 allow_unreachable_code: bool,
172 ) -> proc_macro2::TokenStream {
173 if let syn::Data::Union(_) = s.ast().data {
174 panic!("cannot derive on union")
177 s.bind_with(|binding| {
178 // Handle the lack of a blanket reference impl.
179 if let syn::Type::Reference(_) = binding.ast().ty {
180 synstructure::BindStyle::Move
182 synstructure::BindStyle::Ref
186 let ty_name = s.ast().ident.to_string();
187 let encode_body = match s.variants() {
189 let mut field_idx = 0usize;
190 let encode_inner = s.each_variant(|vi| {
194 let bind_ident = &binding.binding;
195 let field_name = binding
199 .map_or_else(|| field_idx.to_string(), |i| i.to_string());
200 let result = quote! {
201 match ::rustc_serialize::Encoder::emit_struct_field(
206 ::rustc_serialize::Encodable::<#encoder_ty>::encode(#bind_ident, __encoder),
208 ::std::result::Result::Ok(()) => (),
209 ::std::result::Result::Err(__err)
210 => return ::std::result::Result::Err(__err),
216 .collect::<TokenStream>()
219 ::rustc_serialize::Encoder::emit_struct(__encoder, #ty_name, #field_idx, |__encoder| {
220 ::std::result::Result::Ok(match *self { #encode_inner })
225 let mut variant_idx = 0usize;
226 let encode_inner = s.each_variant(|vi| {
227 let variant_name = vi.ast().ident.to_string();
228 let mut field_idx = 0usize;
230 let encode_fields: TokenStream = vi
234 let bind_ident = &binding.binding;
235 let result = quote! {
236 match ::rustc_serialize::Encoder::emit_enum_variant_arg(
240 ::rustc_serialize::Encodable::<#encoder_ty>::encode(#bind_ident, __encoder),
242 ::std::result::Result::Ok(()) => (),
243 ::std::result::Result::Err(__err)
244 => return ::std::result::Result::Err(__err),
252 let result = quote! { ::rustc_serialize::Encoder::emit_enum_variant(
257 |__encoder| { ::std::result::Result::Ok({ #encode_fields }) }
263 ::rustc_serialize::Encoder::emit_enum(__encoder, #ty_name, |__encoder| {
272 let lints = if allow_unreachable_code {
273 quote! { #![allow(unreachable_code)] }
279 quote!(::rustc_serialize::Encodable<#encoder_ty>),
283 __encoder: &mut #encoder_ty,
284 ) -> ::std::result::Result<(), <#encoder_ty as ::rustc_serialize::Encoder>::Error> {