Move IntEncodedWithFixedSize.

Author: cjgillot

compiler/rustc_query_impl/src/on_disk_cache.rs

@@ -15,8 +15,8 @@ use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_query_system::dep_graph::DepContext;
 use rustc_query_system::query::{QueryCache, QueryContext, QuerySideEffects};
 use rustc_serialize::{
-    opaque::{self, FileEncodeResult, FileEncoder, IntEncodedWithFixedSize},
-    Decodable, Decoder, Encodable, Encoder,
+    opaque::{self, FileEncodeResult, FileEncoder},
+    Decodable, Decoder, Encodable, Encoder, IntEncodedWithFixedSize,
 };
 use rustc_session::Session;
 use rustc_span::hygiene::{

compiler/rustc_query_system/src/dep_graph/serialized.rs

@@ -19,8 +19,8 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::sync::Lock;
 use rustc_index::vec::{Idx, IndexVec};
-use rustc_serialize::opaque::{self, FileEncodeResult, FileEncoder, IntEncodedWithFixedSize};
-use rustc_serialize::{Decodable, Decoder, Encodable};
+use rustc_serialize::opaque::{self, FileEncodeResult, FileEncoder};
+use rustc_serialize::{Decodable, Decoder, Encodable, IntEncodedWithFixedSize};
 use smallvec::SmallVec;
 use std::convert::TryInto;
 

compiler/rustc_serialize/src/lib.rs

@@ -20,6 +20,8 @@ Core encoding and decoding interfaces.
 #![cfg_attr(test, feature(test))]
 #![allow(rustc::internal)]
 
+use std::convert::TryInto;
+
 pub use self::serialize::{Decodable, Decoder, Encodable, Encoder};
 
 mod collection_impls;
@@ -31,3 +33,80 @@ pub mod leb128;
 pub mod opaque;
 
 pub mod raw;
+
+// An integer that will always encode to 8 bytes.
+pub struct IntEncodedWithFixedSize(pub u64);
+
+impl IntEncodedWithFixedSize {
+    pub const ENCODED_SIZE: usize = 8;
+}
+
+impl Encodable<opaque::Encoder> for IntEncodedWithFixedSize {
+    #[inline]
+    fn encode(&self, e: &mut opaque::Encoder) -> opaque::EncodeResult {
+        let _start_pos = e.position();
+        e.emit_raw_bytes(&self.0.to_le_bytes())?;
+        let _end_pos = e.position();
+        debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
+        Ok(())
+    }
+}
+
+impl Encodable<opaque::FileEncoder> for IntEncodedWithFixedSize {
+    #[inline]
+    fn encode(&self, e: &mut opaque::FileEncoder) -> opaque::FileEncodeResult {
+        let _start_pos = e.position();
+        e.emit_raw_bytes(&self.0.to_le_bytes())?;
+        let _end_pos = e.position();
+        debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
+        Ok(())
+    }
+}
+
+impl<'a> Decodable<opaque::Decoder<'a>> for IntEncodedWithFixedSize {
+    #[inline]
+    fn decode(decoder: &mut opaque::Decoder<'a>) -> IntEncodedWithFixedSize {
+        let _start_pos = decoder.position();
+        let bytes = decoder.read_raw_bytes(IntEncodedWithFixedSize::ENCODED_SIZE);
+        let value = u64::from_le_bytes(bytes.try_into().unwrap());
+        let _end_pos = decoder.position();
+        debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
+
+        IntEncodedWithFixedSize(value)
+    }
+}
+
+impl Encodable<raw::Encoder> for IntEncodedWithFixedSize {
+    #[inline]
+    fn encode(&self, e: &mut raw::Encoder) -> raw::EncodeResult {
+        let _start_pos = e.position();
+        e.emit_raw_bytes(&self.0.to_le_bytes())?;
+        let _end_pos = e.position();
+        debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
+        Ok(())
+    }
+}
+
+impl Encodable<raw::FileEncoder> for IntEncodedWithFixedSize {
+    #[inline]
+    fn encode(&self, e: &mut raw::FileEncoder) -> raw::FileEncodeResult {
+        let _start_pos = e.position();
+        e.emit_raw_bytes(&self.0.to_le_bytes())?;
+        let _end_pos = e.position();
+        debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
+        Ok(())
+    }
+}
+
+impl<'a> Decodable<raw::Decoder<'a>> for IntEncodedWithFixedSize {
+    #[inline]
+    fn decode(decoder: &mut raw::Decoder<'a>) -> IntEncodedWithFixedSize {
+        let _start_pos = decoder.position();
+        let bytes = decoder.read_raw_bytes(IntEncodedWithFixedSize::ENCODED_SIZE);
+        let _end_pos = decoder.position();
+        debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
+
+        let value = u64::from_le_bytes(bytes.try_into().unwrap());
+        IntEncodedWithFixedSize(value)
+    }
+}

compiler/rustc_serialize/src/opaque.rs

@@ -1,6 +1,5 @@
 use crate::leb128::{self, max_leb128_len};
 use crate::serialize::{self, Decoder as _, Encoder as _};
-use std::convert::TryInto;
 use std::fs::File;
 use std::io::{self, Write};
 use std::mem::MaybeUninit;
@@ -698,45 +697,3 @@ impl<'a> serialize::Decodable<Decoder<'a>> for Vec<u8> {
         d.read_raw_bytes(len).to_owned()
     }
 }
-
-// An integer that will always encode to 8 bytes.
-pub struct IntEncodedWithFixedSize(pub u64);
-
-impl IntEncodedWithFixedSize {
-    pub const ENCODED_SIZE: usize = 8;
-}
-
-impl serialize::Encodable<Encoder> for IntEncodedWithFixedSize {
-    #[inline]
-    fn encode(&self, e: &mut Encoder) -> EncodeResult {
-        let _start_pos = e.position();
-        e.emit_raw_bytes(&self.0.to_le_bytes())?;
-        let _end_pos = e.position();
-        debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
-        Ok(())
-    }
-}
-
-impl serialize::Encodable<FileEncoder> for IntEncodedWithFixedSize {
-    #[inline]
-    fn encode(&self, e: &mut FileEncoder) -> FileEncodeResult {
-        let _start_pos = e.position();
-        e.emit_raw_bytes(&self.0.to_le_bytes())?;
-        let _end_pos = e.position();
-        debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
-        Ok(())
-    }
-}
-
-impl<'a> serialize::Decodable<Decoder<'a>> for IntEncodedWithFixedSize {
-    #[inline]
-    fn decode(decoder: &mut Decoder<'a>) -> IntEncodedWithFixedSize {
-        let _start_pos = decoder.position();
-        let bytes = decoder.read_raw_bytes(IntEncodedWithFixedSize::ENCODED_SIZE);
-        let value = u64::from_le_bytes(bytes.try_into().unwrap());
-        let _end_pos = decoder.position();
-        debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
-
-        IntEncodedWithFixedSize(value)
-    }
-}

compiler/rustc_serialize/src/raw.rs

@@ -506,7 +506,7 @@ impl<'a> Decoder<'a> {
     }
 
     #[inline]
-    fn read_raw_bytes(&mut self, bytes: usize) -> &'a [u8] {
+    pub fn read_raw_bytes(&mut self, bytes: usize) -> &'a [u8] {
         let start = self.position;
         self.position += bytes;
         &self.data[start..self.position]