auto merge of #10727 : erickt/rust/json, r=huonw

This PR does some small modernizations to the json library. First is to remove the `@` boxes, second is to rename the constructors to `new`.

7 files changed, 200 insertions, 195 deletions

diff --git a/src/libextra/json.rs b/src/libextra/json.rs
index 27399651392..30288a08c79 100644
--- a/src/libextra/json.rs
+++ b/src/libextra/json.rs
@@ -54,7 +54,7 @@ pub struct Error {
     /// The column number at which the error occurred
     priv col: uint,
     /// A message describing the type of the error
-    priv msg: @~str,
+    priv msg: ~str,
 }
 
 fn escape_str(s: &str) -> ~str {
@@ -84,17 +84,19 @@ fn spaces(n: uint) -> ~str {
 }
 
 /// A structure for implementing serialization to JSON.
-pub struct Encoder {
-    priv wr: @mut io::Writer,
+pub struct Encoder<'self> {
+    priv wr: &'self mut io::Writer,
 }
 
-/// Creates a new JSON encoder whose output will be written to the writer
-/// specified.
-pub fn Encoder(wr: @mut io::Writer) -> Encoder {
-    Encoder { wr: wr }
+impl<'self> Encoder<'self> {
+    /// Creates a new JSON encoder whose output will be written to the writer
+    /// specified.
+    pub fn init<'a>(wr: &'a mut io::Writer) -> Encoder<'a> {
+        Encoder { wr: wr }
+    }
 }
 
-impl serialize::Encoder for Encoder {
+impl<'self> serialize::Encoder for Encoder<'self> {
     fn emit_nil(&mut self) { write!(self.wr, "null") }
 
     fn emit_uint(&mut self, v: uint) { self.emit_f64(v as f64); }
@@ -127,13 +129,13 @@ impl serialize::Encoder for Encoder {
         write!(self.wr, "{}", escape_str(v))
     }
 
-    fn emit_enum(&mut self, _name: &str, f: |&mut Encoder|) { f(self) }
+    fn emit_enum(&mut self, _name: &str, f: |&mut Encoder<'self>|) { f(self) }
 
     fn emit_enum_variant(&mut self,
                          name: &str,
                          _id: uint,
                          cnt: uint,
-                         f: |&mut Encoder|) {
+                         f: |&mut Encoder<'self>|) {
         // enums are encoded as strings or objects
         // Bunny => "Bunny"
         // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
@@ -148,7 +150,7 @@ impl serialize::Encoder for Encoder {
         }
     }
 
-    fn emit_enum_variant_arg(&mut self, idx: uint, f: |&mut Encoder|) {
+    fn emit_enum_variant_arg(&mut self, idx: uint, f: |&mut Encoder<'self>|) {
         if idx != 0 {
             write!(self.wr, ",");
         }
@@ -159,18 +161,18 @@ impl serialize::Encoder for Encoder {
                                 name: &str,
                                 id: uint,
                                 cnt: uint,
-                                f: |&mut Encoder|) {
+                                f: |&mut Encoder<'self>|) {
         self.emit_enum_variant(name, id, cnt, f)
     }
 
     fn emit_enum_struct_variant_field(&mut self,
                                       _: &str,
                                       idx: uint,
-                                      f: |&mut Encoder|) {
+                                      f: |&mut Encoder<'self>|) {
         self.emit_enum_variant_arg(idx, f)
     }
 
-    fn emit_struct(&mut self, _: &str, _: uint, f: |&mut Encoder|) {
+    fn emit_struct(&mut self, _: &str, _: uint, f: |&mut Encoder<'self>|) {
         write!(self.wr, r"\{");
         f(self);
         write!(self.wr, r"\}");
@@ -179,58 +181,58 @@ impl serialize::Encoder for Encoder {
     fn emit_struct_field(&mut self,
                          name: &str,
                          idx: uint,
-                         f: |&mut Encoder|) {
+                         f: |&mut Encoder<'self>|) {
         if idx != 0 { write!(self.wr, ",") }
         write!(self.wr, "{}:", escape_str(name));
         f(self);
     }
 
-    fn emit_tuple(&mut self, len: uint, f: |&mut Encoder|) {
+    fn emit_tuple(&mut self, len: uint, f: |&mut Encoder<'self>|) {
         self.emit_seq(len, f)
     }
-    fn emit_tuple_arg(&mut self, idx: uint, f: |&mut Encoder|) {
+    fn emit_tuple_arg(&mut self, idx: uint, f: |&mut Encoder<'self>|) {
         self.emit_seq_elt(idx, f)
     }
 
     fn emit_tuple_struct(&mut self,
                          _name: &str,
                          len: uint,
-                         f: |&mut Encoder|) {
+                         f: |&mut Encoder<'self>|) {
         self.emit_seq(len, f)
     }
-    fn emit_tuple_struct_arg(&mut self, idx: uint, f: |&mut Encoder|) {
+    fn emit_tuple_struct_arg(&mut self, idx: uint, f: |&mut Encoder<'self>|) {
         self.emit_seq_elt(idx, f)
     }
 
-    fn emit_option(&mut self, f: |&mut Encoder|) { f(self); }
+    fn emit_option(&mut self, f: |&mut Encoder<'self>|) { f(self); }
     fn emit_option_none(&mut self) { self.emit_nil(); }
-    fn emit_option_some(&mut self, f: |&mut Encoder|) { f(self); }
+    fn emit_option_some(&mut self, f: |&mut Encoder<'self>|) { f(self); }
 
-    fn emit_seq(&mut self, _len: uint, f: |&mut Encoder|) {
+    fn emit_seq(&mut self, _len: uint, f: |&mut Encoder<'self>|) {
         write!(self.wr, "[");
         f(self);
         write!(self.wr, "]");
     }
 
-    fn emit_seq_elt(&mut self, idx: uint, f: |&mut Encoder|) {
+    fn emit_seq_elt(&mut self, idx: uint, f: |&mut Encoder<'self>|) {
         if idx != 0 {
             write!(self.wr, ",");
         }
         f(self)
     }
 
-    fn emit_map(&mut self, _len: uint, f: |&mut Encoder|) {
+    fn emit_map(&mut self, _len: uint, f: |&mut Encoder<'self>|) {
         write!(self.wr, r"\{");
         f(self);
         write!(self.wr, r"\}");
     }
 
-    fn emit_map_elt_key(&mut self, idx: uint, f: |&mut Encoder|) {
+    fn emit_map_elt_key(&mut self, idx: uint, f: |&mut Encoder<'self>|) {
         if idx != 0 { write!(self.wr, ",") }
         f(self)
     }
 
-    fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut Encoder|) {
+    fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut Encoder<'self>|) {
         write!(self.wr, ":");
         f(self)
     }
@@ -238,20 +240,22 @@ impl serialize::Encoder for Encoder {
 
 /// Another encoder for JSON, but prints out human-readable JSON instead of
 /// compact data
-pub struct PrettyEncoder {
-    priv wr: @mut io::Writer,
+pub struct PrettyEncoder<'self> {
+    priv wr: &'self mut io::Writer,
     priv indent: uint,
 }
 
-/// Creates a new encoder whose output will be written to the specified writer
-pub fn PrettyEncoder(wr: @mut io::Writer) -> PrettyEncoder {
-    PrettyEncoder {
-        wr: wr,
-        indent: 0,
+impl<'self> PrettyEncoder<'self> {
+    /// Creates a new encoder whose output will be written to the specified writer
+    pub fn init<'a>(wr: &'a mut io::Writer) -> PrettyEncoder<'a> {
+        PrettyEncoder {
+            wr: wr,
+            indent: 0,
+        }
     }
 }
 
-impl serialize::Encoder for PrettyEncoder {
+impl<'self> serialize::Encoder for PrettyEncoder<'self> {
     fn emit_nil(&mut self) { write!(self.wr, "null") }
 
     fn emit_uint(&mut self, v: uint) { self.emit_f64(v as f64); }
@@ -282,7 +286,7 @@ impl serialize::Encoder for PrettyEncoder {
     fn emit_char(&mut self, v: char) { self.emit_str(str::from_char(v)) }
     fn emit_str(&mut self, v: &str) { write!(self.wr, "{}", escape_str(v)); }
 
-    fn emit_enum(&mut self, _name: &str, f: |&mut PrettyEncoder|) {
+    fn emit_enum(&mut self, _name: &str, f: |&mut PrettyEncoder<'self>|) {
         f(self)
     }
 
@@ -290,7 +294,7 @@ impl serialize::Encoder for PrettyEncoder {
                          name: &str,
                          _: uint,
                          cnt: uint,
-                         f: |&mut PrettyEncoder|) {
+                         f: |&mut PrettyEncoder<'self>|) {
         if cnt == 0 {
             write!(self.wr, "{}", escape_str(name));
         } else {
@@ -304,7 +308,7 @@ impl serialize::Encoder for PrettyEncoder {
 
     fn emit_enum_variant_arg(&mut self,
                              idx: uint,
-                             f: |&mut PrettyEncoder|) {
+                             f: |&mut PrettyEncoder<'self>|) {
         if idx != 0 {
             write!(self.wr, ",\n");
         }
@@ -316,14 +320,14 @@ impl serialize::Encoder for PrettyEncoder {
                                 name: &str,
                                 id: uint,
                                 cnt: uint,
-                                f: |&mut PrettyEncoder|) {
+                                f: |&mut PrettyEncoder<'self>|) {
         self.emit_enum_variant(name, id, cnt, f)
     }
 
     fn emit_enum_struct_variant_field(&mut self,
                                       _: &str,
                                       idx: uint,
-                                      f: |&mut PrettyEncoder|) {
+                                      f: |&mut PrettyEncoder<'self>|) {
         self.emit_enum_variant_arg(idx, f)
     }
 
@@ -331,7 +335,7 @@ impl serialize::Encoder for PrettyEncoder {
     fn emit_struct(&mut self,
                    _: &str,
                    len: uint,
-                   f: |&mut PrettyEncoder|) {
+                   f: |&mut PrettyEncoder<'self>|) {
         if len == 0 {
             write!(self.wr, "\\{\\}");
         } else {
@@ -346,7 +350,7 @@ impl serialize::Encoder for PrettyEncoder {
     fn emit_struct_field(&mut self,
                          name: &str,
                          idx: uint,
-                         f: |&mut PrettyEncoder|) {
+                         f: |&mut PrettyEncoder<'self>|) {
         if idx == 0 {
             write!(self.wr, "\n");
         } else {
@@ -356,30 +360,30 @@ impl serialize::Encoder for PrettyEncoder {
         f(self);
     }
 
-    fn emit_tuple(&mut self, len: uint, f: |&mut PrettyEncoder|) {
+    fn emit_tuple(&mut self, len: uint, f: |&mut PrettyEncoder<'self>|) {
         self.emit_seq(len, f)
     }
-    fn emit_tuple_arg(&mut self, idx: uint, f: |&mut PrettyEncoder|) {
+    fn emit_tuple_arg(&mut self, idx: uint, f: |&mut PrettyEncoder<'self>|) {
         self.emit_seq_elt(idx, f)
     }
 
     fn emit_tuple_struct(&mut self,
                          _: &str,
                          len: uint,
-                         f: |&mut PrettyEncoder|) {
+                         f: |&mut PrettyEncoder<'self>|) {
         self.emit_seq(len, f)
     }
     fn emit_tuple_struct_arg(&mut self,
                              idx: uint,
-                             f: |&mut PrettyEncoder|) {
+                             f: |&mut PrettyEncoder<'self>|) {
         self.emit_seq_elt(idx, f)
     }
 
-    fn emit_option(&mut self, f: |&mut PrettyEncoder|) { f(self); }
+    fn emit_option(&mut self, f: |&mut PrettyEncoder<'self>|) { f(self); }
     fn emit_option_none(&mut self) { self.emit_nil(); }
-    fn emit_option_some(&mut self, f: |&mut PrettyEncoder|) { f(self); }
+    fn emit_option_some(&mut self, f: |&mut PrettyEncoder<'self>|) { f(self); }
 
-    fn emit_seq(&mut self, len: uint, f: |&mut PrettyEncoder|) {
+    fn emit_seq(&mut self, len: uint, f: |&mut PrettyEncoder<'self>|) {
         if len == 0 {
             write!(self.wr, "[]");
         } else {
@@ -391,7 +395,7 @@ impl serialize::Encoder for PrettyEncoder {
         }
     }
 
-    fn emit_seq_elt(&mut self, idx: uint, f: |&mut PrettyEncoder|) {
+    fn emit_seq_elt(&mut self, idx: uint, f: |&mut PrettyEncoder<'self>|) {
         if idx == 0 {
             write!(self.wr, "\n");
         } else {
@@ -401,7 +405,7 @@ impl serialize::Encoder for PrettyEncoder {
         f(self)
     }
 
-    fn emit_map(&mut self, len: uint, f: |&mut PrettyEncoder|) {
+    fn emit_map(&mut self, len: uint, f: |&mut PrettyEncoder<'self>|) {
         if len == 0 {
             write!(self.wr, "\\{\\}");
         } else {
@@ -413,7 +417,7 @@ impl serialize::Encoder for PrettyEncoder {
         }
     }
 
-    fn emit_map_elt_key(&mut self, idx: uint, f: |&mut PrettyEncoder|) {
+    fn emit_map_elt_key(&mut self, idx: uint, f: |&mut PrettyEncoder<'self>|) {
         if idx == 0 {
             write!(self.wr, "\n");
         } else {
@@ -423,7 +427,7 @@ impl serialize::Encoder for PrettyEncoder {
         f(self);
     }
 
-    fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut PrettyEncoder|) {
+    fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut PrettyEncoder<'self>|) {
         write!(self.wr, ": ");
         f(self);
     }
@@ -444,43 +448,45 @@ impl<E: serialize::Encoder> serialize::Encodable<E> for Json {
 
 impl Json{
     /// Encodes a json value into a io::writer.  Uses a single line.
-    pub fn to_writer(&self, wr: @mut io::Writer) {
-        let mut encoder = Encoder(wr);
+    pub fn to_writer(&self, wr: &mut io::Writer) {
+        let mut encoder = Encoder::init(wr);
         self.encode(&mut encoder)
     }
 
     /// Encodes a json value into a io::writer.
     /// Pretty-prints in a more readable format.
-    pub fn to_pretty_writer(&self, wr: @mut io::Writer) {
-        let mut encoder = PrettyEncoder(wr);
+    pub fn to_pretty_writer(&self, wr: &mut io::Writer) {
+        let mut encoder = PrettyEncoder::init(wr);
         self.encode(&mut encoder)
     }
 
     /// Encodes a json value into a string
     pub fn to_pretty_str(&self) -> ~str {
-        let s = @mut MemWriter::new();
-        self.to_pretty_writer(s as @mut io::Writer);
-        str::from_utf8(s.inner_ref().as_slice())
+        let mut s = MemWriter::new();
+        self.to_pretty_writer(&mut s as &mut io::Writer);
+        str::from_utf8_owned(s.inner())
     }
 }
 
 pub struct Parser<T> {
-    priv rdr: ~T,
+    priv rdr: T,
     priv ch: char,
     priv line: uint,
     priv col: uint,
 }
 
-/// Decode a json value from an Iterator<char>
-pub fn Parser<T : Iterator<char>>(rdr: ~T) -> Parser<T> {
-    let mut p = Parser {
-        rdr: rdr,
-        ch: '\x00',
-        line: 1,
-        col: 0,
-    };
-    p.bump();
-    p
+impl<T: Iterator<char>> Parser<T> {
+    /// Decode a json value from an Iterator<char>
+    pub fn init(rdr: T) -> Parser<T> {
+        let mut p = Parser {
+            rdr: rdr,
+            ch: '\x00',
+            line: 1,
+            col: 0,
+        };
+        p.bump();
+        p
+    }
 }
 
 impl<T: Iterator<char>> Parser<T> {
@@ -525,7 +531,7 @@ impl<T : Iterator<char>> Parser<T> {
     }
 
     fn error<T>(&self, msg: ~str) -> Result<T, Error> {
-        Err(Error { line: self.line, col: self.col, msg: @msg })
+        Err(Error { line: self.line, col: self.col, msg: msg })
     }
 
     fn parse_value(&mut self) -> Result<Json, Error> {
@@ -841,14 +847,14 @@ impl<T : Iterator<char>> Parser<T> {
 
 /// Decodes a json value from an `&mut io::Reader`
 pub fn from_reader(rdr: &mut io::Reader) -> Result<Json, Error> {
-    let s = str::from_utf8(rdr.read_to_end());
-    let mut parser = Parser(~s.chars());
+    let s = str::from_utf8_owned(rdr.read_to_end());
+    let mut parser = Parser::init(s.chars());
     parser.parse()
 }
 
 /// Decodes a json value from a string
 pub fn from_str(s: &str) -> Result<Json, Error> {
-    let mut parser = Parser(~s.chars());
+    let mut parser = Parser::init(s.chars());
     parser.parse()
 }
 
@@ -857,10 +863,12 @@ pub struct Decoder {
     priv stack: ~[Json],
 }
 
-/// Creates a new decoder instance for decoding the specified JSON value.
-pub fn Decoder(json: Json) -> Decoder {
-    Decoder {
-        stack: ~[json]
+impl Decoder {
+    /// Creates a new decoder instance for decoding the specified JSON value.
+    pub fn init(json: Json) -> Decoder {
+        Decoder {
+            stack: ~[json]
+        }
     }
 }
 
@@ -1195,10 +1203,6 @@ impl ToJson for Json {
     fn to_json(&self) -> Json { (*self).clone() }
 }
 
-impl ToJson for @Json {
-    fn to_json(&self) -> Json { (**self).to_json() }
-}
-
 impl ToJson for int {
     fn to_json(&self) -> Json { Number(*self as f64) }
 }
@@ -1259,10 +1263,6 @@ impl ToJson for ~str {
     fn to_json(&self) -> Json { String((*self).clone()) }
 }
 
-impl ToJson for @~str {
-    fn to_json(&self) -> Json { String((**self).clone()) }
-}
-
 impl<A:ToJson,B:ToJson> ToJson for (A, B) {
     fn to_json(&self) -> Json {
         match *self {
@@ -1319,15 +1319,15 @@ impl<A:ToJson> ToJson for Option<A> {
 impl to_str::ToStr for Json {
     /// Encodes a json value into a string
     fn to_str(&self) -> ~str {
-        let s = @mut MemWriter::new();
-        self.to_writer(s as @mut io::Writer);
-        str::from_utf8(s.inner_ref().as_slice())
+        let mut s = MemWriter::new();
+        self.to_writer(&mut s as &mut io::Writer);
+        str::from_utf8_owned(s.inner())
     }
 }
 
 impl to_str::ToStr for Error {
     fn to_str(&self) -> ~str {
-        format!("{}:{}: {}", self.line, self.col, *self.msg)
+        format!("{}:{}: {}", self.line, self.col, self.msg)
     }
 }
 
@@ -1507,14 +1507,14 @@ mod tests {
         assert_eq!(a.clone(), from_str(a.to_pretty_str()).unwrap());
     }
 
-    fn with_str_writer(f: |@mut io::Writer|) -> ~str {
+    fn with_str_writer(f: |&mut io::Writer|) -> ~str {
         use std::io::mem::MemWriter;
         use std::io::Decorator;
         use std::str;
 
-        let m = @mut MemWriter::new();
-        f(m as @mut io::Writer);
-        str::from_utf8(*m.inner_ref())
+        let mut m = MemWriter::new();
+        f(&mut m as &mut io::Writer);
+        str::from_utf8_owned(m.inner())
     }
 
     #[test]
@@ -1522,14 +1522,14 @@ mod tests {
         let animal = Dog;
         assert_eq!(
             with_str_writer(|wr| {
-                let mut encoder = Encoder(wr);
+                let mut encoder = Encoder::init(wr);
                 animal.encode(&mut encoder);
             }),
             ~"\"Dog\""
         );
         assert_eq!(
             with_str_writer(|wr| {
-                let mut encoder = PrettyEncoder(wr);
+                let mut encoder = PrettyEncoder::init(wr);
                 animal.encode(&mut encoder);
             }),
             ~"\"Dog\""
@@ -1538,14 +1538,14 @@ mod tests {
         let animal = Frog(~"Henry", 349);
         assert_eq!(
             with_str_writer(|wr| {
-                let mut encoder = Encoder(wr);
+                let mut encoder = Encoder::init(wr);
                 animal.encode(&mut encoder);
             }),
             ~"{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
         );
         assert_eq!(
             with_str_writer(|wr| {
-                let mut encoder = PrettyEncoder(wr);
+                let mut encoder = PrettyEncoder::init(wr);
                 animal.encode(&mut encoder);
             }),
             ~"\
@@ -1561,14 +1561,14 @@ mod tests {
     fn test_write_some() {
         let value = Some(~"jodhpurs");
         let s = with_str_writer(|wr| {
-            let mut encoder = Encoder(wr);
+            let mut encoder = Encoder::init(wr);
             value.encode(&mut encoder);
         });
         assert_eq!(s, ~"\"jodhpurs\"");
 
         let value = Some(~"jodhpurs");
         let s = with_str_writer(|wr| {
-            let mut encoder = PrettyEncoder(wr);
+            let mut encoder = PrettyEncoder::init(wr);
             value.encode(&mut encoder);
         });
         assert_eq!(s, ~"\"jodhpurs\"");
@@ -1578,13 +1578,13 @@ mod tests {
     fn test_write_none() {
         let value: Option<~str> = None;
         let s = with_str_writer(|wr| {
-            let mut encoder = Encoder(wr);
+            let mut encoder = Encoder::init(wr);
             value.encode(&mut encoder);
         });
         assert_eq!(s, ~"null");
 
         let s = with_str_writer(|wr| {
-            let mut encoder = Encoder(wr);
+            let mut encoder = Encoder::init(wr);
             value.encode(&mut encoder);
         });
         assert_eq!(s, ~"null");
@@ -1593,35 +1593,35 @@ mod tests {
     #[test]
     fn test_trailing_characters() {
         assert_eq!(from_str("nulla"),
-            Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"}));
+            Err(Error {line: 1u, col: 5u, msg: ~"trailing characters"}));
         assert_eq!(from_str("truea"),
-            Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"}));
+            Err(Error {line: 1u, col: 5u, msg: ~"trailing characters"}));
         assert_eq!(from_str("falsea"),
-            Err(Error {line: 1u, col: 6u, msg: @~"trailing characters"}));
+            Err(Error {line: 1u, col: 6u, msg: ~"trailing characters"}));
         assert_eq!(from_str("1a"),
-            Err(Error {line: 1u, col: 2u, msg: @~"trailing characters"}));
+            Err(Error {line: 1u, col: 2u, msg: ~"trailing characters"}));
         assert_eq!(from_str("[]a"),
-            Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"}));
+            Err(Error {line: 1u, col: 3u, msg: ~"trailing characters"}));
         assert_eq!(from_str("{}a"),
-            Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"}));
+            Err(Error {line: 1u, col: 3u, msg: ~"trailing characters"}));
     }
 
     #[test]
     fn test_read_identifiers() {
         assert_eq!(from_str("n"),
-            Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"}));
+            Err(Error {line: 1u, col: 2u, msg: ~"invalid syntax"}));
         assert_eq!(from_str("nul"),
-            Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"}));
+            Err(Error {line: 1u, col: 4u, msg: ~"invalid syntax"}));
 
         assert_eq!(from_str("t"),
-            Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"}));
+            Err(Error {line: 1u, col: 2u, msg: ~"invalid syntax"}));
         assert_eq!(from_str("truz"),
-            Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"}));
+            Err(Error {line: 1u, col: 4u, msg: ~"invalid syntax"}));
 
         assert_eq!(from_str("f"),
-            Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"}));
+            Err(Error {line: 1u, col: 2u, msg: ~"invalid syntax"}));
         assert_eq!(from_str("faz"),
-            Err(Error {line: 1u, col: 3u, msg: @~"invalid syntax"}));
+            Err(Error {line: 1u, col: 3u, msg: ~"invalid syntax"}));
 
         assert_eq!(from_str("null"), Ok(Null));
         assert_eq!(from_str("true"), Ok(Boolean(true)));
@@ -1633,15 +1633,15 @@ mod tests {
 
     #[test]
     fn test_decode_identifiers() {
-        let mut decoder = Decoder(from_str("null").unwrap());
+        let mut decoder = Decoder::init(from_str("null").unwrap());
         let v: () = Decodable::decode(&mut decoder);
         assert_eq!(v, ());
 
-        let mut decoder = Decoder(from_str("true").unwrap());
+        let mut decoder = Decoder::init(from_str("true").unwrap());
         let v: bool = Decodable::decode(&mut decoder);
         assert_eq!(v, true);
 
-        let mut decoder = Decoder(from_str("false").unwrap());
+        let mut decoder = Decoder::init(from_str("false").unwrap());
         let v: bool = Decodable::decode(&mut decoder);
         assert_eq!(v, false);
     }
@@ -1649,20 +1649,20 @@ mod tests {
     #[test]
     fn test_read_number() {
         assert_eq!(from_str("+"),
-            Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"}));
+            Err(Error {line: 1u, col: 1u, msg: ~"invalid syntax"}));
         assert_eq!(from_str("."),
-            Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"}));
+            Err(Error {line: 1u, col: 1u, msg: ~"invalid syntax"}));
 
         assert_eq!(from_str("-"),
-            Err(Error {line: 1u, col: 2u, msg: @~"invalid number"}));
+            Err(Error {line: 1u, col: 2u, msg: ~"invalid number"}));
         assert_eq!(from_str("00"),
-            Err(Error {line: 1u, col: 2u, msg: @~"invalid number"}));
+            Err(Error {line: 1u, col: 2u, msg: ~"invalid number"}));
         assert_eq!(from_str("1."),
-            Err(Error {line: 1u, col: 3u, msg: @~"invalid number"}));
+            Err(Error {line: 1u, col: 3u, msg: ~"invalid number"}));
         assert_eq!(from_str("1e"),
-            Err(Error {line: 1u, col: 3u, msg: @~"invalid number"}));
+            Err(Error {line: 1u, col: 3u, msg: ~"invalid number"}));
         assert_eq!(from_str("1e+"),
-            Err(Error {line: 1u, col: 4u, msg: @~"invalid number"}));
+            Err(Error {line: 1u, col: 4u, msg: ~"invalid number"}));
 
         assert_eq!(from_str("3"), Ok(Number(3.0)));
         assert_eq!(from_str("3.1"), Ok(Number(3.1)));
@@ -1676,31 +1676,31 @@ mod tests {
 
     #[test]
     fn test_decode_numbers() {
-        let mut decoder = Decoder(from_str("3").unwrap());
+        let mut decoder = Decoder::init(from_str("3").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, 3.0);
 
-        let mut decoder = Decoder(from_str("3.1").unwrap());
+        let mut decoder = Decoder::init(from_str("3.1").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, 3.1);
 
-        let mut decoder = Decoder(from_str("-1.2").unwrap());
+        let mut decoder = Decoder::init(from_str("-1.2").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, -1.2);
 
-        let mut decoder = Decoder(from_str("0.4").unwrap());
+        let mut decoder = Decoder::init(from_str("0.4").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, 0.4);
 
-        let mut decoder = Decoder(from_str("0.4e5").unwrap());
+        let mut decoder = Decoder::init(from_str("0.4e5").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, 0.4e5);
 
-        let mut decoder = Decoder(from_str("0.4e15").unwrap());
+        let mut decoder = Decoder::init(from_str("0.4e15").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, 0.4e15);
 
-        let mut decoder = Decoder(from_str("0.4e-01").unwrap());
+        let mut decoder = Decoder::init(from_str("0.4e-01").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, 0.4e-01);
     }
@@ -1708,10 +1708,10 @@ mod tests {
     #[test]
     fn test_read_str() {
         assert_eq!(from_str("\""),
-            Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing string"
+            Err(Error {line: 1u, col: 2u, msg: ~"EOF while parsing string"
         }));
         assert_eq!(from_str("\"lol"),
-            Err(Error {line: 1u, col: 5u, msg: @~"EOF while parsing string"
+            Err(Error {line: 1u, col: 5u, msg: ~"EOF while parsing string"
         }));
 
         assert_eq!(from_str("\"\""), Ok(String(~"")));
@@ -1728,39 +1728,39 @@ mod tests {
 
     #[test]
     fn test_decode_str() {
-        let mut decoder = Decoder(from_str("\"\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"");
 
-        let mut decoder = Decoder(from_str("\"foo\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"foo\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"foo");
 
-        let mut decoder = Decoder(from_str("\"\\\"\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\\"\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\"");
 
-        let mut decoder = Decoder(from_str("\"\\b\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\b\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\x08");
 
-        let mut decoder = Decoder(from_str("\"\\n\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\n\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\n");
 
-        let mut decoder = Decoder(from_str("\"\\r\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\r\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\r");
 
-        let mut decoder = Decoder(from_str("\"\\t\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\t\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\t");
 
-        let mut decoder = Decoder(from_str("\"\\u12ab\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\u12ab\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\u12ab");
 
-        let mut decoder = Decoder(from_str("\"\\uAB12\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\uAB12\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\uAB12");
     }
@@ -1768,15 +1768,15 @@ mod tests {
     #[test]
     fn test_read_list() {
         assert_eq!(from_str("["),
-            Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing value"}));
+            Err(Error {line: 1u, col: 2u, msg: ~"EOF while parsing value"}));
         assert_eq!(from_str("[1"),
-            Err(Error {line: 1u, col: 3u, msg: @~"EOF while parsing list"}));
+            Err(Error {line: 1u, col: 3u, msg: ~"EOF while parsing list"}));
         assert_eq!(from_str("[1,"),
-            Err(Error {line: 1u, col: 4u, msg: @~"EOF while parsing value"}));
+            Err(Error {line: 1u, col: 4u, msg: ~"EOF while parsing value"}));
         assert_eq!(from_str("[1,]"),
-            Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"}));
+            Err(Error {line: 1u, col: 4u, msg: ~"invalid syntax"}));
         assert_eq!(from_str("[6 7]"),
-            Err(Error {line: 1u, col: 4u, msg: @~"expected `,` or `]`"}));
+            Err(Error {line: 1u, col: 4u, msg: ~"expected `,` or `]`"}));
 
         assert_eq!(from_str("[]"), Ok(List(~[])));
         assert_eq!(from_str("[ ]"), Ok(List(~[])));
@@ -1793,27 +1793,27 @@ mod tests {
 
     #[test]
     fn test_decode_list() {
-        let mut decoder = Decoder(from_str("[]").unwrap());
+        let mut decoder = Decoder::init(from_str("[]").unwrap());
         let v: ~[()] = Decodable::decode(&mut decoder);
         assert_eq!(v, ~[]);
 
-        let mut decoder = Decoder(from_str("[null]").unwrap());
+        let mut decoder = Decoder::init(from_str("[null]").unwrap());
         let v: ~[()] = Decodable::decode(&mut decoder);
         assert_eq!(v, ~[()]);
 
-        let mut decoder = Decoder(from_str("[true]").unwrap());
+        let mut decoder = Decoder::init(from_str("[true]").unwrap());
         let v: ~[bool] = Decodable::decode(&mut decoder);
         assert_eq!(v, ~[true]);
 
-        let mut decoder = Decoder(from_str("[true]").unwrap());
+        let mut decoder = Decoder::init(from_str("[true]").unwrap());
         let v: ~[bool] = Decodable::decode(&mut decoder);
         assert_eq!(v, ~[true]);
 
-        let mut decoder = Decoder(from_str("[3, 1]").unwrap());
+        let mut decoder = Decoder::init(from_str("[3, 1]").unwrap());
         let v: ~[int] = Decodable::decode(&mut decoder);
         assert_eq!(v, ~[3, 1]);
 
-        let mut decoder = Decoder(from_str("[[3], [1, 2]]").unwrap());
+        let mut decoder = Decoder::init(from_str("[[3], [1, 2]]").unwrap());
         let v: ~[~[uint]] = Decodable::decode(&mut decoder);
         assert_eq!(v, ~[~[3], ~[1, 2]]);
     }
@@ -1824,49 +1824,49 @@ mod tests {
             Err(Error {
                 line: 1u,
                 col: 2u,
-                msg: @~"EOF while parsing object"}));
+                msg: ~"EOF while parsing object"}));
         assert_eq!(from_str("{ "),
             Err(Error {
                 line: 1u,
                 col: 3u,
-                msg: @~"EOF while parsing object"}));
+                msg: ~"EOF while parsing object"}));
         assert_eq!(from_str("{1"),
             Err(Error {
                 line: 1u,
                 col: 2u,
-                msg: @~"key must be a string"}));
+                msg: ~"key must be a string"}));
         assert_eq!(from_str("{ \"a\""),
             Err(Error {
                 line: 1u,
                 col: 6u,
-                msg: @~"EOF while parsing object"}));
+                msg: ~"EOF while parsing object"}));
         assert_eq!(from_str("{\"a\""),
             Err(Error {
                 line: 1u,
                 col: 5u,
-                msg: @~"EOF while parsing object"}));
+                msg: ~"EOF while parsing object"}));
         assert_eq!(from_str("{\"a\" "),
             Err(Error {
                 line: 1u,
                 col: 6u,
-                msg: @~"EOF while parsing object"}));
+                msg: ~"EOF while parsing object"}));
 
         assert_eq!(from_str("{\"a\" 1"),
-            Err(Error {line: 1u, col: 6u, msg: @~"expected `:`"}));
+            Err(Error {line: 1u, col: 6u, msg: ~"expected `:`"}));
         assert_eq!(from_str("{\"a\":"),
-            Err(Error {line: 1u, col: 6u, msg: @~"EOF while parsing value"}));
+            Err(Error {line: 1u, col: 6u, msg: ~"EOF while parsing value"}));
         assert_eq!(from_str("{\"a\":1"),
             Err(Error {
                 line: 1u,
                 col: 7u,
-                msg: @~"EOF while parsing object"}));
+                msg: ~"EOF while parsing object"}));
         assert_eq!(from_str("{\"a\":1 1"),
-            Err(Error {line: 1u, col: 8u, msg: @~"expected `,` or `}`"}));
+            Err(Error {line: 1u, col: 8u, msg: ~"expected `,` or `}`"}));
         assert_eq!(from_str("{\"a\":1,"),
             Err(Error {
                 line: 1u,
                 col: 8u,
-                msg: @~"EOF while parsing object"}));
+                msg: ~"EOF while parsing object"}));
 
         assert_eq!(from_str("{}").unwrap(), mk_object([]));
         assert_eq!(from_str("{\"a\": 3}").unwrap(),
@@ -1915,7 +1915,7 @@ mod tests {
                 { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
             ]
         }";
-        let mut decoder = Decoder(from_str(s).unwrap());
+        let mut decoder = Decoder::init(from_str(s).unwrap());
         let v: Outer = Decodable::decode(&mut decoder);
         assert_eq!(
             v,
@@ -1929,23 +1929,23 @@ mod tests {
 
     #[test]
     fn test_decode_option() {
-        let mut decoder = Decoder(from_str("null").unwrap());
+        let mut decoder = Decoder::init(from_str("null").unwrap());
         let value: Option<~str> = Decodable::decode(&mut decoder);
         assert_eq!(value, None);
 
-        let mut decoder = Decoder(from_str("\"jodhpurs\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"jodhpurs\"").unwrap());
         let value: Option<~str> = Decodable::decode(&mut decoder);
         assert_eq!(value, Some(~"jodhpurs"));
     }
 
     #[test]
     fn test_decode_enum() {
-        let mut decoder = Decoder(from_str("\"Dog\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"Dog\"").unwrap());
         let value: Animal = Decodable::decode(&mut decoder);
         assert_eq!(value, Dog);
 
-        let mut decoder =
-            Decoder(from_str("{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}").unwrap());
+        let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
+        let mut decoder = Decoder::init(from_str(s).unwrap());
         let value: Animal = Decodable::decode(&mut decoder);
         assert_eq!(value, Frog(~"Henry", 349));
     }
@@ -1953,7 +1953,7 @@ mod tests {
     #[test]
     fn test_decode_map() {
         let s = ~"{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\"fields\":[\"Henry\", 349]}}";
-        let mut decoder = Decoder(from_str(s).unwrap());
+        let mut decoder = Decoder::init(from_str(s).unwrap());
         let mut map: TreeMap<~str, Animal> = Decodable::decode(&mut decoder);
 
         assert_eq!(map.pop(&~"a"), Some(Dog));
@@ -1966,7 +1966,7 @@ mod tests {
             Err(Error {
                 line: 3u,
                 col: 8u,
-                msg: @~"EOF while parsing object"}));
+                msg: ~"EOF while parsing object"}));
     }
 
     #[deriving(Decodable)]
@@ -1990,7 +1990,7 @@ mod tests {
             match from_str(to_parse) {
                 Err(e) => Some(e.to_str()),
                 Ok(json) => {
-                    let _: T = Decodable::decode(&mut Decoder(json));
+                    let _: T = Decodable::decode(&mut Decoder::init(json));
                     None
                 }
             }
diff --git a/src/libextra/test.rs b/src/libextra/test.rs
index 2fd38825ae2..93ffb8f9fde 100644
--- a/src/libextra/test.rs
+++ b/src/libextra/test.rs
@@ -945,8 +945,9 @@ impl MetricMap {
     /// Load MetricDiff from a file.
     pub fn load(p: &Path) -> MetricMap {
         assert!(p.exists());
-        let f = @mut File::open(p) as @mut io::Reader;
-        let mut decoder = json::Decoder(json::from_reader(f).unwrap());
+        let mut f = File::open(p);
+        let value = json::from_reader(&mut f as &mut io::Reader).unwrap();
+        let mut decoder = json::Decoder::init(value);
         MetricMap(Decodable::decode(&mut decoder))
     }
 
diff --git a/src/libextra/workcache.rs b/src/libextra/workcache.rs
index beb21133908..ab36defe522 100644
--- a/src/libextra/workcache.rs
+++ b/src/libextra/workcache.rs
@@ -191,7 +191,7 @@ impl Database {
                     Err(e) => fail!("Couldn't parse workcache database (from file {}): {}",
                                     self.db_filename.display(), e.to_str()),
                     Ok(r) => {
-                        let mut decoder = json::Decoder(r);
+                        let mut decoder = json::Decoder::init(r);
                         self.db_cache = Decodable::decode(&mut decoder);
                     }
             }
@@ -256,9 +256,9 @@ enum Work<'self, T> {
     WorkFromTask(&'self Prep<'self>, PortOne<(Exec, T)>),
 }
 
-fn json_encode<T:Encodable<json::Encoder>>(t: &T) -> ~str {
-    let writer = @mut MemWriter::new();
-    let mut encoder = json::Encoder(writer as @mut io::Writer);
+fn json_encode<'self, T:Encodable<json::Encoder<'self>>>(t: &T) -> ~str {
+    let mut writer = MemWriter::new();
+    let mut encoder = json::Encoder::init(&mut writer as &mut io::Writer);
     t.encode(&mut encoder);
     str::from_utf8(writer.inner_ref().as_slice())
 }
@@ -267,7 +267,7 @@ fn json_encode<T:Encodable<json::Encoder>>(t: &T) -> ~str {
 fn json_decode<T:Decodable<json::Decoder>>(s: &str) -> T {
     debug!("json decoding: {}", s);
     let j = json::from_str(s).unwrap();
-    let mut decoder = json::Decoder(j);
+    let mut decoder = json::Decoder::init(j);
     Decodable::decode(&mut decoder)
 }
 
@@ -396,15 +396,15 @@ impl<'self> Prep<'self> {
         return true;
     }
 
-    pub fn exec<T:Send +
-        Encodable<json::Encoder> +
+    pub fn exec<'self, T:Send +
+        Encodable<json::Encoder<'self>> +
         Decodable<json::Decoder>>(
             &'self self, blk: proc(&mut Exec) -> T) -> T {
         self.exec_work(blk).unwrap()
     }
 
-    fn exec_work<T:Send +
-        Encodable<json::Encoder> +
+    fn exec_work<'self, T:Send +
+        Encodable<json::Encoder<'self>> +
         Decodable<json::Decoder>>( // FIXME(#5121)
             &'self self, blk: proc(&mut Exec) -> T) -> Work<'self, T> {
         let mut bo = Some(blk);
@@ -449,7 +449,7 @@ impl<'self> Prep<'self> {
 }
 
 impl<'self, T:Send +
-       Encodable<json::Encoder> +
+       Encodable<json::Encoder<'self>> +
        Decodable<json::Decoder>>
     Work<'self, T> { // FIXME(#5121)
 
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index c51244cddf5..e699aa2edef 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -283,7 +283,7 @@ fn json_input(input: &str) -> Result<Output, ~str> {
             }
             let crate = match obj.pop(&~"crate") {
                 Some(json) => {
-                    let mut d = json::Decoder(json);
+                    let mut d = json::Decoder::init(json);
                     Decodable::decode(&mut d)
                 }
                 None => return Err(~"malformed json"),
@@ -312,9 +312,12 @@ fn json_output(crate: clean::Crate, res: ~[plugins::PluginJson], dst: Path) {
     // FIXME #8335: yuck, Rust -> str -> JSON round trip! No way to .encode
     // straight to the Rust JSON representation.
     let crate_json_str = {
-        let w = @mut MemWriter::new();
-        crate.encode(&mut json::Encoder(w as @mut io::Writer));
-        str::from_utf8(*w.inner_ref())
+        let mut w = MemWriter::new();
+        {
+            let mut encoder = json::Encoder::init(&mut w as &mut io::Writer);
+            crate.encode(&mut encoder);
+        }
+        str::from_utf8_owned(w.inner())
     };
     let crate_json = match json::from_str(crate_json_str) {
         Ok(j) => j,
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 8fbd152543d..54a3dad9495 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -341,11 +341,12 @@ mod test {
     use util::parser_testing::{string_to_expr, string_to_item};
     use util::parser_testing::string_to_stmt;
 
-    #[cfg(test)] fn to_json_str<E : Encodable<extra::json::Encoder>>(val: @E) -> ~str {
-        let writer = @mut MemWriter::new();
-        let mut encoder = extra::json::Encoder(writer as @mut io::Writer);
+    #[cfg(test)]
+    fn to_json_str<'a, E: Encodable<extra::json::Encoder<'a>>>(val: &E) -> ~str {
+        let mut writer = MemWriter::new();
+        let mut encoder = extra::json::Encoder::init(&mut writer as &mut io::Writer);
         val.encode(&mut encoder);
-        str::from_utf8(*writer.inner_ref())
+        str::from_utf8_owned(writer.inner())
     }
 
     // produce a codemap::span
diff --git a/src/test/run-pass/issue-4016.rs b/src/test/run-pass/issue-4016.rs
index c4178961d9e..578d210a6fc 100644
--- a/src/test/run-pass/issue-4016.rs
+++ b/src/test/run-pass/issue-4016.rs
@@ -18,7 +18,7 @@ trait JD : Decodable<json::Decoder> { }
 
 fn exec<T: JD>() {
     let doc = json::from_str("").unwrap();
-    let mut decoder = json::Decoder(doc);
+    let mut decoder = json::Decoder::init(doc);
     let _v: T = Decodable::decode(&mut decoder);
     fail!()
 }
diff --git a/src/test/run-pass/issue-4036.rs b/src/test/run-pass/issue-4036.rs
index ad820712595..bd3ca844263 100644
--- a/src/test/run-pass/issue-4036.rs
+++ b/src/test/run-pass/issue-4036.rs
@@ -17,6 +17,6 @@ use self::extra::serialize;
 
 pub fn main() {
     let json = json::from_str("[1]").unwrap();
-    let mut decoder = json::Decoder(json);
+    let mut decoder = json::Decoder::init(json);
     let _x: ~[int] = serialize::Decodable::decode(&mut decoder);
 }