diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index e616a09024c..725499e5c78 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -2418,8 +2418,7 @@ fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 }
 
 impl<D: Decoder> rustc_serialize::Decodable<D> for AttrId {
-    fn decode(d: &mut D) -> AttrId {
-        d.read_unit();
+    fn decode(_: &mut D) -> AttrId {
         crate::attr::mk_attr_id()
     }
 }
diff --git a/compiler/rustc_data_structures/src/fingerprint.rs b/compiler/rustc_data_structures/src/fingerprint.rs
index e931379dd3a..c88f3e73cff 100644
--- a/compiler/rustc_data_structures/src/fingerprint.rs
+++ b/compiler/rustc_data_structures/src/fingerprint.rs
@@ -153,9 +153,7 @@ fn encode(&self, s: &mut E) -> Result<(), E::Error> {
 impl<D: rustc_serialize::Decoder> Decodable<D> for Fingerprint {
     #[inline]
     fn decode(d: &mut D) -> Self {
-        let mut bytes = [0u8; 16];
-        d.read_raw_bytes_into(&mut bytes);
-        Fingerprint::from_le_bytes(bytes)
+        Fingerprint::from_le_bytes(d.read_raw_bytes(16).try_into().unwrap())
     }
 }
 
diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
index 66968c9ba54..b715f6c3f1f 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -316,7 +316,7 @@ fn read_lazy_with_meta<T: ?Sized + LazyMeta>(&mut self, meta: T::Meta) -> Lazy<T
     }
 
     #[inline]
-    pub fn read_raw_bytes(&mut self, len: usize) -> &'a [u8] {
+    pub fn read_raw_bytes(&mut self, len: usize) -> &[u8] {
         self.opaque.read_raw_bytes(len)
     }
 }
diff --git a/compiler/rustc_middle/src/mir/predecessors.rs b/compiler/rustc_middle/src/mir/predecessors.rs
index 2562baac911..4fe2cde7532 100644
--- a/compiler/rustc_middle/src/mir/predecessors.rs
+++ b/compiler/rustc_middle/src/mir/predecessors.rs
@@ -63,8 +63,7 @@ fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 
 impl<D: serialize::Decoder> serialize::Decodable<D> for PredecessorCache {
     #[inline]
-    fn decode(d: &mut D) -> Self {
-        let () = d.read_unit();
+    fn decode(_: &mut D) -> Self {
         Self::new()
     }
 }
diff --git a/compiler/rustc_middle/src/ty/codec.rs b/compiler/rustc_middle/src/ty/codec.rs
index ecd30ba441f..23fb7a49d9c 100644
--- a/compiler/rustc_middle/src/ty/codec.rs
+++ b/compiler/rustc_middle/src/ty/codec.rs
@@ -465,8 +465,6 @@ mod __ty_decoder_impl {
 
             impl<$($typaram ),*> Decoder for $DecoderName<$($typaram),*> {
                 $crate::__impl_decoder_methods! {
-                    read_unit -> ();
-
                     read_u128 -> u128;
                     read_u64 -> u64;
                     read_u32 -> u32;
@@ -485,12 +483,12 @@ impl<$($typaram ),*> Decoder for $DecoderName<$($typaram),*> {
                     read_f64 -> f64;
                     read_f32 -> f32;
                     read_char -> char;
-                    read_str -> Cow<'_, str>;
+                    read_str -> &str;
                 }
 
                 #[inline]
-                fn read_raw_bytes_into(&mut self, bytes: &mut [u8]) {
-                    self.opaque.read_raw_bytes_into(bytes)
+                fn read_raw_bytes(&mut self, len: usize) -> &[u8] {
+                    self.opaque.read_raw_bytes(len)
                 }
             }
         }
diff --git a/compiler/rustc_serialize/src/opaque.rs b/compiler/rustc_serialize/src/opaque.rs
index 7a05d2b762a..5e5cbacbcff 100644
--- a/compiler/rustc_serialize/src/opaque.rs
+++ b/compiler/rustc_serialize/src/opaque.rs
@@ -1,6 +1,5 @@
 use crate::leb128::{self, max_leb128_len};
-use crate::serialize::{self, Encoder as _};
-use std::borrow::Cow;
+use crate::serialize::{self, Decoder as _, Encoder as _};
 use std::convert::TryInto;
 use std::fs::File;
 use std::io::{self, Write};
@@ -549,13 +548,6 @@ pub fn set_position(&mut self, pos: usize) {
     pub fn advance(&mut self, bytes: usize) {
         self.position += bytes;
     }
-
-    #[inline]
-    pub fn read_raw_bytes(&mut self, bytes: usize) -> &'a [u8] {
-        let start = self.position;
-        self.position += bytes;
-        &self.data[start..self.position]
-    }
 }
 
 macro_rules! read_leb128 {
@@ -563,11 +555,6 @@ macro_rules! read_leb128 {
 }
 
 impl<'a> serialize::Decoder for Decoder<'a> {
-    #[inline]
-    fn read_unit(&mut self) -> () {
-        ()
-    }
-
     #[inline]
     fn read_u128(&mut self) -> u128 {
         read_leb128!(self, read_u128_leb128)
@@ -663,7 +650,7 @@ fn read_char(&mut self) -> char {
     }
 
     #[inline]
-    fn read_str(&mut self) -> Cow<'_, str> {
+    fn read_str(&mut self) -> &'a str {
         let len = self.read_usize();
         let sentinel = self.data[self.position + len];
         assert!(sentinel == STR_SENTINEL);
@@ -671,14 +658,14 @@ fn read_str(&mut self) -> Cow<'_, str> {
             std::str::from_utf8_unchecked(&self.data[self.position..self.position + len])
         };
         self.position += len + 1;
-        Cow::Borrowed(s)
+        s
     }
 
     #[inline]
-    fn read_raw_bytes_into(&mut self, s: &mut [u8]) {
+    fn read_raw_bytes(&mut self, bytes: usize) -> &'a [u8] {
         let start = self.position;
-        self.position += s.len();
-        s.copy_from_slice(&self.data[start..self.position]);
+        self.position += bytes;
+        &self.data[start..self.position]
     }
 }
 
@@ -746,10 +733,10 @@ impl<'a> serialize::Decodable<Decoder<'a>> for IntEncodedWithFixedSize {
     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);
 
-        let value = u64::from_le_bytes(bytes.try_into().unwrap());
         IntEncodedWithFixedSize(value)
     }
 }
diff --git a/compiler/rustc_serialize/src/serialize.rs b/compiler/rustc_serialize/src/serialize.rs
index a012be2857e..42bf6ff2a98 100644
--- a/compiler/rustc_serialize/src/serialize.rs
+++ b/compiler/rustc_serialize/src/serialize.rs
@@ -181,7 +181,6 @@ fn emit_map_elt_val<F>(&mut self, f: F) -> Result<(), Self::Error>
 // concise.
 pub trait Decoder {
     // Primitive types:
-    fn read_unit(&mut self) -> ();
     fn read_usize(&mut self) -> usize;
     fn read_u128(&mut self) -> u128;
     fn read_u64(&mut self) -> u64;
@@ -198,8 +197,8 @@ pub trait Decoder {
     fn read_f64(&mut self) -> f64;
     fn read_f32(&mut self) -> f32;
     fn read_char(&mut self) -> char;
-    fn read_str(&mut self) -> Cow<'_, str>;
-    fn read_raw_bytes_into(&mut self, s: &mut [u8]);
+    fn read_str(&mut self) -> &str;
+    fn read_raw_bytes(&mut self, len: usize) -> &[u8];
 }
 
 /// Trait for types that can be serialized
@@ -313,7 +312,7 @@ fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 
 impl<D: Decoder> Decodable<D> for String {
     fn decode(d: &mut D) -> String {
-        d.read_str().into_owned()
+        d.read_str().to_owned()
     }
 }
 
@@ -324,9 +323,7 @@ fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 }
 
 impl<D: Decoder> Decodable<D> for () {
-    fn decode(d: &mut D) -> () {
-        d.read_unit()
-    }
+    fn decode(_: &mut D) -> () {}
 }
 
 impl<S: Encoder, T> Encodable<S> for PhantomData<T> {
@@ -336,8 +333,7 @@ fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 }
 
 impl<D: Decoder, T> Decodable<D> for PhantomData<T> {
-    fn decode(d: &mut D) -> PhantomData<T> {
-        d.read_unit();
+    fn decode(_: &mut D) -> PhantomData<T> {
         PhantomData
     }
 }