}
let ty_name = s.ast().ident.to_string();
let decode_body = match s.variants() {
- [vi] => vi.construct(|field, index| decode_field(field, index, true)),
+ [vi] => vi.construct(|field, _index| decode_field(field)),
variants => {
let match_inner: TokenStream = variants
.iter()
.enumerate()
.map(|(idx, vi)| {
- let construct = vi.construct(|field, index| decode_field(field, index, false));
+ let construct = vi.construct(|field, _index| decode_field(field));
quote! { #idx => { #construct } }
})
.collect();
)
}
-fn decode_field(field: &syn::Field, index: usize, is_struct: bool) -> proc_macro2::TokenStream {
+fn decode_field(field: &syn::Field) -> proc_macro2::TokenStream {
let field_span = field.ident.as_ref().map_or(field.ty.span(), |ident| ident.span());
let decode_inner_method = if let syn::Type::Reference(_) = field.ty {
quote! { ::rustc_serialize::Decodable::decode }
};
let __decoder = quote! { __decoder };
- let decode_call = if is_struct {
- let field_name = field.ident.as_ref().map_or_else(|| index.to_string(), |i| i.to_string());
- let decode_method = proc_macro2::Ident::new("read_struct_field", field_span);
- // Use the span of the field for the method call, so
- // that backtraces will point to the field.
- quote_spanned! {field_span=>
- ::rustc_serialize::Decoder::#decode_method(
- #__decoder, #field_name, #decode_inner_method)
- }
- } else {
- // Use the span of the field for the method call, so
- // that backtraces will point to the field.
- quote_spanned! {field_span=> #decode_inner_method(#__decoder) }
- };
-
- quote! { #decode_call }
+ // Use the span of the field for the method call, so
+ // that backtraces will point to the field.
+ quote_spanned! {field_span=> #decode_inner_method(#__decoder) }
}
pub fn type_encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
let mut edge_list_data = Vec::with_capacity(edge_count);
for _index in 0..node_count {
- let dep_node: DepNode<K> = d.read_struct_field("node", Decodable::decode);
+ let dep_node: DepNode<K> = Decodable::decode(d);
let _i: SerializedDepNodeIndex = nodes.push(dep_node);
debug_assert_eq!(_i.index(), _index);
- let fingerprint: Fingerprint = d.read_struct_field("fingerprint", Decodable::decode);
+ let fingerprint: Fingerprint = Decodable::decode(d);
let _i: SerializedDepNodeIndex = fingerprints.push(fingerprint);
debug_assert_eq!(_i.index(), _index);
- d.read_struct_field("edges", |d| {
- d.read_seq(|d, len| {
- let start = edge_list_data.len().try_into().unwrap();
- for _ in 0..len {
- let edge = d.read_seq_elt(Decodable::decode);
- edge_list_data.push(edge);
- }
- let end = edge_list_data.len().try_into().unwrap();
- let _i: SerializedDepNodeIndex = edge_list_indices.push((start, end));
- debug_assert_eq!(_i.index(), _index);
- })
+ d.read_seq(|d, len| {
+ let start = edge_list_data.len().try_into().unwrap();
+ for _ in 0..len {
+ let edge = d.read_seq_elt(Decodable::decode);
+ edge_list_data.push(edge);
+ }
+ let end = edge_list_data.len().try_into().unwrap();
+ let _i: SerializedDepNodeIndex = edge_list_indices.push((start, end));
+ debug_assert_eq!(_i.index(), _index);
})
}
f(self, disr)
}
- #[inline]
- fn read_struct_field<T, F>(&mut self, _f_name: &str, f: F) -> T
- where
- F: FnOnce(&mut Self) -> T,
- {
- f(self)
- }
-
#[inline]
fn read_tuple<T, F>(&mut self, _len: usize, f: F) -> T
where
impl<D: Decoder> Decodable<D> for DefId {
default fn decode(d: &mut D) -> DefId {
- DefId {
- krate: d.read_struct_field("krate", Decodable::decode),
- index: d.read_struct_field("index", Decodable::decode),
- }
+ DefId { krate: Decodable::decode(d), index: Decodable::decode(d) }
}
}
}
impl<D: Decoder> Decodable<D> for Span {
default fn decode(s: &mut D) -> Span {
- let lo = s.read_struct_field("lo", Decodable::decode);
- let hi = s.read_struct_field("hi", Decodable::decode);
+ let lo = Decodable::decode(s);
+ let hi = Decodable::decode(s);
Span::new(lo, hi, SyntaxContext::root(), None)
}
impl<D: Decoder> Decodable<D> for SourceFile {
fn decode(d: &mut D) -> SourceFile {
- let name: FileName = d.read_struct_field("name", |d| Decodable::decode(d));
- let src_hash: SourceFileHash = d.read_struct_field("src_hash", |d| Decodable::decode(d));
- let start_pos: BytePos = d.read_struct_field("start_pos", |d| Decodable::decode(d));
- let end_pos: BytePos = d.read_struct_field("end_pos", |d| Decodable::decode(d));
- let lines: Vec<BytePos> = d.read_struct_field("lines", |d| {
+ let name: FileName = Decodable::decode(d);
+ let src_hash: SourceFileHash = Decodable::decode(d);
+ let start_pos: BytePos = Decodable::decode(d);
+ let end_pos: BytePos = Decodable::decode(d);
+ let lines: Vec<BytePos> = {
let num_lines: u32 = Decodable::decode(d);
let mut lines = Vec::with_capacity(num_lines as usize);
}
lines
- });
- let multibyte_chars: Vec<MultiByteChar> =
- d.read_struct_field("multibyte_chars", |d| Decodable::decode(d));
- let non_narrow_chars: Vec<NonNarrowChar> =
- d.read_struct_field("non_narrow_chars", |d| Decodable::decode(d));
- let name_hash: u128 = d.read_struct_field("name_hash", |d| Decodable::decode(d));
- let normalized_pos: Vec<NormalizedPos> =
- d.read_struct_field("normalized_pos", |d| Decodable::decode(d));
- let cnum: CrateNum = d.read_struct_field("cnum", |d| Decodable::decode(d));
+ };
+ let multibyte_chars: Vec<MultiByteChar> = Decodable::decode(d);
+ let non_narrow_chars: Vec<NonNarrowChar> = Decodable::decode(d);
+ let name_hash: u128 = Decodable::decode(d);
+ let normalized_pos: Vec<NormalizedPos> = Decodable::decode(d);
+ let cnum: CrateNum = Decodable::decode(d);
SourceFile {
name,
start_pos,