From f30f54e9d062bdb5b3cb10dd7185470280c1c278 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Wed, 24 Apr 2013 01:29:46 -0700 Subject: librustc: Remove the concept of modes from the compiler. This commit does not remove `ty::arg`, although that should be possible to do now. --- src/libsyntax/parse/parser.rs | 62 ++++++++++++++++++++++++------------------- 1 file changed, 35 insertions(+), 27 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 30275436c06..ae374808270 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -17,10 +17,10 @@ use ast::{RegionTyParamBound, TraitTyParamBound}; use ast::{provided, public, purity}; use ast::{_mod, add, arg, arm, attribute, bind_by_ref, bind_infer}; use ast::{bind_by_copy, bitand, bitor, bitxor, blk}; -use ast::{blk_check_mode, box, by_copy, by_ref}; +use ast::{blk_check_mode, box}; use ast::{crate, crate_cfg, decl, decl_item}; use ast::{decl_local, default_blk, deref, quot, enum_def}; -use ast::{expl, expr, expr_, expr_addr_of, expr_match, expr_again}; +use ast::{expr, expr_, expr_addr_of, expr_match, expr_again}; use ast::{expr_assign, expr_assign_op, expr_binary, expr_block}; use ast::{expr_break, expr_call, expr_cast, expr_copy, expr_do_body}; use ast::{expr_field, expr_fn_block, expr_if, expr_index}; @@ -32,13 +32,13 @@ 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}; -use ast::{ident, impure_fn, infer, inherited, item, item_, item_const}; +use ast::{ident, impure_fn, inherited, item, item_, item_const}; use ast::{item_const, item_enum, item_fn, item_foreign_mod, item_impl}; use ast::{item_mac, item_mod, item_struct, item_trait, item_ty, lit, lit_}; use ast::{lit_bool, lit_float, lit_float_unsuffixed, lit_int}; use ast::{lit_int_unsuffixed, lit_nil, lit_str, lit_uint, local, m_const}; use ast::{m_imm, m_mutbl, mac_, mac_invoc_tt, matcher, match_nonterminal}; -use ast::{match_seq, match_tok, method, mode, mt, mul, mutability}; +use ast::{match_seq, match_tok, method, mt, mul, mutability}; use ast::{named_field, neg, node_id, noreturn, not, pat, pat_box, pat_enum}; use ast::{pat_ident, pat_lit, pat_range, pat_region, pat_struct}; use ast::{pat_tup, pat_uniq, pat_wild, private}; @@ -765,22 +765,22 @@ pub impl Parser { } // parse an optional mode. - fn parse_arg_mode(&self) -> mode { + // XXX: Remove after snapshot. + fn parse_arg_mode(&self) { if self.eat(&token::BINOP(token::MINUS)) { self.obsolete(*self.span, ObsoleteMode); - expl(by_copy) } else if self.eat(&token::ANDAND) { - expl(by_ref) + // Ignore. } else if self.eat(&token::BINOP(token::PLUS)) { if self.eat(&token::BINOP(token::PLUS)) { // ++ mode is obsolete, but we need a snapshot // to stop parsing it. - expl(by_copy) + // Ignore. } else { - expl(by_copy) + // Ignore. } } else { - infer(self.get_id()) + // Ignore. } } @@ -810,16 +810,14 @@ pub impl Parser { // This version of parse arg doesn't necessarily require // identifier names. fn parse_arg_general(&self, require_name: bool) -> arg { - let m; let mut is_mutbl = false; let pat = if require_name || self.is_named_argument() { - m = self.parse_arg_mode(); + self.parse_arg_mode(); is_mutbl = self.eat_keyword(&~"mut"); let pat = self.parse_pat(false); self.expect(&token::COLON); pat } else { - m = infer(self.get_id()); ast_util::ident_to_pat(self.get_id(), *self.last_span, special_idents::invalid) @@ -827,8 +825,12 @@ pub impl Parser { let t = self.parse_ty(false); - ast::arg { mode: m, is_mutbl: is_mutbl, - ty: t, pat: pat, id: self.get_id() } + ast::arg { + is_mutbl: is_mutbl, + ty: t, + pat: pat, + id: self.get_id(), + } } // parse a single function argument @@ -838,7 +840,7 @@ pub impl Parser { // parse an argument in a lambda header e.g. |arg, arg| fn parse_fn_block_arg(&self) -> arg_or_capture_item { - let m = self.parse_arg_mode(); + self.parse_arg_mode(); let is_mutbl = self.eat_keyword(&~"mut"); let pat = self.parse_pat(false); let t = if self.eat(&token::COLON) { @@ -851,7 +853,6 @@ pub impl Parser { } }; either::Left(ast::arg { - mode: m, is_mutbl: is_mutbl, ty: t, pat: pat, @@ -2440,18 +2441,21 @@ pub impl Parser { // used by the copy foo and ref foo patterns to give a good // error message when parsing mistakes like ref foo(a,b) - fn parse_pat_ident(&self, refutable: bool, - binding_mode: ast::binding_mode) -> ast::pat_ { + fn parse_pat_ident(&self, + refutable: bool, + binding_mode: ast::binding_mode) + -> ast::pat_ { if !is_plain_ident(&*self.token) { - self.span_fatal( - *self.last_span, - ~"expected identifier, found path"); + self.span_fatal(*self.last_span, + ~"expected identifier, found path"); } // why a path here, and not just an identifier? let name = self.parse_path_without_tps(); let sub = if self.eat(&token::AT) { Some(self.parse_pat(refutable)) - } else { None }; + } else { + None + }; // just to be friendly, if they write something like // ref Some(i) @@ -4406,10 +4410,11 @@ pub impl Parser { // text that can't be parsed as an item // - mod_items uses extern_mod_allowed = true // - block_tail_ uses extern_mod_allowed = false - fn parse_items_and_view_items(&self, first_item_attrs: ~[attribute], + fn parse_items_and_view_items(&self, + first_item_attrs: ~[attribute], mut extern_mod_allowed: bool, macros_allowed: bool) - -> ParsedItemsAndViewItems { + -> ParsedItemsAndViewItems { let mut attrs = vec::append(first_item_attrs, self.parse_outer_attributes()); // First, parse view items. @@ -4539,8 +4544,11 @@ pub impl Parser { fn parse_str(&self) -> @~str { match *self.token { - token::LIT_STR(s) => { self.bump(); self.id_to_str(s) } - _ => self.fatal(~"expected string literal") + token::LIT_STR(s) => { + self.bump(); + self.id_to_str(s) + } + _ => self.fatal(~"expected string literal") } } } -- cgit 1.4.1-3-g733a5 From 670ab8ac367cd8cfe8b86a1338667e7825d8d68d Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Fri, 26 Apr 2013 16:19:26 -0700 Subject: librustc: Change labels to use the lifetime notation `'`. --- doc/rust.md | 6 ++-- src/libsyntax/ext/asm.rs | 23 +++++++++++---- src/libsyntax/parse/parser.rs | 57 +++++++++++++++++++++++++------------- src/libsyntax/print/pprust.rs | 17 +++++++++--- src/test/run-pass/issue-2216.rs | 12 ++++---- src/test/run-pass/labeled-break.rs | 4 +-- 6 files changed, 79 insertions(+), 40 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/doc/rust.md b/doc/rust.md index 0173f61e730..9f81b38009f 100644 --- a/doc/rust.md +++ b/doc/rust.md @@ -2187,7 +2187,7 @@ A loop expression denotes an infinite loop; see [Continue expressions](#continue-expressions) for continue expressions. ~~~~~~~~{.ebnf .gram} -loop_expr : "loop" [ ident ':' ] '{' block '}'; +loop_expr : [ lifetime ':' ] "loop" '{' block '}'; ~~~~~~~~ A `loop` expression may optionally have a _label_. @@ -2198,7 +2198,7 @@ See [Break expressions](#break-expressions). ### Break expressions ~~~~~~~~{.ebnf .gram} -break_expr : "break" [ ident ]; +break_expr : "break" [ lifetime ]; ~~~~~~~~ A `break` expression has an optional `label`. @@ -2211,7 +2211,7 @@ but must enclose it. ### Continue expressions ~~~~~~~~{.ebnf .gram} -continue_expr : "loop" [ ident ]; +continue_expr : "loop" [ lifetime ]; ~~~~~~~~ A continue expression, written `loop`, also has an optional `label`. diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index 534027bd295..dfebf6f786a 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -52,7 +52,10 @@ pub fn expand_asm(cx: @ext_ctxt, sp: span, tts: &[ast::token_tree]) let mut dialect = ast::asm_att; let mut state = Asm; - loop outer: { + + // Not using labeled break to get us through one round of bootstrapping. + let mut continue = true; + while continue { match state { Asm => { asm = expr_to_str(cx, p.parse_expr(), @@ -139,20 +142,30 @@ pub fn expand_asm(cx: @ext_ctxt, sp: span, tts: &[ast::token_tree]) p.bump(); match next_state(state) { Some(x) => x, - None => break outer + None => { + continue = false; + break + } } } else if *p.token == token::MOD_SEP { p.bump(); let s = match next_state(state) { Some(x) => x, - None => break outer + None => { + continue = false; + break + } }; match next_state(s) { Some(x) => x, - None => break outer + None => { + continue = false; + break + } } } else if *p.token == token::EOF { - break outer; + continue = false; + break; } else { state }; diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index ae374808270..50bdfb2f557 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -348,6 +348,20 @@ pub impl Parser { self.token_is_keyword(&~"fn", tok) } + fn token_is_lifetime(&self, tok: &token::Token) -> bool { + match *tok { + token::LIFETIME(*) => true, + _ => false, + } + } + + fn get_lifetime(&self, tok: &token::Token) -> ast::ident { + match *tok { + token::LIFETIME(ref ident) => copy *ident, + _ => self.bug(~"not a lifetime"), + } + } + // parse a ty_bare_fun type: fn parse_ty_bare_fn(&self) -> ty_ { @@ -1228,8 +1242,14 @@ pub impl Parser { expr_do_body); } else if self.eat_keyword(&~"while") { return self.parse_while_expr(); + } else if self.token_is_lifetime(&*self.token) { + let lifetime = self.get_lifetime(&*self.token); + self.bump(); + self.expect(&token::COLON); + self.expect_keyword(&~"loop"); + return self.parse_loop_expr(Some(lifetime)); } else if self.eat_keyword(&~"loop") { - return self.parse_loop_expr(); + return self.parse_loop_expr(None); } else if self.eat_keyword(&~"match") { return self.parse_match_expr(); } else if self.eat_keyword(&~"unsafe") { @@ -1290,8 +1310,10 @@ pub impl Parser { } else { ex = expr_ret(None); } } else if self.eat_keyword(&~"break") { // BREAK expression - if is_ident(&*self.token) { - ex = expr_break(Some(self.parse_ident())); + if self.token_is_lifetime(&*self.token) { + let lifetime = self.get_lifetime(&*self.token); + self.bump(); + ex = expr_break(Some(lifetime)); } else { ex = expr_break(None); } @@ -1995,37 +2017,32 @@ pub impl Parser { return self.mk_expr(lo, hi, expr_while(cond, body)); } - fn parse_loop_expr(&self) -> @expr { + fn parse_loop_expr(&self, opt_ident: Option) -> @expr { // loop headers look like 'loop {' or 'loop unsafe {' let is_loop_header = *self.token == token::LBRACE || (is_ident(&*self.token) && self.look_ahead(1) == token::LBRACE); - // labeled loop headers look like 'loop foo: {' - let is_labeled_loop_header = - is_ident(&*self.token) - && !self.is_any_keyword(© *self.token) - && self.look_ahead(1) == token::COLON; - if is_loop_header || is_labeled_loop_header { + if is_loop_header { // This is a loop body - let opt_ident; - if is_labeled_loop_header { - opt_ident = Some(self.parse_ident()); - self.expect(&token::COLON); - } else { - opt_ident = None; - } - let lo = self.last_span.lo; let body = self.parse_block(); let hi = body.span.hi; return self.mk_expr(lo, hi, expr_loop(body, opt_ident)); } else { // This is a 'continue' expression + if opt_ident.is_some() { + self.span_err(*self.last_span, + ~"a label may not be used with a `loop` \ + expression"); + } + let lo = self.span.lo; - let ex = if is_ident(&*self.token) { - expr_again(Some(self.parse_ident())) + let ex = if self.token_is_lifetime(&*self.token) { + let lifetime = self.get_lifetime(&*self.token); + self.bump(); + expr_again(Some(lifetime)) } else { expr_again(None) }; diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 337355304d4..d5645ada929 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1210,12 +1210,13 @@ pub fn print_expr(s: @ps, expr: @ast::expr) { print_block(s, blk); } ast::expr_loop(ref blk, opt_ident) => { - head(s, ~"loop"); - space(s.s); for opt_ident.each |ident| { + word(s.s, ~"'"); print_ident(s, *ident); word_space(s, ~":"); } + head(s, ~"loop"); + space(s.s); print_block(s, blk); } ast::expr_match(expr, ref arms) => { @@ -1363,12 +1364,20 @@ pub fn print_expr(s: @ps, expr: @ast::expr) { ast::expr_break(opt_ident) => { word(s.s, ~"break"); space(s.s); - for opt_ident.each |ident| { print_ident(s, *ident); space(s.s) } + for opt_ident.each |ident| { + word(s.s, ~"'"); + print_ident(s, *ident); + space(s.s); + } } ast::expr_again(opt_ident) => { word(s.s, ~"loop"); space(s.s); - for opt_ident.each |ident| { print_ident(s, *ident); space(s.s) } + for opt_ident.each |ident| { + word(s.s, ~"'"); + print_ident(s, *ident); + space(s.s) + } } ast::expr_ret(result) => { word(s.s, ~"return"); diff --git a/src/test/run-pass/issue-2216.rs b/src/test/run-pass/issue-2216.rs index 0be4084b083..98965cb6d91 100644 --- a/src/test/run-pass/issue-2216.rs +++ b/src/test/run-pass/issue-2216.rs @@ -11,17 +11,17 @@ pub fn main() { let mut x = 0; - loop foo: { - loop bar: { - loop quux: { + 'foo: loop { + 'bar: loop { + 'quux: loop { if 1 == 2 { - break foo; + break 'foo; } else { - break bar; + break 'bar; } } - loop foo; + loop 'foo; } x = 42; break; diff --git a/src/test/run-pass/labeled-break.rs b/src/test/run-pass/labeled-break.rs index b26d8f78e64..06ca401a136 100644 --- a/src/test/run-pass/labeled-break.rs +++ b/src/test/run-pass/labeled-break.rs @@ -12,9 +12,9 @@ // xfail-test pub fn main() { - loop foo: { + 'foo: loop { loop { - break foo; + break 'foo; } } } -- cgit 1.4.1-3-g733a5 From 78f33437b66793b10eb2a72d0d20cbf2bf0eacb5 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Mon, 29 Apr 2013 10:47:26 -0700 Subject: libstd: Fix merge fallout. --- src/libstd/net_ip.rs | 1 - src/libstd/priority_queue.rs | 1 - src/libsyntax/parse/mod.rs | 30 ++++++++++++++---------------- 3 files changed, 14 insertions(+), 18 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs index 0608d9dc3f2..800144c0ca7 100644 --- a/src/libstd/net_ip.rs +++ b/src/libstd/net_ip.rs @@ -152,7 +152,6 @@ pub mod v4 { use uv_ip4_name = uv::ll::ip4_name; use core::cast::transmute; - use core::ptr; use core::result; use core::str; use core::uint; diff --git a/src/libstd/priority_queue.rs b/src/libstd/priority_queue.rs index 6f408823410..47af3576c90 100644 --- a/src/libstd/priority_queue.rs +++ b/src/libstd/priority_queue.rs @@ -11,7 +11,6 @@ //! A priority queue implemented with a binary heap use core::old_iter::BaseIter; -use core::ptr::addr_of; #[abi = "rust-intrinsic"] extern "rust-intrinsic" mod rusti { diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index d27d788e23a..7e7931bbb60 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -569,9 +569,8 @@ mod test { let parser = string_to_parser(@~"b : int"); assert_eq!(parser.parse_arg_general(true), ast::arg{ - mode: ast::infer(1), is_mutbl: false, - ty: @ast::Ty{id:4, // fixme + ty: @ast::Ty{id:3, // fixme node: ast::ty_path(@ast::Path{ span:sp(4,4), // this is bizarre... // check this in the original parser? @@ -579,9 +578,9 @@ mod test { idents:~[mk_ident(105)], rp: None, types: ~[]}, - 3), + 2), span:sp(4,7)}, - pat: @ast::pat{id:2, + pat: @ast::pat{id:1, node: ast::pat_ident(ast::bind_by_copy, @ast::Path{ span:sp(0,1), @@ -592,7 +591,7 @@ mod test { None // no idea ), span: sp(0,3)}, // really? - id: 5 // fixme + id: 4 // fixme }) } @@ -604,21 +603,20 @@ mod test { Some( @ast::item{ident:mk_ident(100), attrs:~[], - id: 11, // fixme + id: 10, // fixme node: ast::item_fn(ast::fn_decl{ inputs: ~[ast::arg{ - mode: ast::infer(1), is_mutbl: false, - ty: @ast::Ty{id:4, // fixme + ty: @ast::Ty{id:3, // fixme node: ast::ty_path(@ast::Path{ span:sp(10,13), global:false, idents:~[mk_ident(106)], rp: None, types: ~[]}, - 3), + 2), span:sp(10,13)}, - pat: @ast::pat{id:2, // fixme + pat: @ast::pat{id:1, // fixme node: ast::pat_ident( ast::bind_by_copy, @ast::Path{ @@ -630,9 +628,9 @@ mod test { None // no idea ), span: sp(6,9)}, // bleah. - id: 5 // fixme + id: 4 // fixme }], - output: @ast::Ty{id:6, // fixme + output: @ast::Ty{id:5, // fixme node: ast::ty_nil, span:sp(15,15)}, // not sure cf: ast::return_val @@ -649,8 +647,8 @@ mod test { view_items: ~[], stmts: ~[@spanned{ node: ast::stmt_semi(@ast::expr{ - id: 7, - callee_id: 8, + id: 6, + callee_id: 7, node: ast::expr_path( @ast::Path{ span:sp(17,18), @@ -659,10 +657,10 @@ mod test { rp:None, types: ~[]}), span: sp(17,18)}, - 9), // fixme + 8), // fixme span: sp(17,18)}], expr: None, - id: 10, // fixme + id: 9, // fixme rules: ast::default_blk // no idea }}), vis: ast::inherited, -- cgit 1.4.1-3-g733a5