Convert ret to return

8 files changed, 276 insertions, 265 deletions

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<T: copy>(sep: option<token::token>,
@@ -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<T: copy>(sep: option<token::token>,
@@ -235,14 +235,14 @@ impl parser_common of parser_common for parser {
         let result = self.parse_seq_to_before_gt::<T>(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<T: copy>(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<T: copy>(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::<T>(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::<T>(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<token::token>, 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<initializer> {
         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",