From 2f1ab3a7fad9aeb871479470785250fe2e923e19 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Wed, 27 Mar 2013 06:49:39 -0700 Subject: syntax: Add new values that can be used with the quasiquoter --- src/libsyntax/ext/quote.rs | 159 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 157 insertions(+), 2 deletions(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 6044c3ad3d2..9f3145e4e4e 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -42,8 +42,7 @@ pub mod rt { pub use ast::*; pub use parse::token::*; pub use parse::new_parser_from_tts; - pub use codemap::BytePos; - pub use codemap::span; + pub use codemap::{BytePos, span, dummy_spanned}; use print::pprust; use print::pprust::{item_to_str, ty_to_str}; @@ -119,6 +118,90 @@ pub mod rt { } } + impl ToSource for ast::blk { + fn to_source(&self, cx: @ext_ctxt) -> ~str { + pprust::block_to_str(self, cx.parse_sess().interner) + } + } + + impl<'self> ToSource for &'self str { + fn to_source(&self, _cx: @ext_ctxt) -> ~str { + let lit = dummy_spanned(ast::lit_str(@str::from_slice(*self))); + pprust::lit_to_str(@lit) + } + } + + impl ToSource for int { + fn to_source(&self, _cx: @ext_ctxt) -> ~str { + let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i)); + pprust::lit_to_str(@lit) + } + } + + impl ToSource for i8 { + fn to_source(&self, _cx: @ext_ctxt) -> ~str { + let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i8)); + pprust::lit_to_str(@lit) + } + } + + impl ToSource for i16 { + fn to_source(&self, _cx: @ext_ctxt) -> ~str { + let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i16)); + pprust::lit_to_str(@lit) + } + } + + + impl ToSource for i32 { + fn to_source(&self, _cx: @ext_ctxt) -> ~str { + let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i32)); + pprust::lit_to_str(@lit) + } + } + + impl ToSource for i64 { + fn to_source(&self, _cx: @ext_ctxt) -> ~str { + let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i64)); + pprust::lit_to_str(@lit) + } + } + + impl ToSource for uint { + fn to_source(&self, _cx: @ext_ctxt) -> ~str { + let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u)); + pprust::lit_to_str(@lit) + } + } + + impl ToSource for u8 { + fn to_source(&self, _cx: @ext_ctxt) -> ~str { + let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u8)); + pprust::lit_to_str(@lit) + } + } + + impl ToSource for u16 { + fn to_source(&self, _cx: @ext_ctxt) -> ~str { + let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u16)); + pprust::lit_to_str(@lit) + } + } + + impl ToSource for u32 { + fn to_source(&self, _cx: @ext_ctxt) -> ~str { + let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u32)); + pprust::lit_to_str(@lit) + } + } + + impl ToSource for u64 { + fn to_source(&self, _cx: @ext_ctxt) -> ~str { + let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u64)); + pprust::lit_to_str(@lit) + } + } + // Alas ... we write these out instead. All redundant. impl ToTokens for ast::ident { @@ -163,6 +246,78 @@ pub mod rt { } } + impl ToTokens for ast::blk { + fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { + cx.parse_tts(self.to_source(cx)) + } + } + + impl<'self> ToTokens for &'self str { + fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { + cx.parse_tts(self.to_source(cx)) + } + } + + impl ToTokens for int { + fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { + cx.parse_tts(self.to_source(cx)) + } + } + + impl ToTokens for i8 { + fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { + cx.parse_tts(self.to_source(cx)) + } + } + + impl ToTokens for i16 { + fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { + cx.parse_tts(self.to_source(cx)) + } + } + + impl ToTokens for i32 { + fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { + cx.parse_tts(self.to_source(cx)) + } + } + + impl ToTokens for i64 { + fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { + cx.parse_tts(self.to_source(cx)) + } + } + + impl ToTokens for uint { + fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { + cx.parse_tts(self.to_source(cx)) + } + } + + impl ToTokens for u8 { + fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { + cx.parse_tts(self.to_source(cx)) + } + } + + impl ToTokens for u16 { + fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { + cx.parse_tts(self.to_source(cx)) + } + } + + impl ToTokens for u32 { + fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { + cx.parse_tts(self.to_source(cx)) + } + } + + impl ToTokens for u64 { + fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { + cx.parse_tts(self.to_source(cx)) + } + } + pub trait ExtParseUtils { fn parse_item(&self, s: ~str) -> @ast::item; fn parse_expr(&self, s: ~str) -> @ast::expr; -- cgit 1.4.1-3-g733a5 From bd77e9433f5a76530c3d2acf0fa82caa5167e263 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Wed, 27 Mar 2013 07:01:45 -0700 Subject: syntax: pass some values around by reference --- src/libsyntax/ext/quote.rs | 8 ++++---- src/libsyntax/print/pprust.rs | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 9f3145e4e4e..a6f078d07b4 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -88,7 +88,7 @@ pub mod rt { } } - impl ToSource for ~[@ast::item] { + impl<'self> ToSource for &'self [@ast::item] { fn to_source(&self, cx: @ext_ctxt) -> ~str { str::connect(self.map(|i| i.to_source(cx)), ~"\n\n") } @@ -100,7 +100,7 @@ pub mod rt { } } - impl ToSource for ~[@ast::Ty] { + impl<'self> ToSource for &'self [@ast::Ty] { fn to_source(&self, cx: @ext_ctxt) -> ~str { str::connect(self.map(|i| i.to_source(cx)), ~", ") } @@ -216,7 +216,7 @@ pub mod rt { } } - impl ToTokens for ~[@ast::item] { + impl<'self> ToTokens for &'self [@ast::item] { fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { cx.parse_tts(self.to_source(cx)) } @@ -228,7 +228,7 @@ pub mod rt { } } - impl ToTokens for ~[@ast::Ty] { + impl<'self> ToTokens for &'self [@ast::Ty] { fn to_tokens(&self, cx: @ext_ctxt) -> ~[token_tree] { cx.parse_tts(self.to_source(cx)) } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 9a9834c488b..28b6d132842 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -324,7 +324,7 @@ pub fn commasep(s: @ps, b: breaks, elts: &[IN], op: &fn(@ps, IN)) { pub fn commasep_cmnt(s: @ps, b: breaks, elts: &[IN], op: &fn(@ps, IN), get_span: &fn(IN) -> codemap::span) { box(s, 0u, b); - let len = vec::len::(elts); + let len = elts.len(); let mut i = 0u; for elts.each |elt| { maybe_print_comment(s, get_span(*elt).hi); @@ -2133,7 +2133,7 @@ pub fn print_comment(s: @ps, cmnt: comments::cmnt) { } } -pub fn print_string(s: @ps, st: ~str) { +pub fn print_string(s: @ps, st: &str) { word(s.s, ~"\""); word(s.s, str::escape_default(st)); word(s.s, ~"\""); -- cgit 1.4.1-3-g733a5 From b10b8c3ee41447299504127c341bc363d180356c Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Wed, 27 Mar 2013 00:13:01 -0700 Subject: std: Add tests for json decoding options --- src/libstd/json.rs | 18 ++++++++++++++++++ src/libsyntax/parse/mod.rs | 37 ++++++++++++++++++++++++------------- 2 files changed, 42 insertions(+), 13 deletions(-) (limited to 'src/libsyntax') diff --git a/src/libstd/json.rs b/src/libstd/json.rs index bbca4805d48..3868b689a3f 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -1236,6 +1236,8 @@ mod tests { use core::prelude::*; use core::hashmap::linear::LinearMap; + use std::serialize::Decodable; + fn mk_object(items: &[(~str, Json)]) -> Json { let mut d = ~LinearMap::new(); @@ -1389,6 +1391,8 @@ mod tests { } #[auto_encode] + #[auto_decode] + #[deriving(Eq)] enum Animal { Dog, Frog(~str, int) @@ -1706,6 +1710,20 @@ mod tests { ])); } + #[test] + fn test_read_none() { + let decoder = Decoder(from_str(~"null").unwrap()); + let value: Option<~str> = Decodable::decode(&decoder); + assert_eq!(value, None); + } + + #[test] + fn test_read_some() { + let decoder = Decoder(from_str(~"\"jodhpurs\"").unwrap()); + let value: Option<~str> = Decodable::decode(&decoder); + assert_eq!(value, Some(~"jodhpurs")); + } + #[test] fn test_multiline_errors() { assert_eq!(from_str(~"{\n \"foo\":\n \"bar\""), diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index a0c73668a05..7f6b511f9f0 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -326,19 +326,30 @@ mod test { @~"fn foo (x : int) { x; }", ~[], new_parse_sess(None)); - assert_eq!(to_json_str(@tts), - ~"[[\"tt_tok\",[null,[\"IDENT\",[\"fn\",false]]]],\ - [\"tt_tok\",[null,[\"IDENT\",[\"foo\",false]]]],\ - [\"tt_delim\",[[[\"tt_tok\",[null,[\"LPAREN\",[]]]],\ - [\"tt_tok\",[null,[\"IDENT\",[\"x\",false]]]],\ - [\"tt_tok\",[null,[\"COLON\",[]]]],\ - [\"tt_tok\",[null,[\"IDENT\",[\"int\",false]]]],\ - [\"tt_tok\",[null,[\"RPAREN\",[]]]]]]],\ - [\"tt_delim\",[[[\"tt_tok\",[null,[\"LBRACE\",[]]]],\ - [\"tt_tok\",[null,[\"IDENT\",[\"x\",false]]]],\ - [\"tt_tok\",[null,[\"SEMI\",[]]]],\ - [\"tt_tok\",[null,[\"RBRACE\",[]]]]]]]]" - ); + assert_eq!( + to_json_str(@tts), + ~"[\ + [\"tt_tok\",[null,[\"IDENT\",[\"fn\",false]]]],\ + [\"tt_tok\",[null,[\"IDENT\",[\"foo\",false]]]],\ + [\"tt_delim\",[\ + [\ + [\"tt_tok\",[null,[\"LPAREN\",[]]]],\ + [\"tt_tok\",[null,[\"IDENT\",[\"x\",false]]]],\ + [\"tt_tok\",[null,[\"COLON\",[]]]],\ + [\"tt_tok\",[null,[\"IDENT\",[\"int\",false]]]],\ + [\"tt_tok\",[null,[\"RPAREN\",[]]]]\ + ]\ + ]],\ + [\"tt_delim\",[\ + [\ + [\"tt_tok\",[null,[\"LBRACE\",[]]]],\ + [\"tt_tok\",[null,[\"IDENT\",[\"x\",false]]]],\ + [\"tt_tok\",[null,[\"SEMI\",[]]]],\ + [\"tt_tok\",[null,[\"RBRACE\",[]]]]\ + ]\ + ]]\ + ]" + ); let ast1 = new_parser_from_tts(new_parse_sess(None),~[],tts) .parse_item(~[]); let ast2 = parse_item_from_source_str( -- cgit 1.4.1-3-g733a5 From 4d995e66a274511d70eb02abdb80da43ccf70aee Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Wed, 27 Mar 2013 00:14:52 -0700 Subject: std: change default json enum encoder to use strings or a flat vec --- src/libstd/json.rs | 57 +++++++++++++--------------------------------- src/libsyntax/parse/mod.rs | 32 ++++++++++++++------------ 2 files changed, 33 insertions(+), 56 deletions(-) (limited to 'src/libsyntax') diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 3868b689a3f..d69917c9aff 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -119,22 +119,15 @@ impl serialize::Encoder for Encoder { f() } - fn emit_enum_variant(&self, name: &str, _id: uint, _cnt: uint, f: &fn()) { + fn emit_enum_variant(&self, name: &str, _id: uint, cnt: uint, f: &fn()) { // encoding of enums is special-cased for Option. Specifically: // Some(34) => 34 // None => null - // other enums are encoded as vectors: + // other enums are encoded as strings or vectors: + // Bunny => "Bunny" // Kangaroo(34,"William") => ["Kangaroo",[34,"William"]] - // the default expansion for enums is more verbose than I'd like; - // specifically, the inner pair of brackets seems superfluous, - // BUT the design of the enumeration framework and the requirements - // of the special-case for Option mean that a first argument must - // be encoded "naked"--with no commas--and that the option name - // can't be followed by just a comma, because there might not - // be any elements in the tuple. - // FIXME #4872: this would be more precise and less frightening // with fully-qualified option names. To get that information, // we'd have to change the expansion of auto-encode to pass @@ -144,14 +137,14 @@ impl serialize::Encoder for Encoder { f(); } else if name == ~"None" { self.wr.write_str(~"null"); + } else if cnt == 0 { + self.wr.write_str(escape_str(name)); } else { self.wr.write_char('['); self.wr.write_str(escape_str(name)); self.wr.write_char(','); - self.wr.write_char('['); f(); self.wr.write_char(']'); - self.wr.write_char(']'); } } @@ -256,28 +249,19 @@ impl serialize::Encoder for PrettyEncoder { f(); } else if name == ~"None" { self.emit_nil(); + } else if cnt == 0 { + self.wr.write_str(escape_str(name)); } else { self.wr.write_char('['); self.indent += 2; self.wr.write_char('\n'); self.wr.write_str(spaces(self.indent)); self.wr.write_str(escape_str(name)); - if cnt == 0 { - self.wr.write_str(",\n"); - self.wr.write_str(spaces(self.indent)); - self.wr.write_str("[]\n"); - } else { - self.wr.write_str(",\n"); - self.wr.write_str(spaces(self.indent)); - self.wr.write_str("[\n"); - self.indent += 2; - f(); - self.wr.write_char('\n'); - self.indent -= 2; - self.wr.write_str(spaces(self.indent)); - self.wr.write_str("]\n"); - } + self.wr.write_str(",\n"); + f(); + self.wr.write_char('\n'); self.indent -= 2; + self.wr.write_str(spaces(self.indent)); self.wr.write_char(']'); } } @@ -1406,7 +1390,7 @@ mod tests { let encoder = Encoder(wr); animal.encode(&encoder); }; - assert_eq!(s, ~"[\"Dog\",[]]"); + assert_eq!(s, ~"\"Dog\""); } #[test] @@ -1417,14 +1401,7 @@ mod tests { let encoder = PrettyEncoder(wr); animal.encode(&encoder); }; - assert_eq!( - s, - ~"\ - [\n \ - \"Dog\",\n \ - []\n\ - ]" - ); + assert_eq!(s, ~"\"Dog\""); } #[test] @@ -1435,7 +1412,7 @@ mod tests { let encoder = Encoder(wr); animal.encode(&encoder); }; - assert_eq!(s, ~"[\"Frog\",[\"Henry\",349]]"); + assert_eq!(s, ~"[\"Frog\",\"Henry\",349]"); } #[test] @@ -1451,10 +1428,8 @@ mod tests { ~"\ [\n \ \"Frog\",\n \ - [\n \ - \"Henry\",\n \ - 349\n \ - ]\n\ + \"Henry\",\n \ + 349\n\ ]" ); } diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 7f6b511f9f0..0ddf9111e02 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -329,25 +329,27 @@ mod test { assert_eq!( to_json_str(@tts), ~"[\ - [\"tt_tok\",[null,[\"IDENT\",[\"fn\",false]]]],\ - [\"tt_tok\",[null,[\"IDENT\",[\"foo\",false]]]],\ - [\"tt_delim\",[\ + [\"tt_tok\",null,[\"IDENT\",\"fn\",false]],\ + [\"tt_tok\",null,[\"IDENT\",\"foo\",false]],\ + [\ + \"tt_delim\",\ [\ - [\"tt_tok\",[null,[\"LPAREN\",[]]]],\ - [\"tt_tok\",[null,[\"IDENT\",[\"x\",false]]]],\ - [\"tt_tok\",[null,[\"COLON\",[]]]],\ - [\"tt_tok\",[null,[\"IDENT\",[\"int\",false]]]],\ - [\"tt_tok\",[null,[\"RPAREN\",[]]]]\ + [\"tt_tok\",null,\"LPAREN\"],\ + [\"tt_tok\",null,[\"IDENT\",\"x\",false]],\ + [\"tt_tok\",null,\"COLON\"],\ + [\"tt_tok\",null,[\"IDENT\",\"int\",false]],\ + [\"tt_tok\",null,\"RPAREN\"]\ ]\ - ]],\ - [\"tt_delim\",[\ + ],\ + [\ + \"tt_delim\",\ [\ - [\"tt_tok\",[null,[\"LBRACE\",[]]]],\ - [\"tt_tok\",[null,[\"IDENT\",[\"x\",false]]]],\ - [\"tt_tok\",[null,[\"SEMI\",[]]]],\ - [\"tt_tok\",[null,[\"RBRACE\",[]]]]\ + [\"tt_tok\",null,\"LBRACE\"],\ + [\"tt_tok\",null,[\"IDENT\",\"x\",false]],\ + [\"tt_tok\",null,\"SEMI\"],\ + [\"tt_tok\",null,\"RBRACE\"]\ ]\ - ]]\ + ]\ ]" ); let ast1 = new_parser_from_tts(new_parse_sess(None),~[],tts) -- cgit 1.4.1-3-g733a5 From 478e4498b76178dc0031f88f0d5ee31c5f804d0b Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 26 Mar 2013 15:26:05 -0700 Subject: std: add option type directly to serialize::{En,De}code --- src/libstd/ebml.rs | 26 ++++++++++++- src/libstd/json.rs | 38 +++++++++---------- src/libstd/prettyprint.rs | 14 +++++++ src/libstd/serialize.rs | 29 ++++++--------- src/libsyntax/ext/auto_encode.rs | 79 +++++++++++++++++++++++++++++++++++----- 5 files changed, 138 insertions(+), 48 deletions(-) (limited to 'src/libsyntax') diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 92898af2993..90389602bc4 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -399,8 +399,20 @@ pub mod reader { debug!("read_tup_elt(idx=%u)", idx); f() } - } + fn read_option(&self, f: &fn() -> T) -> Option { + debug!("read_option()"); + do self.read_enum("Option") || { + do self.read_enum_variant |idx| { + match idx { + 0 => None, + 1 => Some(f()), + _ => fail!(), + } + } + } + } + } } pub mod writer { @@ -666,9 +678,19 @@ pub mod writer { fn emit_tup(&self, _len: uint, f: &fn()) { f() } fn emit_tup_elt(&self, _idx: uint, f: &fn()) { f() } - } + fn emit_option(&self, f: &fn()) { + self.emit_enum("Option", f); + } + fn emit_option_none(&self) { + self.emit_enum_variant("None", 0, 0, || ()) + } + fn emit_option_some(&self, f: &fn()) { + self.emit_enum_variant("Some", 1, 1, f) + } + } } + // ___________________________________________________________________________ // Testing diff --git a/src/libstd/json.rs b/src/libstd/json.rs index d69917c9aff..bb1102be9f7 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -120,24 +120,11 @@ impl serialize::Encoder for Encoder { } fn emit_enum_variant(&self, name: &str, _id: uint, cnt: uint, f: &fn()) { - // encoding of enums is special-cased for Option. Specifically: - // Some(34) => 34 - // None => null - - // other enums are encoded as strings or vectors: + // enums are encoded as strings or vectors: // Bunny => "Bunny" // Kangaroo(34,"William") => ["Kangaroo",[34,"William"]] - // FIXME #4872: this would be more precise and less frightening - // with fully-qualified option names. To get that information, - // we'd have to change the expansion of auto-encode to pass - // those along. - - if name == ~"Some" { - f(); - } else if name == ~"None" { - self.wr.write_str(~"null"); - } else if cnt == 0 { + if cnt == 0 { self.wr.write_str(escape_str(name)); } else { self.wr.write_char('['); @@ -193,6 +180,10 @@ impl serialize::Encoder for Encoder { fn emit_tup_elt(&self, idx: uint, f: &fn()) { self.emit_vec_elt(idx, f) } + + fn emit_option(&self, f: &fn()) { f(); } + fn emit_option_none(&self) { self.emit_nil(); } + fn emit_option_some(&self, f: &fn()) { f(); } } pub struct PrettyEncoder { @@ -245,11 +236,7 @@ impl serialize::Encoder for PrettyEncoder { fn emit_enum(&self, _name: &str, f: &fn()) { f() } fn emit_enum_variant(&self, name: &str, _id: uint, cnt: uint, f: &fn()) { - if name == ~"Some" { - f(); - } else if name == ~"None" { - self.emit_nil(); - } else if cnt == 0 { + if cnt == 0 { self.wr.write_str(escape_str(name)); } else { self.wr.write_char('['); @@ -335,6 +322,10 @@ impl serialize::Encoder for PrettyEncoder { fn emit_tup_elt(&self, idx: uint, f: &fn()) { self.emit_vec_elt(idx, f) } + + fn emit_option(&self, f: &fn()) { f(); } + fn emit_option_none(&self) { self.emit_nil(); } + fn emit_option_some(&self, f: &fn()) { f(); } } impl serialize::Encodable for Json { @@ -966,6 +957,13 @@ impl<'self> serialize::Decoder for Decoder<'self> { _ => fail!(~"not a list") } } + + fn read_option(&self, f: &fn() -> T) -> Option { + match *self.peek() { + Null => { self.pop(); None } + _ => Some(f()), + } + } } impl Eq for Json { diff --git a/src/libstd/prettyprint.rs b/src/libstd/prettyprint.rs index f823d73cf0b..ed4f3e957c0 100644 --- a/src/libstd/prettyprint.rs +++ b/src/libstd/prettyprint.rs @@ -182,4 +182,18 @@ impl serialize::Encoder for Serializer { if idx > 0u { self.wr.write_str(~", "); } f(); } + + fn emit_option(&self, f: &fn()) { + f(); + } + + fn emit_option_none(&self) { + self.wr.write_str("None"); + } + + fn emit_option_some(&self, f: &fn()) { + self.wr.write_str("Some("); + f(); + self.wr.write_char(')'); + } } diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index 8e4bbc87b08..69977c6e4fe 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -62,6 +62,11 @@ pub trait Encoder { fn emit_tup(&self, len: uint, f: &fn()); fn emit_tup_elt(&self, idx: uint, f: &fn()); + + // Specialized types: + fn emit_option(&self, f: &fn()); + fn emit_option_none(&self); + fn emit_option_some(&self, f: &fn()); } pub trait Decoder { @@ -103,6 +108,9 @@ pub trait Decoder { fn read_tup(&self, sz: uint, f: &fn() -> T) -> T; fn read_tup_elt(&self, idx: uint, f: &fn() -> T) -> T; + + // Specialized types: + fn read_option(&self, f: &fn() -> T) -> Option; } pub trait Encodable { @@ -368,14 +376,10 @@ impl> Decodable for @[T] { impl> Encodable for Option { fn encode(&self, s: &S) { - do s.emit_enum(~"Option") { + do s.emit_option { match *self { - None => do s.emit_enum_variant(~"None", 0u, 0u) { - }, - - Some(ref v) => do s.emit_enum_variant(~"Some", 1u, 1u) { - s.emit_enum_variant_arg(0u, || v.encode(s)) - } + None => s.emit_option_none(), + Some(ref v) => s.emit_option_some(|| v.encode(s)), } } } @@ -383,16 +387,7 @@ impl> Encodable for Option { impl> Decodable for Option { fn decode(d: &D) -> Option { - do d.read_enum(~"Option") { - do d.read_enum_variant |i| { - match i { - 0 => None, - 1 => Some(d.read_enum_variant_arg( - 0u, || Decodable::decode(d))), - _ => fail!(fmt!("Bad variant for option: %u", i)) - } - } - } + d.read_option(|| Decodable::decode(d)) } } diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index e81e460e832..bafd2bb6adb 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -1177,6 +1177,7 @@ fn mk_enum_deser_body( #[cfg(test)] mod test { + use core::option::{None, Some}; use std::serialize::Encodable; use std::serialize::Encoder; @@ -1190,6 +1191,9 @@ mod test { CallToEmitNil, CallToEmitStruct(~str,uint), CallToEmitField(~str,uint), + CallToEmitOption, + CallToEmitOptionNone, + CallToEmitOptionSome, // all of the ones I was too lazy to handle: CallToOther } @@ -1281,6 +1285,18 @@ mod test { fn emit_tup_elt(&self, +_idx: uint, f: &fn()) { self.add_unknown_to_log(); f(); } + + fn emit_option(&self, f: &fn()) { + self.add_to_log(CallToEmitOption); + f(); + } + fn emit_option_none(&self) { + self.add_to_log(CallToEmitOptionNone); + } + fn emit_option_some(&self, f: &fn()) { + self.add_to_log(CallToEmitOptionSome); + f(); + } } @@ -1296,13 +1312,58 @@ mod test { Magazine(~str) } - #[test] fn encode_enum_test () { - assert_eq!(to_call_log(Book(34,44)), - ~[CallToEmitEnum (~"Written"), - CallToEmitEnumVariant (~"Book",0,2), - CallToEmitEnumVariantArg (0), - CallToEmitUint (34), - CallToEmitEnumVariantArg (1), - CallToEmitUint (44)]); - } + #[test] + fn test_encode_enum() { + assert_eq!( + to_call_log(Book(34,44)), + ~[ + CallToEmitEnum(~"Written"), + CallToEmitEnumVariant(~"Book",0,2), + CallToEmitEnumVariantArg(0), + CallToEmitUint(34), + CallToEmitEnumVariantArg(1), + CallToEmitUint(44), + ] + ); + } + + pub struct BPos(uint); + + #[auto_encode] + pub struct HasPos { pos : BPos } + + #[test] + fn test_encode_newtype() { + assert_eq!( + to_call_log(HasPos { pos:BPos(48) }), + ~[ + CallToEmitStruct(~"HasPos",1), + CallToEmitField(~"pos",0), + CallToEmitUint(48), + ] + ); + } + + #[test] + fn test_encode_option() { + let mut v = None; + + assert_eq!( + to_call_log(v), + ~[ + CallToEmitOption, + CallToEmitOptionNone, + ] + ); + + v = Some(54u); + assert_eq!( + to_call_log(v), + ~[ + CallToEmitOption, + CallToEmitOptionSome, + CallToEmitUint(54) + ] + ); + } } -- cgit 1.4.1-3-g733a5 From 4d6dcefcbb8688b69dd80bc7382a2f593c3b08d8 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 26 Mar 2013 18:46:48 -0700 Subject: std: Decode::read_enum_variant should pass in the variant names Because the json::Decoder uses the string variant name, we need a way to correlate the string to the enum index. This passes in a static &[&str] to read_enum_variant, which allows the json::Decoder to know which branch it's trying to process. --- src/librustc/middle/astencode.rs | 39 +++++++++++++++++++++++++++++++++++++++ src/libstd/ebml.rs | 30 ++++++++++++++++++++++++++++++ src/libstd/json.rs | 27 +++++++++++++++++++++++++-- src/libstd/serialize.rs | 8 ++++++++ src/libsyntax/ext/auto_encode.rs | 17 ++++++++++++++--- 5 files changed, 116 insertions(+), 5 deletions(-) (limited to 'src/libsyntax') diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 1e1dde33037..7b4d1034f74 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -681,6 +681,7 @@ impl vtable_decoder_helpers for reader::Decoder { @self.read_to_vec(|| self.read_vtable_origin(xcx) ) } + #[cfg(stage0)] fn read_vtable_origin(&self, xcx: @ExtendedDecodeContext) -> typeck::vtable_origin { do self.read_enum(~"vtable_origin") { @@ -715,6 +716,44 @@ impl vtable_decoder_helpers for reader::Decoder { } } } + + #[cfg(stage1)] + #[cfg(stage2)] + #[cfg(stage3)] + fn read_vtable_origin(&self, xcx: @ExtendedDecodeContext) + -> typeck::vtable_origin { + do self.read_enum("vtable_origin") { + do self.read_enum_variant(["vtable_static", "vtable_param"]) |i| { + match i { + 0 => { + typeck::vtable_static( + do self.read_enum_variant_arg(0u) { + self.read_def_id(xcx) + }, + do self.read_enum_variant_arg(1u) { + self.read_tys(xcx) + }, + do self.read_enum_variant_arg(2u) { + self.read_vtable_res(xcx) + } + ) + } + 1 => { + typeck::vtable_param( + do self.read_enum_variant_arg(0u) { + self.read_uint() + }, + do self.read_enum_variant_arg(1u) { + self.read_uint() + } + ) + } + // hard to avoid - user input + _ => fail!(~"bad enum variant") + } + } + } + } } // ______________________________________________________________________ diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 90389602bc4..60a00bee0ac 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -337,6 +337,7 @@ pub mod reader { self.push_doc(self.next_doc(EsEnum), f) } + #[cfg(stage0)] fn read_enum_variant(&self, f: &fn(uint) -> T) -> T { debug!("read_enum_variant()"); let idx = self._next_uint(EsEnumVid); @@ -346,6 +347,18 @@ pub mod reader { } } + #[cfg(stage1)] + #[cfg(stage2)] + #[cfg(stage3)] + fn read_enum_variant(&self, _names: &[&str], f: &fn(uint) -> T) -> T { + debug!("read_enum_variant()"); + let idx = self._next_uint(EsEnumVid); + debug!(" idx=%u", idx); + do self.push_doc(self.next_doc(EsEnumBody)) { + f(idx) + } + } + fn read_enum_variant_arg(&self, idx: uint, f: &fn() -> T) -> T { debug!("read_enum_variant_arg(idx=%u)", idx); f() @@ -400,6 +413,7 @@ pub mod reader { f() } + #[cfg(stage0)] fn read_option(&self, f: &fn() -> T) -> Option { debug!("read_option()"); do self.read_enum("Option") || { @@ -412,6 +426,22 @@ pub mod reader { } } } + + #[cfg(stage1)] + #[cfg(stage2)] + #[cfg(stage3)] + fn read_option(&self, f: &fn() -> T) -> Option { + debug!("read_option()"); + do self.read_enum("Option") || { + do self.read_enum_variant(["None", "Some"]) |idx| { + match idx { + 0 => None, + 1 => Some(f()), + _ => fail!(), + } + } + } + } } } diff --git a/src/libstd/json.rs b/src/libstd/json.rs index bb1102be9f7..dc9f629d7e2 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -855,6 +855,7 @@ impl<'self> serialize::Decoder for Decoder<'self> { f() } + #[cfg(stage0)] fn read_enum_variant(&self, f: &fn(uint) -> T) -> T { debug!("read_enum_variant()"); let idx = match *self.peek() { @@ -864,10 +865,32 @@ impl<'self> serialize::Decoder for Decoder<'self> { f(idx) } + #[cfg(stage1)] + #[cfg(stage2)] + #[cfg(stage3)] + fn read_enum_variant(&self, names: &[&str], f: &fn(uint) -> T) -> T { + debug!("read_enum_variant(names=%?)", names); + let name = match *self.peek() { + String(ref s) => s, + List([String(ref s), .. _]) => s, + json => fail!(fmt!("invalid variant: %?", json)), + }; + let idx = match vec::position(names, |n| str::eq_slice(*n, *name)) { + Some(idx) => idx, + None => fail!(fmt!("Unknown variant name: %?", name)), + }; + f(idx) + } + fn read_enum_variant_arg(&self, idx: uint, f: &fn() -> T) -> T { debug!("read_enum_variant_arg(idx=%u)", idx); - if idx != 0 { fail!(~"unknown index") } - f() + match *self.peek() { + List(ref list) => { + self.stack.push(&list[idx + 1]); + f() + } + ref json => fail!(fmt!("not a list: %?", json)), + } } fn read_owned_vec(&self, f: &fn(uint) -> T) -> T { diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index 69977c6e4fe..02f4a934874 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -92,7 +92,15 @@ pub trait Decoder { // Compound types: fn read_enum(&self, name: &str, f: &fn() -> T) -> T; + + #[cfg(stage0)] fn read_enum_variant(&self, f: &fn(uint) -> T) -> T; + + #[cfg(stage1)] + #[cfg(stage2)] + #[cfg(stage3)] + fn read_enum_variant(&self, names: &[&str], f: &fn(uint) -> T) -> T; + fn read_enum_variant_arg(&self, idx: uint, f: &fn() -> T) -> T; fn read_owned(&self, f: &fn() -> T) -> T; diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index bafd2bb6adb..2a112f106a8 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -1059,6 +1059,18 @@ fn mk_enum_deser_body( name: ast::ident, variants: ~[ast::variant] ) -> @ast::expr { + let expr_arm_names = build::mk_base_vec_e( + ext_cx, + span, + do variants.map |variant| { + build::mk_base_str( + ext_cx, + span, + ext_cx.str_of(variant.node.name) + ) + } + ); + let mut arms = do variants.mapi |v_idx, variant| { let body = match variant.node.kind { ast::tuple_variant_kind(ref args) => { @@ -1152,13 +1164,13 @@ fn mk_enum_deser_body( ) ); - // ast for `__d.read_enum_variant($(expr_lambda))` + // ast for `__d.read_enum_variant($expr_arm_names, $(expr_lambda))` let expr_lambda = ext_cx.lambda_expr( ext_cx.expr_method_call( span, ext_cx.expr_var(span, ~"__d"), ext_cx.ident_of(~"read_enum_variant"), - ~[expr_lambda] + ~[expr_arm_names, expr_lambda] ) ); @@ -1174,7 +1186,6 @@ fn mk_enum_deser_body( ) } - #[cfg(test)] mod test { use core::option::{None, Some}; -- cgit 1.4.1-3-g733a5 From b26ae289d0c69350742daa9cadb1c099d2ec3816 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 26 Mar 2013 21:26:29 -0700 Subject: syntax: Fix parsing global generics (Closes #5572) --- src/libsyntax/parse/parser.rs | 5 +++-- src/test/run-pass/issue-5572.rs | 3 +++ 2 files changed, 6 insertions(+), 2 deletions(-) create mode 100644 src/test/run-pass/issue-5572.rs (limited to 'src/libsyntax') diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 53d618e3340..4a84a31dd55 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -2728,8 +2728,9 @@ pub impl Parser { } self.bump(); } - token::IDENT(*) => { + token::MOD_SEP | token::IDENT(*) => { let maybe_bound = match *self.token { + token::MOD_SEP => None, token::IDENT(copy sid, _) => { match *self.id_to_str(sid) { ~"send" | @@ -2757,7 +2758,7 @@ pub impl Parser { result.push(bound); } None => { - let ty = self.parse_ty(false); + let ty = self.parse_ty(true); result.push(TraitTyParamBound(ty)); } } diff --git a/src/test/run-pass/issue-5572.rs b/src/test/run-pass/issue-5572.rs new file mode 100644 index 00000000000..d0db5e5cb3c --- /dev/null +++ b/src/test/run-pass/issue-5572.rs @@ -0,0 +1,3 @@ +fn foo(t: T) { } + +fn main() { } -- cgit 1.4.1-3-g733a5 From 2e0b363a7f8fc4f481eec48e104573f95b52ef6f Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 26 Mar 2013 21:26:49 -0700 Subject: syntax: Remove dead code from the parser --- src/libsyntax/parse/parser.rs | 8 -------- 1 file changed, 8 deletions(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 4a84a31dd55..9cd53e72aa3 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -3116,14 +3116,6 @@ pub impl Parser { // impl Foo { ... } // impl ToStr for ~[T] { ... } fn parse_item_impl(&self, visibility: ast::visibility) -> item_info { - fn wrap_path(p: &Parser, pt: @path) -> @Ty { - @Ty { - id: p.get_id(), - node: ty_path(pt, p.get_id()), - span: pt.span, - } - } - // First, parse type parameters if necessary. let generics = self.parse_generics(); -- cgit 1.4.1-3-g733a5 From 7a199d41a96cbf31152a2b5f4b3881a51ac7a9ae Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 26 Mar 2013 21:42:01 -0700 Subject: syntax: fix pretty printing __log stmts --- src/librustc/middle/liveness.rs | 2 +- src/librustc/middle/moves.rs | 2 +- src/librustc/middle/trans/expr.rs | 2 +- src/librustc/middle/trans/type_use.rs | 2 +- src/librustc/middle/typeck/check/mod.rs | 2 +- src/libsyntax/ast.rs | 8 +------- src/libsyntax/fold.rs | 3 +-- src/libsyntax/parse/parser.rs | 2 +- src/libsyntax/print/pprust.rs | 22 ++++++++-------------- src/libsyntax/visit.rs | 2 +- 10 files changed, 17 insertions(+), 30 deletions(-) (limited to 'src/libsyntax') diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index a92234ba129..5b5f4690e9d 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -1335,7 +1335,7 @@ pub impl Liveness { self.propagate_through_expr(l, ln) } - expr_log(_, l, r) | + expr_log(l, r) | expr_index(l, r) | expr_binary(_, l, r) => { self.propagate_through_exprs(~[l, r], succ) diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs index 16f133b8794..9d0a2c338fc 100644 --- a/src/librustc/middle/moves.rs +++ b/src/librustc/middle/moves.rs @@ -567,7 +567,7 @@ pub impl VisitContext { self.consume_block(blk, visitor); } - expr_log(_, a_expr, b_expr) => { + expr_log(a_expr, b_expr) => { self.consume_expr(a_expr, visitor); self.use_expr(b_expr, Read, visitor); } diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 33576a682a7..6fa2b273746 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -507,7 +507,7 @@ fn trans_rvalue_stmt_unadjusted(bcx: block, expr: @ast::expr) -> block { ast::expr_ret(ex) => { return controlflow::trans_ret(bcx, ex); } - ast::expr_log(_, lvl, a) => { + ast::expr_log(lvl, a) => { return controlflow::trans_log(expr, lvl, bcx, a); } ast::expr_while(cond, ref body) => { diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs index cad2a03f7a1..1d9e57ce8ce 100644 --- a/src/librustc/middle/trans/type_use.rs +++ b/src/librustc/middle/trans/type_use.rs @@ -329,7 +329,7 @@ pub fn mark_for_expr(cx: Context, e: @expr) { type_needs(cx, use_repr, ty::type_autoderef(cx.ccx.tcx, base_ty)); mark_for_method_call(cx, e.id, e.callee_id); } - expr_log(_, _, val) => { + expr_log(_, val) => { node_type_needs(cx, use_tydesc, val.id); } expr_call(f, _, _) => { diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index 75c6bfd5d64..adb8fd82883 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -2402,7 +2402,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, } fcx.write_bot(id); } - ast::expr_log(_, lv, e) => { + ast::expr_log(lv, e) => { check_expr_has_type(fcx, lv, ty::mk_mach_uint(tcx, ast::ty_u32)); diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 6071cc643a3..f873d6b6bb4 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -543,12 +543,6 @@ pub struct expr { span: span, } -#[auto_encode] -#[auto_decode] -#[deriving(Eq)] -pub enum log_level { error, debug, log_other } -// 0 = error, 1 = debug, 2 = log_other - #[auto_encode] #[auto_decode] #[deriving(Eq)] @@ -598,7 +592,7 @@ pub enum expr_ { expr_break(Option), expr_again(Option), expr_ret(Option<@expr>), - expr_log(log_level, @expr, @expr), + expr_log(@expr, @expr), expr_inline_asm(@~str, // asm ~[(@~str, @expr)], // inputs diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 017e95ab4c1..5e56bf18fa8 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -552,9 +552,8 @@ pub fn noop_fold_expr(e: &expr_, fld: @ast_fold) -> expr_ { expr_ret(ref e) => { expr_ret(e.map(|x| fld.fold_expr(*x))) } - expr_log(i, lv, e) => { + expr_log(lv, e) => { expr_log( - i, fld.fold_expr(lv), fld.fold_expr(e) ) diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 9cd53e72aa3..d7af59910b4 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -1230,7 +1230,7 @@ pub impl Parser { let lvl = self.parse_expr(); self.expect(&token::COMMA); let e = self.parse_expr(); - ex = expr_log(ast::log_other, lvl, e); + ex = expr_log(lvl, e); hi = self.span.hi; self.expect(&token::RPAREN); } else if self.eat_keyword(&~"return") { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 28b6d132842..bda5b3671a9 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1386,20 +1386,14 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) { _ => () } } - ast::expr_log(lvl, lexp, expr) => { - match lvl { - ast::debug => { word_nbsp(s, ~"log"); print_expr(s, expr); } - ast::error => { word_nbsp(s, ~"log_err"); print_expr(s, expr); } - ast::log_other => { - word_nbsp(s, ~"log"); - popen(s); - print_expr(s, lexp); - word(s.s, ~","); - space_if_not_bol(s); - print_expr(s, expr); - pclose(s); - } - } + ast::expr_log(lexp, expr) => { + word(s.s, ~"__log"); + popen(s); + print_expr(s, lexp); + word(s.s, ~","); + space_if_not_bol(s); + print_expr(s, expr); + pclose(s); } ast::expr_inline_asm(a, in, out, c, v, _) => { if v { diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index a159c98d21b..2bdf26fba58 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -559,7 +559,7 @@ pub fn visit_expr(ex: @expr, e: E, v: vt) { expr_break(_) => (), expr_again(_) => (), expr_ret(eo) => visit_expr_opt(eo, e, v), - expr_log(_, lv, x) => { + expr_log(lv, x) => { (v.visit_expr)(lv, e, v); (v.visit_expr)(x, e, v); } -- cgit 1.4.1-3-g733a5 From 83e831bc229c2346e2322aaad1fdaa219325a4b3 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 26 Mar 2013 22:24:32 -0700 Subject: syntax: Remove deprecated expr_vstore_fixed --- src/librustc/middle/check_const.rs | 1 - src/librustc/middle/const_eval.rs | 1 - src/librustc/middle/trans/consts.rs | 3 --- src/librustc/middle/trans/expr.rs | 3 --- src/librustc/middle/ty.rs | 1 - src/librustc/middle/typeck/check/mod.rs | 8 -------- src/libsyntax/ast.rs | 1 - src/libsyntax/ext/build.rs | 5 ----- src/libsyntax/parse/parser.rs | 2 +- src/libsyntax/print/pprust.rs | 15 +++------------ 10 files changed, 4 insertions(+), 36 deletions(-) (limited to 'src/libsyntax') diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index f9212d1ff7b..4bbedf5fc00 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -156,7 +156,6 @@ pub fn check_expr(sess: Session, expr_paren(e) => { check_expr(sess, def_map, method_map, tcx, e, is_const, v); } expr_vstore(_, expr_vstore_slice) | - expr_vstore(_, expr_vstore_fixed(_)) | expr_vec(_, m_imm) | expr_addr_of(m_imm, _) | expr_field(*) | diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index a25d873af41..d610b007f35 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -110,7 +110,6 @@ pub fn classify(e: @expr, ast::expr_vstore(e, vstore) => { match vstore { - ast::expr_vstore_fixed(_) | ast::expr_vstore_slice => classify(e, tcx), ast::expr_vstore_uniq | ast::expr_vstore_box | diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index 1362f97c08e..050fc0dd334 100644 --- a/src/librustc/middle/trans/consts.rs +++ b/src/librustc/middle/trans/consts.rs @@ -466,9 +466,6 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef { let (v, _, _) = const_vec(cx, e, *es); v } - ast::expr_vstore(e, ast::expr_vstore_fixed(_)) => { - const_expr(cx, e) - } ast::expr_vstore(sub, ast::expr_vstore_slice) => { match sub.node { ast::expr_lit(ref lit) => { diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 6fa2b273746..5b66f4f3a65 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -714,9 +714,6 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr, ast::expr_vstore(contents, ast::expr_vstore_mut_slice) => { return tvec::trans_slice_vstore(bcx, expr, contents, dest); } - ast::expr_vstore(contents, ast::expr_vstore_fixed(_)) => { - return tvec::trans_fixed_vstore(bcx, expr, contents, dest); - } ast::expr_vec(*) | ast::expr_repeat(*) => { return tvec::trans_fixed_vstore(bcx, expr, expr, dest); } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index edf76ee7c36..475f2c7b13b 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -3117,7 +3117,6 @@ pub fn expr_kind(tcx: ctxt, ast::expr_lit(@codemap::spanned {node: lit_str(_), _}) | ast::expr_vstore(_, ast::expr_vstore_slice) | ast::expr_vstore(_, ast::expr_vstore_mut_slice) | - ast::expr_vstore(_, ast::expr_vstore_fixed(_)) | ast::expr_vec(*) => { RvalueDpsExpr } diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index adb8fd82883..8174899f55e 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -3337,14 +3337,6 @@ pub fn ast_expr_vstore_to_vstore(fcx: @mut FnCtxt, v: ast::expr_vstore) -> ty::vstore { match v { - ast::expr_vstore_fixed(None) => ty::vstore_fixed(n), - ast::expr_vstore_fixed(Some(u)) => { - if n != u { - let s = fmt!("fixed-size sequence mismatch: %u vs. %u",u, n); - fcx.ccx.tcx.sess.span_err(e.span,s); - } - ty::vstore_fixed(u) - } ast::expr_vstore_uniq => ty::vstore_uniq, ast::expr_vstore_box | ast::expr_vstore_mut_box => ty::vstore_box, ast::expr_vstore_slice | ast::expr_vstore_mut_slice => { diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index f873d6b6bb4..10b98ec3c08 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -386,7 +386,6 @@ pub enum vstore { #[auto_decode] #[deriving(Eq)] pub enum expr_vstore { - expr_vstore_fixed(Option), // [1,2,3,4] expr_vstore_uniq, // ~[1,2,3,4] expr_vstore_box, // @[1,2,3,4] expr_vstore_mut_box, // @mut [1,2,3,4] diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index ad71441e046..9499f95f0e7 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -152,11 +152,6 @@ pub fn mk_slice_vec_e(cx: @ext_ctxt, sp: span, +exprs: ~[@ast::expr]) mk_vstore_e(cx, sp, mk_base_vec_e(cx, sp, exprs), ast::expr_vstore_slice) } -pub fn mk_fixed_vec_e(cx: @ext_ctxt, sp: span, +exprs: ~[@ast::expr]) - -> @ast::expr { - mk_vstore_e(cx, sp, mk_base_vec_e(cx, sp, exprs), - ast::expr_vstore_fixed(None)) -} pub fn mk_base_str(cx: @ext_ctxt, sp: span, +s: ~str) -> @ast::expr { let lit = ast::lit_str(@s); return mk_lit(cx, sp, lit); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index d7af59910b4..754f12cc170 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -28,7 +28,7 @@ use ast::{expr_lit, expr_log, expr_loop, expr_loop_body, expr_mac}; use ast::{expr_method_call, expr_paren, expr_path, expr_repeat}; use ast::{expr_ret, expr_swap, expr_struct, expr_tup, expr_unary}; use ast::{expr_vec, expr_vstore, expr_vstore_mut_box, expr_inline_asm}; -use ast::{expr_vstore_fixed, expr_vstore_slice, expr_vstore_box}; +use ast::{expr_vstore_slice, expr_vstore_box}; use ast::{expr_vstore_mut_slice, expr_while, extern_fn, field, fn_decl}; use ast::{expr_vstore_uniq, TyClosure, TyBareFn, Onceness, Once, Many}; use ast::{foreign_item, foreign_item_const, foreign_item_fn, foreign_mod}; diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index bda5b3671a9..d85b40537fa 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1024,8 +1024,6 @@ pub fn print_vstore(s: @ps, t: ast::vstore) { pub fn print_expr_vstore(s: @ps, t: ast::expr_vstore) { match t { - ast::expr_vstore_fixed(Some(i)) => word(s.s, fmt!("%u", i)), - ast::expr_vstore_fixed(None) => word(s.s, ~"_"), ast::expr_vstore_uniq => word(s.s, ~"~"), ast::expr_vstore_box => word(s.s, ~"@"), ast::expr_vstore_mut_box => { @@ -1100,16 +1098,9 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) { let ann_node = node_expr(s, expr); (s.ann.pre)(ann_node); match expr.node { - ast::expr_vstore(e, v) => match v { - ast::expr_vstore_fixed(_) => { - print_expr(s, e); - word(s.s, ~"/"); - print_expr_vstore(s, v); - } - _ => { - print_expr_vstore(s, v); - print_expr(s, e); - } + ast::expr_vstore(e, v) => { + print_expr_vstore(s, v); + print_expr(s, e); }, ast::expr_vec(ref exprs, mutbl) => { ibox(s, indent_unit); -- cgit 1.4.1-3-g733a5