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/attr.rs | 30 ++--- src/libsyntax/parse/classify.rs | 6 +- src/libsyntax/parse/comments.rs | 24 ++-- src/libsyntax/parse/common.rs | 28 ++--- src/libsyntax/parse/eval.rs | 12 +- src/libsyntax/parse/lexer.rs | 172 +++++++++++++------------- src/libsyntax/parse/parser.rs | 267 +++++++++++++++++++++------------------- src/libsyntax/parse/token.rs | 2 +- 8 files changed, 276 insertions(+), 265 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index fb28f952629..265b707899a 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -36,21 +36,21 @@ impl parser_attr of parser_attr for parser { self.bump(); let first_attr = self.parse_attribute_naked(ast::attr_outer, lo); - ret some(left(vec::append(~[first_attr], + return some(left(vec::append(~[first_attr], self.parse_outer_attributes()))); } else if !(self.look_ahead(1u) == token::LT || self.look_ahead(1u) == token::LBRACKET || self.look_ahead(1u) == token::POUND || expect_item_next) { self.bump(); - ret some(right(self.parse_syntax_ext_naked(lo))); - } else { ret none; } + return some(right(self.parse_syntax_ext_naked(lo))); + } else { return none; } } token::DOC_COMMENT(_) { - ret some(left(self.parse_outer_attributes())); + return some(left(self.parse_outer_attributes())); } _ { - ret none; + return none; } } } @@ -80,13 +80,13 @@ impl parser_attr of parser_attr for parser { } } } - ret attrs; + return attrs; } fn parse_attribute(style: ast::attr_style) -> ast::attribute { let lo = self.span.lo; self.expect(token::POUND); - ret self.parse_attribute_naked(style, lo); + return self.parse_attribute_naked(style, lo); } fn parse_attribute_naked(style: ast::attr_style, lo: uint) -> @@ -95,7 +95,7 @@ impl parser_attr of parser_attr for parser { let meta_item = self.parse_meta_item(); self.expect(token::RBRACKET); let mut hi = self.span.hi; - ret spanned(lo, hi, {style: style, value: *meta_item, + return spanned(lo, hi, {style: style, value: *meta_item, is_sugared_doc: false}); } @@ -146,7 +146,7 @@ impl parser_attr of parser_attr for parser { } } } - ret {inner: inner_attrs, next: next_outer_attrs}; + return {inner: inner_attrs, next: next_outer_attrs}; } fn parse_meta_item() -> @ast::meta_item { @@ -157,29 +157,29 @@ impl parser_attr of parser_attr for parser { self.bump(); let lit = self.parse_lit(); let mut hi = self.span.hi; - ret @spanned(lo, hi, ast::meta_name_value(ident, lit)); + return @spanned(lo, hi, ast::meta_name_value(ident, lit)); } token::LPAREN { let inner_items = self.parse_meta_seq(); let mut hi = self.span.hi; - ret @spanned(lo, hi, ast::meta_list(ident, inner_items)); + return @spanned(lo, hi, ast::meta_list(ident, inner_items)); } _ { let mut hi = self.span.hi; - ret @spanned(lo, hi, ast::meta_word(ident)); + return @spanned(lo, hi, ast::meta_word(ident)); } } } fn parse_meta_seq() -> ~[@ast::meta_item] { - ret self.parse_seq(token::LPAREN, token::RPAREN, + return self.parse_seq(token::LPAREN, token::RPAREN, seq_sep_trailing_disallowed(token::COMMA), |p| p.parse_meta_item()).node; } fn parse_optional_meta() -> ~[@ast::meta_item] { - alt self.token { token::LPAREN { ret self.parse_meta_seq(); } - _ { ret ~[]; } } + alt self.token { token::LPAREN { return self.parse_meta_seq(); } + _ { return ~[]; } } } } diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs index 20fb7772d08..8a5e02163be 100644 --- a/src/libsyntax/parse/classify.rs +++ b/src/libsyntax/parse/classify.rs @@ -18,16 +18,16 @@ fn expr_requires_semi_to_be_stmt(e: @ast::expr) -> bool { fn stmt_ends_with_semi(stmt: ast::stmt) -> bool { alt stmt.node { ast::stmt_decl(d, _) { - ret alt d.node { + return alt d.node { ast::decl_local(_) { true } ast::decl_item(_) { false } } } ast::stmt_expr(e, _) { - ret expr_requires_semi_to_be_stmt(e); + return expr_requires_semi_to_be_stmt(e); } ast::stmt_semi(e, _) { - ret false; + return false; } } } diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index c9224c2817f..7c24f8b1245 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -47,7 +47,7 @@ fn strip_doc_comment_decoration(comment: ~str) -> ~str { while j > i && lines[j - 1u].trim().is_empty() { j -= 1u; } - ret lines.slice(i, j); + return lines.slice(i, j); } // drop leftmost columns that contain only values in chars @@ -69,7 +69,7 @@ fn strip_doc_comment_decoration(comment: ~str) -> ~str { } } - ret do lines.map |line| { + return do lines.map |line| { let chars = str::chars(line); if i > chars.len() { ~"" @@ -80,7 +80,7 @@ fn strip_doc_comment_decoration(comment: ~str) -> ~str { } if comment.starts_with(~"//") { - ret comment.slice(3u, comment.len()).trim(); + return comment.slice(3u, comment.len()).trim(); } if comment.starts_with(~"/*") { @@ -89,7 +89,7 @@ fn strip_doc_comment_decoration(comment: ~str) -> ~str { let lines = block_trim(lines, ~"\t ", none); let lines = block_trim(lines, ~"*", some(1u)); let lines = block_trim(lines, ~"\t ", none); - ret str::connect(lines, ~"\n"); + return str::connect(lines, ~"\n"); } fail ~"not a doc-comment: " + comment; @@ -102,14 +102,14 @@ fn read_to_eol(rdr: string_reader) -> ~str { bump(rdr); } if rdr.curr == '\n' { bump(rdr); } - ret val; + return val; } fn read_one_line_comment(rdr: string_reader) -> ~str { let val = read_to_eol(rdr); assert ((val[0] == '/' as u8 && val[1] == '/' as u8) || (val[0] == '#' as u8 && val[1] == '!' as u8)); - ret val; + return val; } fn consume_non_eol_whitespace(rdr: string_reader) { @@ -173,8 +173,10 @@ fn read_line_comments(rdr: string_reader, code_to_the_left: bool, fn all_whitespace(s: ~str, begin: uint, end: uint) -> bool { let mut i: uint = begin; - while i != end { if !is_whitespace(s[i] as char) { ret false; } i += 1u; } - ret true; + while i != end { + if !is_whitespace(s[i] as char) { return false; } i += 1u; + } + return true; } fn trim_whitespace_prefix_and_push_line(&lines: ~[~str], @@ -208,7 +210,7 @@ fn read_block_comment(rdr: string_reader, code_to_the_left: bool, bump(rdr); bump(rdr); } - ret; + return; } let mut curr_line = ~"/*"; @@ -250,7 +252,7 @@ fn read_block_comment(rdr: string_reader, code_to_the_left: bool, } fn peeking_at_comment(rdr: string_reader) -> bool { - ret ((rdr.curr == '/' && nextch(rdr) == '/') || + return ((rdr.curr == '/' && nextch(rdr) == '/') || (rdr.curr == '/' && nextch(rdr) == '*')) || (rdr.curr == '#' && nextch(rdr) == '!'); } @@ -314,5 +316,5 @@ fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler, } first_read = false; } - ret {cmnts: comments, lits: literals}; + return {cmnts: comments, lits: literals}; } diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs index c747c8e9165..e0b551f0e45 100644 --- a/src/libsyntax/parse/common.rs +++ b/src/libsyntax/parse/common.rs @@ -9,13 +9,13 @@ type seq_sep = { }; fn seq_sep_trailing_disallowed(t: token::token) -> seq_sep { - ret {sep: option::some(t), trailing_sep_allowed: false}; + return {sep: option::some(t), trailing_sep_allowed: false}; } fn seq_sep_trailing_allowed(t: token::token) -> seq_sep { - ret {sep: option::some(t), trailing_sep_allowed: true}; + return {sep: option::some(t), trailing_sep_allowed: true}; } fn seq_sep_none() -> seq_sep { - ret {sep: option::none, trailing_sep_allowed: false}; + return {sep: option::none, trailing_sep_allowed: false}; } fn token_to_str(reader: reader, ++token: token::token) -> ~str { @@ -85,7 +85,7 @@ impl parser_common of parser_common for parser { fn parse_ident() -> ast::ident { alt copy self.token { - token::IDENT(i, _) { self.bump(); ret self.get_str(i); } + token::IDENT(i, _) { self.bump(); return self.get_str(i); } token::INTERPOLATED(token::nt_ident(*)) { self.bug( ~"ident interpolation not converted to real token"); } _ { self.fatal(~"expected ident, found `" @@ -98,16 +98,16 @@ impl parser_common of parser_common for parser { let lo = self.span.lo; let ident = self.parse_ident(); let hi = self.span.hi; - ret spanned(lo, hi, {name: ident, id: self.get_id()}); + return spanned(lo, hi, {name: ident, id: self.get_id()}); } fn parse_value_ident() -> ast::ident { self.check_restricted_keywords(); - ret self.parse_ident(); + return self.parse_ident(); } fn eat(tok: token::token) -> bool { - ret if self.token == tok { self.bump(); true } else { false }; + return if self.token == tok { self.bump(); true } else { false }; } // A sanity check that the word we are asking for is a known keyword @@ -217,7 +217,7 @@ impl parser_common of parser_common for parser { vec::push(v, f(self)); } - ret v; + return v; } fn parse_seq_to_gt(sep: option, @@ -225,7 +225,7 @@ impl parser_common of parser_common for parser { let v = self.parse_seq_to_before_gt(sep, f); self.expect_gt(); - ret v; + return v; } fn parse_seq_lt_gt(sep: option, @@ -235,14 +235,14 @@ impl parser_common of parser_common for parser { let result = self.parse_seq_to_before_gt::(sep, f); let hi = self.span.hi; self.expect_gt(); - ret spanned(lo, hi, result); + return spanned(lo, hi, result); } fn parse_seq_to_end(ket: token::token, sep: seq_sep, f: fn(parser) -> T) -> ~[T] { let val = self.parse_seq_to_before_end(ket, sep, f); self.bump(); - ret val; + return val; } @@ -259,7 +259,7 @@ impl parser_common of parser_common for parser { if sep.trailing_sep_allowed && self.token == ket { break; } vec::push(v, f(self)); } - ret v; + return v; } fn parse_unspanned_seq(bra: token::token, @@ -269,7 +269,7 @@ impl parser_common of parser_common for parser { self.expect(bra); let result = self.parse_seq_to_before_end::(ket, sep, f); self.bump(); - ret result; + return result; } // NB: Do not use this function unless you actually plan to place the @@ -281,6 +281,6 @@ impl parser_common of parser_common for parser { let result = self.parse_seq_to_before_end::(ket, sep, f); let hi = self.span.hi; self.bump(); - ret spanned(lo, hi, result); + return spanned(lo, hi, result); } } diff --git a/src/libsyntax/parse/eval.rs b/src/libsyntax/parse/eval.rs index 8a53625be1e..90519c23e5f 100644 --- a/src/libsyntax/parse/eval.rs +++ b/src/libsyntax/parse/eval.rs @@ -28,7 +28,7 @@ fn eval_crate_directives_to_mod(cx: ctx, cdirs: ~[@ast::crate_directive], let mut view_items: ~[@ast::view_item] = ~[]; let mut items: ~[@ast::item] = ~[]; eval_crate_directives(cx, cdirs, prefix, view_items, items); - ret ({view_items: vec::append(view_items, cview_items), + return ({view_items: vec::append(view_items, cview_items), items: vec::append(items, citems)}, cattrs); } @@ -47,7 +47,7 @@ fn parse_companion_mod(cx: ctx, prefix: ~str, suffix: option<~str>) -> (~[@ast::view_item], ~[@ast::item], ~[ast::attribute]) { fn companion_file(+prefix: ~str, suffix: option<~str>) -> ~str { - ret alt suffix { + return alt suffix { option::some(s) { path::connect(prefix, s) } option::none { prefix } } + ~".rs"; @@ -72,18 +72,18 @@ fn parse_companion_mod(cx: ctx, prefix: ~str, suffix: option<~str>) let m0 = p0.parse_mod_items(token::EOF, inner_attrs.next); cx.sess.chpos = r0.chpos; cx.sess.byte_pos = cx.sess.byte_pos + r0.pos; - ret (m0.view_items, m0.items, inner_attrs.inner); + return (m0.view_items, m0.items, inner_attrs.inner); } else { - ret (~[], ~[], ~[]); + return (~[], ~[], ~[]); } } fn cdir_path_opt(id: ast::ident, attrs: ~[ast::attribute]) -> @~str { alt ::attr::first_attr_value_str_by_name(attrs, ~"path") { some(d) { - ret d; + return d; } - none { ret id; } + none { return id; } } } diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index 5a343f370f3..a2d7a04a6bf 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -38,7 +38,7 @@ fn new_string_reader(span_diagnostic: span_handler, itr: @interner<@~str>) -> string_reader { let r = new_low_level_string_reader(span_diagnostic, filemap, itr); string_advance_token(r); /* fill in peek_* */ - ret r; + return r; } /* For comments.rs, which hackily pokes into 'pos' and 'curr' */ @@ -58,7 +58,7 @@ fn new_low_level_string_reader(span_diagnostic: span_handler, r.pos = next.next; r.curr = next.ch; } - ret r; + return r; } fn dup_string_reader(&&r: string_reader) -> string_reader { @@ -73,7 +73,7 @@ impl string_reader_as_reader of reader for string_reader { fn next_token() -> {tok: token::token, sp: span} { let ret_val = {tok: self.peek_tok, sp: self.peek_span}; string_advance_token(self); - ret ret_val; + return ret_val; } fn fatal(m: ~str) -> ! { self.span_diagnostic.span_fatal(copy self.peek_span, m) @@ -112,7 +112,7 @@ fn string_advance_token(&&r: string_reader) { for consume_whitespace_and_comments(r).each |comment| { r.peek_tok = comment.tok; r.peek_span = comment.sp; - ret; + return; } if is_eof(r) { @@ -128,7 +128,7 @@ fn string_advance_token(&&r: string_reader) { fn get_str_from(rdr: string_reader, start: uint) -> ~str unsafe { // I'm pretty skeptical about this subtraction. What if there's a // multi-byte character before the mark? - ret str::slice(*rdr.src, start - 1u, rdr.pos - 1u); + return str::slice(*rdr.src, start - 1u, rdr.pos - 1u); } fn bump(rdr: string_reader) { @@ -155,49 +155,51 @@ fn is_eof(rdr: string_reader) -> bool { } fn nextch(rdr: string_reader) -> char { if rdr.pos < (*rdr.src).len() { - ret str::char_at(*rdr.src, rdr.pos); - } else { ret -1 as char; } + return str::char_at(*rdr.src, rdr.pos); + } else { return -1 as char; } } -fn dec_digit_val(c: char) -> int { ret (c as int) - ('0' as int); } +fn dec_digit_val(c: char) -> int { return (c as int) - ('0' as int); } fn hex_digit_val(c: char) -> int { - if in_range(c, '0', '9') { ret (c as int) - ('0' as int); } - if in_range(c, 'a', 'f') { ret (c as int) - ('a' as int) + 10; } - if in_range(c, 'A', 'F') { ret (c as int) - ('A' as int) + 10; } + if in_range(c, '0', '9') { return (c as int) - ('0' as int); } + if in_range(c, 'a', 'f') { return (c as int) - ('a' as int) + 10; } + if in_range(c, 'A', 'F') { return (c as int) - ('A' as int) + 10; } fail; } -fn bin_digit_value(c: char) -> int { if c == '0' { ret 0; } ret 1; } +fn bin_digit_value(c: char) -> int { if c == '0' { return 0; } return 1; } fn is_whitespace(c: char) -> bool { - ret c == ' ' || c == '\t' || c == '\r' || c == '\n'; + return c == ' ' || c == '\t' || c == '\r' || c == '\n'; } -fn may_begin_ident(c: char) -> bool { ret is_alpha(c) || c == '_'; } +fn may_begin_ident(c: char) -> bool { return is_alpha(c) || c == '_'; } -fn in_range(c: char, lo: char, hi: char) -> bool { ret lo <= c && c <= hi; } +fn in_range(c: char, lo: char, hi: char) -> bool { + return lo <= c && c <= hi +} fn is_alpha(c: char) -> bool { - ret in_range(c, 'a', 'z') || in_range(c, 'A', 'Z'); + return in_range(c, 'a', 'z') || in_range(c, 'A', 'Z'); } -fn is_dec_digit(c: char) -> bool { ret in_range(c, '0', '9'); } +fn is_dec_digit(c: char) -> bool { return in_range(c, '0', '9'); } -fn is_alnum(c: char) -> bool { ret is_alpha(c) || is_dec_digit(c); } +fn is_alnum(c: char) -> bool { return is_alpha(c) || is_dec_digit(c); } fn is_hex_digit(c: char) -> bool { - ret in_range(c, '0', '9') || in_range(c, 'a', 'f') || + return in_range(c, '0', '9') || in_range(c, 'a', 'f') || in_range(c, 'A', 'F'); } -fn is_bin_digit(c: char) -> bool { ret c == '0' || c == '1'; } +fn is_bin_digit(c: char) -> bool { return c == '0' || c == '1'; } // might return a sugared-doc-attr fn consume_whitespace_and_comments(rdr: string_reader) -> option<{tok: token::token, sp: span}> { while is_whitespace(rdr.curr) { bump(rdr); } - ret consume_any_line_comment(rdr); + return consume_any_line_comment(rdr); } // might return a sugared-doc-attr @@ -216,17 +218,17 @@ fn consume_any_line_comment(rdr: string_reader) str::push_char(acc, rdr.curr); bump(rdr); } - ret some({ + return some({ tok: token::DOC_COMMENT((*rdr.interner).intern(@acc)), sp: ast_util::mk_sp(start_chpos, rdr.chpos) }); } else { while rdr.curr != '\n' && !is_eof(rdr) { bump(rdr); } // Restart whitespace munch. - ret consume_whitespace_and_comments(rdr); + return consume_whitespace_and_comments(rdr); } } - '*' { bump(rdr); bump(rdr); ret consume_block_comment(rdr); } + '*' { bump(rdr); bump(rdr); return consume_block_comment(rdr); } _ {} } } else if rdr.curr == '#' { @@ -236,11 +238,11 @@ fn consume_any_line_comment(rdr: string_reader) let loc = codemap::lookup_char_pos_adj(cmap, rdr.chpos); if loc.line == 1u && loc.col == 0u { while rdr.curr != '\n' && !is_eof(rdr) { bump(rdr); } - ret consume_whitespace_and_comments(rdr); + return consume_whitespace_and_comments(rdr); } } } - ret none; + return none; } // might return a sugared-doc-attr @@ -261,7 +263,7 @@ fn consume_block_comment(rdr: string_reader) acc += ~"*/"; bump(rdr); bump(rdr); - ret some({ + return some({ tok: token::DOC_COMMENT((*rdr.interner).intern(@acc)), sp: ast_util::mk_sp(start_chpos, rdr.chpos) }); @@ -285,7 +287,7 @@ fn consume_block_comment(rdr: string_reader) } // restart whitespace munch. - ret consume_whitespace_and_comments(rdr); + return consume_whitespace_and_comments(rdr); } fn scan_exponent(rdr: string_reader) -> option<~str> { @@ -301,9 +303,9 @@ fn scan_exponent(rdr: string_reader) -> option<~str> { } let exponent = scan_digits(rdr, 10u); if str::len(exponent) > 0u { - ret some(rslt + exponent); + return some(rslt + exponent); } else { rdr.fatal(~"scan_exponent: bad fp literal"); } - } else { ret none::<~str>; } + } else { return none::<~str>; } } fn scan_digits(rdr: string_reader, radix: uint) -> ~str { @@ -316,7 +318,7 @@ fn scan_digits(rdr: string_reader, radix: uint) -> ~str { str::push_char(rslt, c); bump(rdr); } - _ { ret rslt; } + _ { return rslt; } } }; } @@ -370,8 +372,8 @@ fn scan_number(c: char, rdr: string_reader) -> token::token { } let parsed = option::get(u64::from_str_radix(num_str, base as u64)); alt tp { - either::left(t) { ret token::LIT_INT(parsed as i64, t); } - either::right(t) { ret token::LIT_UINT(parsed, t); } + either::left(t) { return token::LIT_INT(parsed as i64, t); } + either::right(t) { return token::LIT_UINT(parsed, t); } } } let mut is_float = false; @@ -395,12 +397,12 @@ fn scan_number(c: char, rdr: string_reader) -> token::token { if c == '3' && n == '2' { bump(rdr); bump(rdr); - ret token::LIT_FLOAT((*rdr.interner).intern(@num_str), + return token::LIT_FLOAT((*rdr.interner).intern(@num_str), ast::ty_f32); } else if c == '6' && n == '4' { bump(rdr); bump(rdr); - ret token::LIT_FLOAT((*rdr.interner).intern(@num_str), + return token::LIT_FLOAT((*rdr.interner).intern(@num_str), ast::ty_f64); /* FIXME (#2252): if this is out of range for either a 32-bit or 64-bit float, it won't be noticed till the @@ -410,7 +412,7 @@ fn scan_number(c: char, rdr: string_reader) -> token::token { } } if is_float { - ret token::LIT_FLOAT((*rdr.interner).intern(@num_str), ast::ty_f); + return token::LIT_FLOAT((*rdr.interner).intern(@num_str), ast::ty_f); } else { if str::len(num_str) == 0u { rdr.fatal(~"no valid digits found for number"); @@ -419,7 +421,7 @@ fn scan_number(c: char, rdr: string_reader) -> token::token { debug!{"lexing %s as an unsuffixed integer literal", num_str}; - ret token::LIT_INT_UNSUFFIXED(parsed as i64); + return token::LIT_INT_UNSUFFIXED(parsed as i64); } } @@ -435,7 +437,7 @@ fn scan_numeric_escape(rdr: string_reader, n_hex_digits: uint) -> char { accum_int += hex_digit_val(n); i -= 1u; } - ret accum_int as char; + return accum_int as char; } fn next_token_inner(rdr: string_reader) -> token::token { @@ -454,21 +456,21 @@ fn next_token_inner(rdr: string_reader) -> token::token { bump(rdr); c = rdr.curr; } - if str::eq(accum_str, ~"_") { ret token::UNDERSCORE; } + if str::eq(accum_str, ~"_") { return token::UNDERSCORE; } let is_mod_name = c == ':' && nextch(rdr) == ':'; // FIXME: perform NFKC normalization here. (Issue #2253) - ret token::IDENT((*rdr.interner).intern(@accum_str), is_mod_name); + return token::IDENT((*rdr.interner).intern(@accum_str), is_mod_name); } if is_dec_digit(c) { - ret scan_number(c, rdr); + return scan_number(c, rdr); } fn binop(rdr: string_reader, op: token::binop) -> token::token { bump(rdr); if rdr.curr == '=' { bump(rdr); - ret token::BINOPEQ(op); - } else { ret token::BINOP(op); } + return token::BINOPEQ(op); + } else { return token::BINOP(op); } } alt c { @@ -477,35 +479,35 @@ fn next_token_inner(rdr: string_reader) -> token::token { // One-byte tokens. - ';' { bump(rdr); ret token::SEMI; } - ',' { bump(rdr); ret token::COMMA; } + ';' { bump(rdr); return token::SEMI; } + ',' { bump(rdr); return token::COMMA; } '.' { bump(rdr); if rdr.curr == '.' && nextch(rdr) == '.' { bump(rdr); bump(rdr); - ret token::ELLIPSIS; + return token::ELLIPSIS; } - ret token::DOT; + return token::DOT; } - '(' { bump(rdr); ret token::LPAREN; } - ')' { bump(rdr); ret token::RPAREN; } - '{' { bump(rdr); ret token::LBRACE; } - '}' { bump(rdr); ret token::RBRACE; } - '[' { bump(rdr); ret token::LBRACKET; } - ']' { bump(rdr); ret token::RBRACKET; } - '@' { bump(rdr); ret token::AT; } - '#' { bump(rdr); ret token::POUND; } - '~' { bump(rdr); ret token::TILDE; } + '(' { bump(rdr); return token::LPAREN; } + ')' { bump(rdr); return token::RPAREN; } + '{' { bump(rdr); return token::LBRACE; } + '}' { bump(rdr); return token::RBRACE; } + '[' { bump(rdr); return token::LBRACKET; } + ']' { bump(rdr); return token::RBRACKET; } + '@' { bump(rdr); return token::AT; } + '#' { bump(rdr); return token::POUND; } + '~' { bump(rdr); return token::TILDE; } ':' { bump(rdr); if rdr.curr == ':' { bump(rdr); - ret token::MOD_SEP; - } else { ret token::COLON; } + return token::MOD_SEP; + } else { return token::COLON; } } - '$' { bump(rdr); ret token::DOLLAR; } + '$' { bump(rdr); return token::DOLLAR; } @@ -516,42 +518,42 @@ fn next_token_inner(rdr: string_reader) -> token::token { bump(rdr); if rdr.curr == '=' { bump(rdr); - ret token::EQEQ; + return token::EQEQ; } else if rdr.curr == '>' { bump(rdr); - ret token::FAT_ARROW; + return token::FAT_ARROW; } else { - ret token::EQ; + return token::EQ; } } '!' { bump(rdr); if rdr.curr == '=' { bump(rdr); - ret token::NE; - } else { ret token::NOT; } + return token::NE; + } else { return token::NOT; } } '<' { bump(rdr); alt rdr.curr { - '=' { bump(rdr); ret token::LE; } - '<' { ret binop(rdr, token::SHL); } + '=' { bump(rdr); return token::LE; } + '<' { return binop(rdr, token::SHL); } '-' { bump(rdr); alt rdr.curr { - '>' { bump(rdr); ret token::DARROW; } - _ { ret token::LARROW; } + '>' { bump(rdr); return token::DARROW; } + _ { return token::LARROW; } } } - _ { ret token::LT; } + _ { return token::LT; } } } '>' { bump(rdr); alt rdr.curr { - '=' { bump(rdr); ret token::GE; } - '>' { ret binop(rdr, token::SHR); } - _ { ret token::GT; } + '=' { bump(rdr); return token::GE; } + '>' { return binop(rdr, token::SHR); } + _ { return token::GT; } } } '\'' { @@ -580,7 +582,7 @@ fn next_token_inner(rdr: string_reader) -> token::token { rdr.fatal(~"unterminated character constant"); } bump(rdr); // advance curr past token - ret token::LIT_INT(c2 as i64, ast::ty_char); + return token::LIT_INT(c2 as i64, ast::ty_char); } '"' { let n = rdr.chpos; @@ -623,33 +625,33 @@ fn next_token_inner(rdr: string_reader) -> token::token { } } bump(rdr); - ret token::LIT_STR((*rdr.interner).intern(@accum_str)); + return token::LIT_STR((*rdr.interner).intern(@accum_str)); } '-' { if nextch(rdr) == '>' { bump(rdr); bump(rdr); - ret token::RARROW; - } else { ret binop(rdr, token::MINUS); } + return token::RARROW; + } else { return binop(rdr, token::MINUS); } } '&' { if nextch(rdr) == '&' { bump(rdr); bump(rdr); - ret token::ANDAND; - } else { ret binop(rdr, token::AND); } + return token::ANDAND; + } else { return binop(rdr, token::AND); } } '|' { alt nextch(rdr) { - '|' { bump(rdr); bump(rdr); ret token::OROR; } - _ { ret binop(rdr, token::OR); } + '|' { bump(rdr); bump(rdr); return token::OROR; } + _ { return binop(rdr, token::OR); } } } - '+' { ret binop(rdr, token::PLUS); } - '*' { ret binop(rdr, token::STAR); } - '/' { ret binop(rdr, token::SLASH); } - '^' { ret binop(rdr, token::CARET); } - '%' { ret binop(rdr, token::PERCENT); } + '+' { return binop(rdr, token::PLUS); } + '*' { return binop(rdr, token::STAR); } + '/' { return binop(rdr, token::SLASH); } + '^' { return binop(rdr, token::CARET); } + '%' { return binop(rdr, token::PERCENT); } c { rdr.fatal(fmt!{"unknown start of token: %d", c as int}); } } } 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; } } // diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index cbea14f3185..9d3bbef2cd4 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -331,7 +331,7 @@ fn restricted_keyword_table() -> hashmap<~str, ()> { ~"new", ~"owned", ~"pure", - ~"ref", ~"ret", ~"return", + ~"ref", ~"return", ~"struct", ~"true", ~"trait", ~"type", ~"unchecked", ~"unsafe", -- cgit 1.4.1-3-g733a5