From 18ca312984b331b87b1a205b3cb954b16912ed82 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 28 Nov 2013 14:50:21 -0800 Subject: [PATCH 1/5] Remove @ from json::Error --- src/libextra/json.rs | 82 ++++++++++++++++++++++---------------------- 1 file changed, 41 insertions(+), 41 deletions(-) diff --git a/src/libextra/json.rs b/src/libextra/json.rs index 27399651392..866f8203c48 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 { @@ -525,7 +525,7 @@ impl> Parser { } fn error(&self, msg: ~str) -> Result { - 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 { @@ -1327,7 +1327,7 @@ impl to_str::ToStr for Json { 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) } } @@ -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))); @@ -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))); @@ -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(~""))); @@ -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(~[]))); @@ -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(), @@ -1966,7 +1966,7 @@ mod tests { Err(Error { line: 3u, col: 8u, - msg: @~"EOF while parsing object"})); + msg: ~"EOF while parsing object"})); } #[deriving(Decodable)] From 5b41df4ca027421a86aeb8d2e96f3754b213c1d5 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 28 Nov 2013 14:51:00 -0800 Subject: [PATCH 2/5] Remove some unnecessary impls from json --- src/libextra/json.rs | 8 -------- 1 file changed, 8 deletions(-) diff --git a/src/libextra/json.rs b/src/libextra/json.rs index 866f8203c48..02c1ac077d4 100644 --- a/src/libextra/json.rs +++ b/src/libextra/json.rs @@ -1195,10 +1195,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 +1255,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 ToJson for (A, B) { fn to_json(&self) -> Json { match *self { From f7b739c34c8b25ca6c98a97dcd1189063f1bf5e9 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Fri, 29 Nov 2013 11:11:52 -0800 Subject: [PATCH 3/5] extra: Rename json constructors into *::init --- src/libextra/json.rs | 146 +++++++++++++++++--------------- src/libextra/test.rs | 2 +- src/libextra/workcache.rs | 6 +- src/librustdoc/lib.rs | 4 +- src/libsyntax/parse/mod.rs | 2 +- src/test/run-pass/issue-4016.rs | 2 +- src/test/run-pass/issue-4036.rs | 2 +- 7 files changed, 86 insertions(+), 78 deletions(-) diff --git a/src/libextra/json.rs b/src/libextra/json.rs index 02c1ac077d4..e0792014c77 100644 --- a/src/libextra/json.rs +++ b/src/libextra/json.rs @@ -88,10 +88,12 @@ pub struct Encoder { priv wr: @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 Encoder { + /// Creates a new JSON encoder whose output will be written to the writer + /// specified. + pub fn init(wr: @mut io::Writer) -> Encoder { + Encoder { wr: wr } + } } impl serialize::Encoder for Encoder { @@ -243,11 +245,13 @@ pub struct PrettyEncoder { 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 PrettyEncoder { + /// Creates a new encoder whose output will be written to the specified writer + pub fn init(wr: @mut io::Writer) -> PrettyEncoder { + PrettyEncoder { + wr: wr, + indent: 0, + } } } @@ -445,14 +449,14 @@ impl serialize::Encodable 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); + 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); + let mut encoder = PrettyEncoder::init(wr); self.encode(&mut encoder) } @@ -465,22 +469,24 @@ impl Json{ } pub struct Parser { - priv rdr: ~T, + priv rdr: T, priv ch: char, priv line: uint, priv col: uint, } -/// Decode a json value from an Iterator -pub fn Parser>(rdr: ~T) -> Parser { - let mut p = Parser { - rdr: rdr, - ch: '\x00', - line: 1, - col: 0, - }; - p.bump(); - p +impl> Parser { + /// Decode a json value from an Iterator + pub fn init(rdr: T) -> Parser { + let mut p = Parser { + rdr: rdr, + ch: '\x00', + line: 1, + col: 0, + }; + p.bump(); + p + } } impl> Parser { @@ -842,13 +848,13 @@ impl> Parser { /// Decodes a json value from an `&mut io::Reader` pub fn from_reader(rdr: &mut io::Reader) -> Result { let s = str::from_utf8(rdr.read_to_end()); - let mut parser = Parser(~s.chars()); + let mut parser = Parser::init(s.chars()); parser.parse() } /// Decodes a json value from a string pub fn from_str(s: &str) -> Result { - 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] + } } } @@ -1514,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\"" @@ -1530,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); }), ~"\ @@ -1553,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\""); @@ -1570,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"); @@ -1625,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); } @@ -1668,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); } @@ -1720,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"); } @@ -1785,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]]); } @@ -1907,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, @@ -1921,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)); } @@ -1945,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)); @@ -1982,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 c16d4aa3e16..ba9478e4448 100644 --- a/src/libextra/test.rs +++ b/src/libextra/test.rs @@ -946,7 +946,7 @@ impl MetricMap { 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 decoder = json::Decoder::init(json::from_reader(f).unwrap()); MetricMap(Decodable::decode(&mut decoder)) } diff --git a/src/libextra/workcache.rs b/src/libextra/workcache.rs index beb21133908..27a0f515597 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); } } @@ -258,7 +258,7 @@ enum Work<'self, T> { fn json_encode>(t: &T) -> ~str { let writer = @mut MemWriter::new(); - let mut encoder = json::Encoder(writer as @mut io::Writer); + let mut encoder = json::Encoder::init(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: &T) -> ~str { fn json_decode>(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) } diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index c5b2125c163..5edafa1b1f6 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -283,7 +283,7 @@ fn json_input(input: &str) -> Result { } 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"), @@ -313,7 +313,7 @@ fn json_output(crate: clean::Crate, res: ~[plugins::PluginJson], dst: Path) { // 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)); + crate.encode(&mut json::Encoder::init(w as @mut io::Writer)); str::from_utf8(*w.inner_ref()) }; let crate_json = match json::from_str(crate_json_str) { diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 8fbd152543d..c932c188279 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -343,7 +343,7 @@ mod test { #[cfg(test)] fn to_json_str>(val: @E) -> ~str { let writer = @mut MemWriter::new(); - let mut encoder = extra::json::Encoder(writer as @mut io::Writer); + let mut encoder = extra::json::Encoder::init(writer as @mut io::Writer); val.encode(&mut encoder); str::from_utf8(*writer.inner_ref()) } 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 { } fn exec() { 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); } From 6818b96a66f51c8912e3d8e88fb79e7956743190 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Fri, 29 Nov 2013 10:12:08 -0800 Subject: [PATCH 4/5] extra: json::Encoder should take a &mut io::Writer --- src/libextra/json.rs | 100 ++++++++++++++++++------------------- src/libextra/workcache.rs | 16 +++--- src/libsyntax/parse/mod.rs | 7 +-- 3 files changed, 62 insertions(+), 61 deletions(-) diff --git a/src/libextra/json.rs b/src/libextra/json.rs index e0792014c77..1b2165fb4cf 100644 --- a/src/libextra/json.rs +++ b/src/libextra/json.rs @@ -84,19 +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, } -impl Encoder { +impl<'self> Encoder<'self> { /// Creates a new JSON encoder whose output will be written to the writer /// specified. - pub fn init(wr: @mut io::Writer) -> Encoder { + 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); } @@ -129,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"]} @@ -150,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, ","); } @@ -161,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"\}"); @@ -181,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) } @@ -240,14 +240,14 @@ 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, } -impl PrettyEncoder { +impl<'self> PrettyEncoder<'self> { /// Creates a new encoder whose output will be written to the specified writer - pub fn init(wr: @mut io::Writer) -> PrettyEncoder { + pub fn init<'a>(wr: &'a mut io::Writer) -> PrettyEncoder<'a> { PrettyEncoder { wr: wr, indent: 0, @@ -255,7 +255,7 @@ impl PrettyEncoder { } } -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); } @@ -286,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) } @@ -294,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 { @@ -308,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"); } @@ -320,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) } @@ -335,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 { @@ -350,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 { @@ -360,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 { @@ -395,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 { @@ -405,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 { @@ -417,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 { @@ -427,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); } @@ -448,22 +448,22 @@ impl serialize::Encodable 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) { + 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) { + 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); + let mut s = MemWriter::new(); + self.to_pretty_writer(&mut s as &mut io::Writer); str::from_utf8(s.inner_ref().as_slice()) } } diff --git a/src/libextra/workcache.rs b/src/libextra/workcache.rs index 27a0f515597..ab36defe522 100644 --- a/src/libextra/workcache.rs +++ b/src/libextra/workcache.rs @@ -256,9 +256,9 @@ enum Work<'self, T> { WorkFromTask(&'self Prep<'self>, PortOne<(Exec, T)>), } -fn json_encode>(t: &T) -> ~str { - let writer = @mut MemWriter::new(); - let mut encoder = json::Encoder::init(writer as @mut io::Writer); +fn json_encode<'self, T:Encodable>>(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()) } @@ -396,15 +396,15 @@ impl<'self> Prep<'self> { return true; } - pub fn exec + + pub fn exec<'self, T:Send + + Encodable> + Decodable>( &'self self, blk: proc(&mut Exec) -> T) -> T { self.exec_work(blk).unwrap() } - fn exec_work + + fn exec_work<'self, T:Send + + Encodable> + Decodable>( // 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 + + Encodable> + Decodable> Work<'self, T> { // FIXME(#5121) diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index c932c188279..988e9958c2b 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -341,9 +341,10 @@ 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>(val: @E) -> ~str { - let writer = @mut MemWriter::new(); - let mut encoder = extra::json::Encoder::init(writer as @mut io::Writer); + #[cfg(test)] + fn to_json_str<'a, E: Encodable>>(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()) } From a7b311ac614ea15f7261eb2ddca56072c18b3cba Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Fri, 29 Nov 2013 21:26:03 -0800 Subject: [PATCH 5/5] extra: missed a couple `@` in json --- src/libextra/json.rs | 18 +++++++++--------- src/libextra/test.rs | 5 +++-- src/librustdoc/lib.rs | 9 ++++++--- src/libsyntax/parse/mod.rs | 2 +- 4 files changed, 19 insertions(+), 15 deletions(-) diff --git a/src/libextra/json.rs b/src/libextra/json.rs index 1b2165fb4cf..30288a08c79 100644 --- a/src/libextra/json.rs +++ b/src/libextra/json.rs @@ -464,7 +464,7 @@ impl Json{ pub fn to_pretty_str(&self) -> ~str { let mut s = MemWriter::new(); self.to_pretty_writer(&mut s as &mut io::Writer); - str::from_utf8(s.inner_ref().as_slice()) + str::from_utf8_owned(s.inner()) } } @@ -847,7 +847,7 @@ impl> Parser { /// Decodes a json value from an `&mut io::Reader` pub fn from_reader(rdr: &mut io::Reader) -> Result { - let s = str::from_utf8(rdr.read_to_end()); + let s = str::from_utf8_owned(rdr.read_to_end()); let mut parser = Parser::init(s.chars()); parser.parse() } @@ -1319,9 +1319,9 @@ impl ToJson for Option { 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()) } } @@ -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] diff --git a/src/libextra/test.rs b/src/libextra/test.rs index ba9478e4448..7d6fd81c614 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::init(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/librustdoc/lib.rs b/src/librustdoc/lib.rs index 5edafa1b1f6..b2fb72d983b 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -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::init(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 988e9958c2b..54a3dad9495 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -346,7 +346,7 @@ mod test { 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