bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

auto merge of #19114 : frewsxcv/rust/master, r=bstrie

Browse source 
Fixes #19010
This commit is contained in:
bors 2014-11-21 19:06:52 +00:00
commit 97c043b2e9
4 changed files with 130 additions and 129 deletions
Download patch file Download diff file Expand all files Collapse all files

1
AUTHORS.txt
View file

@ -121,6 +121,7 @@ Cole Mickens <cole.mickens@gmail.com>
Colin Davidson <colrdavidson@gmail.com> Colin Davidson <colrdavidson@gmail.com>
Colin Sherratt <colin.sherratt@gmail.com> Colin Sherratt <colin.sherratt@gmail.com>
Conrad Kleinespel <conradk@conradk.com> Conrad Kleinespel <conradk@conradk.com>
Corey Farwell <coreyf+rust@rwell.org>
Corey Ford <corey@coreyford.name> Corey Ford <corey@coreyford.name>
Corey Richardson <corey@octayn.net> Corey Richardson <corey@octayn.net>
DJUrsus <colinvh@divitu.com> DJUrsus <colinvh@divitu.com>

2
src/librustc_back/target/mod.rs
View file

@ -250,7 +250,7 @@ impl Target {
} ); } );
($key_name:ident, list) => ( { ($key_name:ident, list) => ( {
let name = (stringify!($key_name)).replace("_", "-"); let name = (stringify!($key_name)).replace("_", "-");
obj.find(name[]).map(|o| o.as_list() obj.find(name[]).map(|o| o.as_array()
.map(|v| base.options.$key_name = v.iter() .map(|v| base.options.$key_name = v.iter()
.map(|a| a.as_string().unwrap().to_string()).collect() .map(|a| a.as_string().unwrap().to_string()).collect()
) )

254
src/libserialize/json.rs
View file

@ -28,7 +28,7 @@ Data types that can be encoded are JavaScript types (see the `Json` enum for mor
* `Boolean`: equivalent to rust's `bool` * `Boolean`: equivalent to rust's `bool`
* `Number`: equivalent to rust's `f64` * `Number`: equivalent to rust's `f64`
* `String`: equivalent to rust's `String` * `String`: equivalent to rust's `String`
* `List`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the same * `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the same
array array
* `Object`: equivalent to rust's `Treemap<String, json::Json>` * `Object`: equivalent to rust's `Treemap<String, json::Json>`
* `Null` * `Null`
@ -223,12 +223,12 @@ pub enum Json {
F64(f64), F64(f64),
String(string::String), String(string::String),
Boolean(bool), Boolean(bool),
List(JsonList), Array(JsonArray),
Object(JsonObject), Object(JsonObject),
Null, Null,
} }
pub type JsonList = Vec<Json>; pub type JsonArray = Vec<Json>;
pub type JsonObject = TreeMap<string::String, Json>; pub type JsonObject = TreeMap<string::String, Json>;
/// The errors that can arise while parsing a JSON stream. /// The errors that can arise while parsing a JSON stream.
@ -237,7 +237,7 @@ pub enum ErrorCode {
InvalidSyntax, InvalidSyntax,
InvalidNumber, InvalidNumber,
EOFWhileParsingObject, EOFWhileParsingObject,
EOFWhileParsingList, EOFWhileParsingArray,
EOFWhileParsingValue, EOFWhileParsingValue,
EOFWhileParsingString, EOFWhileParsingString,
KeyMustBeAString, KeyMustBeAString,
@ -278,7 +278,7 @@ pub fn error_str(error: ErrorCode) -> &'static str {
InvalidSyntax => "invalid syntax", InvalidSyntax => "invalid syntax",
InvalidNumber => "invalid number", InvalidNumber => "invalid number",
EOFWhileParsingObject => "EOF While parsing object", EOFWhileParsingObject => "EOF While parsing object",
EOFWhileParsingList => "EOF While parsing list", EOFWhileParsingArray => "EOF While parsing array",
EOFWhileParsingValue => "EOF While parsing value", EOFWhileParsingValue => "EOF While parsing value",
EOFWhileParsingString => "EOF While parsing string", EOFWhileParsingString => "EOF While parsing string",
KeyMustBeAString => "key must be a string", KeyMustBeAString => "key must be a string",
@ -868,7 +868,7 @@ impl<E: ::Encoder<S>, S> Encodable<E, S> for Json {
F64(v) => v.encode(e), F64(v) => v.encode(e),
String(ref v) => v.encode(e), String(ref v) => v.encode(e),
Boolean(v) => v.encode(e), Boolean(v) => v.encode(e),
List(ref v) => v.encode(e), Array(ref v) => v.encode(e),
Object(ref v) => v.encode(e), Object(ref v) => v.encode(e),
Null => e.emit_nil(), Null => e.emit_nil(),
} }
@ -956,16 +956,16 @@ impl Json {
} }
} }
/// Returns true if the Json value is a List. Returns false otherwise. /// Returns true if the Json value is an Array. Returns false otherwise.
pub fn is_list<'a>(&'a self) -> bool { pub fn is_array<'a>(&'a self) -> bool {
self.as_list().is_some() self.as_array().is_some()
} }
/// If the Json value is a List, returns the associated vector. /// If the Json value is an Array, returns the associated vector.
/// Returns None otherwise. /// Returns None otherwise.
pub fn as_list<'a>(&'a self) -> Option<&'a JsonList> { pub fn as_array<'a>(&'a self) -> Option<&'a JsonArray> {
match self { match self {
&List(ref list) => Some(&*list), &Array(ref array) => Some(&*array),
_ => None _ => None
} }
} }
@ -1085,8 +1085,8 @@ impl<'a> ops::Index<&'a str, Json> for Json {
impl ops::Index<uint, Json> for Json { impl ops::Index<uint, Json> for Json {
fn index<'a>(&'a self, idx: &uint) -> &'a Json { fn index<'a>(&'a self, idx: &uint) -> &'a Json {
match self { match self {
&List(ref v) => v.index(idx), &Array(ref v) => v.index(idx),
_ => panic!("can only index Json with uint if it is a list") _ => panic!("can only index Json with uint if it is an array")
} }
} }
} }
@ -1096,8 +1096,8 @@ impl ops::Index<uint, Json> for Json {
pub enum JsonEvent { pub enum JsonEvent {
ObjectStart, ObjectStart,
ObjectEnd, ObjectEnd,
ListStart, ArrayStart,
ListEnd, ArrayEnd,
BooleanValue(bool), BooleanValue(bool),
I64Value(i64), I64Value(i64),
U64Value(u64), U64Value(u64),
@ -1109,10 +1109,10 @@ pub enum JsonEvent {
#[deriving(PartialEq, Show)] #[deriving(PartialEq, Show)]
enum ParserState { enum ParserState {
// Parse a value in a list, true means first element. // Parse a value in an array, true means first element.
ParseArray(bool), ParseArray(bool),
// Parse ',' or ']' after an element in a list. // Parse ',' or ']' after an element in an array.
ParseListComma, ParseArrayComma,
// Parse a key:value in an object, true means first element. // Parse a key:value in an object, true means first element.
ParseObject(bool), ParseObject(bool),
// Parse ',' or ']' after an element in an object. // Parse ',' or ']' after an element in an object.
@ -1601,7 +1601,7 @@ impl<T: Iterator<char>> Parser<T> {
fn parse(&mut self) -> JsonEvent { fn parse(&mut self) -> JsonEvent {
loop { loop {
// The only paths where the loop can spin a new iteration // The only paths where the loop can spin a new iteration
// are in the cases ParseListComma and ParseObjectComma if ',' // are in the cases ParseArrayComma and ParseObjectComma if ','
// is parsed. In these cases the state is set to (respectively) // is parsed. In these cases the state is set to (respectively)
// ParseArray(false) and ParseObject(false), which always return, // ParseArray(false) and ParseObject(false), which always return,
// so there is no risk of getting stuck in an infinite loop. // so there is no risk of getting stuck in an infinite loop.
@ -1613,10 +1613,10 @@ impl<T: Iterator<char>> Parser<T> {
return self.parse_start(); return self.parse_start();
} }
ParseArray(first) => { ParseArray(first) => {
return self.parse_list(first); return self.parse_array(first);
} }
ParseListComma => { ParseArrayComma => {
match self.parse_list_comma_or_end() { match self.parse_array_comma_or_end() {
Some(evt) => { return evt; } Some(evt) => { return evt; }
None => {} None => {}
} }
@ -1644,14 +1644,14 @@ impl<T: Iterator<char>> Parser<T> {
let val = self.parse_value(); let val = self.parse_value();
self.state = match val { self.state = match val {
Error(_) => { ParseFinished } Error(_) => { ParseFinished }
ListStart => { ParseArray(true) } ArrayStart => { ParseArray(true) }
ObjectStart => { ParseObject(true) } ObjectStart => { ParseObject(true) }
_ => { ParseBeforeFinish } _ => { ParseBeforeFinish }
}; };
return val; return val;
} }
fn parse_list(&mut self, first: bool) -> JsonEvent { fn parse_array(&mut self, first: bool) -> JsonEvent {
if self.ch_is(']') { if self.ch_is(']') {
if !first { if !first {
return self.error_event(InvalidSyntax); return self.error_event(InvalidSyntax);
@ -1660,13 +1660,13 @@ impl<T: Iterator<char>> Parser<T> {
self.state = ParseBeforeFinish; self.state = ParseBeforeFinish;
} else { } else {
self.state = if self.stack.last_is_index() { self.state = if self.stack.last_is_index() {
ParseListComma ParseArrayComma
} else { } else {
ParseObjectComma ParseObjectComma
} }
} }
self.bump(); self.bump();
return ListEnd; return ArrayEnd;
} }
if first { if first {
self.stack.push_index(0); self.stack.push_index(0);
@ -1676,14 +1676,14 @@ impl<T: Iterator<char>> Parser<T> {
self.state = match val { self.state = match val {
Error(_) => { ParseFinished } Error(_) => { ParseFinished }
ListStart => { ParseArray(true) } ArrayStart => { ParseArray(true) }
ObjectStart => { ParseObject(true) } ObjectStart => { ParseObject(true) }
_ => { ParseListComma } _ => { ParseArrayComma }
}; };
return val; return val;
} }
fn parse_list_comma_or_end(&mut self) -> Option<JsonEvent> { fn parse_array_comma_or_end(&mut self) -> Option<JsonEvent> {
if self.ch_is(',') { if self.ch_is(',') {
self.stack.bump_index(); self.stack.bump_index();
self.state = ParseArray(false); self.state = ParseArray(false);
@ -1695,15 +1695,15 @@ impl<T: Iterator<char>> Parser<T> {
self.state = ParseBeforeFinish; self.state = ParseBeforeFinish;
} else { } else {
self.state = if self.stack.last_is_index() { self.state = if self.stack.last_is_index() {
ParseListComma ParseArrayComma
} else { } else {
ParseObjectComma ParseObjectComma
} }
} }
self.bump(); self.bump();
return Some(ListEnd); return Some(ArrayEnd);
} else if self.eof() { } else if self.eof() {
return Some(self.error_event(EOFWhileParsingList)); return Some(self.error_event(EOFWhileParsingArray));
} else { } else {
return Some(self.error_event(InvalidSyntax)); return Some(self.error_event(InvalidSyntax));
} }
@ -1722,7 +1722,7 @@ impl<T: Iterator<char>> Parser<T> {
self.state = ParseBeforeFinish; self.state = ParseBeforeFinish;
} else { } else {
self.state = if self.stack.last_is_index() { self.state = if self.stack.last_is_index() {
ParseListComma ParseArrayComma
} else { } else {
ParseObjectComma ParseObjectComma
} }
@ -1757,7 +1757,7 @@ impl<T: Iterator<char>> Parser<T> {
self.state = match val { self.state = match val {
Error(_) => { ParseFinished } Error(_) => { ParseFinished }
ListStart => { ParseArray(true) } ArrayStart => { ParseArray(true) }
ObjectStart => { ParseObject(true) } ObjectStart => { ParseObject(true) }
_ => { ParseObjectComma } _ => { ParseObjectComma }
}; };
@ -1770,7 +1770,7 @@ impl<T: Iterator<char>> Parser<T> {
self.state = ParseBeforeFinish; self.state = ParseBeforeFinish;
} else { } else {
self.state = if self.stack.last_is_index() { self.state = if self.stack.last_is_index() {
ParseListComma ParseArrayComma
} else { } else {
ParseObjectComma ParseObjectComma
} }
@ -1797,7 +1797,7 @@ impl<T: Iterator<char>> Parser<T> {
}, },
'[' => { '[' => {
self.bump(); self.bump();
ListStart ArrayStart
} }
'{' => { '{' => {
self.bump(); self.bump();
@ -1864,21 +1864,21 @@ impl<T: Iterator<char>> Builder<T> {
Ok(String(temp)) Ok(String(temp))
} }
Some(Error(e)) => { Err(e) } Some(Error(e)) => { Err(e) }
Some(ListStart) => { self.build_list() } Some(ArrayStart) => { self.build_array() }
Some(ObjectStart) => { self.build_object() } Some(ObjectStart) => { self.build_object() }
Some(ObjectEnd) => { self.parser.error(InvalidSyntax) } Some(ObjectEnd) => { self.parser.error(InvalidSyntax) }
Some(ListEnd) => { self.parser.error(InvalidSyntax) } Some(ArrayEnd) => { self.parser.error(InvalidSyntax) }
None => { self.parser.error(EOFWhileParsingValue) } None => { self.parser.error(EOFWhileParsingValue) }
} }
} }
fn build_list(&mut self) -> Result<Json, BuilderError> { fn build_array(&mut self) -> Result<Json, BuilderError> {
self.bump(); self.bump();
let mut values = Vec::new(); let mut values = Vec::new();
loop { loop {
if self.token == Some(ListEnd) { if self.token == Some(ArrayEnd) {
return Ok(List(values.into_iter().collect())); return Ok(Array(values.into_iter().collect()));
} }
match self.build_value() { match self.build_value() {
Ok(v) => values.push(v), Ok(v) => values.push(v),
@ -2093,13 +2093,13 @@ impl ::Decoder<DecoderError> for Decoder {
} }
}; };
match o.remove(&"fields".to_string()) { match o.remove(&"fields".to_string()) {
Some(List(l)) => { Some(Array(l)) => {
for field in l.into_iter().rev() { for field in l.into_iter().rev() {
self.stack.push(field); self.stack.push(field);
} }
}, },
Some(val) => { Some(val) => {
return Err(ExpectedError("List".to_string(), format!("{}", val))) return Err(ExpectedError("Array".to_string(), format!("{}", val)))
} }
None => { None => {
return Err(MissingFieldError("fields".to_string())) return Err(MissingFieldError("fields".to_string()))
@ -2229,9 +2229,9 @@ impl ::Decoder<DecoderError> for Decoder {
fn read_seq<T>(&mut self, f: |&mut Decoder, uint| -> DecodeResult<T>) -> DecodeResult<T> { fn read_seq<T>(&mut self, f: |&mut Decoder, uint| -> DecodeResult<T>) -> DecodeResult<T> {
debug!("read_seq()"); debug!("read_seq()");
let list = try!(expect!(self.pop(), List)); let array = try!(expect!(self.pop(), Array));
let len = list.len(); let len = array.len();
for v in list.into_iter().rev() { for v in array.into_iter().rev() {
self.stack.push(v); self.stack.push(v);
} }
f(self, len) f(self, len)
@ -2343,7 +2343,7 @@ macro_rules! tuple_impl {
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn to_json(&self) -> Json { fn to_json(&self) -> Json {
match *self { match *self {
($(ref $tyvar),*,) => List(vec![$($tyvar.to_json()),*]) ($(ref $tyvar),*,) => Array(vec![$($tyvar.to_json()),*])
} }
} }
} }
@ -2364,11 +2364,11 @@ tuple_impl!{A, B, C, D, E, F, G, H, I, J, K}
tuple_impl!{A, B, C, D, E, F, G, H, I, J, K, L} tuple_impl!{A, B, C, D, E, F, G, H, I, J, K, L}
impl<A: ToJson> ToJson for [A] { impl<A: ToJson> ToJson for [A] {
fn to_json(&self) -> Json { List(self.iter().map(|elt| elt.to_json()).collect()) } fn to_json(&self) -> Json { Array(self.iter().map(|elt| elt.to_json()).collect()) }
} }
impl<A: ToJson> ToJson for Vec<A> { impl<A: ToJson> ToJson for Vec<A> {
fn to_json(&self) -> Json { List(self.iter().map(|elt| elt.to_json()).collect()) } fn to_json(&self) -> Json { Array(self.iter().map(|elt| elt.to_json()).collect()) }
} }
impl<A: ToJson> ToJson for TreeMap<string::String, A> { impl<A: ToJson> ToJson for TreeMap<string::String, A> {
@ -2420,13 +2420,13 @@ mod tests {
use self::DecodeEnum::*; use self::DecodeEnum::*;
use self::test::Bencher; use self::test::Bencher;
use {Encodable, Decodable}; use {Encodable, Decodable};
use super::{List, Encoder, Decoder, Error, Boolean, I64, U64, F64, String, Null, use super::{Array, Encoder, Decoder, Error, Boolean, I64, U64, F64, String, Null,
PrettyEncoder, Object, Json, from_str, ParseError, ExpectedError, PrettyEncoder, Object, Json, from_str, ParseError, ExpectedError,
MissingFieldError, UnknownVariantError, DecodeResult, DecoderError, MissingFieldError, UnknownVariantError, DecodeResult, DecoderError,
JsonEvent, Parser, StackElement, JsonEvent, Parser, StackElement,
ObjectStart, ObjectEnd, ListStart, ListEnd, BooleanValue, U64Value, ObjectStart, ObjectEnd, ArrayStart, ArrayEnd, BooleanValue, U64Value,
F64Value, StringValue, NullValue, SyntaxError, Key, Index, Stack, F64Value, StringValue, NullValue, SyntaxError, Key, Index, Stack,
InvalidSyntax, InvalidNumber, EOFWhileParsingObject, EOFWhileParsingList, InvalidSyntax, InvalidNumber, EOFWhileParsingObject, EOFWhileParsingArray,
EOFWhileParsingValue, EOFWhileParsingString, KeyMustBeAString, ExpectedColon, EOFWhileParsingValue, EOFWhileParsingString, KeyMustBeAString, ExpectedColon,
TrailingCharacters, TrailingComma}; TrailingCharacters, TrailingComma};
use std::{i64, u64, f32, f64, io}; use std::{i64, u64, f32, f64, io};
@ -2558,28 +2558,28 @@ mod tests {
} }
#[test] #[test]
fn test_write_list() { fn test_write_array() {
assert_eq!(List(vec![]).to_string().into_string(), "[]".to_string()); assert_eq!(Array(vec![]).to_string().into_string(), "[]".to_string());
assert_eq!(List(vec![]).to_pretty_str().into_string(), "[]".to_string()); assert_eq!(Array(vec![]).to_pretty_str().into_string(), "[]".to_string());
assert_eq!(List(vec![Boolean(true)]).to_string().into_string(), "[true]".to_string()); assert_eq!(Array(vec![Boolean(true)]).to_string().into_string(), "[true]".to_string());
assert_eq!( assert_eq!(
List(vec![Boolean(true)]).to_pretty_str().into_string(), Array(vec![Boolean(true)]).to_pretty_str().into_string(),
"\ "\
[\n \ [\n \
true\n\ true\n\
]".to_string() ]".to_string()
); );
let long_test_list = List(vec![ let long_test_array = Array(vec![
Boolean(false), Boolean(false),
Null, Null,
List(vec![String("foo\nbar".to_string()), F64(3.5)])]); Array(vec![String("foo\nbar".to_string()), F64(3.5)])]);
assert_eq!(long_test_list.to_string().into_string(), assert_eq!(long_test_array.to_string().into_string(),
"[false,null,[\"foo\\nbar\",3.5]]".to_string()); "[false,null,[\"foo\\nbar\",3.5]]".to_string());
assert_eq!( assert_eq!(
long_test_list.to_pretty_str().into_string(), long_test_array.to_pretty_str().into_string(),
"\ "\
[\n \ [\n \
false,\n \ false,\n \
@ -2612,7 +2612,7 @@ mod tests {
); );
let complex_obj = mk_object(&[ let complex_obj = mk_object(&[
("b".to_string(), List(vec![ ("b".to_string(), Array(vec![
mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]), mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
mk_object(&[("d".to_string(), String("".to_string()))]) mk_object(&[("d".to_string(), String("".to_string()))])
])) ]))
@ -2644,7 +2644,7 @@ mod tests {
let a = mk_object(&[ let a = mk_object(&[
("a".to_string(), Boolean(true)), ("a".to_string(), Boolean(true)),
("b".to_string(), List(vec![ ("b".to_string(), Array(vec![
mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]), mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
mk_object(&[("d".to_string(), String("".to_string()))]) mk_object(&[("d".to_string(), String("".to_string()))])
])) ]))
@ -2878,28 +2878,28 @@ mod tests {
} }
#[test] #[test]
fn test_read_list() { fn test_read_array() {
assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2))); assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingList, 1, 3))); assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4))); assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4))); assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4))); assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
assert_eq!(from_str("[]"), Ok(List(vec![]))); assert_eq!(from_str("[]"), Ok(Array(vec![])));
assert_eq!(from_str("[ ]"), Ok(List(vec![]))); assert_eq!(from_str("[ ]"), Ok(Array(vec![])));
assert_eq!(from_str("[true]"), Ok(List(vec![Boolean(true)]))); assert_eq!(from_str("[true]"), Ok(Array(vec![Boolean(true)])));
assert_eq!(from_str("[ false ]"), Ok(List(vec![Boolean(false)]))); assert_eq!(from_str("[ false ]"), Ok(Array(vec![Boolean(false)])));
assert_eq!(from_str("[null]"), Ok(List(vec![Null]))); assert_eq!(from_str("[null]"), Ok(Array(vec![Null])));
assert_eq!(from_str("[3, 1]"), assert_eq!(from_str("[3, 1]"),
Ok(List(vec![U64(3), U64(1)]))); Ok(Array(vec![U64(3), U64(1)])));
assert_eq!(from_str("\n[3, 2]\n"), assert_eq!(from_str("\n[3, 2]\n"),
Ok(List(vec![U64(3), U64(2)]))); Ok(Array(vec![U64(3), U64(2)])));
assert_eq!(from_str("[2, [4, 1]]"), assert_eq!(from_str("[2, [4, 1]]"),
Ok(List(vec![U64(2), List(vec![U64(4), U64(1)])]))); Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])])));
} }
#[test] #[test]
fn test_decode_list() { fn test_decode_array() {
let v: Vec<()> = super::decode("[]").unwrap(); let v: Vec<()> = super::decode("[]").unwrap();
assert_eq!(v, vec![]); assert_eq!(v, vec![]);
@ -2967,7 +2967,7 @@ mod tests {
"{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(), "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
mk_object(&[ mk_object(&[
("a".to_string(), F64(1.0)), ("a".to_string(), F64(1.0)),
("b".to_string(), List(vec![Boolean(true)])) ("b".to_string(), Array(vec![Boolean(true)]))
])); ]));
assert_eq!(from_str( assert_eq!(from_str(
"{\ "{\
@ -2980,7 +2980,7 @@ mod tests {
}").unwrap(), }").unwrap(),
mk_object(&[ mk_object(&[
("a".to_string(), F64(1.0)), ("a".to_string(), F64(1.0)),
("b".to_string(), List(vec![ ("b".to_string(), Array(vec![
Boolean(true), Boolean(true),
String("foo\nbar".to_string()), String("foo\nbar".to_string()),
mk_object(&[ mk_object(&[
@ -3097,7 +3097,7 @@ mod tests {
check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}", check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
ExpectedError("String".to_string(), "{}".to_string())); ExpectedError("String".to_string(), "{}".to_string()));
check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}", check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
ExpectedError("List".to_string(), "null".to_string())); ExpectedError("Array".to_string(), "null".to_string()));
check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}", check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}",
MissingFieldError("w".to_string())); MissingFieldError("w".to_string()));
} }
@ -3110,7 +3110,7 @@ mod tests {
check_err::<DecodeEnum>("{\"variant\": \"A\"}", check_err::<DecodeEnum>("{\"variant\": \"A\"}",
MissingFieldError("fields".to_string())); MissingFieldError("fields".to_string()));
check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}", check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}",
ExpectedError("List".to_string(), "null".to_string())); ExpectedError("Array".to_string(), "null".to_string()));
check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}", check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}",
UnknownVariantError("C".to_string())); UnknownVariantError("C".to_string()));
} }
@ -3139,10 +3139,10 @@ mod tests {
#[test] #[test]
fn test_index(){ fn test_index(){
let json_value = from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap(); let json_value = from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap();
let ref list = json_value["animals"]; let ref array = json_value["animals"];
assert_eq!(list[0].as_string().unwrap(), "dog"); assert_eq!(array[0].as_string().unwrap(), "dog");
assert_eq!(list[1].as_string().unwrap(), "cat"); assert_eq!(array[1].as_string().unwrap(), "cat");
assert_eq!(list[2].as_string().unwrap(), "mouse"); assert_eq!(array[2].as_string().unwrap(), "mouse");
} }
#[test] #[test]
@ -3159,17 +3159,17 @@ mod tests {
} }
#[test] #[test]
fn test_is_list(){ fn test_is_array(){
let json_value = from_str("[1, 2, 3]").unwrap(); let json_value = from_str("[1, 2, 3]").unwrap();
assert!(json_value.is_list()); assert!(json_value.is_array());
} }
#[test] #[test]
fn test_as_list(){ fn test_as_array(){
let json_value = from_str("[1, 2, 3]").unwrap(); let json_value = from_str("[1, 2, 3]").unwrap();
let json_list = json_value.as_list(); let json_array = json_value.as_array();
let expected_length = 3; let expected_length = 3;
assert!(json_list.is_some() && json_list.unwrap().len() == expected_length); assert!(json_array.is_some() && json_array.unwrap().len() == expected_length);
} }
#[test] #[test]
@ -3328,7 +3328,7 @@ mod tests {
tree.insert("hello".into_string(), String("guten tag".into_string())); tree.insert("hello".into_string(), String("guten tag".into_string()));
tree.insert("goodbye".into_string(), String("sayonara".into_string())); tree.insert("goodbye".into_string(), String("sayonara".into_string()));
let json = List( let json = Array(
// The following layout below should look a lot like // The following layout below should look a lot like
// the pretty-printed JSON (indent * x) // the pretty-printed JSON (indent * x)
vec! vec!
@ -3336,7 +3336,7 @@ mod tests {
String("greetings".into_string()), // 1x String("greetings".into_string()), // 1x
Object(tree), // 1x + 2x + 2x + 1x Object(tree), // 1x + 2x + 2x + 1x
) // 0x ) // 0x
// End JSON list (7 lines) // End JSON array (7 lines)
); );
// Helper function for counting indents // Helper function for counting indents
@ -3425,19 +3425,19 @@ mod tests {
vec![ vec![
(ObjectStart, vec![]), (ObjectStart, vec![]),
(StringValue("bar".to_string()), vec![Key("foo")]), (StringValue("bar".to_string()), vec![Key("foo")]),
(ListStart, vec![Key("array")]), (ArrayStart, vec![Key("array")]),
(U64Value(0), vec![Key("array"), Index(0)]), (U64Value(0), vec![Key("array"), Index(0)]),
(U64Value(1), vec![Key("array"), Index(1)]), (U64Value(1), vec![Key("array"), Index(1)]),
(U64Value(2), vec![Key("array"), Index(2)]), (U64Value(2), vec![Key("array"), Index(2)]),
(U64Value(3), vec![Key("array"), Index(3)]), (U64Value(3), vec![Key("array"), Index(3)]),
(U64Value(4), vec![Key("array"), Index(4)]), (U64Value(4), vec![Key("array"), Index(4)]),
(U64Value(5), vec![Key("array"), Index(5)]), (U64Value(5), vec![Key("array"), Index(5)]),
(ListEnd, vec![Key("array")]), (ArrayEnd, vec![Key("array")]),
(ListStart, vec![Key("idents")]), (ArrayStart, vec![Key("idents")]),
(NullValue, vec![Key("idents"), Index(0)]), (NullValue, vec![Key("idents"), Index(0)]),
(BooleanValue(true), vec![Key("idents"), Index(1)]), (BooleanValue(true), vec![Key("idents"), Index(1)]),
(BooleanValue(false), vec![Key("idents"), Index(2)]), (BooleanValue(false), vec![Key("idents"), Index(2)]),
(ListEnd, vec![Key("idents")]), (ArrayEnd, vec![Key("idents")]),
(ObjectEnd, vec![]), (ObjectEnd, vec![]),
] ]
); );
@ -3495,9 +3495,9 @@ mod tests {
vec![ vec![
(ObjectStart, vec![]), (ObjectStart, vec![]),
(F64Value(1.0), vec![Key("a")]), (F64Value(1.0), vec![Key("a")]),
(ListStart, vec![Key("b")]), (ArrayStart, vec![Key("b")]),
(BooleanValue(true),vec![Key("b"), Index(0)]), (BooleanValue(true),vec![Key("b"), Index(0)]),
(ListEnd, vec![Key("b")]), (ArrayEnd, vec![Key("b")]),
(ObjectEnd, vec![]), (ObjectEnd, vec![]),
] ]
); );
@ -3513,7 +3513,7 @@ mod tests {
vec![ vec![
(ObjectStart, vec![]), (ObjectStart, vec![]),
(F64Value(1.0), vec![Key("a")]), (F64Value(1.0), vec![Key("a")]),
(ListStart, vec![Key("b")]), (ArrayStart, vec![Key("b")]),
(BooleanValue(true), vec![Key("b"), Index(0)]), (BooleanValue(true), vec![Key("b"), Index(0)]),
(StringValue("foo\nbar".to_string()), vec![Key("b"), Index(1)]), (StringValue("foo\nbar".to_string()), vec![Key("b"), Index(1)]),
(ObjectStart, vec![Key("b"), Index(2)]), (ObjectStart, vec![Key("b"), Index(2)]),
@ -3521,87 +3521,87 @@ mod tests {
(NullValue, vec![Key("b"), Index(2), Key("c"), Key("d")]), (NullValue, vec![Key("b"), Index(2), Key("c"), Key("d")]),
(ObjectEnd, vec![Key("b"), Index(2), Key("c")]), (ObjectEnd, vec![Key("b"), Index(2), Key("c")]),
(ObjectEnd, vec![Key("b"), Index(2)]), (ObjectEnd, vec![Key("b"), Index(2)]),
(ListEnd, vec![Key("b")]), (ArrayEnd, vec![Key("b")]),
(ObjectEnd, vec![]), (ObjectEnd, vec![]),
] ]
); );
} }
#[test] #[test]
#[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064) #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
fn test_read_list_streaming() { fn test_read_array_streaming() {
assert_stream_equal( assert_stream_equal(
"[]", "[]",
vec![ vec![
(ListStart, vec![]), (ArrayStart, vec![]),
(ListEnd, vec![]), (ArrayEnd, vec![]),
] ]
); );
assert_stream_equal( assert_stream_equal(
"[ ]", "[ ]",
vec![ vec![
(ListStart, vec![]), (ArrayStart, vec![]),
(ListEnd, vec![]), (ArrayEnd, vec![]),
] ]
); );
assert_stream_equal( assert_stream_equal(
"[true]", "[true]",
vec![ vec![
(ListStart, vec![]), (ArrayStart, vec![]),
(BooleanValue(true), vec![Index(0)]), (BooleanValue(true), vec![Index(0)]),
(ListEnd, vec![]), (ArrayEnd, vec![]),
] ]
); );
assert_stream_equal( assert_stream_equal(
"[ false ]", "[ false ]",
vec![ vec![
(ListStart, vec![]), (ArrayStart, vec![]),
(BooleanValue(false), vec![Index(0)]), (BooleanValue(false), vec![Index(0)]),
(ListEnd, vec![]), (ArrayEnd, vec![]),
] ]
); );
assert_stream_equal( assert_stream_equal(
"[null]", "[null]",
vec![ vec![
(ListStart, vec![]), (ArrayStart, vec![]),
(NullValue, vec![Index(0)]), (NullValue, vec![Index(0)]),
(ListEnd, vec![]), (ArrayEnd, vec![]),
] ]
); );
assert_stream_equal( assert_stream_equal(
"[3, 1]", "[3, 1]",
vec![ vec![
(ListStart, vec![]), (ArrayStart, vec![]),
(U64Value(3), vec![Index(0)]), (U64Value(3), vec![Index(0)]),
(U64Value(1), vec![Index(1)]), (U64Value(1), vec![Index(1)]),
(ListEnd, vec![]), (ArrayEnd, vec![]),
] ]
); );
assert_stream_equal( assert_stream_equal(
"\n[3, 2]\n", "\n[3, 2]\n",
vec![ vec![
(ListStart, vec![]), (ArrayStart, vec![]),
(U64Value(3), vec![Index(0)]), (U64Value(3), vec![Index(0)]),
(U64Value(2), vec![Index(1)]), (U64Value(2), vec![Index(1)]),
(ListEnd, vec![]), (ArrayEnd, vec![]),
] ]
); );
assert_stream_equal( assert_stream_equal(
"[2, [4, 1]]", "[2, [4, 1]]",
vec![ vec![
(ListStart, vec![]), (ArrayStart, vec![]),
(U64Value(2), vec![Index(0)]), (U64Value(2), vec![Index(0)]),
(ListStart, vec![Index(1)]), (ArrayStart, vec![Index(1)]),
(U64Value(4), vec![Index(1), Index(0)]), (U64Value(4), vec![Index(1), Index(0)]),
(U64Value(1), vec![Index(1), Index(1)]), (U64Value(1), vec![Index(1), Index(1)]),
(ListEnd, vec![Index(1)]), (ArrayEnd, vec![Index(1)]),
(ListEnd, vec![]), (ArrayEnd, vec![]),
] ]
); );
assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1, 2))); assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1, 2)));
assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2))); assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingList, 1, 3))); assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4))); assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4))); assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4))); assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
@ -3693,8 +3693,8 @@ mod tests {
use std::collections::{HashMap,TreeMap}; use std::collections::{HashMap,TreeMap};
use super::ToJson; use super::ToJson;
let list2 = List(vec!(U64(1), U64(2))); let array2 = Array(vec!(U64(1), U64(2)));
let list3 = List(vec!(U64(1), U64(2), U64(3))); let array3 = Array(vec!(U64(1), U64(2), U64(3)));
let object = { let object = {
let mut tree_map = TreeMap::new(); let mut tree_map = TreeMap::new();
tree_map.insert("a".to_string(), U64(1)); tree_map.insert("a".to_string(), U64(1));
@ -3702,7 +3702,7 @@ mod tests {
Object(tree_map) Object(tree_map)
}; };
assert_eq!(list2.to_json(), list2); assert_eq!(array2.to_json(), array2);
assert_eq!(object.to_json(), object); assert_eq!(object.to_json(), object);
assert_eq!(3_i.to_json(), I64(3)); assert_eq!(3_i.to_json(), I64(3));
assert_eq!(4_i8.to_json(), I64(4)); assert_eq!(4_i8.to_json(), I64(4));
@ -3723,12 +3723,12 @@ mod tests {
assert_eq!(false.to_json(), Boolean(false)); assert_eq!(false.to_json(), Boolean(false));
assert_eq!("abc".to_json(), String("abc".into_string())); assert_eq!("abc".to_json(), String("abc".into_string()));
assert_eq!("abc".into_string().to_json(), String("abc".into_string())); assert_eq!("abc".into_string().to_json(), String("abc".into_string()));
assert_eq!((1u, 2u).to_json(), list2); assert_eq!((1u, 2u).to_json(), array2);
assert_eq!((1u, 2u, 3u).to_json(), list3); assert_eq!((1u, 2u, 3u).to_json(), array3);
assert_eq!([1u, 2].to_json(), list2); assert_eq!([1u, 2].to_json(), array2);
assert_eq!((&[1u, 2, 3]).to_json(), list3); assert_eq!((&[1u, 2, 3]).to_json(), array3);
assert_eq!((vec![1u, 2]).to_json(), list2); assert_eq!((vec![1u, 2]).to_json(), array2);
assert_eq!(vec!(1u, 2, 3).to_json(), list3); assert_eq!(vec!(1u, 2, 3).to_json(), array3);
let mut tree_map = TreeMap::new(); let mut tree_map = TreeMap::new();
tree_map.insert("a".to_string(), 1u); tree_map.insert("a".to_string(), 1u);
tree_map.insert("b".to_string(), 2); tree_map.insert("b".to_string(), 2);

2
src/test/run-pass/issue-2804.rs
View file

@ -59,7 +59,7 @@ fn add_interfaces(store: int, managed_ip: String, device: HashMap<String, json::
-> Vec<(String, object)> { -> Vec<(String, object)> {
match device["interfaces".to_string()] match device["interfaces".to_string()]
{ {
json::List(ref interfaces) => json::Array(ref interfaces) =>
{ {
interfaces.iter().map(|interface| { interfaces.iter().map(|interface| {
add_interface(store, managed_ip.clone(), (*interface).clone()) add_interface(store, managed_ip.clone(), (*interface).clone())