Delete Decoder::read_struct

diff --git a/compiler/rustc_macros/src/serialize.rs b/compiler/rustc_macros/src/serialize.rs
index 2c4b794ffa19e67c860abdd5a8a712de3450e789..af8b85f25fdcc551034b2c87bfa276bc9e79a97f 100644 (file)
--- a/compiler/rustc_macros/src/serialize.rs
+++ b/compiler/rustc_macros/src/serialize.rs
@@ -42,15 +42,7 @@ fn decodable_body(
     }
     let ty_name = s.ast().ident.to_string();
     let decode_body = match s.variants() {
-        [vi] => {
-            let construct = vi.construct(|field, index| decode_field(field, index, true));
-            quote! {
-                ::rustc_serialize::Decoder::read_struct(
-                    __decoder,
-                    |__decoder| { #construct },
-                )
-            }
-        }
+        [vi] => vi.construct(|field, index| decode_field(field, index, true)),
         variants => {
             let match_inner: TokenStream = variants
                 .iter()

diff --git a/compiler/rustc_query_system/src/dep_graph/serialized.rs b/compiler/rustc_query_system/src/dep_graph/serialized.rs
index c95dff13d6615ffe71097d8f480fad6097a7f9c6..8c85605c0301304e2dc4c85d6ef8d0d4e144ea9c 100644 (file)
--- a/compiler/rustc_query_system/src/dep_graph/serialized.rs
+++ b/compiler/rustc_query_system/src/dep_graph/serialized.rs
@@ -122,29 +122,26 @@ fn decode(d: &mut opaque::Decoder<'a>) -> SerializedDepGraph<K> {
         let mut edge_list_data = Vec::with_capacity(edge_count);
 
         for _index in 0..node_count {
-            d.read_struct(|d| {
-                let dep_node: DepNode<K> = d.read_struct_field("node", Decodable::decode);
-                let _i: SerializedDepNodeIndex = nodes.push(dep_node);
-                debug_assert_eq!(_i.index(), _index);
-
-                let fingerprint: Fingerprint =
-                    d.read_struct_field("fingerprint", Decodable::decode);
-                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);
-                    })
+            let dep_node: DepNode<K> = d.read_struct_field("node", Decodable::decode);
+            let _i: SerializedDepNodeIndex = nodes.push(dep_node);
+            debug_assert_eq!(_i.index(), _index);
+
+            let fingerprint: Fingerprint = d.read_struct_field("fingerprint", Decodable::decode);
+            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);
                 })
-            });
+            })
         }
 
         let index: FxHashMap<_, _> =

diff --git a/compiler/rustc_serialize/src/serialize.rs b/compiler/rustc_serialize/src/serialize.rs
index 5e62a0f1eb2e62fc2f7b728d1af4e72d9c70e0b6..1ce62d1224b0dc79f974b4a510ba8adfe945020d 100644 (file)
--- a/compiler/rustc_serialize/src/serialize.rs
+++ b/compiler/rustc_serialize/src/serialize.rs
@@ -210,14 +210,6 @@ fn read_enum_variant<T, F>(&mut self, mut f: F) -> T
         f(self, disr)
     }
 
-    #[inline]
-    fn read_struct<T, F>(&mut self, f: F) -> T
-    where
-        F: FnOnce(&mut Self) -> T,
-    {
-        f(self)
-    }
-
     #[inline]
     fn read_struct_field<T, F>(&mut self, _f_name: &str, f: F) -> T
     where

diff --git a/compiler/rustc_span/src/def_id.rs b/compiler/rustc_span/src/def_id.rs
index 147c1f9e043395d99a6d611f785f3ed76ea64f1b..5b6f110413a1b89f21c0371a9288abf53d5544a3 100644 (file)
--- a/compiler/rustc_span/src/def_id.rs
+++ b/compiler/rustc_span/src/def_id.rs
@@ -299,10 +299,10 @@ impl<E: Encoder> Encodable<E> for DefId {
 
 impl<D: Decoder> Decodable<D> for DefId {
     default fn decode(d: &mut D) -> DefId {
-        d.read_struct(|d| DefId {
+        DefId {
             krate: d.read_struct_field("krate", Decodable::decode),
             index: d.read_struct_field("index", Decodable::decode),
-        })
+        }
     }
 }
 

diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index 5991b4d217c6ec05eee37a2da453aa0942678158..93f45985a7c3e53ff33c9cb7eb1b5abf49bdd9bd 100644 (file)
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -979,12 +979,10 @@ impl<E: Encoder> Encodable<E> for Span {
 }
 impl<D: Decoder> Decodable<D> for Span {
     default fn decode(s: &mut D) -> Span {
-        s.read_struct(|d| {
-            let lo = d.read_struct_field("lo", Decodable::decode);
-            let hi = d.read_struct_field("hi", Decodable::decode);
+        let lo = s.read_struct_field("lo", Decodable::decode);
+        let hi = s.read_struct_field("hi", Decodable::decode);
 
-            Span::new(lo, hi, SyntaxContext::root(), None)
-        })
+        Span::new(lo, hi, SyntaxContext::root(), None)
     }
 }
 
@@ -1440,65 +1438,62 @@ fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 
 impl<D: Decoder> Decodable<D> for SourceFile {
     fn decode(d: &mut D) -> SourceFile {
-        d.read_struct(|d| {
-            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 num_lines: u32 = Decodable::decode(d);
-                let mut lines = Vec::with_capacity(num_lines as usize);
-
-                if num_lines > 0 {
-                    // Read the number of bytes used per diff.
-                    let bytes_per_diff: u8 = Decodable::decode(d);
-
-                    // Read the first element.
-                    let mut line_start: BytePos = Decodable::decode(d);
-                    lines.push(line_start);
-
-                    for _ in 1..num_lines {
-                        let diff = match bytes_per_diff {
-                            1 => d.read_u8() as u32,
-                            2 => d.read_u16() as u32,
-                            4 => d.read_u32(),
-                            _ => unreachable!(),
-                        };
+        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 num_lines: u32 = Decodable::decode(d);
+            let mut lines = Vec::with_capacity(num_lines as usize);
+
+            if num_lines > 0 {
+                // Read the number of bytes used per diff.
+                let bytes_per_diff: u8 = Decodable::decode(d);
+
+                // Read the first element.
+                let mut line_start: BytePos = Decodable::decode(d);
+                lines.push(line_start);
+
+                for _ in 1..num_lines {
+                    let diff = match bytes_per_diff {
+                        1 => d.read_u8() as u32,
+                        2 => d.read_u16() as u32,
+                        4 => d.read_u32(),
+                        _ => unreachable!(),
+                    };
 
-                        line_start = line_start + BytePos(diff);
+                    line_start = line_start + BytePos(diff);
 
-                        lines.push(line_start);
-                    }
+                    lines.push(line_start);
                 }
-
-                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));
-            SourceFile {
-                name,
-                start_pos,
-                end_pos,
-                src: None,
-                src_hash,
-                // Unused - the metadata decoder will construct
-                // a new SourceFile, filling in `external_src` properly
-                external_src: Lock::new(ExternalSource::Unneeded),
-                lines,
-                multibyte_chars,
-                non_narrow_chars,
-                normalized_pos,
-                name_hash,
-                cnum,
             }
-        })
+
+            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));
+        SourceFile {
+            name,
+            start_pos,
+            end_pos,
+            src: None,
+            src_hash,
+            // Unused - the metadata decoder will construct
+            // a new SourceFile, filling in `external_src` properly
+            external_src: Lock::new(ExternalSource::Unneeded),
+            lines,
+            multibyte_chars,
+            non_narrow_chars,
+            normalized_pos,
+            name_hash,
+            cnum,
+        }
     }
 }