From b355936b4da0831f47afe8f251daee503c8caa32 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 1 Aug 2012 17:30:05 -0700 Subject: Convert ret to return --- src/libsyntax/parse/parser.rs | 267 ++++++++++++++++++++++-------------------- 1 file changed, 137 insertions(+), 130 deletions(-) (limited to 'src/libsyntax/parse/parser.rs') diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index ada3810b45f..4eaf32e9968 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -108,11 +108,11 @@ macro_rules! maybe_whole_expr { {$p:expr} => { alt copy $p.token { INTERPOLATED(token::nt_expr(e)) { $p.bump(); - ret pexpr(e); + return pexpr(e); } INTERPOLATED(token::nt_path(pt)) { $p.bump(); - ret $p.mk_pexpr($p.span.lo, $p.span.lo, + return $p.mk_pexpr($p.span.lo, $p.span.lo, expr_path(pt)); } _ {} @@ -121,7 +121,7 @@ macro_rules! maybe_whole_expr { macro_rules! maybe_whole { {$p:expr, $constructor:path} => { alt copy $p.token { - INTERPOLATED($constructor(x)) { $p.bump(); ret x; } + INTERPOLATED($constructor(x)) { $p.bump(); return x; } _ {} }} } @@ -132,7 +132,7 @@ fn dummy() { /* we will need this to bootstrap maybe_whole! */ #macro[[#maybe_whole_path[p], alt p.token { - INTERPOLATED(token::nt_path(pt)) { p.bump(); ret pt; } + INTERPOLATED(token::nt_path(pt)) { p.bump(); return pt; } _ {} }]]; } @@ -198,9 +198,9 @@ class parser { } fn buffer_length() -> int { if self.buffer_start <= self.buffer_end { - ret self.buffer_end - self.buffer_start; + return self.buffer_end - self.buffer_start; } - ret (4 - self.buffer_start) + self.buffer_end; + return (4 - self.buffer_start) + self.buffer_end; } fn look_ahead(distance: uint) -> token::token { let dist = distance as int; @@ -208,7 +208,7 @@ class parser { self.buffer[self.buffer_end] = self.reader.next_token(); self.buffer_end = (self.buffer_end + 1) & 3; } - ret copy self.buffer[(self.buffer_start + dist - 1) & 3].tok; + return copy self.buffer[(self.buffer_start + dist - 1) & 3].tok; } fn fatal(m: ~str) -> ! { self.sess.span_diagnostic.span_fatal(copy self.span, m) @@ -255,7 +255,7 @@ class parser { id: p.get_id()} }; let (ret_style, ret_ty) = self.parse_ret_ty(); - ret {inputs: inputs, output: ret_ty, + return {inputs: inputs, output: ret_ty, purity: purity, cf: ret_style}; } @@ -315,7 +315,7 @@ class parser { fn parse_mt() -> mt { let mutbl = self.parse_mutability(); let t = self.parse_ty(false); - ret {ty: t, mutbl: mutbl}; + return {ty: t, mutbl: mutbl}; } fn parse_ty_field() -> ty_field { @@ -324,11 +324,13 @@ class parser { let id = self.parse_ident(); self.expect(token::COLON); let ty = self.parse_ty(false); - ret spanned(lo, ty.span.hi, {ident: id, mt: {ty: ty, mutbl: mutbl}}); + return spanned(lo, ty.span.hi, { + ident: id, mt: {ty: ty, mutbl: mutbl} + }); } fn parse_ret_ty() -> (ret_style, @ty) { - ret if self.eat(token::RARROW) { + return if self.eat(token::RARROW) { let lo = self.span.lo; if self.eat(token::NOT) { (noreturn, @{id: self.get_id(), @@ -391,7 +393,7 @@ class parser { alt self.maybe_parse_dollar_mac() { some(e) { - ret @{id: self.get_id(), + return @{id: self.get_id(), node: ty_mac(spanned(lo, self.span.hi, e)), span: mk_sp(lo, self.span.hi)}; } @@ -457,7 +459,7 @@ class parser { } else { self.fatal(~"expected type"); }; let sp = mk_sp(lo, self.last_span.hi); - ret @{id: self.get_id(), + return @{id: self.get_id(), node: alt self.maybe_parse_fixed_vstore() { // Consider a fixed vstore suffix (/N or /_) none { t } @@ -596,7 +598,7 @@ class parser { self.bump(); self.lit_from_token(tok) }; - ret {node: lit, span: mk_sp(lo, self.last_span.hi)}; + return {node: lit, span: mk_sp(lo, self.last_span.hi)}; } fn parse_path_without_tps() -> @path { @@ -639,7 +641,7 @@ class parser { let lo = self.span.lo; let path = self.parse_path_without_tps(); if colons && !self.eat(token::MOD_SEP) { - ret path; + return path; } // Parse the region parameter, if any, which will @@ -670,7 +672,7 @@ class parser { } }; - ret @{span: mk_sp(lo, tps.span.hi), + return @{span: mk_sp(lo, tps.span.hi), rp: rp, types: tps.node with *path}; } @@ -691,16 +693,16 @@ class parser { let i = self.parse_ident(); self.expect(sep); let e = self.parse_expr(); - ret spanned(lo, e.span.hi, {mutbl: m, ident: i, expr: e}); + return spanned(lo, e.span.hi, {mutbl: m, ident: i, expr: e}); } fn mk_expr(lo: uint, hi: uint, +node: expr_) -> @expr { - ret @{id: self.get_id(), callee_id: self.get_id(), + return @{id: self.get_id(), callee_id: self.get_id(), node: node, span: mk_sp(lo, hi)}; } fn mk_mac_expr(lo: uint, hi: uint, m: mac_) -> @expr { - ret @{id: self.get_id(), + return @{id: self.get_id(), callee_id: self.get_id(), node: expr_mac({node: m, span: mk_sp(lo, hi)}), span: mk_sp(lo, hi)}; @@ -711,12 +713,12 @@ class parser { let lv_lit = @{node: lit_uint(i as u64, ty_u32), span: span}; - ret @{id: self.get_id(), callee_id: self.get_id(), + return @{id: self.get_id(), callee_id: self.get_id(), node: expr_lit(lv_lit), span: span}; } fn mk_pexpr(lo: uint, hi: uint, node: expr_) -> pexpr { - ret pexpr(self.mk_expr(lo, hi, node)); + return pexpr(self.mk_expr(lo, hi, node)); } fn to_expr(e: pexpr) -> @expr { @@ -734,7 +736,7 @@ class parser { let mut ex: expr_; alt self.maybe_parse_dollar_mac() { - some(x) {ret pexpr(self.mk_mac_expr(lo, self.span.hi, x));} + some(x) {return pexpr(self.mk_mac_expr(lo, self.span.hi, x));} _ {} } @@ -744,7 +746,7 @@ class parser { hi = self.span.hi; self.bump(); let lit = @spanned(lo, hi, lit_nil); - ret self.mk_pexpr(lo, hi, expr_lit(lit)); + return self.mk_pexpr(lo, hi, expr_lit(lit)); } let mut es = ~[self.parse_expr()]; while self.token == token::COMMA { @@ -758,7 +760,7 @@ class parser { // This is so that wrappers around parse_bottom_expr() // can tell whether the expression was parenthesized or not, // which affects expr_is_complete(). - ret self.mk_pexpr(lo, hi, expr_tup(es)); + return self.mk_pexpr(lo, hi, expr_tup(es)); } else if self.token == token::LBRACE { if self.looking_at_record_literal() { ex = self.parse_record_literal(); @@ -766,29 +768,30 @@ class parser { } else { self.bump(); let blk = self.parse_block_tail(lo, default_blk); - ret self.mk_pexpr(blk.span.lo, blk.span.hi, expr_block(blk)); + return self.mk_pexpr(blk.span.lo, blk.span.hi, + expr_block(blk)); } } else if token::is_bar(self.token) { - ret pexpr(self.parse_lambda_expr()); + return pexpr(self.parse_lambda_expr()); } else if self.eat_keyword(~"new") { self.expect(token::LPAREN); let r = self.parse_expr(); self.expect(token::RPAREN); let v = self.parse_expr(); - ret self.mk_pexpr(lo, self.span.hi, + return self.mk_pexpr(lo, self.span.hi, expr_new(r, self.get_id(), v)); } else if self.eat_keyword(~"if") { - ret pexpr(self.parse_if_expr()); + return pexpr(self.parse_if_expr()); } else if self.eat_keyword(~"for") { - ret pexpr(self.parse_sugary_call_expr(~"for", expr_loop_body)); + return pexpr(self.parse_sugary_call_expr(~"for", expr_loop_body)); } else if self.eat_keyword(~"do") { - ret pexpr(self.parse_sugary_call_expr(~"do", expr_do_body)); + return pexpr(self.parse_sugary_call_expr(~"do", expr_do_body)); } else if self.eat_keyword(~"while") { - ret pexpr(self.parse_while_expr()); + return pexpr(self.parse_while_expr()); } else if self.eat_keyword(~"loop") { - ret pexpr(self.parse_loop_expr()); + return pexpr(self.parse_loop_expr()); } else if self.eat_keyword(~"alt") || self.eat_keyword(~"match") { - ret pexpr(self.parse_alt_expr()); + return pexpr(self.parse_alt_expr()); } else if self.eat_keyword(~"fn") { let proto = self.parse_fn_ty_proto(); alt proto { @@ -798,11 +801,11 @@ class parser { } _ { /* fallthrough */ } } - ret pexpr(self.parse_fn_expr(proto)); + return pexpr(self.parse_fn_expr(proto)); } else if self.eat_keyword(~"unchecked") { - ret pexpr(self.parse_block_expr(lo, unchecked_blk)); + return pexpr(self.parse_block_expr(lo, unchecked_blk)); } else if self.eat_keyword(~"unsafe") { - ret pexpr(self.parse_block_expr(lo, unsafe_blk)); + return pexpr(self.parse_block_expr(lo, unsafe_blk)); } else if self.token == token::LBRACKET { self.bump(); let mutbl = self.parse_mutability(); @@ -813,7 +816,7 @@ class parser { ex = expr_vec(es, mutbl); } else if self.token == token::ELLIPSIS { self.bump(); - ret pexpr(self.mk_mac_expr(lo, self.span.hi, mac_ellipsis)); + return pexpr(self.mk_mac_expr(lo, self.span.hi, mac_ellipsis)); } else if self.token == token::POUND { let ex_ext = self.parse_syntax_ext(); hi = ex_ext.span.hi; @@ -875,7 +878,8 @@ class parser { }; let hi = self.span.hi; - ret pexpr(self.mk_mac_expr(lo, hi, mac_invoc_tt(pth, tts))); + return pexpr(self.mk_mac_expr( + lo, hi, mac_invoc_tt(pth, tts))); } else if self.token == token::LBRACE { // This might be a struct literal. if self.looking_at_record_literal() { @@ -895,7 +899,7 @@ class parser { hi = pth.span.hi; self.expect(token::RBRACE); ex = expr_struct(pth, fields); - ret self.mk_pexpr(lo, hi, ex); + return self.mk_pexpr(lo, hi, ex); } } @@ -923,19 +927,19 @@ class parser { _ { } } - ret self.mk_pexpr(lo, hi, ex); + return self.mk_pexpr(lo, hi, ex); } fn parse_block_expr(lo: uint, blk_mode: blk_check_mode) -> @expr { self.expect(token::LBRACE); let blk = self.parse_block_tail(lo, blk_mode); - ret self.mk_expr(blk.span.lo, blk.span.hi, expr_block(blk)); + return self.mk_expr(blk.span.lo, blk.span.hi, expr_block(blk)); } fn parse_syntax_ext() -> @expr { let lo = self.span.lo; self.expect(token::POUND); - ret self.parse_syntax_ext_naked(lo); + return self.parse_syntax_ext_naked(lo); } fn parse_syntax_ext_naked(lo: uint) -> @expr { @@ -977,7 +981,7 @@ class parser { let hi = self.last_span.lo; b = some({span: mk_sp(lo,hi)}); } - ret self.mk_mac_expr(lo, self.span.hi, mac_invoc(pth, e, b)); + return self.mk_mac_expr(lo, self.span.hi, mac_invoc(pth, e, b)); } fn parse_dot_or_call_expr() -> pexpr { @@ -986,7 +990,7 @@ class parser { } fn permits_call() -> bool { - ret self.restriction != RESTRICT_NO_CALL_EXPRS; + return self.restriction != RESTRICT_NO_CALL_EXPRS; } fn parse_dot_or_call_expr_with(e0: pexpr) -> pexpr { @@ -1036,10 +1040,10 @@ class parser { e = self.mk_pexpr(lo, hi, expr_index(self.to_expr(e), ix)); } - _ { ret e; } + _ { return e; } } } - ret e; + return e; } fn parse_sep_and_zerok() -> (option, bool) { @@ -1047,7 +1051,7 @@ class parser { || self.token == token::BINOP(token::PLUS) { let zerok = self.token == token::BINOP(token::STAR); self.bump(); - ret (none, zerok); + return (none, zerok); } else { let sep = self.token; self.bump(); @@ -1055,7 +1059,7 @@ class parser { || self.token == token::BINOP(token::PLUS) { let zerok = self.token == token::BINOP(token::STAR); self.bump(); - ret (some(sep), zerok); + return (some(sep), zerok); } else { self.fatal(~"expected `*` or `+`"); } @@ -1083,19 +1087,19 @@ class parser { seq_sep_none(), |p| p.parse_token_tree()); let (s, z) = p.parse_sep_and_zerok(); - ret tt_seq(mk_sp(sp.lo ,p.span.hi), seq.node, s, z); + return tt_seq(mk_sp(sp.lo ,p.span.hi), seq.node, s, z); } else { - ret tt_nonterminal(sp, p.parse_ident()); + return tt_nonterminal(sp, p.parse_ident()); } } _ { /* ok */ } } let res = tt_tok(p.span, p.token); p.bump(); - ret res; + return res; } - ret alt self.token { + return alt self.token { token::LPAREN | token::LBRACE | token::LBRACKET { let ket = token::flip_delimiter(self.token); tt_delim(vec::append( @@ -1112,7 +1116,8 @@ class parser { fn parse_matchers() -> ~[matcher] { let name_idx = @mut 0u; - ret self.parse_matcher_subseq(name_idx, token::LBRACE, token::RBRACE); + return self.parse_matcher_subseq( + name_idx, token::LBRACE, token::RBRACE); } @@ -1134,7 +1139,7 @@ class parser { self.bump(); - ret ret_val; + return ret_val; } fn parse_matcher(name_idx: @mut uint) -> matcher { @@ -1165,7 +1170,7 @@ class parser { m }; - ret spanned(lo, self.span.hi, m); + return spanned(lo, self.span.hi, m); } @@ -1211,7 +1216,7 @@ class parser { _ { expr_addr_of(m, e) } }; } - _ { ret self.parse_dot_or_call_expr(); } + _ { return self.parse_dot_or_call_expr(); } } } token::AT { @@ -1238,29 +1243,29 @@ class parser { _ { expr_unary(uniq(m), e) } }; } - _ { ret self.parse_dot_or_call_expr(); } + _ { return self.parse_dot_or_call_expr(); } } - ret self.mk_pexpr(lo, hi, ex); + return self.mk_pexpr(lo, hi, ex); } fn parse_binops() -> @expr { - ret self.parse_more_binops(self.parse_prefix_expr(), 0u); + return self.parse_more_binops(self.parse_prefix_expr(), 0u); } fn parse_more_binops(plhs: pexpr, min_prec: uint) -> @expr { let lhs = self.to_expr(plhs); - if self.expr_is_complete(plhs) { ret lhs; } + if self.expr_is_complete(plhs) { return lhs; } let peeked = self.token; if peeked == token::BINOP(token::OR) && (self.restriction == RESTRICT_NO_BAR_OP || self.restriction == RESTRICT_NO_BAR_OR_DOUBLEBAR_OP) { - ret lhs; + return lhs; } if peeked == token::OROR && self.restriction == RESTRICT_NO_BAR_OR_DOUBLEBAR_OP { - ret lhs; + return lhs; } let cur_opt = token_to_binop(peeked); alt cur_opt { @@ -1273,7 +1278,7 @@ class parser { self.get_id(); // see ast_util::op_expr_callee_id let bin = self.mk_pexpr(lhs.span.lo, rhs.span.hi, expr_binary(cur_op, lhs, rhs)); - ret self.parse_more_binops(bin, min_prec); + return self.parse_more_binops(bin, min_prec); } } _ {} @@ -1282,9 +1287,9 @@ class parser { let rhs = self.parse_ty(true); let _as = self.mk_pexpr(lhs.span.lo, rhs.span.hi, expr_cast(lhs, rhs)); - ret self.parse_more_binops(_as, min_prec); + return self.parse_more_binops(_as, min_prec); } - ret lhs; + return lhs; } fn parse_assign_expr() -> @expr { @@ -1294,7 +1299,7 @@ class parser { token::EQ { self.bump(); let rhs = self.parse_expr(); - ret self.mk_expr(lo, rhs.span.hi, expr_assign(lhs, rhs)); + return self.mk_expr(lo, rhs.span.hi, expr_assign(lhs, rhs)); } token::BINOPEQ(op) { self.bump(); @@ -1313,21 +1318,22 @@ class parser { token::SHR { aop = shr; } } self.get_id(); // see ast_util::op_expr_callee_id - ret self.mk_expr(lo, rhs.span.hi, expr_assign_op(aop, lhs, rhs)); + return self.mk_expr(lo, rhs.span.hi, + expr_assign_op(aop, lhs, rhs)); } token::LARROW { self.bump(); let rhs = self.parse_expr(); - ret self.mk_expr(lo, rhs.span.hi, expr_move(lhs, rhs)); + return self.mk_expr(lo, rhs.span.hi, expr_move(lhs, rhs)); } token::DARROW { self.bump(); let rhs = self.parse_expr(); - ret self.mk_expr(lo, rhs.span.hi, expr_swap(lhs, rhs)); + return self.mk_expr(lo, rhs.span.hi, expr_swap(lhs, rhs)); } _ {/* fall through */ } } - ret lhs; + return lhs; } fn parse_if_expr() -> @expr { @@ -1342,7 +1348,7 @@ class parser { hi = elexpr.span.hi; } let q = {cond: cond, then: thn, els: els, lo: lo, hi: hi}; - ret self.mk_expr(q.lo, q.hi, expr_if(q.cond, q.then, q.els)); + return self.mk_expr(q.lo, q.hi, expr_if(q.cond, q.then, q.els)); } fn parse_fn_expr(proto: proto) -> @expr { @@ -1355,7 +1361,7 @@ class parser { |p| p.parse_arg_or_capture_item()); let body = self.parse_block(); - ret self.mk_expr(lo, body.span.hi, + return self.mk_expr(lo, body.span.hi, expr_fn(proto, decl, body, capture_clause)); } @@ -1406,16 +1412,16 @@ class parser { id: self.get_id(), rules: default_blk}; let fakeblock = spanned(body.span.lo, body.span.hi, fakeblock); - ret self.mk_expr(lo, body.span.hi, + return self.mk_expr(lo, body.span.hi, expr_fn_block(decl, fakeblock, captures)); } fn parse_else_expr() -> @expr { if self.eat_keyword(~"if") { - ret self.parse_if_expr(); + return self.parse_if_expr(); } else { let blk = self.parse_block(); - ret self.mk_expr(blk.span.lo, blk.span.hi, expr_block(blk)); + return self.mk_expr(blk.span.lo, blk.span.hi, expr_block(blk)); } } @@ -1464,14 +1470,14 @@ class parser { let cond = self.parse_expr(); let body = self.parse_block_no_value(); let mut hi = body.span.hi; - ret self.mk_expr(lo, hi, expr_while(cond, body)); + return self.mk_expr(lo, hi, expr_while(cond, body)); } fn parse_loop_expr() -> @expr { let lo = self.last_span.lo; let body = self.parse_block_no_value(); let mut hi = body.span.hi; - ret self.mk_expr(lo, hi, expr_loop(body)); + return self.mk_expr(lo, hi, expr_loop(body)); } // For distingishing between record literals and blocks @@ -1505,7 +1511,7 @@ class parser { vec::push(fields, self.parse_field(token::COLON)); } self.expect(token::RBRACE); - ret expr_rec(fields, base); + return expr_rec(fields, base); } fn parse_alt_expr() -> @expr { @@ -1547,11 +1553,11 @@ class parser { } let mut hi = self.span.hi; self.bump(); - ret self.mk_expr(lo, hi, expr_alt(discriminant, arms, mode)); + return self.mk_expr(lo, hi, expr_alt(discriminant, arms, mode)); } fn parse_expr() -> @expr { - ret self.parse_expr_res(UNRESTRICTED); + return self.parse_expr_res(UNRESTRICTED); } fn parse_expr_res(r: restriction) -> @expr { @@ -1559,28 +1565,28 @@ class parser { self.restriction = r; let e = self.parse_assign_expr(); self.restriction = old; - ret e; + return e; } fn parse_initializer() -> option { alt self.token { token::EQ { self.bump(); - ret some({op: init_assign, expr: self.parse_expr()}); + return some({op: init_assign, expr: self.parse_expr()}); } token::LARROW { self.bump(); - ret some({op: init_move, expr: self.parse_expr()}); + return some({op: init_move, expr: self.parse_expr()}); } // Now that the the channel is the first argument to receive, // combining it with an initializer doesn't really make sense. // case (token::RECV) { // self.bump(); - // ret some(rec(op = init_recv, + // return some(rec(op = init_recv, // expr = self.parse_expr())); // } _ { - ret none; + return none; } } } @@ -1590,7 +1596,7 @@ class parser { loop { vec::push(pats, self.parse_pat(true)); if self.token == token::BINOP(token::OR) { self.bump(); } - else { ret pats; } + else { return pats; } }; } @@ -1779,7 +1785,7 @@ class parser { } } } - ret @{id: self.get_id(), node: pat, span: mk_sp(lo, hi)}; + return @{id: self.get_id(), node: pat, span: mk_sp(lo, hi)}; } fn parse_local(is_mutbl: bool, @@ -1791,7 +1797,7 @@ class parser { span: mk_sp(lo, lo)}; if self.eat(token::COLON) { ty = self.parse_ty(false); } let init = if allow_init { self.parse_initializer() } else { none }; - ret @spanned(lo, self.last_span.hi, + return @spanned(lo, self.last_span.hi, {is_mutbl: is_mutbl, ty: ty, pat: pat, init: init, id: self.get_id()}); } @@ -1803,7 +1809,7 @@ class parser { while self.eat(token::COMMA) { vec::push(locals, self.parse_local(is_mutbl, true)); } - ret @spanned(lo, self.last_span.hi, decl_local(locals)); + return @spanned(lo, self.last_span.hi, decl_local(locals)); } /* assumes "let" token has already been consumed */ @@ -1819,7 +1825,7 @@ class parser { let name = self.parse_ident(); self.expect(token::COLON); let ty = self.parse_ty(false); - ret @{node: instance_var(name, ty, is_mutbl, self.get_id(), pr), + return @{node: instance_var(name, ty, is_mutbl, self.get_id(), pr), span: mk_sp(lo, self.last_span.hi)}; } @@ -1836,14 +1842,15 @@ class parser { check_expected_item(self, first_item_attrs); self.expect_keyword(~"let"); let decl = self.parse_let(); - ret @spanned(lo, decl.span.hi, stmt_decl(decl, self.get_id())); + return @spanned(lo, decl.span.hi, stmt_decl(decl, self.get_id())); } else { let mut item_attrs; alt self.parse_outer_attrs_or_ext(first_item_attrs) { none { item_attrs = ~[]; } some(left(attrs)) { item_attrs = attrs; } some(right(ext)) { - ret @spanned(lo, ext.span.hi, stmt_expr(ext, self.get_id())); + return @spanned(lo, ext.span.hi, + stmt_expr(ext, self.get_id())); } } @@ -1853,7 +1860,7 @@ class parser { some(i) { let mut hi = i.span.hi; let decl = @spanned(lo, hi, decl_item(i)); - ret @spanned(lo, hi, stmt_decl(decl, self.get_id())); + return @spanned(lo, hi, stmt_decl(decl, self.get_id())); } none() { /* fallthrough */ } } @@ -1862,7 +1869,7 @@ class parser { // Remainder are line-expr stmts. let e = self.parse_expr_res(RESTRICT_STMT_EXPR); - ret @spanned(lo, e.span.hi, stmt_expr(e, self.get_id())); + return @spanned(lo, e.span.hi, stmt_expr(e, self.get_id())); } } @@ -1870,14 +1877,14 @@ class parser { log(debug, (~"expr_is_complete", self.restriction, print::pprust::expr_to_str(*e), classify::expr_requires_semi_to_be_stmt(*e))); - ret self.restriction == RESTRICT_STMT_EXPR && + return self.restriction == RESTRICT_STMT_EXPR && !classify::expr_requires_semi_to_be_stmt(*e); } fn parse_block() -> blk { let (attrs, blk) = self.parse_inner_attrs_and_block(false); assert vec::is_empty(attrs); - ret blk; + return blk; } fn parse_inner_attrs_and_block(parse_attrs: bool) @@ -1897,17 +1904,17 @@ class parser { self.expect(token::LBRACE); let {inner, next} = maybe_parse_inner_attrs_and_next(self, parse_attrs); - ret (inner, self.parse_block_tail_(lo, unchecked_blk, next)); + return (inner, self.parse_block_tail_(lo, unchecked_blk, next)); } else if self.eat_keyword(~"unsafe") { self.expect(token::LBRACE); let {inner, next} = maybe_parse_inner_attrs_and_next(self, parse_attrs); - ret (inner, self.parse_block_tail_(lo, unsafe_blk, next)); + return (inner, self.parse_block_tail_(lo, unsafe_blk, next)); } else { self.expect(token::LBRACE); let {inner, next} = maybe_parse_inner_attrs_and_next(self, parse_attrs); - ret (inner, self.parse_block_tail_(lo, default_blk, next)); + return (inner, self.parse_block_tail_(lo, default_blk, next)); } } @@ -1915,7 +1922,7 @@ class parser { // We parse blocks that cannot have a value the same as any other // block; the type checker will make sure that the tail expression (if // any) has unit type. - ret self.parse_block(); + return self.parse_block(); } // Precondition: already parsed the '{' or '#{' @@ -1983,7 +1990,7 @@ class parser { self.bump(); let bloc = {view_items: view_items, stmts: stmts, expr: expr, id: self.get_id(), rules: s}; - ret spanned(lo, hi, bloc); + return spanned(lo, hi, bloc); } fn parse_ty_param() -> ty_param { @@ -2003,7 +2010,7 @@ class parser { push(bounds, bound_trait(self.parse_ty(false))); } } } - ret {ident: ident, id: self.get_id(), bounds: @bounds}; + return {ident: ident, id: self.get_id(), bounds: @bounds}; } fn parse_ty_params() -> ~[ty_param] { @@ -2025,7 +2032,7 @@ class parser { let capture_clause = @either::rights(args_or_capture_items); let (ret_style, ret_ty) = self.parse_ret_ty(); - ret ({inputs: inputs, + return ({inputs: inputs, output: ret_ty, purity: purity, cf: ret_style}, capture_clause); @@ -2183,7 +2190,7 @@ class parser { } else { @{id: self.get_id(), node: ty_infer, span: self.span} }; - ret ({inputs: either::lefts(inputs_captures), + return ({inputs: either::lefts(inputs_captures), output: output, purity: impure_fn, cf: return_val}, @@ -2193,13 +2200,13 @@ class parser { fn parse_fn_header() -> {ident: ident, tps: ~[ty_param]} { let id = self.parse_value_ident(); let ty_params = self.parse_ty_params(); - ret {ident: id, tps: ty_params}; + return {ident: id, tps: ty_params}; } fn mk_item(lo: uint, hi: uint, +ident: ident, +node: item_, vis: visibility, +attrs: ~[attribute]) -> @item { - ret @{ident: ident, + return @{ident: ident, attrs: attrs, id: self.get_id(), node: node, @@ -2441,10 +2448,10 @@ class parser { !self.token_is_pound_or_doc_comment(self.token) { let a_var = self.parse_instance_var(vis); self.expect(token::SEMI); - ret a_var; + return a_var; } else { let m = self.parse_method(vis); - ret @{node: class_method(m), span: m.span}; + return @{node: class_method(m), span: m.span}; } } @@ -2475,21 +2482,21 @@ class parser { vec::push(results, self.parse_single_class_item(private)); } self.bump(); - ret members(results); + return members(results); } let attrs = self.parse_outer_attributes(); if self.eat_keyword(~"new") { // result type is always the type of the class - ret self.parse_ctor(attrs, ty_path(class_name_with_tps, + return self.parse_ctor(attrs, ty_path(class_name_with_tps, self.get_id())); } else if self.eat_keyword(~"drop") { - ret self.parse_dtor(attrs); + return self.parse_dtor(attrs); } else { - ret members(~[self.parse_single_class_item(public)]); + return members(~[self.parse_single_class_item(public)]); } } @@ -2529,7 +2536,7 @@ class parser { self.fatal(~"expected item"); } - ret {view_items: view_items, items: items}; + return {view_items: view_items, items: items}; } fn parse_item_const() -> item_info { @@ -2558,7 +2565,7 @@ class parser { let (decl, _) = self.parse_fn_decl(purity, |p| p.parse_arg()); let mut hi = self.span.hi; self.expect(token::SEMI); - ret @{ident: t.ident, + return @{ident: t.ident, attrs: attrs, node: foreign_item_fn(decl, t.tps), id: self.get_id(), @@ -2595,7 +2602,7 @@ class parser { initial_attrs = ~[]; vec::push(items, self.parse_foreign_item(attrs)); } - ret {view_items: view_items, + return {view_items: view_items, items: items}; } @@ -2616,7 +2623,7 @@ class parser { fn parse_type_decl() -> {lo: uint, ident: ident} { let lo = self.last_span.lo; let id = self.parse_ident(); - ret {lo: lo, ident: id}; + return {lo: lo, ident: id}; } fn parse_item_type() -> item_info { @@ -2654,7 +2661,7 @@ class parser { id: self.get_id(), disr_expr: none, vis: public}); - ret (id, item_enum(~[variant], ty_params), none); + return (id, item_enum(~[variant], ty_params), none); } self.expect(token::LBRACE); @@ -2787,7 +2794,7 @@ class parser { hi: self.span.hi, expn_info: none}}; (id, item_mac(m), none) - } else { ret none; }; + } else { return none; }; some(self.mk_item(lo, self.last_span.hi, ident, item_, vis, alt extra_attrs { some(as) { vec::append(attrs, as) } @@ -2798,7 +2805,7 @@ class parser { fn parse_use() -> view_item_ { let ident = self.parse_ident(); let metadata = self.parse_optional_meta(); - ret view_item_use(ident, metadata, self.get_id()); + return view_item_use(ident, metadata, self.get_id()); } fn parse_view_path() -> @view_path { @@ -2818,7 +2825,7 @@ class parser { } let path = @{span: mk_sp(lo, self.span.hi), global: false, idents: path, rp: none, types: ~[]}; - ret @spanned(lo, self.span.hi, + return @spanned(lo, self.span.hi, view_path_simple(first_ident, path, self.get_id())); } @@ -2843,7 +2850,7 @@ class parser { let path = @{span: mk_sp(lo, self.span.hi), global: false, idents: path, rp: none, types: ~[]}; - ret @spanned(lo, self.span.hi, + return @spanned(lo, self.span.hi, view_path_list(path, idents, self.get_id())); } @@ -2853,7 +2860,7 @@ class parser { let path = @{span: mk_sp(lo, self.span.hi), global: false, idents: path, rp: none, types: ~[]}; - ret @spanned(lo, self.span.hi, + return @spanned(lo, self.span.hi, view_path_glob(path, self.get_id())); } @@ -2866,7 +2873,7 @@ class parser { let last = path[vec::len(path) - 1u]; let path = @{span: mk_sp(lo, self.span.hi), global: false, idents: path, rp: none, types: ~[]}; - ret @spanned(lo, self.span.hi, + return @spanned(lo, self.span.hi, view_path_simple(last, path, self.get_id())); } @@ -2876,7 +2883,7 @@ class parser { self.bump(); vec::push(vp, self.parse_view_path()); } - ret vp; + return vp; } fn is_view_item() -> bool { @@ -2922,7 +2929,7 @@ class parser { let crate_attrs = self.parse_inner_attrs_and_next(); let first_item_outer_attrs = crate_attrs.next; let m = self.parse_mod_items(token::EOF, first_item_outer_attrs); - ret @spanned(lo, self.span.lo, + return @spanned(lo, self.span.lo, {directives: ~[], module: m, attrs: crate_attrs.inner, @@ -2968,7 +2975,7 @@ class parser { token::SEMI { let mut hi = self.span.hi; self.bump(); - ret spanned(lo, hi, cdir_src_mod(id, outer_attrs)); + return spanned(lo, hi, cdir_src_mod(id, outer_attrs)); } // mod x = "foo_dir" { ...directives... } token::LBRACE { @@ -2980,15 +2987,15 @@ class parser { next_outer_attr); let mut hi = self.span.hi; self.expect(token::RBRACE); - ret spanned(lo, hi, + return spanned(lo, hi, cdir_dir_mod(id, cdirs, mod_attrs)); } _ { self.unexpected(); } } } else if self.is_view_item() { let vi = self.parse_view_item(outer_attrs); - ret spanned(lo, vi.span.hi, cdir_view_item(vi)); - } else { ret self.fatal(~"expected crate directive"); } + return spanned(lo, vi.span.hi, cdir_view_item(vi)); + } else { return self.fatal(~"expected crate directive"); } } fn parse_crate_directives(term: token::token, @@ -3013,7 +3020,7 @@ class parser { vec::push(cdirs, cdir); first_outer_attr = ~[]; } - ret cdirs; + return cdirs; } } // -- cgit 1.4.1-3-g733a5