fix fallout from invalid map key type error

Author: Oliver Schneider

src/librustdoc/html/render.rs

@@ -253,7 +253,7 @@ thread_local!(pub static CURRENT_LOCATION_KEY: RefCell<Vec<String>> =
 pub fn run(mut krate: clean::Crate,
            external_html: &ExternalHtml,
            dst: Path,
-           passes: HashSet<String>) -> io::IoResult<()> {
+           passes: HashSet<String>) -> json::EncodeResult {
     let mut cx = Context {
         dst: dst,
         src_root: krate.src.dir_path(),
@@ -1084,7 +1084,7 @@ impl Context {
     /// This currently isn't parallelized, but it'd be pretty easy to add
     /// parallelization to this function.
     fn krate(mut self, mut krate: clean::Crate,
-             stability: stability_summary::ModuleSummary) -> io::IoResult<()> {
+             stability: stability_summary::ModuleSummary) -> json::EncodeResult {
         let mut item = match krate.module.take() {
             Some(i) => i,
             None => return Ok(())
@@ -1110,9 +1110,10 @@ impl Context {
             };
             let html_dst = &this.dst.join("stability.html");
             let mut html_out = BufferedWriter::new(try!(File::create(html_dst)));
-            layout::render(&mut html_out, &this.layout, &page,
+            try!(layout::render(&mut html_out, &this.layout, &page,
                            &Sidebar{ cx: this, item: &item },
-                           &stability)
+                           &stability));
+            Ok(())
         }));
 
         // render the crate documentation

src/librustdoc/lib.rs

@@ -468,7 +468,7 @@ fn json_input(input: &str) -> Result<Output, String> {
 /// Outputs the crate/plugin json as a giant json blob at the specified
 /// destination.
 fn json_output(krate: clean::Crate, res: Vec<plugins::PluginJson> ,
-               dst: Path) -> io::IoResult<()> {
+               dst: Path) -> json::EncodeResult {
     // {
     //   "schema": version,
     //   "crate": { parsed crate ... },

src/libsyntax/ast.rs

@@ -1682,6 +1682,6 @@ mod test {
             exported_macros: Vec::new(),
         };
         // doesn't matter which encoder we use....
-        let _f = &e as &serialize::Encodable<json::Encoder, io::IoError>;
+        let _f = &e as &serialize::Encodable<json::Encoder, json::EncoderError>;
     }
 }

src/libtest/lib.rs

@@ -850,7 +850,8 @@ pub fn fmt_bench_samples(bs: &BenchSamples) -> String {
 }
 
 // A simple console test runner
-pub fn run_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn> ) -> io::IoResult<bool> {
+pub fn run_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn> )
+                         -> Result<bool, json::EncoderError> {
 
     fn callback<T: Writer>(event: &TestEvent, st: &mut ConsoleTestState<T>) -> io::IoResult<()> {
         match (*event).clone() {
@@ -914,7 +915,7 @@ pub fn run_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn> ) -> io::IoR
                                           pth.display()).as_slice()));
         }
     }
-    return st.write_run_finish(&opts.ratchet_metrics, opts.ratchet_noise_percent);
+    return Ok(try!(st.write_run_finish(&opts.ratchet_metrics, opts.ratchet_noise_percent)));
 }
 
 #[test]
@@ -1207,7 +1208,7 @@ impl MetricMap {
     }
 
     /// Write MetricDiff to a file.
-    pub fn save(&self, p: &Path) -> io::IoResult<()> {
+    pub fn save(&self, p: &Path) -> json::EncodeResult {
         let mut file = try!(File::create(p));
         let MetricMap(ref map) = *self;
         let mut enc = json::PrettyEncoder::new(&mut file);

src/test/compile-fail/variance-trait-matching-2.rs

@@ -12,9 +12,10 @@ extern crate serialize;
 
 use std::io;
 use serialize::{Encodable, Encoder};
+use serialize::json;
 
 pub fn buffer_encode<'a,
-                     T:Encodable<serialize::json::Encoder<'a>,io::IoError>>(
+                     T:Encodable<json::Encoder<'a>,json::EncoderError>>(
                      to_encode_object: &T)
                      -> Vec<u8> {
     let mut m = Vec::new();

src/test/run-pass/issue-11881.rs

@@ -39,8 +39,8 @@ enum WireProtocol {
 
 fn encode_json<'a,
                T: Encodable<json::Encoder<'a>,
-                            std::io::IoError>>(val: &T,
-                                               wr: &'a mut SeekableMemWriter) {
+                            json::EncoderError>>(val: &T,
+                                                 wr: &'a mut SeekableMemWriter) {
     let mut encoder = json::Encoder::new(wr);
     val.encode(&mut encoder);
 }

src/test/run-pass/issue-15924.rs

@@ -21,7 +21,7 @@ struct Foo<T> {
 }
 
 #[unsafe_destructor]
-impl<'a, T: Encodable<json::Encoder<'a>, IoError>> Drop for Foo<T> {
+impl<'a, T: Encodable<json::Encoder<'a>, json::EncoderError>> Drop for Foo<T> {
     fn drop(&mut self) {
         json::encode(&self.v);
     }