Use delayed error handling for `Encodable` and `Encoder` infallible.

There are two impls of the `Encoder` trait: `opaque::Encoder` and
`opaque::FileEncoder`. The former encodes into memory and is infallible, the
latter writes to file and is fallible.

Currently, standard `Result`/`?`/`unwrap` error handling is used, but this is a
bit verbose and has non-trivial cost, which is annoying given how rare failures
are (especially in the infallible `opaque::Encoder` case).

This commit changes how `Encoder` fallibility is handled. All the `emit_*`
methods are now infallible. `opaque::Encoder` requires no great changes for
this. `opaque::FileEncoder` now implements a delayed error handling strategy.
If a failure occurs, it records this via the `res` field, and all subsequent
encoding operations are skipped if `res` indicates an error has occurred. Once
encoding is complete, the new `finish` method is called, which returns a
`Result`. In other words, there is now a single `Result`-producing method
instead of many of them.

This has very little effect on how any file errors are reported if
`opaque::FileEncoder` has any failures.

Much of this commit is boring mechanical changes, removing `Result` return
values and `?` or `unwrap` from expressions. The more interesting parts are as
follows.
- serialize.rs: The `Encoder` trait gains an `Ok` associated type. The
  `into_inner` method is changed into `finish`, which returns
  `Result<Vec<u8>, !>`.
- opaque.rs: The `FileEncoder` adopts the delayed error handling
  strategy. Its `Ok` type is a `usize`, returning the number of bytes
  written, replacing previous uses of `FileEncoder::position`.
- Various methods that take an encoder now consume it, rather than being
  passed a mutable reference, e.g. `serialize_query_result_cache`.

5 files changed, 28 insertions, 15 deletions

diff --git a/src/librustdoc/scrape_examples.rs b/src/librustdoc/scrape_examples.rs
index 0fa492af1ad..242f926967c 100644
--- a/src/librustdoc/scrape_examples.rs
+++ b/src/librustdoc/scrape_examples.rs
@@ -18,7 +18,7 @@ use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_serialize::{
     opaque::{Decoder, FileEncoder},
-    Decodable, Encodable,
+    Decodable, Encodable, Encoder,
 };
 use rustc_session::getopts;
 use rustc_span::{
@@ -314,8 +314,8 @@ pub(crate) fn run(
 
         // Save output to provided path
         let mut encoder = FileEncoder::new(options.output_path).map_err(|e| e.to_string())?;
-        calls.encode(&mut encoder).map_err(|e| e.to_string())?;
-        encoder.flush().map_err(|e| e.to_string())?;
+        calls.encode(&mut encoder);
+        encoder.finish().map_err(|e| e.to_string())?;
 
         Ok(())
     };
diff --git a/src/test/ui-fulldeps/deriving-encodable-decodable-box.rs b/src/test/ui-fulldeps/deriving-encodable-decodable-box.rs
index 678ba18bf04..a09deeec4f1 100644
--- a/src/test/ui-fulldeps/deriving-encodable-decodable-box.rs
+++ b/src/test/ui-fulldeps/deriving-encodable-decodable-box.rs
@@ -8,7 +8,7 @@ extern crate rustc_serialize;
 
 use rustc_macros::{Decodable, Encodable};
 use rustc_serialize::opaque;
-use rustc_serialize::{Decodable, Encodable};
+use rustc_serialize::{Decodable, Encodable, Encoder};
 
 #[derive(Encodable, Decodable)]
 struct A {
@@ -17,9 +17,13 @@ struct A {
 
 fn main() {
     let obj = A { foo: Box::new([true, false]) };
-    let mut encoder = opaque::Encoder::new(vec![]);
-    obj.encode(&mut encoder).unwrap();
-    let mut decoder = opaque::Decoder::new(&encoder.data, 0);
+
+    let mut encoder = opaque::Encoder::new();
+    obj.encode(&mut encoder);
+    let data = encoder.finish().unwrap();
+
+    let mut decoder = opaque::Decoder::new(&data, 0);
     let obj2 = A::decode(&mut decoder);
+
     assert_eq!(obj.foo, obj2.foo);
 }
diff --git a/src/test/ui-fulldeps/deriving-encodable-decodable-cell-refcell.rs b/src/test/ui-fulldeps/deriving-encodable-decodable-cell-refcell.rs
index 5cc5c41364a..9b6fb0e5806 100644
--- a/src/test/ui-fulldeps/deriving-encodable-decodable-cell-refcell.rs
+++ b/src/test/ui-fulldeps/deriving-encodable-decodable-cell-refcell.rs
@@ -10,7 +10,7 @@ extern crate rustc_serialize;
 
 use rustc_macros::{Decodable, Encodable};
 use rustc_serialize::opaque;
-use rustc_serialize::{Decodable, Encodable};
+use rustc_serialize::{Decodable, Encodable, Encoder};
 use std::cell::{Cell, RefCell};
 
 #[derive(Encodable, Decodable)]
@@ -26,10 +26,14 @@ struct B {
 
 fn main() {
     let obj = B { foo: Cell::new(true), bar: RefCell::new(A { baz: 2 }) };
-    let mut encoder = opaque::Encoder::new(vec![]);
-    obj.encode(&mut encoder).unwrap();
-    let mut decoder = opaque::Decoder::new(&encoder.data, 0);
+
+    let mut encoder = opaque::Encoder::new();
+    obj.encode(&mut encoder);
+    let data = encoder.finish().unwrap();
+
+    let mut decoder = opaque::Decoder::new(&data, 0);
     let obj2 = B::decode(&mut decoder);
+
     assert_eq!(obj.foo.get(), obj2.foo.get());
     assert_eq!(obj.bar.borrow().baz, obj2.bar.borrow().baz);
 }
diff --git a/src/test/ui-fulldeps/issue-11881.rs b/src/test/ui-fulldeps/issue-11881.rs
index 9641470a68b..f6360db9b5f 100644
--- a/src/test/ui-fulldeps/issue-11881.rs
+++ b/src/test/ui-fulldeps/issue-11881.rs
@@ -75,6 +75,7 @@ enum WireProtocol {
 fn encode_json<T: for<'a> Encodable<JsonEncoder<'a>>>(val: &T, wr: &mut Cursor<Vec<u8>>) {
     write!(wr, "{}", as_json(val));
 }
+
 fn encode_opaque<T: Encodable<OpaqueEncoder>>(val: &T, wr: Vec<u8>) {
     let mut encoder = OpaqueEncoder(wr);
     val.encode(&mut encoder);
diff --git a/src/test/ui-fulldeps/issue-14021.rs b/src/test/ui-fulldeps/issue-14021.rs
index f7e0043f521..4241456367e 100644
--- a/src/test/ui-fulldeps/issue-14021.rs
+++ b/src/test/ui-fulldeps/issue-14021.rs
@@ -9,16 +9,20 @@ extern crate rustc_serialize;
 
 use rustc_macros::{Decodable, Encodable};
 use rustc_serialize::opaque;
-use rustc_serialize::{Decodable, Encodable};
+use rustc_serialize::{Decodable, Encodable, Encoder};
 
 #[derive(Encodable, Decodable, PartialEq, Debug)]
 struct UnitLikeStruct;
 
 pub fn main() {
     let obj = UnitLikeStruct;
-    let mut encoder = opaque::Encoder::new(vec![]);
-    obj.encode(&mut encoder).unwrap();
-    let mut decoder = opaque::Decoder::new(&encoder.data, 0);
+
+    let mut encoder = opaque::Encoder::new();
+    obj.encode(&mut encoder);
+    let data = encoder.finish().unwrap();
+
+    let mut decoder = opaque::Decoder::new(&data, 0);
     let obj2 = UnitLikeStruct::decode(&mut decoder);
+
     assert_eq!(obj, obj2);
 }