diff options
Diffstat (limited to 'src/libsyntax')
35 files changed, 626 insertions, 600 deletions
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index 4ef4288376c..90330db78a7 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -61,7 +61,7 @@ fn extend(cx: ctx, +elt: ident) -> @path { } fn mk_ast_map_visitor() -> vt { - ret visit::mk_vt(@{ + return visit::mk_vt(@{ visit_item: map_item, visit_expr: map_expr, visit_fn: map_fn, @@ -79,7 +79,7 @@ fn map_crate(diag: span_handler, c: crate) -> map { mut local_id: 0u, diag: diag}; visit::visit_crate(c, cx, mk_ast_map_visitor()); - ret cx.map; + return cx.map; } // Used for items loaded from external crate that are being inlined into this diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index a2ac336f605..1ba0beea305 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -19,7 +19,7 @@ pure fn mk_sp(lo: uint, hi: uint) -> span { } // make this a const, once the compiler supports it -pure fn dummy_sp() -> span { ret mk_sp(0u, 0u); } +pure fn dummy_sp() -> span { return mk_sp(0u, 0u); } pure fn path_name(p: @path) -> ~str { path_name_i(p.idents) } @@ -44,7 +44,7 @@ pure fn stmt_id(s: stmt) -> node_id { fn variant_def_ids(d: def) -> {enm: def_id, var: def_id} { alt d { def_variant(enum_id, var_id) { - ret {enm: enum_id, var: var_id}; } + return {enm: enum_id, var: var_id}; } _ { fail ~"non-variant in variant_def_ids"; } } } @@ -66,40 +66,40 @@ pure fn def_id_of_def(d: def) -> def_id { pure fn binop_to_str(op: binop) -> ~str { alt op { - add { ret ~"+"; } - subtract { ret ~"-"; } - mul { ret ~"*"; } - div { ret ~"/"; } - rem { ret ~"%"; } - and { ret ~"&&"; } - or { ret ~"||"; } - bitxor { ret ~"^"; } - bitand { ret ~"&"; } - bitor { ret ~"|"; } - shl { ret ~"<<"; } - shr { ret ~">>"; } - eq { ret ~"=="; } - lt { ret ~"<"; } - le { ret ~"<="; } - ne { ret ~"!="; } - ge { ret ~">="; } - gt { ret ~">"; } + add { return ~"+"; } + subtract { return ~"-"; } + mul { return ~"*"; } + div { return ~"/"; } + rem { return ~"%"; } + and { return ~"&&"; } + or { return ~"||"; } + bitxor { return ~"^"; } + bitand { return ~"&"; } + bitor { return ~"|"; } + shl { return ~"<<"; } + shr { return ~">>"; } + eq { return ~"=="; } + lt { return ~"<"; } + le { return ~"<="; } + ne { return ~"!="; } + ge { return ~">="; } + gt { return ~">"; } } } pure fn binop_to_method_name(op: binop) -> option<~str> { alt op { - add { ret some(~"add"); } - subtract { ret some(~"sub"); } - mul { ret some(~"mul"); } - div { ret some(~"div"); } - rem { ret some(~"modulo"); } - bitxor { ret some(~"bitxor"); } - bitand { ret some(~"bitand"); } - bitor { ret some(~"bitor"); } - shl { ret some(~"shl"); } - shr { ret some(~"shr"); } - and | or | eq | lt | le | ne | ge | gt { ret none; } + add { return some(~"add"); } + subtract { return some(~"sub"); } + mul { return some(~"mul"); } + div { return some(~"div"); } + rem { return some(~"modulo"); } + bitxor { return some(~"bitxor"); } + bitand { return some(~"bitand"); } + bitor { return some(~"bitor"); } + shl { return some(~"shl"); } + shr { return some(~"shr"); } + and | or | eq | lt | le | ne | ge | gt { return none; } } } @@ -117,16 +117,16 @@ pure fn is_shift_binop(b: binop) -> bool { pure fn unop_to_str(op: unop) -> ~str { alt op { - box(mt) { if mt == m_mutbl { ret ~"@mut "; } ret ~"@"; } - uniq(mt) { if mt == m_mutbl { ret ~"~mut "; } ret ~"~"; } - deref { ret ~"*"; } - not { ret ~"!"; } - neg { ret ~"-"; } + box(mt) { if mt == m_mutbl { ~"@mut " } else { ~"@" } } + uniq(mt) { if mt == m_mutbl { ~"~mut " } else { ~"~" } } + deref { ~"*" } + not { ~"!" } + neg { ~"-" } } } pure fn is_path(e: @expr) -> bool { - ret alt e.node { expr_path(_) { true } _ { false } }; + return alt e.node { expr_path(_) { true } _ { false } }; } pure fn int_ty_to_str(t: int_ty) -> ~str { @@ -192,10 +192,10 @@ fn is_exported(i: ident, m: _mod) -> bool { for vps.each |vp| { alt vp.node { ast::view_path_simple(id, _, _) { - if id == i { ret true; } + if id == i { return true; } alt parent_enum { some(parent_enum_id) { - if id == parent_enum_id { ret true; } + if id == parent_enum_id { return true; } } _ {} } @@ -203,9 +203,9 @@ fn is_exported(i: ident, m: _mod) -> bool { ast::view_path_list(path, ids, _) { if vec::len(path.idents) == 1u { - if i == path.idents[0] { ret true; } + if i == path.idents[0] { return true; } for ids.each |id| { - if id.node.name == i { ret true; } + if id.node.name == i { return true; } } } else { fail ~"export of path-qualified list"; @@ -223,40 +223,40 @@ fn is_exported(i: ident, m: _mod) -> bool { // If there are no declared exports then // everything not imported is exported // even if it's local (since it's explicit) - ret !has_explicit_exports && local; + return !has_explicit_exports && local; } pure fn is_call_expr(e: @expr) -> bool { alt e.node { expr_call(_, _, _) { true } _ { false } } } -fn eq_ty(&&a: @ty, &&b: @ty) -> bool { ret box::ptr_eq(a, b); } +fn eq_ty(&&a: @ty, &&b: @ty) -> bool { return box::ptr_eq(a, b); } fn hash_ty(&&t: @ty) -> uint { let res = (t.span.lo << 16u) + t.span.hi; - ret res; + return res; } fn def_eq(a: ast::def_id, b: ast::def_id) -> bool { - ret a.crate == b.crate && a.node == b.node; + return a.crate == b.crate && a.node == b.node; } fn hash_def(d: ast::def_id) -> uint { let mut h = 5381u; h = (h << 5u) + h ^ (d.crate as uint); h = (h << 5u) + h ^ (d.node as uint); - ret h; + return h; } fn new_def_hash<V: copy>() -> std::map::hashmap<ast::def_id, V> { let hasher: std::map::hashfn<ast::def_id> = hash_def; let eqer: std::map::eqfn<ast::def_id> = def_eq; - ret std::map::hashmap::<ast::def_id, V>(hasher, eqer); + return std::map::hashmap::<ast::def_id, V>(hasher, eqer); } fn block_from_expr(e: @expr) -> blk { let blk_ = default_block(~[], option::some::<@expr>(e), e.id); - ret {node: blk_, span: e.span}; + return {node: blk_, span: e.span}; } fn default_block(+stmts1: ~[@stmt], expr1: option<@expr>, id1: node_id) -> @@ -551,7 +551,7 @@ fn compute_id_range(visit_ids_fn: fn(fn@(node_id))) -> id_range { *min = int::min(*min, id); *max = int::max(*max, id + 1); } - ret {min:*min, max:*max}; + return {min:*min, max:*max}; } fn compute_id_range_for_inlined_item(item: inlined_item) -> id_range { diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 5801bc895e5..bfaa7fa3bbd 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -52,25 +52,25 @@ export require_unique_names; fn mk_name_value_item_str(+name: ast::ident, +value: ~str) -> @ast::meta_item { let value_lit = dummy_spanned(ast::lit_str(@value)); - ret mk_name_value_item(name, value_lit); + return mk_name_value_item(name, value_lit); } fn mk_name_value_item(+name: ast::ident, +value: ast::lit) -> @ast::meta_item { - ret @dummy_spanned(ast::meta_name_value(name, value)); + return @dummy_spanned(ast::meta_name_value(name, value)); } fn mk_list_item(+name: ast::ident, +items: ~[@ast::meta_item]) -> @ast::meta_item { - ret @dummy_spanned(ast::meta_list(name, items)); + return @dummy_spanned(ast::meta_list(name, items)); } fn mk_word_item(+name: ast::ident) -> @ast::meta_item { - ret @dummy_spanned(ast::meta_word(name)); + return @dummy_spanned(ast::meta_word(name)); } fn mk_attr(item: @ast::meta_item) -> ast::attribute { - ret dummy_spanned({style: ast::attr_inner, value: *item, + return dummy_spanned({style: ast::attr_inner, value: *item, is_sugared_doc: false}); } @@ -81,7 +81,7 @@ fn mk_sugared_doc_attr(text: ~str, lo: uint, hi: uint) -> ast::attribute { value: spanned(lo, hi, ast::meta_name_value(@~"doc", lit)), is_sugared_doc: true }; - ret spanned(lo, hi, attr); + return spanned(lo, hi, attr); } /* Conversion */ @@ -92,7 +92,7 @@ fn attr_meta(attr: ast::attribute) -> @ast::meta_item { @attr.node.value } fn attr_metas(attrs: ~[ast::attribute]) -> ~[@ast::meta_item] { let mut mitems = ~[]; for attrs.each |a| { vec::push(mitems, attr_meta(a)); } - ret mitems; + return mitems; } fn desugar_doc_attr(attr: ast::attribute) -> ast::attribute { @@ -100,7 +100,7 @@ fn desugar_doc_attr(attr: ast::attribute) -> ast::attribute { let comment = get_meta_item_value_str(@attr.node.value).get(); let meta = mk_name_value_item_str(@~"doc", strip_doc_comment_decoration(*comment)); - ret mk_attr(meta); + return mk_attr(meta); } else { attr } @@ -178,7 +178,7 @@ fn find_attrs_by_name(attrs: ~[ast::attribute], +name: ~str) -> } else { option::none } } ); - ret vec::filter_map(attrs, filter); + return vec::filter_map(attrs, filter); } /// Searcha list of meta items and return only those with a specific name @@ -189,7 +189,7 @@ fn find_meta_items_by_name(metas: ~[@ast::meta_item], +name: ~str) -> option::some(m) } else { option::none } }; - ret vec::filter_map(metas, filter); + return vec::filter_map(metas, filter); } /** @@ -202,14 +202,14 @@ fn contains(haystack: ~[@ast::meta_item], needle: @ast::meta_item) -> bool { for haystack.each |item| { debug!{"looking in %s", print::pprust::meta_item_to_str(*item)}; - if eq(item, needle) { debug!{"found it!"}; ret true; } + if eq(item, needle) { debug!{"found it!"}; return true; } } #debug("found it not :("); - ret false; + return false; } fn eq(a: @ast::meta_item, b: @ast::meta_item) -> bool { - ret alt a.node { + return alt a.node { ast::meta_word(na) { alt b.node { ast::meta_word(nb) { na == nb } _ { false } } } @@ -232,7 +232,7 @@ fn eq(a: @ast::meta_item, b: @ast::meta_item) -> bool { fn contains_name(metas: ~[@ast::meta_item], +name: ~str) -> bool { let matches = find_meta_items_by_name(metas, name); - ret vec::len(matches) > 0u; + return vec::len(matches) > 0u; } fn attrs_contains_name(attrs: ~[ast::attribute], +name: ~str) -> bool { @@ -243,9 +243,9 @@ fn first_attr_value_str_by_name(attrs: ~[ast::attribute], +name: ~str) -> option<@~str> { let mattrs = find_attrs_by_name(attrs, name); if vec::len(mattrs) > 0u { - ret get_meta_item_value_str(attr_meta(mattrs[0])); + return get_meta_item_value_str(attr_meta(mattrs[0])); } - ret option::none; + return option::none; } fn last_meta_item_by_name( @@ -297,19 +297,19 @@ fn sort_meta_items(+items: ~[@ast::meta_item]) -> ~[@ast::meta_item] { ast::meta_list(name, _) { /* FIXME (#2543) */ copy name } } } - ret key(ma) <= key(mb); + return key(ma) <= key(mb); } // This is sort of stupid here, converting to a vec of mutables and back let v: ~[mut @ast::meta_item] = vec::to_mut(items); std::sort::quick_sort(lteq, v); - ret vec::from_mut(v); + return vec::from_mut(v); } fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: ast::ident) -> ~[@ast::meta_item] { - ret vec::filter_map(items, |item| { + return vec::filter_map(items, |item| { if get_meta_item_name(item) != name { option::some(/* FIXME (#2543) */ copy item) } else { @@ -326,7 +326,7 @@ fn find_linkage_attrs(attrs: ~[ast::attribute]) -> ~[ast::attribute] { _ { debug!{"ignoring link attribute that has incorrect type"}; } } } - ret found; + return found; } /** @@ -342,7 +342,7 @@ fn find_linkage_metas(attrs: ~[ast::attribute]) -> ~[@ast::meta_item] { } fn foreign_abi(attrs: ~[ast::attribute]) -> either<~str, ast::foreign_abi> { - ret alt attr::first_attr_value_str_by_name(attrs, ~"abi") { + return alt attr::first_attr_value_str_by_name(attrs, ~"abi") { option::none { either::right(ast::foreign_abi_cdecl) } diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 0c211395223..95742451396 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -58,7 +58,7 @@ fn new_filemap_w_substr(+filename: filename, +substr: file_substr, src: @~str, start_pos_ch: uint, start_pos_byte: uint) -> filemap { - ret @{name: filename, substr: substr, src: src, + return @{name: filename, substr: substr, src: src, start_pos: {ch: start_pos_ch, byte: start_pos_byte}, mut lines: ~[{ch: start_pos_ch, byte: start_pos_byte}]}; } @@ -66,14 +66,14 @@ fn new_filemap_w_substr(+filename: filename, +substr: file_substr, fn new_filemap(+filename: filename, src: @~str, start_pos_ch: uint, start_pos_byte: uint) -> filemap { - ret new_filemap_w_substr(filename, fss_none, src, + return new_filemap_w_substr(filename, fss_none, src, start_pos_ch, start_pos_byte); } fn mk_substr_filename(cm: codemap, sp: span) -> ~str { let pos = lookup_char_pos(cm, sp.lo); - ret fmt!{"<%s:%u:%u>", pos.file.name, pos.line, pos.col}; + return fmt!{"<%s:%u:%u>", pos.file.name, pos.line, pos.col}; } fn next_line(file: filemap, chpos: uint, byte_pos: uint) { @@ -102,22 +102,22 @@ fn lookup_line(map: codemap, pos: uint, lookup: lookup_fn) let m = (a + b) / 2u; if lookup(f.lines[m]) > pos { b = m; } else { a = m; } } - ret {fm: f, line: a}; + return {fm: f, line: a}; } fn lookup_pos(map: codemap, pos: uint, lookup: lookup_fn) -> loc { let {fm: f, line: a} = lookup_line(map, pos, lookup); - ret {file: f, line: a + 1u, col: pos - lookup(f.lines[a])}; + return {file: f, line: a + 1u, col: pos - lookup(f.lines[a])}; } fn lookup_char_pos(map: codemap, pos: uint) -> loc { - pure fn lookup(pos: file_pos) -> uint { ret pos.ch; } - ret lookup_pos(map, pos, lookup); + pure fn lookup(pos: file_pos) -> uint { return pos.ch; } + return lookup_pos(map, pos, lookup); } fn lookup_byte_pos(map: codemap, pos: uint) -> loc { - pure fn lookup(pos: file_pos) -> uint { ret pos.byte; } - ret lookup_pos(map, pos, lookup); + pure fn lookup(pos: file_pos) -> uint { return pos.byte; } + return lookup_pos(map, pos, lookup); } fn lookup_char_pos_adj(map: codemap, pos: uint) @@ -144,7 +144,7 @@ fn lookup_char_pos_adj(map: codemap, pos: uint) } fn adjust_span(map: codemap, sp: span) -> span { - pure fn lookup(pos: file_pos) -> uint { ret pos.ch; } + pure fn lookup(pos: file_pos) -> uint { return pos.ch; } let line = lookup_line(map, sp.lo, lookup); alt (line.fm.substr) { fss_none {sp} @@ -166,14 +166,14 @@ type span = {lo: uint, hi: uint, expn_info: expn_info}; fn span_to_str_no_adj(sp: span, cm: codemap) -> ~str { let lo = lookup_char_pos(cm, sp.lo); let hi = lookup_char_pos(cm, sp.hi); - ret fmt!{"%s:%u:%u: %u:%u", lo.file.name, + return fmt!{"%s:%u:%u: %u:%u", lo.file.name, lo.line, lo.col, hi.line, hi.col} } fn span_to_str(sp: span, cm: codemap) -> ~str { let lo = lookup_char_pos_adj(cm, sp.lo); let hi = lookup_char_pos_adj(cm, sp.hi); - ret fmt!{"%s:%u:%u: %u:%u", lo.filename, + return fmt!{"%s:%u:%u: %u:%u", lo.filename, lo.line, lo.col, hi.line, hi.col} } @@ -181,7 +181,7 @@ type file_lines = {file: filemap, lines: ~[uint]}; fn span_to_filename(sp: span, cm: codemap::codemap) -> filename { let lo = lookup_char_pos(cm, sp.lo); - ret /* FIXME (#2543) */ copy lo.file.name; + return /* FIXME (#2543) */ copy lo.file.name; } fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines { @@ -191,7 +191,7 @@ fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines { for uint::range(lo.line - 1u, hi.line as uint) |i| { vec::push(lines, i); }; - ret @{file: lo.file, lines: lines}; + return @{file: lo.file, lines: lines}; } fn get_line(fm: filemap, line: int) -> ~str unsafe { @@ -205,7 +205,7 @@ fn get_line(fm: filemap, line: int) -> ~str unsafe { fn lookup_byte_offset(cm: codemap::codemap, chpos: uint) -> {fm: filemap, pos: uint} { - pure fn lookup(pos: file_pos) -> uint { ret pos.ch; } + pure fn lookup(pos: file_pos) -> uint { return pos.ch; } let {fm, line} = lookup_line(cm, chpos, lookup); let line_offset = fm.lines[line].byte - fm.start_pos.byte; let col = chpos - fm.lines[line].ch; @@ -217,17 +217,17 @@ fn span_to_snippet(sp: span, cm: codemap::codemap) -> ~str { let begin = lookup_byte_offset(cm, sp.lo); let end = lookup_byte_offset(cm, sp.hi); assert begin.fm == end.fm; - ret str::slice(*begin.fm.src, begin.pos, end.pos); + return str::slice(*begin.fm.src, begin.pos, end.pos); } fn get_snippet(cm: codemap::codemap, fidx: uint, lo: uint, hi: uint) -> ~str { let fm = cm.files[fidx]; - ret str::slice(*fm.src, lo, hi) + return str::slice(*fm.src, lo, hi) } fn get_filemap(cm: codemap, filename: ~str) -> filemap { - for cm.files.each |fm| { if fm.name == filename { ret fm; } } + for cm.files.each |fm| { if fm.name == filename { return fm; } } //XXjdm the following triggers a mismatched type bug // (or expected function, found _|_) fail; // ("asking for " + filename + " which we don't know about"); diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index d9292afc96a..98cf3953a29 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -88,7 +88,7 @@ impl codemap_handler of handler for handler_t { fn abort_if_errors() { let s; alt self.err_count { - 0u { ret; } + 0u { return; } 1u { s = ~"aborting due to previous error"; } _ { s = fmt!{"aborting due to %u previous errors", self.err_count}; } diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index e8505387fa8..2947201003f 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -107,7 +107,7 @@ fn syntax_expander_table() -> hashmap<~str, syntax_extension> { builtin(ext::source_util::expand_mod)); syntax_expanders.insert(~"proto", builtin_item_tt(ext::pipes::expand_proto)); - ret syntax_expanders; + return syntax_expanders; } @@ -148,7 +148,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess, fn backtrace() -> expn_info { self.backtrace } fn mod_push(i: ast::ident) { vec::push(self.mod_path, i); } fn mod_pop() { vec::pop(self.mod_path); } - fn mod_path() -> ~[ast::ident] { ret self.mod_path; } + fn mod_path() -> ~[ast::ident] { return self.mod_path; } fn bt_push(ei: codemap::expn_info_) { alt ei { expanded_from({call_site: cs, callie: callie}) { @@ -193,7 +193,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess, self.parse_sess.span_diagnostic.handler().bug(msg); } fn next_id() -> ast::node_id { - ret parse::next_node_id(self.parse_sess); + return parse::next_node_id(self.parse_sess); } } let imp : ctxt_repr = { @@ -202,14 +202,14 @@ fn mk_ctxt(parse_sess: parse::parse_sess, mut backtrace: none, mut mod_path: ~[] }; - ret imp as ext_ctxt + return imp as ext_ctxt } fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, error: ~str) -> ~str { alt expr.node { ast::expr_lit(l) { alt l.node { - ast::lit_str(s) { ret *s; } + ast::lit_str(s) { return *s; } _ { cx.span_fatal(l.span, error); } } } @@ -222,7 +222,7 @@ fn expr_to_ident(cx: ext_ctxt, expr: @ast::expr, error: ~str) -> ast::ident { ast::expr_path(p) { if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { cx.span_fatal(expr.span, error); - } else { ret p.idents[0]; } + } else { return p.idents[0]; } } _ { cx.span_fatal(expr.span, error); } } @@ -230,7 +230,7 @@ fn expr_to_ident(cx: ext_ctxt, expr: @ast::expr, error: ~str) -> ast::ident { fn get_mac_args_no_max(cx: ext_ctxt, sp: span, arg: ast::mac_arg, min: uint, name: ~str) -> ~[@ast::expr] { - ret get_mac_args(cx, sp, arg, min, none, name); + return get_mac_args(cx, sp, arg, min, none, name); } fn get_mac_args(cx: ext_ctxt, sp: span, arg: ast::mac_arg, @@ -250,7 +250,7 @@ fn get_mac_args(cx: ext_ctxt, sp: span, arg: ast::mac_arg, cx.span_fatal(sp, fmt!{"#%s needs at least %u arguments.", name, min}); } - _ { ret elts; /* we're good */} + _ { return elts; /* we're good */} } } _ { @@ -308,7 +308,7 @@ fn tt_args_to_original_flavor(cx: ext_ctxt, sp: span, arg: ~[ast::token_tree]) _ { fail ~"badly-structured parse result"; } }; - ret some(@{id: parse::next_node_id(cx.parse_sess()), + return some(@{id: parse::next_node_id(cx.parse_sess()), callee_id: parse::next_node_id(cx.parse_sess()), node: ast::expr_vec(args, ast::m_imm), span: sp}); } diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 5eca1e8e17c..ab2d93faabe 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -3,7 +3,7 @@ import base::ext_ctxt; fn mk_expr(cx: ext_ctxt, sp: codemap::span, expr: ast::expr_) -> @ast::expr { - ret @{id: cx.next_id(), callee_id: cx.next_id(), + return @{id: cx.next_id(), callee_id: cx.next_id(), node: expr, span: sp}; } @@ -13,15 +13,15 @@ fn mk_lit(cx: ext_ctxt, sp: span, lit: ast::lit_) -> @ast::expr { } fn mk_int(cx: ext_ctxt, sp: span, i: int) -> @ast::expr { let lit = ast::lit_int(i as i64, ast::ty_i); - ret mk_lit(cx, sp, lit); + return mk_lit(cx, sp, lit); } fn mk_uint(cx: ext_ctxt, sp: span, u: uint) -> @ast::expr { let lit = ast::lit_uint(u as u64, ast::ty_u); - ret mk_lit(cx, sp, lit); + return mk_lit(cx, sp, lit); } fn mk_u8(cx: ext_ctxt, sp: span, u: u8) -> @ast::expr { let lit = ast::lit_uint(u as u64, ast::ty_u8); - ret mk_lit(cx, sp, lit); + return mk_lit(cx, sp, lit); } fn mk_binary(cx: ext_ctxt, sp: span, op: ast::binop, lhs: @ast::expr, rhs: @ast::expr) @@ -48,7 +48,7 @@ fn mk_access_(cx: ext_ctxt, sp: span, p: @ast::expr, m: ast::ident) fn mk_access(cx: ext_ctxt, sp: span, p: ~[ast::ident], m: ast::ident) -> @ast::expr { let pathexpr = mk_path(cx, sp, p); - ret mk_access_(cx, sp, pathexpr, m); + return mk_access_(cx, sp, pathexpr, m); } fn mk_call_(cx: ext_ctxt, sp: span, fn_expr: @ast::expr, args: ~[@ast::expr]) -> @ast::expr { @@ -57,7 +57,7 @@ fn mk_call_(cx: ext_ctxt, sp: span, fn_expr: @ast::expr, fn mk_call(cx: ext_ctxt, sp: span, fn_path: ~[ast::ident], args: ~[@ast::expr]) -> @ast::expr { let pathexpr = mk_path(cx, sp, fn_path); - ret mk_call_(cx, sp, pathexpr, args); + return mk_call_(cx, sp, pathexpr, args); } // e = expr, t = type fn mk_base_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr]) -> @@ -79,7 +79,7 @@ fn mk_fixed_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr]) -> } fn mk_base_str(cx: ext_ctxt, sp: span, s: ~str) -> @ast::expr { let lit = ast::lit_str(@s); - ret mk_lit(cx, sp, lit); + return mk_lit(cx, sp, lit); } fn mk_uniq_str(cx: ext_ctxt, sp: span, s: ~str) -> @ast::expr { mk_vstore_e(cx, sp, mk_base_str(cx, sp, s), ast::vstore_uniq) diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs index b3545cc635d..f5d22e6754c 100644 --- a/src/libsyntax/ext/concat_idents.rs +++ b/src/libsyntax/ext/concat_idents.rs @@ -8,7 +8,7 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, res += *expr_to_ident(cx, e, ~"expected an ident"); } - ret @{id: cx.next_id(), + return @{id: cx.next_id(), callee_id: cx.next_id(), node: ast::expr_path(@{span: sp, global: false, idents: ~[@res], rp: none, types: ~[]}), diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs index e03fc2ce47b..4aa55e88f16 100644 --- a/src/libsyntax/ext/env.rs +++ b/src/libsyntax/ext/env.rs @@ -17,8 +17,8 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, let var = expr_to_str(cx, args[0], ~"#env requires a string"); alt os::getenv(var) { - option::none { ret mk_uniq_str(cx, sp, ~""); } - option::some(s) { ret mk_uniq_str(cx, sp, s); } + option::none { return mk_uniq_str(cx, sp, ~""); } + option::some(s) { return mk_uniq_str(cx, sp, s); } } } diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 62e5841a749..24cc78e366e 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -15,7 +15,7 @@ fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt, orig: fn@(expr_, span, ast_fold) -> (expr_, span)) -> (expr_, span) { - ret alt e { + return alt e { // expr_mac should really be expr_ext or something; it's the // entry-point for all syntax extensions. expr_mac(mac) { @@ -159,7 +159,7 @@ fn expand_mod_items(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt, } }; - ret {items: new_items with module_}; + return {items: new_items with module_}; } @@ -185,9 +185,9 @@ fn expand_item(exts: hashmap<~str, syntax_extension>, if is_mod { cx.mod_push(it.ident); } let ret_val = orig(it, fld); if is_mod { cx.mod_pop(); } - ret ret_val; + return ret_val; } - none { ret none; } + none { return none; } } } @@ -221,7 +221,7 @@ fn expand_item_mac(exts: hashmap<~str, syntax_extension>, } }; cx.bt_pop(); - ret maybe_it + return maybe_it } _ { cx.span_fatal(it.span, fmt!{"%s is not a legal here", *extname}) } @@ -235,7 +235,7 @@ fn expand_item_mac(exts: hashmap<~str, syntax_extension>, fn new_span(cx: ext_ctxt, sp: span) -> span { /* this discards information in the case of macro-defining macros */ - ret {lo: sp.lo, hi: sp.hi, expn_info: cx.backtrace()}; + return {lo: sp.lo, hi: sp.hi, expn_info: cx.backtrace()}; } // FIXME (#2247): this is a terrible kludge to inject some macros into @@ -244,7 +244,7 @@ fn new_span(cx: ext_ctxt, sp: span) -> span { // compiled part of libcore at very least. fn core_macros() -> ~str { - ret + return ~"{ #macro[[#error[f, ...], log(core::error, #fmt[f, ...])]]; #macro[[#warn[f, ...], log(core::warn, #fmt[f, ...])]]; @@ -275,7 +275,7 @@ fn expand_crate(parse_sess: parse::parse_sess, f.fold_expr(cm); let res = @f.fold_crate(*c); - ret res; + return res; } // Local Variables: // mode: rust diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs index d8549ca21c8..10820664344 100644 --- a/src/libsyntax/ext/fmt.rs +++ b/src/libsyntax/ext/fmt.rs @@ -27,7 +27,7 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: span, arg: ast::mac_arg, parse_fmt_err_(cx, fmtspan, s) }; let pieces = parse_fmt_string(fmt, parse_fmt_err); - ret pieces_to_expr(cx, sp, pieces, args); + return pieces_to_expr(cx, sp, pieces, args); } // FIXME (#2249): A lot of these functions for producing expressions can @@ -38,12 +38,12 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, pieces: ~[piece], args: ~[@ast::expr]) -> @ast::expr { fn make_path_vec(_cx: ext_ctxt, ident: ast::ident) -> ~[ast::ident] { - ret ~[@~"extfmt", @~"rt", ident]; + return ~[@~"extfmt", @~"rt", ident]; } fn make_rt_path_expr(cx: ext_ctxt, sp: span, ident: ast::ident) -> @ast::expr { let path = make_path_vec(cx, ident); - ret mk_path(cx, sp, path); + return mk_path(cx, sp, path); } // Produces an AST expression that represents a RT::conv record, // which tells the RT::conv* functions how to perform the conversion @@ -62,18 +62,18 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, tmp_expr = mk_binary(cx, sp, ast::bitor, tmp_expr, make_rt_path_expr(cx, sp, @fstr)); } - ret tmp_expr; + return tmp_expr; } fn make_count(cx: ext_ctxt, sp: span, cnt: count) -> @ast::expr { alt cnt { count_implied { - ret make_rt_path_expr(cx, sp, @~"count_implied"); + return make_rt_path_expr(cx, sp, @~"count_implied"); } count_is(c) { let count_lit = mk_int(cx, sp, c); let count_is_path = make_path_vec(cx, @~"count_is"); let count_is_args = ~[count_lit]; - ret mk_call(cx, sp, count_is_path, count_is_args); + return mk_call(cx, sp, count_is_path, count_is_args); } _ { cx.span_unimpl(sp, ~"unimplemented #fmt conversion"); } } @@ -91,12 +91,12 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, ty_octal { rt_type = ~"ty_octal"; } _ { rt_type = ~"ty_default"; } } - ret make_rt_path_expr(cx, sp, @rt_type); + return make_rt_path_expr(cx, sp, @rt_type); } fn make_conv_rec(cx: ext_ctxt, sp: span, flags_expr: @ast::expr, width_expr: @ast::expr, precision_expr: @ast::expr, ty_expr: @ast::expr) -> @ast::expr { - ret mk_rec_e(cx, sp, + return mk_rec_e(cx, sp, ~[{ident: @~"flags", ex: flags_expr}, {ident: @~"width", ex: width_expr}, {ident: @~"precision", ex: precision_expr}, @@ -106,7 +106,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, let rt_conv_width = make_count(cx, sp, cnv.width); let rt_conv_precision = make_count(cx, sp, cnv.precision); let rt_conv_ty = make_ty(cx, sp, cnv.ty); - ret make_conv_rec(cx, sp, rt_conv_flags, rt_conv_width, + return make_conv_rec(cx, sp, rt_conv_flags, rt_conv_width, rt_conv_precision, rt_conv_ty); } fn make_conv_call(cx: ext_ctxt, sp: span, conv_type: ~str, cnv: conv, @@ -115,7 +115,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, let path = make_path_vec(cx, @fname); let cnv_expr = make_rt_conv_expr(cx, sp, cnv); let args = ~[cnv_expr, arg]; - ret mk_call(cx, arg.span, path, args); + return mk_call(cx, arg.span, path, args); } fn make_new_conv(cx: ext_ctxt, sp: span, cnv: conv, arg: @ast::expr) -> @@ -125,10 +125,10 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, fn is_signed_type(cnv: conv) -> bool { alt cnv.ty { ty_int(s) { - alt s { signed { ret true; } unsigned { ret false; } } + alt s { signed { return true; } unsigned { return false; } } } - ty_float { ret true; } - _ { ret false; } + ty_float { return true; } + _ { return false; } } } let unsupported = ~"conversion not supported in #fmt string"; @@ -168,22 +168,28 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, _ { cx.span_unimpl(sp, unsupported); } } alt cnv.ty { - ty_str { ret make_conv_call(cx, arg.span, ~"str", cnv, arg); } + ty_str { return make_conv_call(cx, arg.span, ~"str", cnv, arg); } ty_int(sign) { alt sign { - signed { ret make_conv_call(cx, arg.span, ~"int", cnv, arg); } + signed { + return make_conv_call(cx, arg.span, ~"int", cnv, arg); + } unsigned { - ret make_conv_call(cx, arg.span, ~"uint", cnv, arg); + return make_conv_call(cx, arg.span, ~"uint", cnv, arg); } } } - ty_bool { ret make_conv_call(cx, arg.span, ~"bool", cnv, arg); } - ty_char { ret make_conv_call(cx, arg.span, ~"char", cnv, arg); } - ty_hex(_) { ret make_conv_call(cx, arg.span, ~"uint", cnv, arg); } - ty_bits { ret make_conv_call(cx, arg.span, ~"uint", cnv, arg); } - ty_octal { ret make_conv_call(cx, arg.span, ~"uint", cnv, arg); } - ty_float { ret make_conv_call(cx, arg.span, ~"float", cnv, arg); } - ty_poly { ret make_conv_call(cx, arg.span, ~"poly", cnv, arg); } + ty_bool { return make_conv_call(cx, arg.span, ~"bool", cnv, arg); } + ty_char { return make_conv_call(cx, arg.span, ~"char", cnv, arg); } + ty_hex(_) { + return make_conv_call(cx, arg.span, ~"uint", cnv, arg); + } + ty_bits { return make_conv_call(cx, arg.span, ~"uint", cnv, arg); } + ty_octal { return make_conv_call(cx, arg.span, ~"uint", cnv, arg); } + ty_float { + return make_conv_call(cx, arg.span, ~"float", cnv, arg); + } + ty_poly { return make_conv_call(cx, arg.span, ~"poly", cnv, arg); } } } fn log_conv(c: conv) { @@ -275,7 +281,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, } let arg_vec = mk_fixed_vec_e(cx, fmt_sp, piece_exprs); - ret mk_call(cx, fmt_sp, ~[@~"str", @~"concat"], ~[arg_vec]); + return mk_call(cx, fmt_sp, ~[@~"str", @~"concat"], ~[arg_vec]); } // // Local Variables: diff --git a/src/libsyntax/ext/ident_to_str.rs b/src/libsyntax/ext/ident_to_str.rs index 54f97912f3d..06faff9ee1b 100644 --- a/src/libsyntax/ext/ident_to_str.rs +++ b/src/libsyntax/ext/ident_to_str.rs @@ -6,6 +6,6 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { let args = get_mac_args(cx,sp,arg,1u,option::some(1u),~"ident_to_str"); - ret mk_uniq_str(cx, sp, *expr_to_ident(cx, args[0u], + return mk_uniq_str(cx, sp, *expr_to_ident(cx, args[0u], ~"expected an ident")); } diff --git a/src/libsyntax/ext/log_syntax.rs b/src/libsyntax/ext/log_syntax.rs index 70d83b164c8..f84e496be9c 100644 --- a/src/libsyntax/ext/log_syntax.rs +++ b/src/libsyntax/ext/log_syntax.rs @@ -11,6 +11,6 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, ); //trivial expression - ret @{id: cx.next_id(), callee_id: cx.next_id(), + return @{id: cx.next_id(), callee_id: cx.next_id(), node: ast::expr_rec(~[], option::none), span: sp}; } diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs index 0375f742b4b..ea8c8c04b0e 100644 --- a/src/libsyntax/ext/pipes/parse_proto.rs +++ b/src/libsyntax/ext/pipes/parse_proto.rs @@ -19,7 +19,7 @@ impl proto_parser of proto_parser for parser { {sep: none, trailing_sep_allowed: false}, |self| self.parse_state(proto)); - ret proto; + return proto; } fn parse_state(proto: protocol) { diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs index b9f77ea3fc2..1805fd9fa35 100644 --- a/src/libsyntax/ext/pipes/proto.rs +++ b/src/libsyntax/ext/pipes/proto.rs @@ -149,7 +149,7 @@ class protocol_ { fn has_ty_params() -> bool { for self.states.each |s| { if s.ty_params.len() > 0 { - ret true; + return true; } } false diff --git a/src/libsyntax/ext/qquote.rs b/src/libsyntax/ext/qquote.rs index 94753ea88e0..1c3e0aa5181 100644 --- a/src/libsyntax/ext/qquote.rs +++ b/src/libsyntax/ext/qquote.rs @@ -112,7 +112,7 @@ fn gather_anti_quotes<N: qq_helper>(lo: uint, node: N) -> aq_ctxt do cx.gather.swap |v| { vec::to_mut(std::sort::merge_sort(|a,b| a.lo < b.lo, v)) }; - ret cx; + return cx; } fn visit_aq<T:qq_helper>(node: T, constr: ~str, &&cx: aq_ctxt, v: vt<aq_ctxt>) @@ -155,7 +155,7 @@ fn expand_ast(ecx: ext_ctxt, _sp: span, } let body = get_mac_body(ecx,_sp,body); - ret alt what { + return alt what { ~"crate" {finish(ecx, body, parse_crate)} ~"expr" {finish(ecx, body, parse_expr)} ~"ty" {finish(ecx, body, parse_ty)} @@ -268,7 +268,7 @@ fn finish<T: qq_helper> ~[@~"syntax", @~"ext", @~"qquote", @node.get_fold_fn()])]); } - ret rcall; + return rcall; } fn replace<T>(node: T, repls: ~[fragment], ff: fn (ast_fold, T) -> T) @@ -280,7 +280,7 @@ fn replace<T>(node: T, repls: ~[fragment], ff: fn (ast_fold, T) -> T) fold_ty: |a,b,c|replace_ty(repls, a, b, c, aft.fold_ty) with *aft}; - ret ff(make_fold(f_pre), node); + return ff(make_fold(f_pre), node); } fn fold_crate(f: ast_fold, &&n: @ast::crate) -> @ast::crate { @f.fold_crate(*n) diff --git a/src/libsyntax/ext/simplext.rs b/src/libsyntax/ext/simplext.rs index b261e7657a2..b835300d5c7 100644 --- a/src/libsyntax/ext/simplext.rs +++ b/src/libsyntax/ext/simplext.rs @@ -13,9 +13,9 @@ export add_new_extension; fn path_to_ident(pth: @path) -> option<ident> { if vec::len(pth.idents) == 1u && vec::len(pth.types) == 0u { - ret some(pth.idents[0u]); + return some(pth.idents[0u]); } - ret none; + return none; } //a vec of binders might be a little big. @@ -94,7 +94,7 @@ fn elts_to_ell(cx: ext_ctxt, elts: ~[@expr]) -> } idx += 1u; } - ret alt res { + return alt res { some(val) { val } none { {pre: elts, rep: none, post: ~[]} } } @@ -104,18 +104,18 @@ fn option_flatten_map<T: copy, U: copy>(f: fn@(T) -> option<U>, v: ~[T]) -> option<~[U]> { let mut res = ~[]; for v.each |elem| { - alt f(elem) { none { ret none; } some(fv) { vec::push(res, fv); } } + alt f(elem) { none { return none; } some(fv) { vec::push(res, fv); } } } - ret some(res); + return some(res); } fn a_d_map(ad: arb_depth<matchable>, f: selector) -> match_result { alt ad { - leaf(x) { ret f(x); } + leaf(x) { return f(x); } seq(ads, span) { alt option_flatten_map(|x| a_d_map(x, f), *ads) { - none { ret none; } - some(ts) { ret some(seq(@ts, span)); } + none { return none; } + some(ts) { return some(seq(@ts, span)); } } } } @@ -123,12 +123,12 @@ fn a_d_map(ad: arb_depth<matchable>, f: selector) -> match_result { fn compose_sels(s1: selector, s2: selector) -> selector { fn scomp(s1: selector, s2: selector, m: matchable) -> match_result { - ret alt s1(m) { + return alt s1(m) { none { none } some(matches) { a_d_map(matches, s2) } } } - ret { |x| scomp(s1, s2, x) }; + return { |x| scomp(s1, s2, x) }; } @@ -150,9 +150,11 @@ fn pattern_to_selectors(cx: ext_ctxt, e: @expr) -> binders { literal_ast_matchers: dvec()}; //this oughta return binders instead, but macro args are a sequence of //expressions, rather than a single expression - fn trivial_selector(m: matchable) -> match_result { ret some(leaf(m)); } + fn trivial_selector(m: matchable) -> match_result { + return some(leaf(m)); + } p_t_s_rec(cx, match_expr(e), trivial_selector, res); - ret res; + return res; } @@ -165,7 +167,7 @@ fn use_selectors_to_bind(b: binders, e: @expr) -> option<bindings> { let res = box_str_hash::<arb_depth<matchable>>(); //need to do this first, to check vec lengths. for b.literal_ast_matchers.each |sel| { - alt sel(match_expr(e)) { none { ret none; } _ { } } + alt sel(match_expr(e)) { none { return none; } _ { } } } let mut never_mind: bool = false; for b.real_binders.each |key, val| { @@ -175,18 +177,18 @@ fn use_selectors_to_bind(b: binders, e: @expr) -> option<bindings> { } }; //HACK: `ret` doesn't work in `for each` - if never_mind { ret none; } - ret some(res); + if never_mind { return none; } + return some(res); } /* use the bindings on the body to generate the expanded code */ fn transcribe(cx: ext_ctxt, b: bindings, body: @expr) -> @expr { let idx_path: @mut ~[uint] = @mut ~[]; - fn new_id(_old: node_id, cx: ext_ctxt) -> node_id { ret cx.next_id(); } + fn new_id(_old: node_id, cx: ext_ctxt) -> node_id { return cx.next_id(); } fn new_span(cx: ext_ctxt, sp: span) -> span { /* this discards information in the case of macro-defining macros */ - ret {lo: sp.lo, hi: sp.hi, expn_info: cx.backtrace()}; + return {lo: sp.lo, hi: sp.hi, expn_info: cx.backtrace()}; } let afp = default_ast_fold(); let f_pre = @@ -209,7 +211,7 @@ fn transcribe(cx: ext_ctxt, b: bindings, body: @expr) -> @expr { with *afp}; let f = make_fold(f_pre); let result = f.fold_expr(body); - ret result; + return result; } @@ -219,25 +221,25 @@ fn follow(m: arb_depth<matchable>, idx_path: @mut ~[uint]) -> let mut res: arb_depth<matchable> = m; for vec::each(*idx_path) |idx| { res = alt res { - leaf(_) { ret res;/* end of the line */ } + leaf(_) { return res;/* end of the line */ } seq(new_ms, _) { new_ms[idx] } } } - ret res; + return res; } fn follow_for_trans(cx: ext_ctxt, mmaybe: option<arb_depth<matchable>>, idx_path: @mut ~[uint]) -> option<matchable> { alt mmaybe { - none { ret none } + none { return none } some(m) { - ret alt follow(m, idx_path) { + return alt follow(m, idx_path) { seq(_, sp) { cx.span_fatal(sp, ~"syntax matched under ... but not " + ~"used that way.") } - leaf(m) { ret some(m) } + leaf(m) { return some(m) } } } } @@ -250,7 +252,7 @@ fn free_vars(b: bindings, e: @expr, it: fn(ident)) { fn mark_ident(&&i: ident, _fld: ast_fold, b: bindings, idents: hashmap<ident, ()>) -> ident { if b.contains_key(i) { idents.insert(i, ()); } - ret i; + return i; } // using fold is a hack: we want visit, but it doesn't hit idents ) : // solve this with macros @@ -319,7 +321,7 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], } } res = vec::append(res, vec::map(post, recur)); - ret res; + return res; } } } @@ -329,7 +331,7 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], // substitute, in a position that's required to be an ident fn transcribe_ident(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], &&i: ident, _fld: ast_fold) -> ident { - ret alt follow_for_trans(cx, b.find(i), idx_path) { + return alt follow_for_trans(cx, b.find(i), idx_path) { some(match_ident(a_id)) { a_id.node } some(m) { match_error(cx, m, ~"an identifier") } none { i } @@ -340,7 +342,7 @@ fn transcribe_ident(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], fn transcribe_path(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], p: path, _fld: ast_fold) -> path { // Don't substitute into qualified names. - if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret p; } + if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { return p; } alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) { some(match_ident(id)) { {span: id.span, global: false, idents: ~[id.node], @@ -358,7 +360,7 @@ fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], orig: fn@(ast::expr_, span, ast_fold)->(ast::expr_, span)) -> (ast::expr_, span) { - ret alt e { + return alt e { expr_path(p) { // Don't substitute into qualified names. if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { @@ -387,7 +389,7 @@ fn transcribe_type(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], orig: fn@(ast::ty_, span, ast_fold) -> (ast::ty_, span)) -> (ast::ty_, span) { - ret alt t { + return alt t { ast::ty_path(pth, _) { alt path_to_ident(pth) { some(id) { @@ -413,7 +415,7 @@ fn transcribe_block(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], orig: fn@(blk_, span, ast_fold) -> (blk_, span)) -> (blk_, span) { - ret alt block_to_ident(blk) { + return alt block_to_ident(blk) { some(id) { alt follow_for_trans(cx, b.find(id), idx_path) { some(match_block(new_blk)) { (new_blk.node, new_blk.span) } @@ -474,7 +476,7 @@ fn p_t_s_rec(cx: ext_ctxt, m: matchable, s: selector, b: binders) { _ { fn select(cx: ext_ctxt, m: matchable, pat: @expr) -> match_result { - ret alt m { + return alt m { match_expr(e) { if e == pat { some(leaf(match_exact)) } else { none } } @@ -494,7 +496,7 @@ fn p_t_s_rec(cx: ext_ctxt, m: matchable, s: selector, b: binders) { /* make a match more precise */ fn specialize_match(m: matchable) -> matchable { - ret alt m { + return alt m { match_expr(e) { alt e.node { expr_path(pth) { @@ -515,7 +517,7 @@ fn p_t_s_r_path(cx: ext_ctxt, p: @path, s: selector, b: binders) { alt path_to_ident(p) { some(p_id) { fn select(cx: ext_ctxt, m: matchable) -> match_result { - ret alt m { + return alt m { match_expr(e) { some(leaf(specialize_match(m))) } _ { cx.bug(~"broken traversal in p_t_s_r") } } @@ -530,8 +532,8 @@ fn p_t_s_r_path(cx: ext_ctxt, p: @path, s: selector, b: binders) { } fn block_to_ident(blk: blk_) -> option<ident> { - if vec::len(blk.stmts) != 0u { ret none; } - ret alt blk.expr { + if vec::len(blk.stmts) != 0u { return none; } + return alt blk.expr { some(expr) { alt expr.node { expr_path(pth) { path_to_ident(pth) } _ { none } } } @@ -542,7 +544,7 @@ fn block_to_ident(blk: blk_) -> option<ident> { fn p_t_s_r_mac(cx: ext_ctxt, mac: ast::mac, _s: selector, _b: binders) { fn select_pt_1(cx: ext_ctxt, m: matchable, fn_m: fn(ast::mac) -> match_result) -> match_result { - ret alt m { + return alt m { match_expr(e) { alt e.node { expr_mac(mac) { fn_m(mac) } _ { none } } } @@ -565,7 +567,7 @@ fn p_t_s_r_ellipses(cx: ext_ctxt, repeat_me: @expr, offset: uint, s: selector, b: binders) { fn select(cx: ext_ctxt, repeat_me: @expr, offset: uint, m: matchable) -> match_result { - ret alt m { + return alt m { match_expr(e) { alt e.node { expr_vec(arg_elts, _) { @@ -595,7 +597,7 @@ fn p_t_s_r_length(cx: ext_ctxt, len: uint, at_least: bool, s: selector, b: binders) { fn len_select(_cx: ext_ctxt, m: matchable, at_least: bool, len: uint) -> match_result { - ret alt m { + return alt m { match_expr(e) { alt e.node { expr_vec(arg_elts, _) { @@ -619,7 +621,7 @@ fn p_t_s_r_actual_vector(cx: ext_ctxt, elts: ~[@expr], _repeat_after: bool, let mut idx: uint = 0u; while idx < vec::len(elts) { fn select(cx: ext_ctxt, m: matchable, idx: uint) -> match_result { - ret alt m { + return alt m { match_expr(e) { alt e.node { expr_vec(arg_elts, _) { @@ -709,7 +711,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg, let ext = |a,b,c,d, move clauses| generic_extension(a,b,c,d,clauses); - ret {ident: + return {ident: alt macro_name { some(id) { id } none { @@ -728,7 +730,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg, }; for clauses.each |c| { alt use_selectors_to_bind(c.params, arg) { - some(bindings) { ret transcribe(cx, bindings, c.body); } + some(bindings) { return transcribe(cx, bindings, c.body); } none { again; } } } diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 226292086f8..00c1e4ff47a 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -18,7 +18,7 @@ fn expand_line(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { get_mac_args(cx, sp, arg, 0u, option::some(0u), ~"line"); let loc = codemap::lookup_char_pos(cx.codemap(), sp.lo); - ret mk_uint(cx, sp, loc.line); + return mk_uint(cx, sp, loc.line); } /* col!{}: expands to the current column number */ @@ -26,7 +26,7 @@ fn expand_col(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { get_mac_args(cx, sp, arg, 0u, option::some(0u), ~"col"); let loc = codemap::lookup_char_pos(cx.codemap(), sp.lo); - ret mk_uint(cx, sp, loc.col); + return mk_uint(cx, sp, loc.col); } /* file!{}: expands to the current filename */ @@ -37,19 +37,19 @@ fn expand_file(cx: ext_ctxt, sp: span, arg: ast::mac_arg, get_mac_args(cx, sp, arg, 0u, option::some(0u), ~"file"); let { file: @{ name: filename, _ }, _ } = codemap::lookup_char_pos(cx.codemap(), sp.lo); - ret mk_uniq_str(cx, sp, filename); + return mk_uniq_str(cx, sp, filename); } fn expand_stringify(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { let args = get_mac_args(cx, sp, arg, 1u, option::some(1u), ~"stringify"); - ret mk_uniq_str(cx, sp, pprust::expr_to_str(args[0])); + return mk_uniq_str(cx, sp, pprust::expr_to_str(args[0])); } fn expand_mod(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { get_mac_args(cx, sp, arg, 0u, option::some(0u), ~"file"); - ret mk_uniq_str(cx, sp, + return mk_uniq_str(cx, sp, str::connect(cx.mod_path().map(|x|*x), ~"::")); } @@ -60,7 +60,7 @@ fn expand_include(cx: ext_ctxt, sp: span, arg: ast::mac_arg, let p = parse::new_parser_from_file(cx.parse_sess(), cx.cfg(), res_rel_file(cx, sp, file), parse::parser::SOURCE_FILE); - ret p.parse_expr(); + return p.parse_expr(); } fn expand_include_str(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, @@ -77,7 +77,7 @@ fn expand_include_str(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, } } - ret mk_uniq_str(cx, sp, result::unwrap(res)); + return mk_uniq_str(cx, sp, result::unwrap(res)); } fn expand_include_bin(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, @@ -91,7 +91,7 @@ fn expand_include_bin(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, let u8_exprs = vec::map(src, |char: u8| { mk_u8(cx, sp, char) }); - ret mk_uniq_vec_e(cx, sp, u8_exprs); + return mk_uniq_vec_e(cx, sp, u8_exprs); } result::err(e) { cx.parse_sess().span_diagnostic.handler().fatal(e) @@ -104,9 +104,9 @@ fn res_rel_file(cx: ext_ctxt, sp: codemap::span, +arg: path) -> path { if !path::path_is_absolute(arg) { let cu = codemap::span_to_filename(sp, cx.codemap()); let dir = path::dirname(cu); - ret path::connect(dir, arg); + return path::connect(dir, arg); } else { - ret arg; + return arg; } } diff --git a/src/libsyntax/ext/tt/earley_parser.rs b/src/libsyntax/ext/tt/earley_parser.rs index ed4e2e44f08..6930c09e7ce 100644 --- a/src/libsyntax/ext/tt/earley_parser.rs +++ b/src/libsyntax/ext/tt/earley_parser.rs @@ -129,7 +129,7 @@ fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@named_match]) } let ret_val = box_str_hash::<@named_match>(); for ms.each() |m| { n_rec(p_s, m, res, ret_val) } - ret ret_val; + return ret_val; } enum parse_result { @@ -260,13 +260,13 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher]) /* error messages here could be improved with links to orig. rules */ if tok == EOF { if eof_eis.len() == 1u { - ret success( + return success( nameize(sess, ms, vec::map(eof_eis[0u].matches, |dv| dv.pop()))); } else if eof_eis.len() > 1u { - ret failure(sp, ~"Ambiguity: multiple successful parses"); + return failure(sp, ~"Ambiguity: multiple successful parses"); } else { - ret failure(sp, ~"Unexpected end of macro invocation"); + return failure(sp, ~"Unexpected end of macro invocation"); } } else { if (bb_eis.len() > 0u && next_eis.len() > 0u) @@ -277,12 +277,12 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher]) fmt!{"%s ('%s')", *name, *bind} } _ { fail; } } }), ~" or "); - ret failure(sp, fmt!{ + return failure(sp, fmt!{ "Local ambiguity: multiple parsing options: \ built-in NTs %s or %u other options.", nts, next_eis.len()}); } else if (bb_eis.len() == 0u && next_eis.len() == 0u) { - ret failure(sp, ~"No rules expected the token " + return failure(sp, ~"No rules expected the token " + to_str(*rdr.interner(), tok)); } else if (next_eis.len() > 0u) { /* Now process the next token */ diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index a5fc20c461b..3c680640a31 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -70,7 +70,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident, ~[rhs]); let p = parser(cx.parse_sess(), cx.cfg(), trncbr as reader, SOURCE_FILE); - ret mr_expr(p.parse_expr()); + return mr_expr(p.parse_expr()); } failure(sp, msg) { if sp.lo >= best_fail_spot.lo { @@ -87,5 +87,8 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident, let exp = |cx, sp, arg| generic_extension(cx, sp, arg, lhses, rhses); - ret mr_def({ident: name, ext: expr_tt({expander: exp, span: some(sp)})}); + return mr_def({ + ident: name, + ext: expr_tt({expander: exp, span: some(sp)}) + }); } \ No newline at end of file diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 9ab6261052a..9fda95c464e 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -56,7 +56,7 @@ fn new_tt_reader(sp_diag: span_handler, itr: @interner<@~str>, mut cur_span: ast_util::mk_sp(0u,0u) }; tt_next_token(r); /* get cur_tok and cur_span set up */ - ret r; + return r; } pure fn dup_tt_frame(&&f: tt_frame) -> tt_frame { @@ -145,7 +145,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} { alt r.cur.up { tt_frame_up(none) { r.cur_tok = EOF; - ret ret_val; + return ret_val; } tt_frame_up(some(tt_f)) { if r.cur.dotdotdoted { @@ -163,7 +163,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} { alt r.cur.sep { some(tk) { r.cur_tok = tk; /* repeat same span, I guess */ - ret ret_val; + return ret_val; } none {} } @@ -180,7 +180,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} { tt_tok(sp, tok) { r.cur_span = sp; r.cur_tok = tok; r.cur.idx += 1u; - ret ret_val; + return ret_val; } tt_seq(sp, tts, sep, zerok) { alt lockstep_iter_size(tt_seq(sp, tts, sep, zerok), r) { @@ -204,7 +204,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} { } r.cur.idx += 1u; - ret tt_next_token(r); + return tt_next_token(r); } else { vec::push(r.repeat_len, len); vec::push(r.repeat_idx, 0u); @@ -223,12 +223,12 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} { matched_nonterminal(nt_ident(sn,b)) { r.cur_span = sp; r.cur_tok = IDENT(sn,b); r.cur.idx += 1u; - ret ret_val; + return ret_val; } matched_nonterminal(other_whole_nt) { r.cur_span = sp; r.cur_tok = INTERPOLATED(other_whole_nt); r.cur.idx += 1u; - ret ret_val; + return ret_val; } matched_seq(*) { r.sp_diag.span_fatal( diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 7900b5eea15..ee0512e1b07 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -79,7 +79,7 @@ type ast_fold_precursor = @{ //used in noop_fold_item and noop_fold_crate and noop_fold_crate_directive fn fold_meta_item_(&&mi: @meta_item, fld: ast_fold) -> @meta_item { - ret @{node: + return @{node: alt mi.node { meta_word(id) { meta_word(fld.fold_ident(id)) } meta_list(id, mis) { @@ -97,21 +97,21 @@ fn fold_meta_item_(&&mi: @meta_item, fld: ast_fold) -> @meta_item { //used in noop_fold_item and noop_fold_crate fn fold_attribute_(at: attribute, fld: ast_fold) -> attribute { - ret {node: {style: at.node.style, + return {node: {style: at.node.style, value: *fold_meta_item_(@at.node.value, fld), is_sugared_doc: at.node.is_sugared_doc }, span: fld.new_span(at.span)}; } //used in noop_fold_foreign_item and noop_fold_fn_decl fn fold_arg_(a: arg, fld: ast_fold) -> arg { - ret {mode: a.mode, + return {mode: a.mode, ty: fld.fold_ty(a.ty), ident: fld.fold_ident(a.ident), id: fld.new_id(a.id)}; } //used in noop_fold_expr, and possibly elsewhere in the future fn fold_mac_(m: mac, fld: ast_fold) -> mac { - ret {node: + return {node: alt m.node { mac_invoc(pth, arg, body) { mac_invoc(fld.fold_path(pth), @@ -126,7 +126,7 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac { } fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl { - ret {inputs: vec::map(decl.inputs, |x| fold_arg_(x, fld) ), + return {inputs: vec::map(decl.inputs, |x| fold_arg_(x, fld) ), output: fld.fold_ty(decl.output), purity: decl.purity, cf: decl.cf} @@ -153,15 +153,17 @@ fn noop_fold_crate(c: crate_, fld: ast_fold) -> crate_ { let fold_meta_item = |x| fold_meta_item_(x, fld); let fold_attribute = |x| fold_attribute_(x, fld); - ret {directives: vec::map(c.directives, |x| fld.fold_crate_directive(x)), - module: fld.fold_mod(c.module), - attrs: vec::map(c.attrs, fold_attribute), - config: vec::map(c.config, fold_meta_item)}; + return { + directives: vec::map(c.directives, |x| fld.fold_crate_directive(x)), + module: fld.fold_mod(c.module), + attrs: vec::map(c.attrs, fold_attribute), + config: vec::map(c.config, fold_meta_item) + }; } fn noop_fold_crate_directive(cd: crate_directive_, fld: ast_fold) -> crate_directive_ { - ret alt cd { + return alt cd { cdir_src_mod(id, attrs) { cdir_src_mod(fld.fold_ident(id), /* FIXME (#2543) */ copy attrs) } @@ -176,7 +178,7 @@ fn noop_fold_crate_directive(cd: crate_directive_, fld: ast_fold) -> } fn noop_fold_view_item(vi: view_item_, _fld: ast_fold) -> view_item_ { - ret /* FIXME (#2543) */ copy vi; + return /* FIXME (#2543) */ copy vi; } @@ -185,7 +187,7 @@ fn noop_fold_foreign_item(&&ni: @foreign_item, fld: ast_fold) let fold_arg = |x| fold_arg_(x, fld); let fold_attribute = |x| fold_attribute_(x, fld); - ret @{ident: fld.fold_ident(ni.ident), + return @{ident: fld.fold_ident(ni.ident), attrs: vec::map(ni.attrs, fold_attribute), node: alt ni.node { @@ -204,7 +206,7 @@ fn noop_fold_foreign_item(&&ni: @foreign_item, fld: ast_fold) fn noop_fold_item(&&i: @item, fld: ast_fold) -> option<@item> { let fold_attribute = |x| fold_attribute_(x, fld); - ret some(@{ident: fld.fold_ident(i.ident), + return some(@{ident: fld.fold_ident(i.ident), attrs: vec::map(i.attrs, fold_attribute), id: fld.new_id(i.id), node: fld.fold_item_underscore(i.node), @@ -225,7 +227,7 @@ fn noop_fold_class_item(&&ci: @class_member, fld: ast_fold) } fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ { - ret alt i { + return alt i { item_const(t, e) { item_const(fld.fold_ty(t), fld.fold_expr(e)) } item_fn(decl, typms, body) { item_fn(fold_fn_decl(decl, fld), @@ -294,7 +296,7 @@ fn fold_trait_ref(&&p: @trait_ref, fld: ast_fold) -> @trait_ref { } fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method { - ret @{ident: fld.fold_ident(m.ident), + return @{ident: fld.fold_ident(m.ident), attrs: /* FIXME (#2543) */ copy m.attrs, tps: fold_ty_params(m.tps, fld), self_ty: m.self_ty, @@ -308,7 +310,7 @@ fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method { fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ { - ret {view_items: vec::map(b.view_items, |x| fld.fold_view_item(x)), + return {view_items: vec::map(b.view_items, |x| fld.fold_view_item(x)), stmts: vec::map(b.stmts, |x| fld.fold_stmt(x)), expr: option::map(b.expr, |x| fld.fold_expr(x)), id: fld.new_id(b.id), @@ -316,7 +318,7 @@ fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ { } fn noop_fold_stmt(s: stmt_, fld: ast_fold) -> stmt_ { - ret alt s { + return alt s { stmt_decl(d, nid) { stmt_decl(fld.fold_decl(d), fld.new_id(nid)) } stmt_expr(e, nid) { stmt_expr(fld.fold_expr(e), fld.new_id(nid)) } stmt_semi(e, nid) { stmt_semi(fld.fold_expr(e), fld.new_id(nid)) } @@ -324,13 +326,13 @@ fn noop_fold_stmt(s: stmt_, fld: ast_fold) -> stmt_ { } fn noop_fold_arm(a: arm, fld: ast_fold) -> arm { - ret {pats: vec::map(a.pats, |x| fld.fold_pat(x)), + return {pats: vec::map(a.pats, |x| fld.fold_pat(x)), guard: option::map(a.guard, |x| fld.fold_expr(x)), body: fld.fold_block(a.body)}; } fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ { - ret alt p { + return alt p { pat_wild { pat_wild } pat_ident(binding_mode, pth, sub) { pat_ident(binding_mode, @@ -375,14 +377,14 @@ fn noop_fold_decl(d: decl_, fld: ast_fold) -> decl_ { fn wrap<T>(f: fn@(T, ast_fold) -> T) -> fn@(T, span, ast_fold) -> (T, span) { - ret fn@(x: T, s: span, fld: ast_fold) -> (T, span) { + return fn@(x: T, s: span, fld: ast_fold) -> (T, span) { (f(x, fld), s) } } fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ { fn fold_field_(field: field, fld: ast_fold) -> field { - ret {node: + return {node: {mutbl: field.node.mutbl, ident: fld.fold_ident(field.node.ident), expr: fld.fold_expr(field.node.expr)}, @@ -392,7 +394,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ { let fold_mac = |x| fold_mac_(x, fld); - ret alt e { + return alt e { expr_new(p, i, v) { expr_new(fld.fold_expr(p), fld.new_id(i), @@ -514,18 +516,18 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ { // ...nor do modules fn noop_fold_mod(m: _mod, fld: ast_fold) -> _mod { - ret {view_items: vec::map(m.view_items, |x| fld.fold_view_item(x)), + return {view_items: vec::map(m.view_items, |x| fld.fold_view_item(x)), items: vec::filter_map(m.items, |x| fld.fold_item(x))}; } fn noop_fold_foreign_mod(nm: foreign_mod, fld: ast_fold) -> foreign_mod { - ret {view_items: vec::map(nm.view_items, |x| fld.fold_view_item(x)), + return {view_items: vec::map(nm.view_items, |x| fld.fold_view_item(x)), items: vec::map(nm.items, |x| fld.fold_foreign_item(x))} } fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ { fn fold_variant_arg_(va: variant_arg, fld: ast_fold) -> variant_arg { - ret {ty: fld.fold_ty(va.ty), id: fld.new_id(va.id)}; + return {ty: fld.fold_ty(va.ty), id: fld.new_id(va.id)}; } let fold_variant_arg = |x| fold_variant_arg_(x, fld); let args = vec::map(v.args, fold_variant_arg); @@ -537,7 +539,7 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ { some(e) {some(fld.fold_expr(e))} none {none} }; - ret {name: /* FIXME (#2543) */ copy v.name, + return {name: /* FIXME (#2543) */ copy v.name, attrs: attrs, args: args, id: fld.new_id(v.id), disr_expr: de, @@ -545,18 +547,18 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ { } fn noop_fold_ident(&&i: ident, _fld: ast_fold) -> ident { - ret /* FIXME (#2543) */ copy i; + return /* FIXME (#2543) */ copy i; } fn noop_fold_path(&&p: path, fld: ast_fold) -> path { - ret {span: fld.new_span(p.span), global: p.global, + return {span: fld.new_span(p.span), global: p.global, idents: vec::map(p.idents, |x| fld.fold_ident(x)), rp: p.rp, types: vec::map(p.types, |x| fld.fold_ty(x))}; } fn noop_fold_local(l: local_, fld: ast_fold) -> local_ { - ret {is_mutbl: l.is_mutbl, + return {is_mutbl: l.is_mutbl, ty: fld.fold_ty(l.ty), pat: fld.fold_pat(l.pat), init: @@ -573,15 +575,15 @@ fn noop_fold_local(l: local_, fld: ast_fold) -> local_ { /* temporarily eta-expand because of a compiler bug with using `fn<T>` as a value */ fn noop_map_exprs(f: fn@(&&@expr) -> @expr, es: ~[@expr]) -> ~[@expr] { - ret vec::map(es, f); + return vec::map(es, f); } -fn noop_id(i: node_id) -> node_id { ret i; } +fn noop_id(i: node_id) -> node_id { return i; } -fn noop_span(sp: span) -> span { ret sp; } +fn noop_span(sp: span) -> span { return sp; } fn default_ast_fold() -> ast_fold_precursor { - ret @{fold_crate: wrap(noop_fold_crate), + return @{fold_crate: wrap(noop_fold_crate), fold_crate_directive: wrap(noop_fold_crate_directive), fold_view_item: noop_fold_view_item, fold_foreign_item: noop_fold_foreign_item, @@ -611,17 +613,17 @@ impl of ast_fold for ast_fold_precursor { /* naturally, a macro to write these would be nice */ fn fold_crate(c: crate) -> crate { let (n, s) = self.fold_crate(c.node, c.span, self as ast_fold); - ret {node: n, span: self.new_span(s)}; + return {node: n, span: self.new_span(s)}; } fn fold_crate_directive(&&c: @crate_directive) -> @crate_directive { let (n, s) = self.fold_crate_directive(c.node, c.span, self as ast_fold); - ret @{node: n, + return @{node: n, span: self.new_span(s)}; } fn fold_view_item(&&x: @view_item) -> @view_item { - ret @{node: self.fold_view_item(x.node, self as ast_fold), + return @{node: self.fold_view_item(x.node, self as ast_fold), attrs: vec::map(x.attrs, |a| fold_attribute_(a, self as ast_fold)), vis: x.vis, @@ -629,10 +631,10 @@ impl of ast_fold for ast_fold_precursor { } fn fold_foreign_item(&&x: @foreign_item) -> @foreign_item { - ret self.fold_foreign_item(x, self as ast_fold); + return self.fold_foreign_item(x, self as ast_fold); } fn fold_item(&&i: @item) -> option<@item> { - ret self.fold_item(i, self as ast_fold); + return self.fold_item(i, self as ast_fold); } fn fold_class_item(&&ci: @class_member) -> @class_member { @{node: alt ci.node { @@ -647,65 +649,65 @@ impl of ast_fold for ast_fold_precursor { } fn fold_item_underscore(i: item_) -> item_ { - ret self.fold_item_underscore(i, self as ast_fold); + return self.fold_item_underscore(i, self as ast_fold); } fn fold_method(&&x: @method) -> @method { - ret self.fold_method(x, self as ast_fold); + return self.fold_method(x, self as ast_fold); } fn fold_block(x: blk) -> blk { let (n, s) = self.fold_block(x.node, x.span, self as ast_fold); - ret {node: n, span: self.new_span(s)}; + return {node: n, span: self.new_span(s)}; } fn fold_stmt(&&x: @stmt) -> @stmt { let (n, s) = self.fold_stmt(x.node, x.span, self as ast_fold); - ret @{node: n, span: self.new_span(s)}; + return @{node: n, span: self.new_span(s)}; } fn fold_arm(x: arm) -> arm { - ret self.fold_arm(x, self as ast_fold); + return self.fold_arm(x, self as ast_fold); } fn fold_pat(&&x: @pat) -> @pat { let (n, s) = self.fold_pat(x.node, x.span, self as ast_fold); - ret @{id: self.new_id(x.id), + return @{id: self.new_id(x.id), node: n, span: self.new_span(s)}; } fn fold_decl(&&x: @decl) -> @decl { let (n, s) = self.fold_decl(x.node, x.span, self as ast_fold); - ret @{node: n, span: self.new_span(s)}; + return @{node: n, span: self.new_span(s)}; } fn fold_expr(&&x: @expr) -> @expr { let (n, s) = self.fold_expr(x.node, x.span, self as ast_fold); - ret @{id: self.new_id(x.id), + return @{id: self.new_id(x.id), callee_id: self.new_id(x.callee_id), node: n, span: self.new_span(s)}; } fn fold_ty(&&x: @ty) -> @ty { let (n, s) = self.fold_ty(x.node, x.span, self as ast_fold); - ret @{id: self.new_id(x.id), node: n, span: self.new_span(s)}; + return @{id: self.new_id(x.id), node: n, span: self.new_span(s)}; } fn fold_mod(x: _mod) -> _mod { - ret self.fold_mod(x, self as ast_fold); + return self.fold_mod(x, self as ast_fold); } fn fold_foreign_mod(x: foreign_mod) -> foreign_mod { - ret self.fold_foreign_mod(x, self as ast_fold); + return self.fold_foreign_mod(x, self as ast_fold); } fn fold_variant(x: variant) -> variant { let (n, s) = self.fold_variant(x.node, x.span, self as ast_fold); - ret {node: n, span: self.new_span(s)}; + return {node: n, span: self.new_span(s)}; } fn fold_ident(&&x: ident) -> ident { - ret self.fold_ident(x, self as ast_fold); + return self.fold_ident(x, self as ast_fold); } fn fold_path(&&x: @path) -> @path { @self.fold_path(*x, self as ast_fold) } fn fold_local(&&x: @local) -> @local { let (n, s) = self.fold_local(x.node, x.span, self as ast_fold); - ret @{node: n, span: self.new_span(s)}; + return @{node: n, span: self.new_span(s)}; } fn map_exprs(f: fn@(&&@expr) -> @expr, e: ~[@expr]) -> ~[@expr] { self.map_exprs(f, e) diff --git a/src/libsyntax/parse.rs b/src/libsyntax/parse.rs index 39f4654a138..dad80246bf5 100644 --- a/src/libsyntax/parse.rs +++ b/src/libsyntax/parse.rs @@ -34,7 +34,7 @@ type parse_sess = @{ fn new_parse_sess(demitter: option<emitter>) -> parse_sess { let cm = codemap::new_codemap(); - ret @{cm: cm, + return @{cm: cm, mut next_id: 1, span_diagnostic: mk_span_handler(mk_handler(demitter), cm), interner: @interner::mk::<@~str>(|x| str::hash(*x), @@ -44,7 +44,7 @@ fn new_parse_sess(demitter: option<emitter>) -> parse_sess { fn new_parse_sess_special_handler(sh: span_handler, cm: codemap::codemap) -> parse_sess { - ret @{cm: cm, + return @{cm: cm, mut next_id: 1, span_diagnostic: sh, interner: @interner::mk::<@~str>(|x| str::hash(*x), @@ -81,7 +81,7 @@ fn parse_crate_from_crate_file(input: ~str, cfg: ast::crate_cfg, cx, cdirs, prefix, option::some(companionmod)); let mut hi = p.span.hi; p.expect(token::EOF); - ret @ast_util::respan(ast_util::mk_sp(lo, hi), + return @ast_util::respan(ast_util::mk_sp(lo, hi), {directives: cdirs, module: m, attrs: vec::append(crate_attrs, attrs), @@ -95,7 +95,7 @@ fn parse_crate_from_source_file(input: ~str, cfg: ast::crate_cfg, let r = p.parse_crate_mod(cfg); sess.chpos = rdr.chpos; sess.byte_pos = sess.byte_pos + rdr.pos; - ret r; + return r; } fn parse_crate_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg, @@ -105,7 +105,7 @@ fn parse_crate_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg, let r = p.parse_crate_mod(cfg); sess.chpos = rdr.chpos; sess.byte_pos = sess.byte_pos + rdr.pos; - ret r; + return r; } fn parse_expr_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg, @@ -115,7 +115,7 @@ fn parse_expr_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg, let r = p.parse_expr(); sess.chpos = rdr.chpos; sess.byte_pos = sess.byte_pos + rdr.pos; - ret r; + return r; } fn parse_item_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg, @@ -127,7 +127,7 @@ fn parse_item_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg, let r = p.parse_item(attrs, vis); sess.chpos = rdr.chpos; sess.byte_pos = sess.byte_pos + rdr.pos; - ret r; + return r; } fn parse_stmt_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg, @@ -138,7 +138,7 @@ fn parse_stmt_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg, let r = p.parse_stmt(attrs); sess.chpos = rdr.chpos; sess.byte_pos = sess.byte_pos + rdr.pos; - ret r; + return r; } fn parse_from_source_str<T>(f: fn (p: parser) -> T, @@ -155,7 +155,7 @@ fn parse_from_source_str<T>(f: fn (p: parser) -> T, } sess.chpos = rdr.chpos; sess.byte_pos = sess.byte_pos + rdr.pos; - ret r; + return r; } fn next_node_id(sess: parse_sess) -> node_id { @@ -163,7 +163,7 @@ fn next_node_id(sess: parse_sess) -> node_id { sess.next_id += 1; // ID 0 is reserved for the crate and doesn't actually exist in the AST assert rv != 0; - ret rv; + return rv; } fn new_parser_etc_from_source_str(sess: parse_sess, cfg: ast::crate_cfg, @@ -175,14 +175,14 @@ fn new_parser_etc_from_source_str(sess: parse_sess, cfg: ast::crate_cfg, sess.cm.files.push(filemap); let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap, sess.interner); - ret (parser(sess, cfg, srdr as reader, ftype), srdr); + return (parser(sess, cfg, srdr as reader, ftype), srdr); } fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg, +name: ~str, +ss: codemap::file_substr, source: @~str) -> parser { let (p, _) = new_parser_etc_from_source_str(sess, cfg, name, ss, source); - ret p; + return p; } @@ -199,18 +199,18 @@ fn new_parser_etc_from_file(sess: parse_sess, cfg: ast::crate_cfg, sess.cm.files.push(filemap); let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap, sess.interner); - ret (parser(sess, cfg, srdr as reader, ftype), srdr); + return (parser(sess, cfg, srdr as reader, ftype), srdr); } fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, +path: ~str, ftype: parser::file_type) -> parser { let (p, _) = new_parser_etc_from_file(sess, cfg, path, ftype); - ret p; + return p; } fn new_parser_from_tt(sess: parse_sess, cfg: ast::crate_cfg, tt: ~[ast::token_tree]) -> parser { let trdr = lexer::new_tt_reader(sess.span_diagnostic, sess.interner, none, tt); - ret parser(sess, cfg, trdr as reader, parser::SOURCE_FILE) + return parser(sess, cfg, trdr as reader, parser::SOURCE_FILE) } 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", diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index a2479ef1365..9228ea2e0d5 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -63,11 +63,11 @@ enum token { STRING(@~str, int), BREAK(break_t), BEGIN(begin_t), END, EOF, } fn tok_str(++t: token) -> ~str { alt t { - STRING(s, len) { ret fmt!{"STR(%s,%d)", *s, len}; } - BREAK(_) { ret ~"BREAK"; } - BEGIN(_) { ret ~"BEGIN"; } - END { ret ~"END"; } - EOF { ret ~"EOF"; } + STRING(s, len) { return fmt!{"STR(%s,%d)", *s, len}; } + BREAK(_) { return ~"BREAK"; } + BEGIN(_) { return ~"BEGIN"; } + END { return ~"END"; } + EOF { return ~"EOF"; } } } @@ -86,7 +86,7 @@ fn buf_str(toks: ~[mut token], szs: ~[mut int], left: uint, right: uint, i %= n; } s += ~"]"; - ret s; + return s; } enum print_stack_break { fits, broken(breaks), } @@ -333,11 +333,11 @@ impl printer for printer { if self.top == self.bottom { self.scan_stack_empty = true; } else { self.top += self.buf_len - 1u; self.top %= self.buf_len; } - ret x; + return x; } fn scan_top() -> uint { assert (!self.scan_stack_empty); - ret self.scan_stack[self.top]; + return self.scan_stack[self.top]; } fn scan_pop_bottom() -> uint { assert (!self.scan_stack_empty); @@ -345,7 +345,7 @@ impl printer for printer { if self.top == self.bottom { self.scan_stack_empty = true; } else { self.bottom += 1u; self.bottom %= self.buf_len; } - ret x; + return x; } fn advance_right() { self.right += 1u; @@ -517,10 +517,10 @@ fn space(p: printer) { spaces(p, 1u); } fn hardbreak(p: printer) { spaces(p, size_infinity as uint); } fn hardbreak_tok_offset(off: int) -> token { - ret BREAK({offset: off, blank_space: size_infinity}); + return BREAK({offset: off, blank_space: size_infinity}); } -fn hardbreak_tok() -> token { ret hardbreak_tok_offset(0); } +fn hardbreak_tok() -> token { return hardbreak_tok_offset(0); } // diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index b02bebf58b7..6a2b5c787de 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -22,7 +22,7 @@ type pp_ann = {pre: fn@(ann_node), post: fn@(ann_node)}; fn no_ann() -> pp_ann { fn ignore(_node: ann_node) { } - ret {pre: ignore, post: ignore}; + return {pre: ignore, post: ignore}; } type ps = @@ -47,7 +47,7 @@ fn end(s: ps) { } fn rust_printer(writer: io::writer) -> ps { - ret @{s: pp::mk_printer(writer, default_columns), + return @{s: pp::mk_printer(writer, default_columns), cm: none::<codemap>, intr: @interner::mk::<@~str>(|x| str::hash(*x), |x,y| str::eq(*x, *y)), @@ -95,24 +95,26 @@ fn print_crate_(s: ps, &&crate: @ast::crate) { eof(s.s); } -fn ty_to_str(ty: @ast::ty) -> ~str { ret to_str(ty, print_type); } +fn ty_to_str(ty: @ast::ty) -> ~str { return to_str(ty, print_type); } -fn pat_to_str(pat: @ast::pat) -> ~str { ret to_str(pat, print_pat); } +fn pat_to_str(pat: @ast::pat) -> ~str { return to_str(pat, print_pat); } -fn expr_to_str(e: @ast::expr) -> ~str { ret to_str(e, print_expr); } +fn expr_to_str(e: @ast::expr) -> ~str { return to_str(e, print_expr); } -fn stmt_to_str(s: ast::stmt) -> ~str { ret to_str(s, print_stmt); } +fn stmt_to_str(s: ast::stmt) -> ~str { return to_str(s, print_stmt); } -fn item_to_str(i: @ast::item) -> ~str { ret to_str(i, print_item); } +fn item_to_str(i: @ast::item) -> ~str { return to_str(i, print_item); } -fn attr_to_str(i: ast::attribute) -> ~str { ret to_str(i, print_attribute); } +fn attr_to_str(i: ast::attribute) -> ~str { + return to_str(i, print_attribute); +} fn typarams_to_str(tps: ~[ast::ty_param]) -> ~str { - ret to_str(tps, print_type_params) + return to_str(tps, print_type_params) } fn path_to_str(&&p: @ast::path) -> ~str { - ret to_str(p, |a,b| print_path(a, b, false)); + return to_str(p, |a,b| print_path(a, b, false)); } fn fun_to_str(decl: ast::fn_decl, name: ast::ident, @@ -152,15 +154,15 @@ fn block_to_str(blk: ast::blk) -> ~str { } fn meta_item_to_str(mi: ast::meta_item) -> ~str { - ret to_str(@mi, print_meta_item); + return to_str(@mi, print_meta_item); } fn attribute_to_str(attr: ast::attribute) -> ~str { - ret to_str(attr, print_attribute); + return to_str(attr, print_attribute); } fn variant_to_str(var: ast::variant) -> ~str { - ret to_str(var, print_variant); + return to_str(var, print_variant); } #[test] @@ -228,14 +230,14 @@ fn is_end(s: ps) -> bool { } fn is_bol(s: ps) -> bool { - ret s.s.last_token() == pp::EOF || + return s.s.last_token() == pp::EOF || s.s.last_token() == pp::hardbreak_tok(); } fn in_cbox(s: ps) -> bool { let len = s.boxes.len(); - if len == 0u { ret false; } - ret s.boxes[len - 1u] == pp::consistent; + if len == 0u { return false; } + return s.boxes[len - 1u] == pp::consistent; } fn hardbreak_if_not_bol(s: ps) { if !is_bol(s) { hardbreak(s.s); } } @@ -294,7 +296,7 @@ fn commasep_cmnt<IN>(s: ps, b: breaks, elts: ~[IN], op: fn(ps, IN), } fn commasep_exprs(s: ps, b: breaks, exprs: ~[@ast::expr]) { - fn expr_span(&&expr: @ast::expr) -> codemap::span { ret expr.span; } + fn expr_span(&&expr: @ast::expr) -> codemap::span { return expr.span; } commasep_cmnt(s, b, exprs, print_expr, expr_span); } @@ -365,7 +367,7 @@ fn print_type_ex(s: ps, &&ty: @ast::ty, print_colons: bool) { print_type(s, f.node.mt.ty); end(s); } - fn get_span(f: ast::ty_field) -> codemap::span { ret f.span; } + fn get_span(f: ast::ty_field) -> codemap::span { return f.span; } commasep_cmnt(s, consistent, fields, print_field, get_span); word(s.s, ~",}"); } @@ -805,7 +807,7 @@ fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type, s.ann.post(ann_node); } -// ret and fail, without arguments cannot appear is the discriminant of if, +// return and fail, without arguments cannot appear is the discriminant of if, // alt, do, & while unambiguously without being parenthesized fn print_maybe_parens_discrim(s: ps, e: @ast::expr) { let disambig = alt e.node { @@ -909,7 +911,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) { print_expr(s, field.node.expr); end(s); } - fn get_span(field: ast::field) -> codemap::span { ret field.span; } + fn get_span(field: ast::field) -> codemap::span { return field.span; } maybe_print_comment(s, expr.span.lo); ibox(s, indent_unit); @@ -1162,7 +1164,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) { ast::expr_break { word(s.s, ~"break"); } ast::expr_again { word(s.s, ~"again"); } ast::expr_ret(result) { - word(s.s, ~"ret"); + word(s.s, ~"return"); alt result { some(expr) { word(s.s, ~" "); print_expr(s, expr); } _ { } @@ -1339,7 +1341,7 @@ fn print_pat(s: ps, &&pat: @ast::pat) { print_pat(s, f.pat); end(s); } - fn get_span(f: ast::field_pat) -> codemap::span { ret f.pat.span; } + fn get_span(f: ast::field_pat) -> codemap::span { return f.pat.span; } commasep_cmnt(s, consistent, fields, print_field, get_span); if etc { if vec::len(fields) != 0u { word_space(s, ~","); } @@ -1603,10 +1605,10 @@ fn print_ty_fn(s: ps, opt_proto: option<ast::proto>, fn maybe_print_trailing_comment(s: ps, span: codemap::span, next_pos: option<uint>) { let mut cm; - alt s.cm { some(ccm) { cm = ccm; } _ { ret; } } + alt s.cm { some(ccm) { cm = ccm; } _ { return; } } alt next_comment(s) { some(cmnt) { - if cmnt.style != comments::trailing { ret; } + if cmnt.style != comments::trailing { return; } let span_line = codemap::lookup_char_pos(cm, span.hi); let comment_line = codemap::lookup_char_pos(cm, cmnt.pos); let mut next = cmnt.pos + 1u; @@ -1638,7 +1640,7 @@ fn print_literal(s: ps, &&lit: @ast::lit) { alt next_lit(s, lit.span.lo) { some(ltrl) { word(s.s, ltrl.lit); - ret; + return; } _ {} } @@ -1680,20 +1682,20 @@ fn print_literal(s: ps, &&lit: @ast::lit) { } } -fn lit_to_str(l: @ast::lit) -> ~str { ret to_str(l, print_literal); } +fn lit_to_str(l: @ast::lit) -> ~str { return to_str(l, print_literal); } fn next_lit(s: ps, pos: uint) -> option<comments::lit> { alt s.literals { some(lits) { while s.cur_lit < vec::len(lits) { let ltrl = lits[s.cur_lit]; - if ltrl.pos > pos { ret none; } + if ltrl.pos > pos { return none; } s.cur_lit += 1u; - if ltrl.pos == pos { ret some(ltrl); } + if ltrl.pos == pos { return some(ltrl); } } - ret none; + return none; } - _ { ret none; } + _ { return none; } } } @@ -1773,10 +1775,10 @@ fn next_comment(s: ps) -> option<comments::cmnt> { alt s.comments { some(cmnts) { if s.cur_cmnt < vec::len(cmnts) { - ret some(cmnts[s.cur_cmnt]); - } else { ret none::<comments::cmnt>; } + return some(cmnts[s.cur_cmnt]); + } else { return none::<comments::cmnt>; } } - _ { ret none::<comments::cmnt>; } + _ { return none::<comments::cmnt>; } } } @@ -1804,7 +1806,7 @@ fn print_purity(s: ps, p: ast::purity) { } fn proto_to_str(p: ast::proto) -> ~str { - ret alt p { + return alt p { ast::proto_bare { ~"extern fn" } ast::proto_any { ~"fn" } ast::proto_block { ~"fn&" } diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs index 4886b903d73..5c2f78bce3b 100644 --- a/src/libsyntax/util/interner.rs +++ b/src/libsyntax/util/interner.rs @@ -15,7 +15,7 @@ fn mk<T: const copy>(hasher: hashfn<T>, eqer: eqfn<T>) -> interner<T> { let m = map::hashmap::<T, uint>(hasher, eqer); let hi: hash_interner<T> = {map: m, vect: dvec(), hasher: hasher, eqer: eqer}; - ret hi as interner::<T>; + return hi as interner::<T>; } /* when traits can extend traits, we should extend index<uint,T> to get [] */ @@ -28,12 +28,12 @@ trait interner<T: const copy> { impl <T: const copy> of interner<T> for hash_interner<T> { fn intern(val: T) -> uint { alt self.map.find(val) { - some(idx) { ret idx; } + some(idx) { return idx; } none { let new_idx = self.vect.len(); self.map.insert(val, new_idx); self.vect.push(val); - ret new_idx; + return new_idx; } } } @@ -43,5 +43,5 @@ impl <T: const copy> of interner<T> for hash_interner<T> { // where we first check a pred and then rely on it, ceasing to fail is ok. pure fn get(idx: uint) -> T { self.vect.get_elt(idx) } - fn len() -> uint { ret self.vect.len(); } + fn len() -> uint { return self.vect.len(); } } \ No newline at end of file diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 5cf73da1944..4cbe13b6d5c 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -64,7 +64,7 @@ type visitor<E> = visit_class_item: fn@(@class_member, E, vt<E>)}; fn default_visitor<E>() -> visitor<E> { - ret @{visit_mod: |a,b,c,d,e|visit_mod::<E>(a, b, c, d, e), + return @{visit_mod: |a,b,c,d,e|visit_mod::<E>(a, b, c, d, e), visit_view_item: |a,b,c|visit_view_item::<E>(a, b, c), visit_foreign_item: |a,b,c|visit_foreign_item::<E>(a, b, c), visit_item: |a,b,c|visit_item::<E>(a, b, c), @@ -466,7 +466,7 @@ type simple_visitor = fn simple_ignore_ty(_t: @ty) {} fn default_simple_visitor() -> simple_visitor { - ret @{visit_mod: fn@(_m: _mod, _sp: span, _id: node_id) { }, + return @{visit_mod: fn@(_m: _mod, _sp: span, _id: node_id) { }, visit_view_item: fn@(_vi: @view_item) { }, visit_foreign_item: fn@(_ni: @foreign_item) { }, visit_item: fn@(_i: @item) { }, @@ -574,7 +574,7 @@ fn mk_simple_visitor(v: simple_visitor) -> vt<()> { f(cm); visit_class_item(cm, e, v); } - ret mk_vt(@{visit_mod: |a,b,c,d,e|v_mod(v.visit_mod, a, b, c, d, e), + return mk_vt(@{visit_mod: |a,b,c,d,e|v_mod(v.visit_mod, a, b, c, d, e), visit_view_item: |a,b,c| v_view_item(v.visit_view_item, a, b, c), visit_foreign_item: |