diff options
| author | Brian Anderson <banderson@mozilla.com> | 2012-08-01 17:30:05 -0700 |
|---|---|---|
| committer | Brian Anderson <banderson@mozilla.com> | 2012-08-01 19:16:06 -0700 |
| commit | b355936b4da0831f47afe8f251daee503c8caa32 (patch) | |
| tree | 9f870e26f773af714cbcf7f315de5ff3722300c3 /src/rustc | |
| parent | dc499f193e473abc78c557feaa86969bbe7aa159 (diff) | |
| download | rust-b355936b4da0831f47afe8f251daee503c8caa32.tar.gz rust-b355936b4da0831f47afe8f251daee503c8caa32.zip | |
Convert ret to return
Diffstat (limited to 'src/rustc')
78 files changed, 1683 insertions, 1640 deletions
diff --git a/src/rustc/back/abi.rs b/src/rustc/back/abi.rs index 8213ff1576e..706c8ed991e 100644 --- a/src/rustc/back/abi.rs +++ b/src/rustc/back/abi.rs @@ -66,13 +66,13 @@ const worst_case_glue_call_args: uint = 7u; const abi_version: uint = 1u; -fn memcpy_glue_name() -> ~str { ret ~"rust_memcpy_glue"; } +fn memcpy_glue_name() -> ~str { return ~"rust_memcpy_glue"; } -fn bzero_glue_name() -> ~str { ret ~"rust_bzero_glue"; } +fn bzero_glue_name() -> ~str { return ~"rust_bzero_glue"; } -fn yield_glue_name() -> ~str { ret ~"rust_yield_glue"; } +fn yield_glue_name() -> ~str { return ~"rust_yield_glue"; } -fn no_op_type_glue_name() -> ~str { ret ~"rust_no_op_type_glue"; } +fn no_op_type_glue_name() -> ~str { return ~"rust_no_op_type_glue"; } // // Local Variables: // mode: rust diff --git a/src/rustc/back/link.rs b/src/rustc/back/link.rs index fede7d55af9..7e6c9567b4b 100644 --- a/src/rustc/back/link.rs +++ b/src/rustc/back/link.rs @@ -51,9 +51,9 @@ mod write { fn is_object_or_assembly_or_exe(ot: output_type) -> bool { if ot == output_type_assembly || ot == output_type_object || ot == output_type_exe { - ret true; + return true; } - ret false; + return false; } // Decides what to call an intermediate file, given the name of the output @@ -64,7 +64,7 @@ mod write { some(dot_pos) { str::slice(output_path, 0u, dot_pos) } none { output_path } }; - ret stem + ~"." + extension; + return stem + ~"." + extension; } fn run_passes(sess: session, llmod: ModuleRef, output: ~str) { @@ -234,7 +234,7 @@ mod write { llvm::LLVMDisposeModule(llmod); if sess.time_llvm_passes() { llvm::LLVMRustPrintPassTimings(); } - ret; + return; } if opts.output_type == output_type_llvm_assembly { @@ -334,7 +334,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str, } } else { vec::push(cmh_items, meta); } } - ret {name: name, vers: vers, cmh_items: cmh_items}; + return {name: name, vers: vers, cmh_items: cmh_items}; } // This calculates CMH as defined above @@ -343,11 +343,11 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str, metas: provided_metas, dep_hashes: ~[@~str]) -> ~str { fn len_and_str(s: ~str) -> ~str { - ret fmt!{"%u_%s", str::len(s), s}; + return fmt!{"%u_%s", str::len(s), s}; } fn len_and_str_lit(l: ast::lit) -> ~str { - ret len_and_str(pprust::lit_to_str(@l)); + return len_and_str(pprust::lit_to_str(@l)); } let cmh_items = attr::sort_meta_items(metas.cmh_items); @@ -374,18 +374,18 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str, symbol_hasher.input_str(len_and_str(*dh)); } - ret truncated_hash_result(symbol_hasher); + return truncated_hash_result(symbol_hasher); } fn warn_missing(sess: session, name: ~str, default: ~str) { - if !sess.building_library { ret; } + if !sess.building_library { return; } sess.warn(fmt!{"missing crate link meta `%s`, using `%s` as default", name, default}); } fn crate_meta_name(sess: session, _crate: ast::crate, output: ~str, metas: provided_metas) -> @~str { - ret alt metas.name { + return alt metas.name { some(v) { v } none { let name = @@ -407,7 +407,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str, fn crate_meta_vers(sess: session, _crate: ast::crate, metas: provided_metas) -> @~str { - ret alt metas.vers { + return alt metas.vers { some(v) { v } none { let vers = ~"0.0"; @@ -424,7 +424,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str, let extras_hash = crate_meta_extras_hash(symbol_hasher, c, provided_metas, dep_hashes); - ret {name: name, vers: vers, extras_hash: extras_hash}; + return {name: name, vers: vers, extras_hash: extras_hash}; } fn truncated_hash_result(symbol_hasher: hash::streaming) -> ~str unsafe { @@ -447,16 +447,16 @@ fn symbol_hash(tcx: ty::ctxt, symbol_hasher: hash::streaming, t: ty::t, let hash = truncated_hash_result(symbol_hasher); // Prefix with _ so that it never blends into adjacent digits - ret ~"_" + hash; + return ~"_" + hash; } fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> ~str { alt ccx.type_hashcodes.find(t) { - some(h) { ret h; } + some(h) { return h; } none { let hash = symbol_hash(ccx.tcx, ccx.symbol_hasher, t, ccx.link_meta); ccx.type_hashcodes.insert(t, hash); - ret hash; + return hash; } } } @@ -491,10 +491,10 @@ fn sanitize(s: ~str) -> ~str { if result.len() > 0u && result[0] != '_' as u8 && ! char::is_XID_start(result[0] as char) { - ret ~"_" + result; + return ~"_" + result; } - ret result; + return result; } fn mangle(ss: path) -> ~str { @@ -513,14 +513,14 @@ fn mangle(ss: path) -> ~str { } fn exported_name(path: path, hash: @~str, vers: @~str) -> ~str { - ret mangle( + return mangle( vec::append_one(vec::append_one(path, path_name(hash)), path_name(vers))); } fn mangle_exported_name(ccx: @crate_ctxt, path: path, t: ty::t) -> ~str { let hash = get_symbol_hash(ccx, t); - ret exported_name(path, @hash, ccx.link_meta.vers); + return exported_name(path, @hash, ccx.link_meta.vers); } fn mangle_internal_name_by_type_only(ccx: @crate_ctxt, @@ -528,20 +528,20 @@ fn mangle_internal_name_by_type_only(ccx: @crate_ctxt, ~str { let s = @util::ppaux::ty_to_short_str(ccx.tcx, t); let hash = get_symbol_hash(ccx, t); - ret mangle(~[path_name(name), path_name(s), path_name(@hash)]); + return mangle(~[path_name(name), path_name(s), path_name(@hash)]); } fn mangle_internal_name_by_path_and_seq(ccx: @crate_ctxt, path: path, flav: @~str) -> ~str { - ret mangle(vec::append_one(path, path_name(@ccx.names(*flav)))); + return mangle(vec::append_one(path, path_name(@ccx.names(*flav)))); } fn mangle_internal_name_by_path(_ccx: @crate_ctxt, path: path) -> ~str { - ret mangle(path); + return mangle(path); } fn mangle_internal_name_by_seq(ccx: @crate_ctxt, flav: @~str) -> ~str { - ret ccx.names(*flav); + return ccx.names(*flav); } // If the user wants an exe generated we need to invoke @@ -558,15 +558,15 @@ fn link_binary(sess: session, (config.os == session::os_linux || config.os == session::os_freebsd) && option::is_some(found) && option::get(found) == 0u { - ret str::slice(filename, 3u, str::len(filename)); - } else { ret filename; } + return str::slice(filename, 3u, str::len(filename)); + } else { return filename; } }; fn rmext(filename: ~str) -> ~str { let mut parts = str::split_char(filename, '.'); vec::pop(parts); - ret str::connect(parts, ~"."); + return str::connect(parts, ~"."); } - ret alt config.os { + return alt config.os { session::os_macos { rmext(rmlib(filename)) } session::os_linux { rmext(rmlib(filename)) } session::os_freebsd { rmext(rmlib(filename)) } diff --git a/src/rustc/back/rpath.rs b/src/rustc/back/rpath.rs index 4f85fb48f2a..d92c5f8379e 100644 --- a/src/rustc/back/rpath.rs +++ b/src/rustc/back/rpath.rs @@ -18,7 +18,7 @@ fn get_rpath_flags(sess: session::session, out_filename: ~str) -> ~[~str] { // No rpath on windows if os == session::os_win32 { - ret ~[]; + return ~[]; } debug!{"preparing the RPATH!"}; @@ -89,7 +89,7 @@ fn get_rpaths(os: session::os, cwd: path::path, sysroot: path::path, // Remove duplicates let rpaths = minimize_rpaths(rpaths); - ret rpaths; + return rpaths; } fn get_rpaths_relative_to_output(os: session::os, @@ -148,9 +148,9 @@ fn get_relative_to(abs1: path::path, abs2: path::path) -> path::path { vec::push_all(path, vec::view(split2, start_idx, len2 - 1u)); if vec::is_not_empty(path) { - ret path::connect_many(path); + return path::connect_many(path); } else { - ret ~"."; + return ~"."; } } @@ -192,7 +192,7 @@ fn minimize_rpaths(rpaths: ~[~str]) -> ~[~str] { set.insert(rpath, ()); } } - ret minimized; + return minimized; } #[cfg(unix)] diff --git a/src/rustc/back/upcall.rs b/src/rustc/back/upcall.rs index 94c69976c8c..0b6b2455ac7 100644 --- a/src/rustc/back/upcall.rs +++ b/src/rustc/back/upcall.rs @@ -36,7 +36,7 @@ fn declare_upcalls(targ_cfg: @session::config, let mut arg_tys: ~[TypeRef] = ~[]; for tys.each |t| { vec::push(arg_tys, t); } let fn_ty = T_fn(arg_tys, rv); - ret base::decl_cdecl_fn(llmod, prefix + name, fn_ty); + return base::decl_cdecl_fn(llmod, prefix + name, fn_ty); } fn nothrow(f: ValueRef) -> ValueRef { base::set_no_unwind(f); f @@ -47,7 +47,7 @@ fn declare_upcalls(targ_cfg: @session::config, let int_t = T_int(targ_cfg); let size_t = T_size_t(targ_cfg); - ret @{_fail: dv(~"fail", ~[T_ptr(T_i8()), + return @{_fail: dv(~"fail", ~[T_ptr(T_i8()), T_ptr(T_i8()), size_t]), trace: dv(~"trace", ~[T_ptr(T_i8()), diff --git a/src/rustc/back/x86.rs b/src/rustc/back/x86.rs index a7cd20e875b..93001f5e06a 100644 --- a/src/rustc/back/x86.rs +++ b/src/rustc/back/x86.rs @@ -3,7 +3,7 @@ import session::sess_os_to_meta_os; import metadata::loader::meta_section_name; fn get_target_strs(target_os: session::os) -> target_strs::t { - ret { + return { module_asm: ~"", meta_sect_name: meta_section_name(sess_os_to_meta_os(target_os)), diff --git a/src/rustc/back/x86_64.rs b/src/rustc/back/x86_64.rs index 63399cd2b41..76a63fbf3d9 100644 --- a/src/rustc/back/x86_64.rs +++ b/src/rustc/back/x86_64.rs @@ -3,7 +3,7 @@ import session::sess_os_to_meta_os; import metadata::loader::meta_section_name; fn get_target_strs(target_os: session::os) -> target_strs::t { - ret { + return { module_asm: ~"", meta_sect_name: meta_section_name(sess_os_to_meta_os(target_os)), diff --git a/src/rustc/driver/driver.rs b/src/rustc/driver/driver.rs index 387f62034da..fd4f29a6ad0 100644 --- a/src/rustc/driver/driver.rs +++ b/src/rustc/driver/driver.rs @@ -50,7 +50,7 @@ fn default_configuration(sess: session, argv0: ~str, input: input) -> session::arch_arm { ~"arm" } }; - ret ~[ // Target bindings. + return ~[ // Target bindings. attr::mk_word_item(@os::family()), mk(@~"target_os", os::sysname()), mk(@~"target_family", os::family()), @@ -76,7 +76,7 @@ fn build_configuration(sess: session, argv0: ~str, input: input) -> ~[attr::mk_word_item(@~"notest")] } }; - ret vec::append(vec::append(user_cfg, gen_cfg), default_cfg); + return vec::append(vec::append(user_cfg, gen_cfg), default_cfg); } // Convert strings provided as --cfg [cfgspec] into a crate_cfg @@ -86,7 +86,7 @@ fn parse_cfgspecs(cfgspecs: ~[~str]) -> ast::crate_cfg { // meta_word variant. let mut words = ~[]; for cfgspecs.each |s| { vec::push(words, attr::mk_word_item(@s)); } - ret words; + return words; } enum input { @@ -111,13 +111,13 @@ fn parse_input(sess: session, cfg: ast::crate_cfg, input: input) } fn time<T>(do_it: bool, what: ~str, thunk: fn() -> T) -> T { - if !do_it { ret thunk(); } + if !do_it { return thunk(); } let start = std::time::precise_time_s(); let rv = thunk(); let end = std::time::precise_time_s(); io::stdout().write_str(fmt!{"time: %3.3f s\t%s\n", end - start, what}); - ret rv; + return rv; } enum compile_upto { @@ -135,7 +135,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg, let time_passes = sess.time_passes(); let mut crate = time(time_passes, ~"parsing", ||parse_input(sess, cfg, input) ); - if upto == cu_parse { ret {crate: crate, tcx: none}; } + if upto == cu_parse { return {crate: crate, tcx: none}; } sess.building_library = session::building_library( sess.opts.crate_type, crate, sess.opts.test); @@ -150,7 +150,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg, syntax::ext::expand::expand_crate(sess.parse_sess, sess.opts.cfg, crate)); - if upto == cu_expand { ret {crate: crate, tcx: none}; } + if upto == cu_expand { return {crate: crate, tcx: none}; } crate = time(time_passes, ~"intrinsic injection", || front::intrinsic_inject::inject_intrinsic(sess, crate)); @@ -205,7 +205,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg, middle::check_const::check_crate(sess, crate, ast_map, def_map, method_map, ty_cx)); - if upto == cu_typeck { ret {crate: crate, tcx: some(ty_cx)}; } + if upto == cu_typeck { return {crate: crate, tcx: some(ty_cx)}; } time(time_passes, ~"block-use checking", || middle::block_use::check_crate(ty_cx, crate)); @@ -228,7 +228,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg, time(time_passes, ~"lint checking", || lint::check_crate(ty_cx, crate)); - if upto == cu_no_trans { ret {crate: crate, tcx: some(ty_cx)}; } + if upto == cu_no_trans { return {crate: crate, tcx: some(ty_cx)}; } let outputs = option::get(outputs); let maps = {mutbl_map: mutbl_map, root_map: root_map, @@ -247,13 +247,13 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg, sess.opts.output_type != link::output_type_exe || sess.opts.static && sess.building_library; - if stop_after_codegen { ret {crate: crate, tcx: some(ty_cx)}; } + if stop_after_codegen { return {crate: crate, tcx: some(ty_cx)}; } time(time_passes, ~"linking", || link::link_binary(sess, outputs.obj_filename, outputs.out_filename, link_meta)); - ret {crate: crate, tcx: some(ty_cx)}; + return {crate: crate, tcx: some(ty_cx)}; } fn compile_input(sess: session, cfg: ast::crate_cfg, input: input, @@ -338,7 +338,7 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input, } fn get_os(triple: ~str) -> option<session::os> { - ret if str::contains(triple, ~"win32") || + if str::contains(triple, ~"win32") || str::contains(triple, ~"mingw32") { some(session::os_win32) } else if str::contains(triple, ~"darwin") { @@ -347,11 +347,12 @@ fn get_os(triple: ~str) -> option<session::os> { some(session::os_linux) } else if str::contains(triple, ~"freebsd") { some(session::os_freebsd) - } else { none }; + } else { none } } fn get_arch(triple: ~str) -> option<session::arch> { - ret if str::contains(triple, ~"i386") || str::contains(triple, ~"i486") || + if str::contains(triple, ~"i386") || + str::contains(triple, ~"i486") || str::contains(triple, ~"i586") || str::contains(triple, ~"i686") || str::contains(triple, ~"i786") { @@ -361,7 +362,7 @@ fn get_arch(triple: ~str) -> option<session::arch> { } else if str::contains(triple, ~"arm") || str::contains(triple, ~"xscale") { some(session::arch_arm) - } else { none }; + } else { none } } fn build_target_config(sopts: @session::options, @@ -388,7 +389,7 @@ fn build_target_config(sopts: @session::options, let target_cfg: @session::config = @{os: os, arch: arch, target_strs: target_strs, int_type: int_type, uint_type: uint_type, float_type: float_type}; - ret target_cfg; + return target_cfg; } fn host_triple() -> ~str { @@ -401,7 +402,7 @@ fn host_triple() -> ~str { // be grabbing (at compile time) the target triple that this rustc is // built with and calling that (at runtime) the host triple. let ht = env!{"CFG_HOST_TRIPLE"}; - ret if ht != ~"" { + return if ht != ~"" { ht } else { fail ~"rustc built without CFG_HOST_TRIPLE" @@ -530,7 +531,7 @@ fn build_session_options(matches: getopts::matches, parse_only: parse_only, no_trans: no_trans, debugging_opts: debugging_opts}; - ret sopts; + return sopts; } fn build_session(sopts: @session::options, @@ -573,22 +574,23 @@ fn build_session_(sopts: @session::options, fn parse_pretty(sess: session, &&name: ~str) -> pp_mode { if str::eq(name, ~"normal") { - ret ppm_normal; + return ppm_normal; } else if str::eq(name, ~"expanded") { - ret ppm_expanded; + return ppm_expanded; } else if str::eq(name, ~"typed") { - ret ppm_typed; + return ppm_typed; } else if str::eq(name, ~"expanded,identified") { - ret ppm_expanded_identified; + return ppm_expanded_identified; } else if str::eq(name, ~"identified") { - ret ppm_identified; + return ppm_identified; } sess.fatal(~"argument to `pretty` must be one of `normal`, `typed`, or " + ~"`identified`"); } fn opts() -> ~[getopts::opt] { - ret ~[optflag(~"h"), optflag(~"help"), optflag(~"v"), optflag(~"version"), + return ~[optflag(~"h"), optflag(~"help"), + optflag(~"v"), optflag(~"version"), optflag(~"emit-llvm"), optflagopt(~"pretty"), optflag(~"ls"), optflag(~"parse-only"), optflag(~"no-trans"), optflag(~"O"), optopt(~"opt-level"), optmulti(~"L"), optflag(~"S"), @@ -699,7 +701,7 @@ fn build_output_filenames(input: input, } } } - ret @{out_filename: out_path, + return @{out_filename: out_path, obj_filename: obj_path}; } diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs index 5a592434710..14d00c2d547 100644 --- a/src/rustc/driver/rustc.rs +++ b/src/rustc/driver/rustc.rs @@ -121,7 +121,7 @@ fn run_compiler(args: ~[~str], demitter: diagnostic::emitter) { let mut args = args; let binary = vec::shift(args); - if vec::len(args) == 0u { usage(binary); ret; } + if vec::len(args) == 0u { usage(binary); return; } let matches = alt getopts::getopts(args, opts()) { @@ -133,24 +133,24 @@ fn run_compiler(args: ~[~str], demitter: diagnostic::emitter) { if opt_present(matches, ~"h") || opt_present(matches, ~"help") { usage(binary); - ret; + return; } let lint_flags = vec::append(getopts::opt_strs(matches, ~"W"), getopts::opt_strs(matches, ~"warn")); if lint_flags.contains(~"help") { describe_warnings(); - ret; + return; } if getopts::opt_strs(matches, ~"Z").contains(~"help") { describe_debug_flags(); - ret; + return; } if opt_present(matches, ~"v") || opt_present(matches, ~"version") { version(binary); - ret; + return; } let input = alt vec::len(matches.free) { 0u { early_error(demitter, ~"no input filename given") } @@ -176,7 +176,10 @@ fn run_compiler(args: ~[~str], demitter: diagnostic::emitter) { ~"normal"), |a| parse_pretty(sess, a) ); alt pretty { - some::<pp_mode>(ppm) { pretty_print_input(sess, cfg, input, ppm); ret; } + some::<pp_mode>(ppm) { + pretty_print_input(sess, cfg, input, ppm); + return; + } none::<pp_mode> {/* continue */ } } let ls = opt_present(matches, ~"ls"); @@ -189,7 +192,7 @@ fn run_compiler(args: ~[~str], demitter: diagnostic::emitter) { early_error(demitter, ~"can not list metadata for stdin"); } } - ret; + return; } compile_input(sess, cfg, input, odir, ofile); diff --git a/src/rustc/driver/session.rs b/src/rustc/driver/session.rs index 173c66fba1d..e70c97754b9 100644 --- a/src/rustc/driver/session.rs +++ b/src/rustc/driver/session.rs @@ -168,7 +168,7 @@ impl session for session { self.span_lint_level(level, span, msg); } fn next_node_id() -> ast::node_id { - ret syntax::parse::next_node_id(self.parse_sess); + return syntax::parse::next_node_id(self.parse_sess); } fn diagnostic() -> diagnostic::span_handler { self.span_diagnostic diff --git a/src/rustc/front/config.rs b/src/rustc/front/config.rs index c633cf5d2af..9deaae5ecf1 100644 --- a/src/rustc/front/config.rs +++ b/src/rustc/front/config.rs @@ -31,7 +31,7 @@ fn strip_items(crate: @ast::crate, in_cfg: in_cfg_pred) let fold = fold::make_fold(precursor); let res = @fold.fold_crate(*crate); - ret res; + return res; } fn filter_item(cx: ctxt, &&item: @ast::item) -> @@ -54,8 +54,10 @@ fn fold_mod(cx: ctxt, m: ast::_mod, fld: fold::ast_fold) -> let filtered_items = vec::filter_map(m.items, item_filter); let view_item_filter = |a| filter_view_item(cx, a); let filtered_view_items = vec::filter_map(m.view_items, view_item_filter); - ret {view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(x)), - items: vec::filter_map(filtered_items, |x| fld.fold_item(x))}; + return { + view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(x)), + items: vec::filter_map(filtered_items, |x| fld.fold_item(x)) + }; } fn filter_foreign_item(cx: ctxt, &&item: @ast::foreign_item) -> @@ -72,8 +74,10 @@ fn fold_foreign_mod(cx: ctxt, nm: ast::foreign_mod, let view_item_filter = |a| filter_view_item(cx, a); let filtered_view_items = vec::filter_map( nm.view_items, view_item_filter); - ret {view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(x)), - items: filtered_items}; + return { + view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(x)), + items: filtered_items + }; } fn filter_stmt(cx: ctxt, &&stmt: @ast::stmt) -> @@ -97,7 +101,7 @@ fn fold_block(cx: ctxt, b: ast::blk_, fld: fold::ast_fold) -> ast::blk_ { let filter = |a| filter_stmt(cx, a); let filtered_stmts = vec::filter_map(b.stmts, filter); - ret {view_items: b.view_items, + return {view_items: b.view_items, stmts: vec::map(filtered_stmts, |x| fld.fold_stmt(x)), expr: option::map(b.expr, |x| fld.fold_expr(x)), id: b.id, @@ -105,15 +109,15 @@ fn fold_block(cx: ctxt, b: ast::blk_, fld: fold::ast_fold) -> } fn item_in_cfg(cx: ctxt, item: @ast::item) -> bool { - ret cx.in_cfg(item.attrs); + return cx.in_cfg(item.attrs); } fn foreign_item_in_cfg(cx: ctxt, item: @ast::foreign_item) -> bool { - ret cx.in_cfg(item.attrs); + return cx.in_cfg(item.attrs); } fn view_item_in_cfg(cx: ctxt, item: @ast::view_item) -> bool { - ret cx.in_cfg(item.attrs); + return cx.in_cfg(item.attrs); } // Determine if an item should be translated in the current crate @@ -134,13 +138,13 @@ fn metas_in_cfg(cfg: ast::crate_cfg, metas: ~[@ast::meta_item]) -> bool { |&&i| attr::get_meta_item_list(i) )); let has_cfg_metas = vec::len(cfg_metas) > 0u; - if !has_cfg_metas { ret true; } + if !has_cfg_metas { return true; } for cfg_metas.each |cfg_mi| { - if attr::contains(cfg, cfg_mi) { ret true; } + if attr::contains(cfg, cfg_mi) { return true; } } - ret false; + return false; } diff --git a/src/rustc/front/core_inject.rs b/src/rustc/front/core_inject.rs index 24b1a8094e3..7103c736206 100644 --- a/src/rustc/front/core_inject.rs +++ b/src/rustc/front/core_inject.rs @@ -23,7 +23,7 @@ fn inject_libcore_ref(sess: session, crate: @ast::crate) -> @ast::crate { fn spanned<T: copy>(x: T) -> @ast::spanned<T> { - ret @{node: x, + return @{node: x, span: dummy_sp()}; } @@ -43,6 +43,6 @@ fn inject_libcore_ref(sess: session, let vis = vec::append(~[vi1, vi2], crate.node.module.view_items); - ret @{node: {module: { view_items: vis with crate.node.module } + return @{node: {module: { view_items: vis with crate.node.module } with crate.node} with *crate } } diff --git a/src/rustc/front/intrinsic_inject.rs b/src/rustc/front/intrinsic_inject.rs index 920d4e2ee8c..34a60fda151 100644 --- a/src/rustc/front/intrinsic_inject.rs +++ b/src/rustc/front/intrinsic_inject.rs @@ -24,6 +24,6 @@ fn inject_intrinsic(sess: session, let items = vec::append(~[item], crate.node.module.items); - ret @{node: {module: { items: items with crate.node.module } + return @{node: {module: { items: items with crate.node.module } with crate.node} with *crate } } diff --git a/src/rustc/front/test.rs b/src/rustc/front/test.rs index 1cf825a5e6b..87011c2ad33 100644 --- a/src/rustc/front/test.rs +++ b/src/rustc/front/test.rs @@ -51,7 +51,7 @@ fn generate_test_harness(sess: session::session, let fold = fold::make_fold(precursor); let res = @fold.fold_crate(*crate); - ret res; + return res; } fn strip_test_functions(crate: @ast::crate) -> @ast::crate { @@ -82,7 +82,7 @@ fn fold_mod(_cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod { let mod_nomain = {view_items: m.view_items, items: vec::filter_map(m.items, nomain)}; - ret fold::noop_fold_mod(mod_nomain, fld); + return fold::noop_fold_mod(mod_nomain, fld); } fn fold_crate(cx: test_ctxt, c: ast::crate_, fld: fold::ast_fold) -> @@ -91,7 +91,7 @@ fn fold_crate(cx: test_ctxt, c: ast::crate_, fld: fold::ast_fold) -> // Add a special __test module to the crate that will contain code // generated for the test harness - ret {module: add_test_module(cx, folded.module) with folded}; + return {module: add_test_module(cx, folded.module) with folded}; } @@ -121,7 +121,7 @@ fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) -> let res = fold::noop_fold_item(i, fld); vec::pop(cx.path); - ret res; + return res; } fn is_test_fn(i: @ast::item) -> bool { @@ -140,7 +140,7 @@ fn is_test_fn(i: @ast::item) -> bool { } } - ret has_test_attr && has_test_signature(i); + return has_test_attr && has_test_signature(i); } fn is_ignored(cx: test_ctxt, i: @ast::item) -> bool { @@ -148,7 +148,7 @@ fn is_ignored(cx: test_ctxt, i: @ast::item) -> bool { let ignoreitems = attr::attr_metas(ignoreattrs); let cfg_metas = vec::concat(vec::filter_map(ignoreitems, |&&i| attr::get_meta_item_list(i) )); - ret if vec::is_not_empty(ignoreitems) { + return if vec::is_not_empty(ignoreitems) { config::metas_in_cfg(cx.crate.node.config, cfg_metas) } else { false @@ -161,7 +161,7 @@ fn should_fail(i: @ast::item) -> bool { fn add_test_module(cx: test_ctxt, m: ast::_mod) -> ast::_mod { let testmod = mk_test_module(cx); - ret {items: vec::append_one(m.items, testmod) with m}; + return {items: vec::append_one(m.items, testmod) with m}; } /* @@ -203,11 +203,11 @@ fn mk_test_module(cx: test_ctxt) -> @ast::item { debug!{"Synthetic test module:\n%s\n", pprust::item_to_str(@item)}; - ret @item; + return @item; } fn nospan<T: copy>(t: T) -> ast::spanned<T> { - ret {node: t, span: dummy_sp()}; + return {node: t, span: dummy_sp()}; } fn path_node(ids: ~[ast::ident]) -> @ast::path { @@ -238,7 +238,7 @@ fn mk_tests(cx: test_ctxt) -> @ast::item { node: item_, vis: ast::public, span: dummy_sp()}; - ret @item; + return @item; } fn mk_path(cx: test_ctxt, path: ~[ast::ident]) -> ~[ast::ident] { @@ -270,7 +270,7 @@ fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty { let inner_ty = @{id: cx.sess.next_node_id(), node: ast::ty_vec(vec_mt), span: dummy_sp()}; - ret @{id: cx.sess.next_node_id(), + return @{id: cx.sess.next_node_id(), node: ast::ty_uniq({ty: inner_ty, mutbl: ast::m_imm}), span: dummy_sp()}; } @@ -286,7 +286,7 @@ fn mk_test_desc_vec(cx: test_ctxt) -> @ast::expr { callee_id: cx.sess.next_node_id(), node: ast::expr_vec(descs, ast::m_imm), span: dummy_sp()}; - ret @{id: cx.sess.next_node_id(), + return @{id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(), node: ast::expr_vstore(inner_expr, ast::vstore_uniq), span: dummy_sp()}; @@ -358,7 +358,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr { let desc_rec: ast::expr = {id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(), node: desc_rec_, span: span}; - ret @desc_rec; + return @desc_rec; } // Produces a bare function that wraps the test function @@ -400,7 +400,7 @@ fn mk_test_wrapper(cx: test_ctxt, span: span }; - ret @wrapper_expr; + return @wrapper_expr; } fn mk_main(cx: test_ctxt) -> @ast::item { @@ -451,7 +451,7 @@ fn mk_main(cx: test_ctxt) -> @ast::item { node: item_, vis: ast::public, span: dummy_sp()}; - ret @item; + return @item; } fn mk_test_main_call(cx: test_ctxt) -> @ast::expr { @@ -497,7 +497,7 @@ fn mk_test_main_call(cx: test_ctxt) -> @ast::expr { {id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(), node: test_main_call_expr_, span: dummy_sp()}; - ret @test_main_call_expr; + return @test_main_call_expr; } // Local Variables: diff --git a/src/rustc/lib/llvm.rs b/src/rustc/lib/llvm.rs index 68fcb8c9183..2a327a25b11 100644 --- a/src/rustc/lib/llvm.rs +++ b/src/rustc/lib/llvm.rs @@ -995,28 +995,28 @@ fn associate_type(tn: type_names, s: ~str, t: TypeRef) { } fn type_has_name(tn: type_names, t: TypeRef) -> option<~str> { - ret tn.type_names.find(t); + return tn.type_names.find(t); } fn name_has_type(tn: type_names, s: ~str) -> option<TypeRef> { - ret tn.named_types.find(s); + return tn.named_types.find(s); } fn mk_type_names() -> type_names { - fn hash(&&t: TypeRef) -> uint { ret t as uint; } - fn eq(&&a: TypeRef, &&b: TypeRef) -> bool { ret a as uint == b as uint; } + fn hash(&&t: TypeRef) -> uint { return t as uint; } + fn eq(&&a: TypeRef, &&b: TypeRef) -> bool { a as uint == b as uint } @{type_names: std::map::hashmap(hash, eq), named_types: std::map::str_hash()} } fn type_to_str(names: type_names, ty: TypeRef) -> ~str { - ret type_to_str_inner(names, ~[], ty); + return type_to_str_inner(names, ~[], ty); } fn type_to_str_inner(names: type_names, outer0: ~[TypeRef], ty: TypeRef) -> ~str { alt type_has_name(names, ty) { - option::some(n) { ret n; } + option::some(n) { return n; } _ {} } @@ -1032,20 +1032,20 @@ fn type_to_str_inner(names: type_names, outer0: ~[TypeRef], ty: TypeRef) -> if first { first = false; } else { s += ~", "; } s += type_to_str_inner(names, outer, t); } - ret s; + return s; } alt kind { - Void { ret ~"Void"; } - Half { ret ~"Half"; } - Float { ret ~"Float"; } - Double { ret ~"Double"; } - X86_FP80 { ret ~"X86_FP80"; } - FP128 { ret ~"FP128"; } - PPC_FP128 { ret ~"PPC_FP128"; } - Label { ret ~"Label"; } + Void { return ~"Void"; } + Half { return ~"Half"; } + Float { return ~"Float"; } + Double { return ~"Double"; } + X86_FP80 { return ~"X86_FP80"; } + FP128 { return ~"FP128"; } + PPC_FP128 { return ~"PPC_FP128"; } + Label { return ~"Label"; } Integer { - ret ~"i" + int::str(llvm::LLVMGetIntTypeWidth(ty) as int); + return ~"i" + int::str(llvm::LLVMGetIntTypeWidth(ty) as int); } Function { let mut s = ~"fn("; @@ -1058,7 +1058,7 @@ fn type_to_str_inner(names: type_names, outer0: ~[TypeRef], ty: TypeRef) -> s += tys_str(names, outer, args); s += ~") -> "; s += type_to_str_inner(names, outer, out_ty); - ret s; + return s; } Struct { let mut s: ~str = ~"{"; @@ -1069,11 +1069,11 @@ fn type_to_str_inner(names: type_names, outer0: ~[TypeRef], ty: TypeRef) -> } s += tys_str(names, outer, elts); s += ~"}"; - ret s; + return s; } Array { let el_ty = llvm::LLVMGetElementType(ty); - ret ~"[" + type_to_str_inner(names, outer, el_ty) + ~" x " + + return ~"[" + type_to_str_inner(names, outer, el_ty) + ~" x " + uint::str(llvm::LLVMGetArrayLength(ty) as uint) + ~"]"; } Pointer { @@ -1082,7 +1082,7 @@ fn type_to_str_inner(names: type_names, outer0: ~[TypeRef], ty: TypeRef) -> i += 1u; if tout as int == ty as int { let n: uint = vec::len::<TypeRef>(outer0) - i; - ret ~"*\\" + int::str(n as int); + return ~"*\\" + int::str(n as int); } } let addrstr = { @@ -1093,17 +1093,17 @@ fn type_to_str_inner(names: type_names, outer0: ~[TypeRef], ty: TypeRef) -> fmt!{"addrspace(%u)", addrspace} } }; - ret addrstr + ~"*" + + return addrstr + ~"*" + type_to_str_inner(names, outer, llvm::LLVMGetElementType(ty)); } - Vector { ret ~"Vector"; } - Metadata { ret ~"Metadata"; } - X86_MMX { ret ~"X86_MMAX"; } + Vector { return ~"Vector"; } + Metadata { return ~"Metadata"; } + X86_MMX { return ~"X86_MMAX"; } } } fn float_width(llt: TypeRef) -> uint { - ret alt llvm::LLVMGetTypeKind(llt) as int { + return alt llvm::LLVMGetTypeKind(llt) as int { 1 { 32u } 2 { 64u } 3 { 80u } @@ -1116,7 +1116,7 @@ fn fn_ty_param_tys(fn_ty: TypeRef) -> ~[TypeRef] unsafe { let args = vec::from_elem(llvm::LLVMCountParamTypes(fn_ty) as uint, 0 as TypeRef); llvm::LLVMGetParamTypes(fn_ty, vec::unsafe::to_ptr(args)); - ret args; + return args; } @@ -1133,7 +1133,7 @@ type target_data = {lltd: TargetDataRef, dtor: @target_data_res}; fn mk_target_data(string_rep: ~str) -> target_data { let lltd = str::as_c_str(string_rep, |buf| llvm::LLVMCreateTargetData(buf) ); - ret {lltd: lltd, dtor: @target_data_res(lltd)}; + return {lltd: lltd, dtor: @target_data_res(lltd)}; } /* Memory-managed interface to pass managers. */ @@ -1148,7 +1148,7 @@ type pass_manager = {llpm: PassManagerRef, dtor: @pass_manager_res}; fn mk_pass_manager() -> pass_manager { let llpm = llvm::LLVMCreatePassManager(); - ret {llpm: llpm, dtor: @pass_manager_res(llpm)}; + return {llpm: llpm, dtor: @pass_manager_res(llpm)}; } /* Memory-managed interface to object files. */ @@ -1163,8 +1163,8 @@ type object_file = {llof: ObjectFileRef, dtor: @object_file_res}; fn mk_object_file(llmb: MemoryBufferRef) -> option<object_file> { let llof = llvm::LLVMCreateObjectFile(llmb); - if llof as int == 0 { ret option::none::<object_file>; } - ret option::some({llof: llof, dtor: @object_file_res(llof)}); + if llof as int == 0 { return option::none::<object_file>; } + return option::some({llof: llof, dtor: @object_file_res(llof)}); } /* Memory-managed interface to section iterators. */ @@ -1179,7 +1179,7 @@ type section_iter = {llsi: SectionIteratorRef, dtor: @section_iter_res}; fn mk_section_iter(llof: ObjectFileRef) -> section_iter { let llsi = llvm::LLVMGetSections(llof); - ret {llsi: llsi, dtor: @section_iter_res(llsi)}; + return {llsi: llsi, dtor: @section_iter_res(llsi)}; } // diff --git a/src/rustc/metadata/common.rs b/src/rustc/metadata/common.rs index 946f3c764fa..8f97c204611 100644 --- a/src/rustc/metadata/common.rs +++ b/src/rustc/metadata/common.rs @@ -127,12 +127,14 @@ enum astencode_tag { // Reserves 0x50 -- 0x6f } // djb's cdb hashes. -fn hash_node_id(&&node_id: int) -> uint { ret 177573u ^ (node_id as uint); } +fn hash_node_id(&&node_id: int) -> uint { + return 177573u ^ (node_id as uint); +} fn hash_path(&&s: ~str) -> uint { let mut h = 5381u; for str::each(s) |ch| { h = (h << 5u) + h ^ (ch as uint); } - ret h; + return h; } type link_meta = {name: @~str, vers: @~str, extras_hash: ~str}; diff --git a/src/rustc/metadata/creader.rs b/src/rustc/metadata/creader.rs index d0f8ac2747d..06eb2bea3d2 100644 --- a/src/rustc/metadata/creader.rs +++ b/src/rustc/metadata/creader.rs @@ -116,7 +116,7 @@ fn visit_item(e: env, i: @ast::item) { alt attr::foreign_abi(i.attrs) { either::right(abi) { if abi != ast::foreign_abi_cdecl && - abi != ast::foreign_abi_stdcall { ret; } + abi != ast::foreign_abi_stdcall { return; } } either::left(msg) { e.diag.span_fatal(i.span, msg); } } @@ -177,10 +177,10 @@ fn existing_match(e: env, metas: ~[@ast::meta_item], hash: ~str) -> for e.crate_cache.each |c| { if loader::metadata_matches(*c.metas, metas) && (hash.is_empty() || *c.hash == hash) { - ret some(c.cnum); + return some(c.cnum); } } - ret none; + return none; } fn resolve_crate(e: env, ident: ast::ident, metas: ~[@ast::meta_item], @@ -228,10 +228,10 @@ fn resolve_crate(e: env, ident: ast::ident, metas: ~[@ast::meta_item], let cstore = e.cstore; cstore::set_crate_data(cstore, cnum, cmeta); cstore::add_used_crate_file(cstore, cfilename); - ret cnum; + return cnum; } some(cnum) { - ret cnum; + return cnum; } } } @@ -266,7 +266,7 @@ fn resolve_crate_deps(e: env, cdata: @~[u8]) -> cstore::cnum_map { } } } - ret cnum_map; + return cnum_map; } // Local Variables: diff --git a/src/rustc/metadata/csearch.rs b/src/rustc/metadata/csearch.rs index 91a22b9fe2f..9e2b7c174ef 100644 --- a/src/rustc/metadata/csearch.rs +++ b/src/rustc/metadata/csearch.rs @@ -35,12 +35,12 @@ export maybe_get_item_ast, found_ast, found, found_parent, not_found; fn get_symbol(cstore: cstore::cstore, def: ast::def_id) -> ~str { let cdata = cstore::get_crate_data(cstore, def.crate).data; - ret decoder::get_symbol(cdata, def.node); + return decoder::get_symbol(cdata, def.node); } fn get_type_param_count(cstore: cstore::cstore, def: ast::def_id) -> uint { let cdata = cstore::get_crate_data(cstore, def.crate).data; - ret decoder::get_type_param_count(cdata, def.node); + return decoder::get_type_param_count(cdata, def.node); } fn lookup_defs(cstore: cstore::cstore, cnum: ast::crate_num, @@ -51,7 +51,7 @@ fn lookup_defs(cstore: cstore::cstore, cnum: ast::crate_num, let (c, data, def) = elt; vec::push(result, decoder::lookup_def(c, data, def)); } - ret result; + return result; } fn lookup_method_purity(cstore: cstore::cstore, did: ast::def_id) @@ -83,7 +83,7 @@ fn resolve_path(cstore: cstore::cstore, cnum: ast::crate_num, } } } - ret result; + return result; } /// Iterates over all the paths in the given crate. @@ -125,7 +125,7 @@ fn get_enum_variants(tcx: ty::ctxt, def: ast::def_id) -> ~[ty::variant_info] { let cstore = tcx.cstore; let cdata = cstore::get_crate_data(cstore, def.crate); - ret decoder::get_enum_variants(cdata, def.node, tcx) + return decoder::get_enum_variants(cdata, def.node, tcx) } fn get_impls_for_mod(cstore: cstore::cstore, def: ast::def_id, @@ -147,7 +147,7 @@ fn get_method_names_if_trait(cstore: cstore::cstore, def: ast::def_id) -> option<@dvec<@~str>> { let cdata = cstore::get_crate_data(cstore, def.crate); - ret decoder::get_method_names_if_trait(cdata, def.node); + return decoder::get_method_names_if_trait(cdata, def.node); } fn get_item_attrs(cstore: cstore::cstore, @@ -173,7 +173,7 @@ fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_bounds_and_ty { fn get_region_param(cstore: metadata::cstore::cstore, def: ast::def_id) -> bool { let cdata = cstore::get_crate_data(cstore, def.crate); - ret decoder::get_region_param(cdata, def.node); + return decoder::get_region_param(cdata, def.node); } fn get_field_type(tcx: ty::ctxt, class_id: ast::def_id, @@ -193,7 +193,7 @@ fn get_field_type(tcx: ty::ctxt, class_id: ast::def_id, class_id, def} ); debug!{"got field data %?", the_field}; let ty = decoder::item_type(def, the_field, tcx, cdata); - ret {bounds: @~[], rp: false, ty: ty}; + return {bounds: @~[], rp: false, ty: ty}; } // Given a def_id for an impl or class, return the traits it implements, diff --git a/src/rustc/metadata/cstore.rs b/src/rustc/metadata/cstore.rs index fd541c33d2d..dce5a108a03 100644 --- a/src/rustc/metadata/cstore.rs +++ b/src/rustc/metadata/cstore.rs @@ -71,7 +71,7 @@ fn mk_cstore() -> cstore { let meta_cache = map::int_hash::<crate_metadata>(); let crate_map = map::int_hash::<ast::crate_num>(); let mod_path_map = new_def_hash(); - ret private(@{metas: meta_cache, + return private(@{metas: meta_cache, use_crate_map: crate_map, mod_path_map: mod_path_map, mut used_crate_files: ~[], @@ -80,17 +80,17 @@ fn mk_cstore() -> cstore { } fn get_crate_data(cstore: cstore, cnum: ast::crate_num) -> crate_metadata { - ret p(cstore).metas.get(cnum); + return p(cstore).metas.get(cnum); } fn get_crate_hash(cstore: cstore, cnum: ast::crate_num) -> @~str { let cdata = get_crate_data(cstore, cnum); - ret decoder::get_crate_hash(cdata.data); + return decoder::get_crate_hash(cdata.data); } fn get_crate_vers(cstore: cstore, cnum: ast::crate_num) -> @~str { let cdata = get_crate_data(cstore, cnum); - ret decoder::get_crate_vers(cdata.data); + return decoder::get_crate_vers(cdata.data); } fn set_crate_data(cstore: cstore, cnum: ast::crate_num, @@ -104,7 +104,7 @@ fn set_crate_data(cstore: cstore, cnum: ast::crate_num, } fn have_crate_data(cstore: cstore, cnum: ast::crate_num) -> bool { - ret p(cstore).metas.contains_key(cnum); + return p(cstore).metas.contains_key(cnum); } fn iter_crate_data(cstore: cstore, i: fn(ast::crate_num, crate_metadata)) { @@ -118,19 +118,19 @@ fn add_used_crate_file(cstore: cstore, lib: ~str) { } fn get_used_crate_files(cstore: cstore) -> ~[~str] { - ret p(cstore).used_crate_files; + return p(cstore).used_crate_files; } fn add_used_library(cstore: cstore, lib: ~str) -> bool { assert lib != ~""; - if vec::contains(p(cstore).used_libraries, lib) { ret false; } + if vec::contains(p(cstore).used_libraries, lib) { return false; } vec::push(p(cstore).used_libraries, lib); - ret true; + return true; } fn get_used_libraries(cstore: cstore) -> ~[~str] { - ret p(cstore).used_libraries; + return p(cstore).used_libraries; } fn add_used_link_args(cstore: cstore, args: ~str) { @@ -138,7 +138,7 @@ fn add_used_link_args(cstore: cstore, args: ~str) { } fn get_used_link_args(cstore: cstore) -> ~[~str] { - ret p(cstore).used_link_args; + return p(cstore).used_link_args; } fn add_use_stmt_cnum(cstore: cstore, use_id: ast::node_id, @@ -164,15 +164,15 @@ fn get_dep_hashes(cstore: cstore) -> ~[@~str] { vec::push(result, {name: @cdata.name, hash: hash}); }; fn lteq(a: crate_hash, b: crate_hash) -> bool { - ret *a.name <= *b.name; + return *a.name <= *b.name; } let sorted = std::sort::merge_sort(lteq, result); debug!{"sorted:"}; for sorted.each |x| { debug!{" hash[%s]: %s", *x.name, *x.hash}; } - fn mapper(ch: crate_hash) -> @~str { ret ch.hash; } - ret vec::map(sorted, mapper); + fn mapper(ch: crate_hash) -> @~str { return ch.hash; } + return vec::map(sorted, mapper); } fn get_path(cstore: cstore, d: ast::def_id) -> ~[ast::ident] { diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs index 37da481a82d..f8252a04ed0 100644 --- a/src/rustc/metadata/decoder.rs +++ b/src/rustc/metadata/decoder.rs @@ -75,7 +75,7 @@ fn lookup_hash(d: ebml::doc, eq_fn: fn(x:&[u8]) -> bool, hash: uint) -> for ebml::tagged_docs(bucket, belt) |elt| { let pos = io::u64_from_be_bytes(*elt.data, elt.start, 4u) as uint; if eq_fn(vec::slice(*elt.data, elt.start + 4u, elt.end)) { - ret some(ebml::doc_at(d.data, pos).doc); + return some(ebml::doc_at(d.data, pos).doc); } }; none @@ -83,7 +83,7 @@ fn lookup_hash(d: ebml::doc, eq_fn: fn(x:&[u8]) -> bool, hash: uint) -> fn maybe_find_item(item_id: int, items: ebml::doc) -> option<ebml::doc> { fn eq_item(bytes: &[u8], item_id: int) -> bool { - ret io::u64_from_be_bytes(vec::slice(bytes, 0u, 4u), 0u, 4u) as int + return io::u64_from_be_bytes(vec::slice(bytes, 0u, 4u), 0u, 4u) as int == item_id; } lookup_hash(items, @@ -92,7 +92,7 @@ fn maybe_find_item(item_id: int, items: ebml::doc) -> option<ebml::doc> { } fn find_item(item_id: int, items: ebml::doc) -> ebml::doc { - ret option::get(maybe_find_item(item_id, items)); + return option::get(maybe_find_item(item_id, items)); } // Looks up an item in the given metadata and returns an ebml doc pointing @@ -112,12 +112,12 @@ fn item_family(item: ebml::doc) -> char { fn item_symbol(item: ebml::doc) -> ~str { let sym = ebml::get_doc(item, tag_items_data_item_symbol); - ret str::from_bytes(ebml::doc_data(sym)); + return str::from_bytes(ebml::doc_data(sym)); } fn item_parent_item(d: ebml::doc) -> option<ast::def_id> { for ebml::tagged_docs(d, tag_items_data_parent_item) |did| { - ret some(ebml::with_doc_data(did, |d| parse_def_id(d))); + return some(ebml::with_doc_data(did, |d| parse_def_id(d))); } none } @@ -125,7 +125,7 @@ fn item_parent_item(d: ebml::doc) -> option<ast::def_id> { // XXX: This has nothing to do with classes. fn class_member_id(d: ebml::doc, cdata: cmd) -> ast::def_id { let tagdoc = ebml::get_doc(d, tag_def_id); - ret translate_def_id(cdata, ebml::with_doc_data(tagdoc, + return translate_def_id(cdata, ebml::with_doc_data(tagdoc, |d| parse_def_id(d))); } @@ -204,7 +204,7 @@ fn enum_variant_ids(item: ebml::doc, cdata: cmd) -> ~[ast::def_id] { let ext = ebml::with_doc_data(p, |d| parse_def_id(d)); vec::push(ids, {crate: cdata.cnum, node: ext.node}); }; - ret ids; + return ids; } // Given a path and serialized crate metadata, returns the IDs of the @@ -215,16 +215,16 @@ fn resolve_path(path: ~[ast::ident], data: @~[u8]) -> ~[ast::def_id] { let data_len = data.len(); let s_len = s.len(); if data_len != s_len { - ret false; + return false; } let mut i = 0; while i < data_len { if data[i] != s[i] { - ret false; + return false; } i += 1; } - ret true; + return true; } let s = ast_util::path_name_i(path); let md = ebml::doc(data); @@ -236,7 +236,7 @@ fn resolve_path(path: ~[ast::ident], data: @~[u8]) -> ~[ast::def_id] { let did_doc = ebml::get_doc(doc, tag_def_id); vec::push(result, ebml::with_doc_data(did_doc, |d| parse_def_id(d))); } - ret result; + return result; } fn item_path(item_doc: ebml::doc) -> ast_map::path { @@ -260,7 +260,7 @@ fn item_path(item_doc: ebml::doc) -> ast_map::path { } } - ret result; + return result; } fn item_name(item: ebml::doc) -> ast::ident { @@ -304,7 +304,7 @@ fn lookup_def(cnum: ast::crate_num, data: @~[u8], did_: ast::def_id) -> let item = lookup_item(did_.node, data); let did = {crate: cnum, node: did_.node}; // We treat references to enums as references to types. - ret def_like_to_def(item_to_def_like(item, did, cnum)); + return def_like_to_def(item_to_def_like(item, did, cnum)); } fn get_type(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) @@ -316,12 +316,12 @@ fn get_type(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) item_ty_param_bounds(item, tcx, cdata) } else { @~[] }; let rp = item_ty_region_param(item); - ret {bounds: tp_bounds, rp: rp, ty: t}; + return {bounds: tp_bounds, rp: rp, ty: t}; } fn get_region_param(cdata: cmd, id: ast::node_id) -> bool { let item = lookup_item(id, cdata.data); - ret item_ty_region_param(item); + return item_ty_region_param(item); } fn get_type_param_count(data: @~[u8], id: ast::node_id) -> uint { @@ -382,7 +382,7 @@ fn class_dtor(cdata: cmd, id: ast::node_id) -> option<ast::def_id> { } fn get_symbol(data: @~[u8], id: ast::node_id) -> ~str { - ret item_symbol(lookup_item(id, data)); + return item_symbol(lookup_item(id, data)); } // Something that a name can resolve to. @@ -394,7 +394,7 @@ enum def_like { fn def_like_to_def(def_like: def_like) -> ast::def { alt def_like { - dl_def(def) { ret def; } + dl_def(def) { return def; } dl_impl(*) { fail ~"found impl in def_like_to_def"; } dl_field { fail ~"found field in def_like_to_def"; } } @@ -445,7 +445,7 @@ fn each_path(cdata: cmd, f: fn(path_entry) -> bool) { // If broken, stop here. if broken { - ret; + return; } // Next, go through all the paths. We will find items that we didn't know @@ -561,7 +561,7 @@ fn get_enum_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) id: did, disr_val: disr_val}); disr_val += 1; } - ret infos; + return infos; } // NB: These types are duplicated in resolve.rs @@ -591,10 +591,10 @@ fn get_self_ty(item: ebml::doc) -> ast::self_ty_ { let self_ty_kind = string[0]; alt self_ty_kind as char { - 'r' => { ret ast::sty_by_ref; } - 'v' => { ret ast::sty_value; } - '@' => { ret ast::sty_box(get_mutability(string[1])); } - '~' => { ret ast::sty_uniq(get_mutability(string[1])); } + 'r' => { return ast::sty_by_ref; } + 'v' => { return ast::sty_value; } + '@' => { return ast::sty_box(get_mutability(string[1])); } + '~' => { return ast::sty_uniq(get_mutability(string[1])); } '&' => { let mutability = get_mutability(string[1]); @@ -609,7 +609,7 @@ fn get_self_ty(item: ebml::doc) -> ast::self_ty_ { region = ast::re_named(@region_string); } - ret ast::sty_region(@{ id: 0, node: region }, mutability); + return ast::sty_region(@{ id: 0, node: region }, mutability); } _ => { fail fmt!{"unknown self type code: `%c`", self_ty_kind as char}; @@ -698,14 +698,14 @@ fn get_method_names_if_trait(cdata: cmd, node_id: ast::node_id) let item = lookup_item(node_id, cdata.data); if item_family(item) != 'I' { - ret none; + return none; } let resulting_method_names = @dvec(); for ebml::tagged_docs(item, tag_item_trait_method) |method| { (*resulting_method_names).push(item_name(method)); } - ret some(resulting_method_names); + return some(resulting_method_names); } fn get_item_attrs(cdata: cmd, @@ -769,39 +769,39 @@ fn read_path(d: ebml::doc) -> {path: ~str, pos: uint} { let pos = io::u64_from_be_bytes(desc, 0u, 4u) as uint; let pathbytes = vec::slice::<u8>(desc, 4u, vec::len::<u8>(desc)); let path = str::from_bytes(pathbytes); - ret {path: path, pos: pos}; + return {path: path, pos: pos}; } fn describe_def(items: ebml::doc, id: ast::def_id) -> ~str { - if id.crate != ast::local_crate { ret ~"external"; } + if id.crate != ast::local_crate { return ~"external"; } let it = alt maybe_find_item(id.node, items) { some(it) { it } none { fail (fmt!{"describe_def: item not found %?", id}); } }; - ret item_family_to_str(item_family(it)); + return item_family_to_str(item_family(it)); } fn item_family_to_str(fam: char) -> ~str { alt check fam { - 'c' { ret ~"const"; } - 'f' { ret ~"fn"; } - 'u' { ret ~"unsafe fn"; } - 'p' { ret ~"pure fn"; } - 'F' { ret ~"foreign fn"; } - 'U' { ret ~"unsafe foreign fn"; } - 'P' { ret ~"pure foreign fn"; } - 'y' { ret ~"type"; } - 'T' { ret ~"foreign type"; } - 't' { ret ~"type"; } - 'm' { ret ~"mod"; } - 'n' { ret ~"foreign mod"; } - 'v' { ret ~"enum"; } - 'i' { ret ~"impl"; } - 'I' { ret ~"trait"; } - 'C' { ret ~"class"; } - 'S' { ret ~"struct"; } - 'g' { ret ~"public field"; } - 'j' { ret ~"private field"; } + 'c' { return ~"const"; } + 'f' { return ~"fn"; } + 'u' { return ~"unsafe fn"; } + 'p' { return ~"pure fn"; } + 'F' { return ~"foreign fn"; } + 'U' { return ~"unsafe foreign fn"; } + 'P' { return ~"pure foreign fn"; } + 'y' { return ~"type"; } + 'T' { return ~"foreign type"; } + 't' { return ~"type"; } + 'm' { return ~"mod"; } + 'n' { return ~"foreign mod"; } + 'v' { return ~"enum"; } + 'i' { return ~"impl"; } + 'I' { return ~"trait"; } + 'C' { return ~"class"; } + 'S' { return ~"struct"; } + 'g' { return ~"public field"; } + 'j' { return ~"private field"; } } } @@ -827,7 +827,7 @@ fn get_meta_items(md: ebml::doc) -> ~[@ast::meta_item] { let subitems = get_meta_items(meta_item_doc); vec::push(items, attr::mk_list_item(@n, subitems)); }; - ret items; + return items; } fn get_attributes(md: ebml::doc) -> ~[ast::attribute] { @@ -848,7 +848,7 @@ fn get_attributes(md: ebml::doc) -> ~[ast::attribute] { } option::none { } } - ret attrs; + return attrs; } fn list_meta_items(meta_items: ebml::doc, out: io::writer) { @@ -868,7 +868,7 @@ fn list_crate_attributes(md: ebml::doc, hash: @~str, out: io::writer) { } fn get_crate_attributes(data: @~[u8]) -> ~[ast::attribute] { - ret get_attributes(ebml::doc(data)); + return get_attributes(ebml::doc(data)); } type crate_dep = {cnum: ast::crate_num, name: ast::ident, @@ -889,7 +889,7 @@ fn get_crate_deps(data: @~[u8]) -> ~[crate_dep] { hash: @docstr(depdoc, tag_crate_dep_hash)}); crate_num += 1; }; - ret deps; + return deps; } fn list_crate_deps(data: @~[u8], out: io::writer) { @@ -906,12 +906,12 @@ fn list_crate_deps(data: @~[u8], out: io::writer) { fn get_crate_hash(data: @~[u8]) -> @~str { let cratedoc = ebml::doc(data); let hashdoc = ebml::get_doc(cratedoc, tag_crate_hash); - ret @str::from_bytes(ebml::doc_data(hashdoc)); + return @str::from_bytes(ebml::doc_data(hashdoc)); } fn get_crate_vers(data: @~[u8]) -> @~str { let attrs = decoder::get_crate_attributes(data); - ret alt attr::last_meta_item_value_str_by_name( + return alt attr::last_meta_item_value_str_by_name( attr::find_linkage_metas(attrs), ~"vers") { some(ver) { ver } none { @~"0.0" } @@ -968,7 +968,7 @@ fn get_crate_module_paths(bytes: @~[u8]) -> ~[(ast::def_id, ~str)] { // unified later by using the mods map vec::push(res, (did, path)); } - ret do vec::filter(res) |x| { + return do vec::filter(res) |x| { let (_, xp) = x; mods.contains_key(xp) } @@ -989,11 +989,11 @@ fn list_crate_metadata(bytes: @~[u8], out: io::writer) { // crate to the correct local crate number. fn translate_def_id(cdata: cmd, did: ast::def_id) -> ast::def_id { if did.crate == ast::local_crate { - ret {crate: cdata.cnum, node: did.node}; + return {crate: cdata.cnum, node: did.node}; } alt cdata.cnum_map.find(did.crate) { - option::some(n) { ret {crate: n, node: did.node}; } + option::some(n) { return {crate: n, node: did.node}; } option::none { fail ~"didn't find a crate in the cnum_map"; } } } diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs index c82869d164c..6dd4e0142de 100644 --- a/src/rustc/metadata/encoder.rs +++ b/src/rustc/metadata/encoder.rs @@ -248,7 +248,7 @@ fn encode_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt, crate: @crate) encode_module_item_paths(ebml_w, ecx, crate.node.module, path, index); encode_reexport_paths(ebml_w, ecx, index); ebml_w.end_tag(); - ret index; + return index; } fn encode_reexport_paths(ebml_w: ebml::writer, @@ -273,7 +273,7 @@ fn encode_family(ebml_w: ebml::writer, c: char) { ebml_w.end_tag(); } -fn def_to_str(did: def_id) -> ~str { ret fmt!{"%d:%d", did.crate, did.node}; } +fn def_to_str(did: def_id) -> ~str { fmt!{"%d:%d", did.crate, did.node} } fn encode_type_param_bounds(ebml_w: ebml::writer, ecx: @encode_ctxt, params: ~[ty_param]) { @@ -617,7 +617,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item, false } }; - if !must_write && !reachable(ecx, item.id) { ret; } + if !must_write && !reachable(ecx, item.id) { return; } fn add_to_index_(item: @item, ebml_w: ebml::writer, index: @mut ~[entry<int>]) { @@ -854,7 +854,7 @@ fn encode_info_for_foreign_item(ecx: @encode_ctxt, ebml_w: ebml::writer, nitem: @foreign_item, index: @mut ~[entry<int>], path: ast_map::path, abi: foreign_abi) { - if !reachable(ecx, nitem.id) { ret; } + if !reachable(ecx, nitem.id) { return; } vec::push(*index, {val: nitem.id, pos: ebml_w.writer.tell()}); ebml_w.start_tag(tag_items_data_item); @@ -922,7 +922,7 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer, with *visit::default_visitor() })); ebml_w.end_tag(); - ret *index; + return *index; } @@ -941,7 +941,7 @@ fn create_index<T: copy>(index: ~[entry<T>], hash_fn: fn@(T) -> uint) -> for buckets.each |bucket| { vec::push(buckets_frozen, @*bucket); } - ret buckets_frozen; + return buckets_frozen; } fn encode_index<T>(ebml_w: ebml::writer, buckets: ~[@~[entry<T>]], @@ -1047,7 +1047,7 @@ fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> ~[attribute] { let meta_items = vec::append(~[name_item, vers_item], other_items); let link_item = attr::mk_list_item(@~"link", meta_items); - ret attr::mk_attr(link_item); + return attr::mk_attr(link_item); } let mut attrs: ~[attribute] = ~[]; @@ -1070,7 +1070,7 @@ fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> ~[attribute] { if !found_link_attr { vec::push(attrs, synthesize_link_attr(ecx, ~[])); } - ret attrs; + return attrs; } fn encode_crate_deps(ebml_w: ebml::writer, cstore: cstore::cstore) { @@ -1100,7 +1100,7 @@ fn encode_crate_deps(ebml_w: ebml::writer, cstore: cstore::cstore) { } // mut -> immutable hack for vec::map - ret vec::slice(deps, 0u, vec::len(deps)); + return vec::slice(deps, 0u, vec::len(deps)); } // We're just going to write a list of crate 'name-hash-version's, with @@ -1189,7 +1189,7 @@ fn encoded_ty(tcx: ty::ctxt, t: ty::t) -> ~str { abbrevs: tyencode::ac_no_abbrevs}; let buf = io::mem_buffer(); tyencode::enc_ty(io::mem_buffer_writer(buf), cx, t); - ret io::mem_buffer_str(buf); + return io::mem_buffer_str(buf); } diff --git a/src/rustc/metadata/filesearch.rs b/src/rustc/metadata/filesearch.rs index 6bd002c356e..65dd8a5a3e8 100644 --- a/src/rustc/metadata/filesearch.rs +++ b/src/rustc/metadata/filesearch.rs @@ -85,7 +85,7 @@ fn search<T: copy>(filesearch: filesearch, pick: pick<T>) -> option<T> { } if option::is_some(rslt) { break; } } - ret rslt; + return rslt; } fn relative_target_lib_path(target_triple: ~str) -> ~[path] { @@ -97,7 +97,7 @@ fn make_target_lib_path(sysroot: path, let path = vec::append(~[sysroot], relative_target_lib_path(target_triple)); let path = path::connect_many(path); - ret path; + return path; } fn get_default_sysroot() -> path { diff --git a/src/rustc/metadata/loader.rs b/src/rustc/metadata/loader.rs index 12d47cb86cf..c3949acb0af 100644 --- a/src/rustc/metadata/loader.rs +++ b/src/rustc/metadata/loader.rs @@ -38,7 +38,7 @@ type ctxt = { fn load_library_crate(cx: ctxt) -> {ident: ~str, data: @~[u8]} { alt find_library_crate(cx) { - some(t) { ret t; } + some(t) { return t; } none { cx.diag.span_fatal( cx.span, fmt!{"can't find crate for `%s`", *cx.ident}); @@ -52,12 +52,12 @@ fn find_library_crate(cx: ctxt) -> option<{ident: ~str, data: @~[u8]}> { } fn libname(cx: ctxt) -> {prefix: ~str, suffix: ~str} { - if cx.static { ret {prefix: ~"lib", suffix: ~".rlib"}; } + if cx.static { return {prefix: ~"lib", suffix: ~".rlib"}; } alt cx.os { - os_win32 { ret {prefix: ~"", suffix: ~".dll"}; } - os_macos { ret {prefix: ~"lib", suffix: ~".dylib"}; } - os_linux { ret {prefix: ~"lib", suffix: ~".so"}; } - os_freebsd { ret {prefix: ~"lib", suffix: ~".so"}; } + os_win32 { return {prefix: ~"", suffix: ~".dll"}; } + os_macos { return {prefix: ~"lib", suffix: ~".dylib"}; } + os_linux { return {prefix: ~"lib", suffix: ~".so"}; } + os_freebsd { return {prefix: ~"lib", suffix: ~".so"}; } } } @@ -143,7 +143,7 @@ fn crate_matches(crate_data: @~[u8], metas: ~[@ast::meta_item], let linkage_metas = attr::find_linkage_metas(attrs); if hash.is_not_empty() { let chash = decoder::get_crate_hash(crate_data); - if *chash != hash { ret false; } + if *chash != hash { return false; } } metadata_matches(linkage_metas, metas) } @@ -163,10 +163,10 @@ fn metadata_matches(extern_metas: ~[@ast::meta_item], debug!{"looking for %s", pprust::meta_item_to_str(*needed)}; if !attr::contains(extern_metas, needed) { debug!{"missing %s", pprust::meta_item_to_str(*needed)}; - ret false; + return false; } } - ret true; + return true; } fn get_metadata_section(os: os, @@ -174,10 +174,10 @@ fn get_metadata_section(os: os, let mb = str::as_c_str(filename, |buf| { llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf) }); - if mb as int == 0 { ret option::none::<@~[u8]>; } + if mb as int == 0 { return option::none::<@~[u8]>; } let of = alt mk_object_file(mb) { option::some(of) { of } - _ { ret option::none::<@~[u8]>; } + _ { return option::none::<@~[u8]>; } }; let si = mk_section_iter(of.llof); while llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False { @@ -188,12 +188,12 @@ fn get_metadata_section(os: os, let csz = llvm::LLVMGetSectionSize(si.llsi) as uint; unsafe { let cvbuf: *u8 = unsafe::reinterpret_cast(cbuf); - ret some(@vec::unsafe::from_buf(cvbuf, csz)); + return some(@vec::unsafe::from_buf(cvbuf, csz)); } } llvm::LLVMMoveToNextSection(si.llsi); } - ret option::none::<@~[u8]>; + return option::none::<@~[u8]>; } fn meta_section_name(os: os) -> ~str { diff --git a/src/rustc/metadata/tydecode.rs b/src/rustc/metadata/tydecode.rs index fad9d2d942f..df7bea1bd0e 100644 --- a/src/rustc/metadata/tydecode.rs +++ b/src/rustc/metadata/tydecode.rs @@ -26,18 +26,18 @@ fn peek(st: @pstate) -> char { fn next(st: @pstate) -> char { let ch = st.data[st.pos] as char; st.pos = st.pos + 1u; - ret ch; + return ch; } fn next_byte(st: @pstate) -> u8 { let b = st.data[st.pos]; st.pos = st.pos + 1u; - ret b; + return b; } fn parse_ident(st: @pstate, last: char) -> ast::ident { - fn is_last(b: char, c: char) -> bool { ret c == b; } - ret parse_ident_(st, |a| is_last(last, a) ); + fn is_last(b: char, c: char) -> bool { return c == b; } + return parse_ident_(st, |a| is_last(last, a) ); } fn parse_ident_(st: @pstate, is_last: fn@(char) -> bool) -> @@ -46,7 +46,7 @@ fn parse_ident_(st: @pstate, is_last: fn@(char) -> bool) -> while !is_last(peek(st)) { rslt += str::from_byte(next_byte(st)); } - ret @rslt; + return @rslt; } @@ -65,14 +65,14 @@ fn parse_ret_ty(st: @pstate, conv: conv_did) -> (ast::ret_style, ty::t) { fn parse_path(st: @pstate) -> @ast::path { let mut idents: ~[ast::ident] = ~[]; - fn is_last(c: char) -> bool { ret c == '(' || c == ':'; } + fn is_last(c: char) -> bool { return c == '(' || c == ':'; } vec::push(idents, parse_ident_(st, is_last)); loop { alt peek(st) { ':' { next(st); next(st); } c { if c == '(' { - ret @{span: ast_util::dummy_sp(), + return @{span: ast_util::dummy_sp(), global: false, idents: idents, rp: none, types: ~[]}; } else { vec::push(idents, parse_ident_(st, is_last)); } @@ -82,7 +82,7 @@ fn parse_path(st: @pstate) -> @ast::path { } fn parse_ty_rust_fn(st: @pstate, conv: conv_did) -> ty::t { - ret ty::mk_fn(st.tcx, parse_ty_fn(st, conv)); + return ty::mk_fn(st.tcx, parse_ty_fn(st, conv)); } fn parse_proto(c: char) -> ast::proto { @@ -103,7 +103,7 @@ fn parse_vstore(st: @pstate) -> ty::vstore { if '0' <= c && c <= '9' { let n = parse_int(st) as uint; assert next(st) == '|'; - ret ty::vstore_fixed(n); + return ty::vstore_fixed(n); } alt check next(st) { @@ -123,7 +123,7 @@ fn parse_substs(st: @pstate, conv: conv_did) -> ty::substs { while peek(st) != ']' { vec::push(params, parse_ty(st, conv)); } st.pos = st.pos + 1u; - ret {self_r: self_r, + return {self_r: self_r, self_ty: self_ty, tps: params}; } @@ -178,70 +178,70 @@ fn parse_str(st: @pstate, term: char) -> ~str { result += str::from_byte(next_byte(st)); } next(st); - ret result; + return result; } fn parse_ty(st: @pstate, conv: conv_did) -> ty::t { alt check next(st) { - 'n' { ret ty::mk_nil(st.tcx); } - 'z' { ret ty::mk_bot(st.tcx); } - 'b' { ret ty::mk_bool(st.tcx); } - 'i' { ret ty::mk_int(st.tcx); } - 'u' { ret ty::mk_uint(st.tcx); } - 'l' { ret ty::mk_float(st.tcx); } + 'n' { return ty::mk_nil(st.tcx); } + 'z' { return ty::mk_bot(st.tcx); } + 'b' { return ty::mk_bool(st.tcx); } + 'i' { return ty::mk_int(st.tcx); } + 'u' { return ty::mk_uint(st.tcx); } + 'l' { return ty::mk_float(st.tcx); } 'M' { alt check next(st) { - 'b' { ret ty::mk_mach_uint(st.tcx, ast::ty_u8); } - 'w' { ret ty::mk_mach_uint(st.tcx, ast::ty_u16); } - 'l' { ret ty::mk_mach_uint(st.tcx, ast::ty_u32); } - 'd' { ret ty::mk_mach_uint(st.tcx, ast::ty_u64); } - 'B' { ret ty::mk_mach_int(st.tcx, ast::ty_i8); } - 'W' { ret ty::mk_mach_int(st.tcx, ast::ty_i16); } - 'L' { ret ty::mk_mach_int(st.tcx, ast::ty_i32); } - 'D' { ret ty::mk_mach_int(st.tcx, ast::ty_i64); } - 'f' { ret ty::mk_mach_float(st.tcx, ast::ty_f32); } - 'F' { ret ty::mk_mach_float(st.tcx, ast::ty_f64); } + 'b' { return ty::mk_mach_uint(st.tcx, ast::ty_u8); } + 'w' { return ty::mk_mach_uint(st.tcx, ast::ty_u16); } + 'l' { return ty::mk_mach_uint(st.tcx, ast::ty_u32); } + 'd' { return ty::mk_mach_uint(st.tcx, ast::ty_u64); } + 'B' { return ty::mk_mach_int(st.tcx, ast::ty_i8); } + 'W' { return ty::mk_mach_int(st.tcx, ast::ty_i16); } + 'L' { return ty::mk_mach_int(st.tcx, ast::ty_i32); } + 'D' { return ty::mk_mach_int(st.tcx, ast::ty_i64); } + 'f' { return ty::mk_mach_float(st.tcx, ast::ty_f32); } + 'F' { return ty::mk_mach_float(st.tcx, ast::ty_f64); } } } - 'c' { ret ty::mk_char(st.tcx); } + 'c' { return ty::mk_char(st.tcx); } 't' { assert (next(st) == '['); let def = parse_def(st, conv); let substs = parse_substs(st, conv); assert next(st) == ']'; - ret ty::mk_enum(st.tcx, def, substs); + return ty::mk_enum(st.tcx, def, substs); } 'x' { assert next(st) == '['; let def = parse_def(st, conv); let substs = parse_substs(st, conv); assert next(st) == ']'; - ret ty::mk_trait(st.tcx, def, substs); + return ty::mk_trait(st.tcx, def, substs); } 'p' { let did = parse_def(st, conv); - ret ty::mk_param(st.tcx, parse_int(st) as uint, did); + return ty::mk_param(st.tcx, parse_int(st) as uint, did); } 's' { - ret ty::mk_self(st.tcx); + return ty::mk_self(st.tcx); } - '@' { ret ty::mk_box(st.tcx, parse_mt(st, conv)); } - '~' { ret ty::mk_uniq(st.tcx, parse_mt(st, conv)); } - '*' { ret ty::mk_ptr(st.tcx, parse_mt(st, conv)); } + '@' { return ty::mk_box(st.tcx, parse_mt(st, conv)); } + '~' { return ty::mk_uniq(st.tcx, parse_mt(st, conv)); } + '*' { return ty::mk_ptr(st.tcx, parse_mt(st, conv)); } '&' { let r = parse_region(st); let mt = parse_mt(st, conv); - ret ty::mk_rptr(st.tcx, r, mt); + return ty::mk_rptr(st.tcx, r, mt); } - 'U' { ret ty::mk_unboxed_vec(st.tcx, parse_mt(st, conv)); } + 'U' { return ty::mk_unboxed_vec(st.tcx, parse_mt(st, conv)); } 'V' { let mt = parse_mt(st, conv); let v = parse_vstore(st); - ret ty::mk_evec(st.tcx, mt, v); + return ty::mk_evec(st.tcx, mt, v); } 'v' { let v = parse_vstore(st); - ret ty::mk_estr(st.tcx, v); + return ty::mk_estr(st.tcx, v); } 'R' { assert (next(st) == '['); @@ -251,29 +251,29 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t { vec::push(fields, {ident: name, mt: parse_mt(st, conv)}); } st.pos = st.pos + 1u; - ret ty::mk_rec(st.tcx, fields); + return ty::mk_rec(st.tcx, fields); } 'T' { assert (next(st) == '['); let mut params = ~[]; while peek(st) != ']' { vec::push(params, parse_ty(st, conv)); } st.pos = st.pos + 1u; - ret ty::mk_tup(st.tcx, params); + return ty::mk_tup(st.tcx, params); } 'f' { parse_ty_rust_fn(st, conv) } 'X' { - ret ty::mk_var(st.tcx, ty::tv_vid(parse_int(st) as uint)); + return ty::mk_var(st.tcx, ty::tv_vid(parse_int(st) as uint)); } - 'Y' { ret ty::mk_type(st.tcx); } + 'Y' { return ty::mk_type(st.tcx); } 'C' { let ck = alt check next(st) { '&' { ty::ck_block } '@' { ty::ck_box } '~' { ty::ck_uniq } }; - ret ty::mk_opaque_closure_ptr(st.tcx, ck); + return ty::mk_opaque_closure_ptr(st.tcx, ck); } '#' { let pos = parse_hex(st); @@ -281,12 +281,12 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t { let len = parse_hex(st); assert (next(st) == '#'); alt st.tcx.rcache.find({cnum: st.crate, pos: pos, len: len}) { - some(tt) { ret tt; } + some(tt) { return tt; } none { let ps = @{pos: pos with *st}; let tt = parse_ty(ps, conv); st.tcx.rcache.insert({cnum: st.crate, pos: pos, len: len}, tt); - ret tt; + return tt; } } } @@ -304,7 +304,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t { debug!{"parsed a def_id %?", did}; let substs = parse_substs(st, conv); assert (next(st) == ']'); - ret ty::mk_class(st.tcx, did, substs); + return ty::mk_class(st.tcx, did, substs); } c { error!{"unexpected char in type string: %c", c}; fail;} } @@ -317,21 +317,21 @@ fn parse_mt(st: @pstate, conv: conv_did) -> ty::mt { '?' { next(st); m = ast::m_const; } _ { m = ast::m_imm; } } - ret {ty: parse_ty(st, conv), mutbl: m}; + return {ty: parse_ty(st, conv), mutbl: m}; } fn parse_def(st: @pstate, conv: conv_did) -> ast::def_id { let mut def = ~[]; while peek(st) != '|' { vec::push(def, next_byte(st)); } st.pos = st.pos + 1u; - ret conv(parse_def_id(def)); + return conv(parse_def_id(def)); } fn parse_int(st: @pstate) -> int { let mut n = 0; loop { let cur = peek(st); - if cur < '0' || cur > '9' { ret n; } + if cur < '0' || cur > '9' { return n; } st.pos = st.pos + 1u; n *= 10; n += (cur as int) - ('0' as int); @@ -342,7 +342,7 @@ fn parse_hex(st: @pstate) -> uint { let mut n = 0u; loop { let cur = peek(st); - if (cur < '0' || cur > '9') && (cur < 'a' || cur > 'f') { ret n; } + if (cur < '0' || cur > '9') && (cur < 'a' || cur > 'f') { return n; } st.pos = st.pos + 1u; n *= 16u; if '0' <= cur && cur <= '9' { @@ -378,7 +378,7 @@ fn parse_ty_fn(st: @pstate, conv: conv_did) -> ty::fn_ty { } st.pos += 1u; // eat the ']' let (ret_style, ret_ty) = parse_ret_ty(st, conv); - ret {purity: purity, proto: proto, inputs: inputs, output: ret_ty, + return {purity: purity, proto: proto, inputs: inputs, output: ret_ty, ret_style: ret_style}; } @@ -405,7 +405,7 @@ fn parse_def_id(buf: &[u8]) -> ast::def_id { none { fail (fmt!{"internal error: parse_def_id: id expected, but \ found %?", def_part}); } }; - ret {crate: crate_num, node: def_num}; + return {crate: crate_num, node: def_num}; } fn parse_bounds_data(data: @~[u8], start: uint, diff --git a/src/rustc/metadata/tyencode.rs b/src/rustc/metadata/tyencode.rs index 7bcf6d77841..02a6b0f826a 100644 --- a/src/rustc/metadata/tyencode.rs +++ b/src/rustc/metadata/tyencode.rs @@ -35,8 +35,8 @@ enum abbrev_ctxt { ac_no_abbrevs, ac_use_abbrevs(hashmap<ty::t, ty_abbrev>), } fn cx_uses_abbrevs(cx: @ctxt) -> bool { alt cx.abbrevs { - ac_no_abbrevs { ret false; } - ac_use_abbrevs(_) { ret true; } + ac_no_abbrevs { return false; } + ac_use_abbrevs(_) { return true; } } } @@ -56,7 +56,7 @@ fn enc_ty(w: io::writer, cx: @ctxt, t: ty::t) { } ac_use_abbrevs(abbrevs) { alt abbrevs.find(t) { - some(a) { w.write_str(*a.s); ret; } + some(a) { w.write_str(*a.s); return; } none { let pos = w.tell(); alt ty::type_def_id(t) { @@ -79,7 +79,7 @@ fn enc_ty(w: io::writer, cx: @ctxt, t: ty::t) { let mut n = u; let mut len = 0u; while n != 0u { len += 1u; n = n >> 4u; } - ret len; + return len; } let abbrev_len = 3u + estimate_sz(pos) + estimate_sz(len); if abbrev_len < len { @@ -89,7 +89,7 @@ fn enc_ty(w: io::writer, cx: @ctxt, t: ty::t) { let a = {pos: pos, len: len, s: @s}; abbrevs.insert(t, a); } - ret; + return; } } } diff --git a/src/rustc/middle/astencode.rs b/src/rustc/middle/astencode.rs index 5ec3c3882ac..8f672d19047 100644 --- a/src/rustc/middle/astencode.rs +++ b/src/rustc/middle/astencode.rs @@ -147,12 +147,12 @@ fn decode_inlined_item(cdata: cstore::crate_metadata, fn reserve_id_range(sess: session, from_id_range: ast_util::id_range) -> ast_util::id_range { // Handle the case of an empty range: - if ast_util::empty(from_id_range) { ret from_id_range; } + if ast_util::empty(from_id_range) { return from_id_range; } let cnt = from_id_range.max - from_id_range.min; let to_id_min = sess.parse_sess.next_id; let to_id_max = sess.parse_sess.next_id + cnt; sess.parse_sess.next_id = to_id_max; - ret {min: to_id_min, max: to_id_min}; + return {min: to_id_min, max: to_id_min}; } impl translation_routines for extended_decode_ctxt { @@ -972,7 +972,7 @@ fn test_more() { roundtrip(#ast[item]{ fn foo(x: uint, y: uint) -> uint { let z = x + y; - ret z; + return z; } }); } @@ -983,13 +983,13 @@ fn test_simplification() { let item_in = ast::ii_item(#ast[item] { fn new_int_alist<B: copy>() -> alist<int, B> { fn eq_int(&&a: int, &&b: int) -> bool { a == b } - ret {eq_fn: eq_int, mut data: ~[]}; + return {eq_fn: eq_int, mut data: ~[]}; } }); let item_out = simplify_ast(item_in); let item_exp = ast::ii_item(#ast[item] { fn new_int_alist<B: copy>() -> alist<int, B> { - ret {eq_fn: eq_int, mut data: ~[]}; + return {eq_fn: eq_int, mut data: ~[]}; } }); alt (item_out, item_exp) { diff --git a/src/rustc/middle/borrowck.rs b/src/rustc/middle/borrowck.rs index c94326d668a..3f4a32bff86 100644 --- a/src/rustc/middle/borrowck.rs +++ b/src/rustc/middle/borrowck.rs @@ -267,7 +267,7 @@ fn check_crate(tcx: ty::ctxt, make_stat(bccx, bccx.req_pure_paths)}); } - ret (bccx.root_map, bccx.mutbl_map); + return (bccx.root_map, bccx.mutbl_map); fn make_stat(bccx: borrowck_ctxt, stat: uint) -> ~str { let stat_f = stat as float; @@ -410,12 +410,12 @@ fn save_and_restore<T:copy,U>(&save_and_restore_t: T, f: fn() -> U) -> U { let old_save_and_restore_t = save_and_restore_t; let u <- f(); save_and_restore_t = old_save_and_restore_t; - ret u; + return u; } /// Creates and returns a new root_map fn root_map() -> root_map { - ret hashmap(root_map_key_hash, root_map_key_eq); + return hashmap(root_map_key_hash, root_map_key_eq); fn root_map_key_eq(k1: root_map_key, k2: root_map_key) -> bool { k1.id == k2.id && k1.derefs == k2.derefs diff --git a/src/rustc/middle/borrowck/categorization.rs b/src/rustc/middle/borrowck/categorization.rs index 36b35dbbdbc..ebcb380b4e9 100644 --- a/src/rustc/middle/borrowck/categorization.rs +++ b/src/rustc/middle/borrowck/categorization.rs @@ -133,12 +133,12 @@ impl public_methods for borrowck_ctxt { alt expr.node { ast::expr_unary(ast::deref, e_base) { if self.method_map.contains_key(expr.id) { - ret self.cat_rvalue(expr, expr_ty); + return self.cat_rvalue(expr, expr_ty); } let base_cmt = self.cat_expr(e_base); alt self.cat_deref(expr, base_cmt, 0u, true) { - some(cmt) { ret cmt; } + some(cmt) { return cmt; } none { tcx.sess.span_bug( e_base.span, @@ -150,7 +150,7 @@ impl public_methods for borrowck_ctxt { ast::expr_field(base, f_name, _) { if self.method_map.contains_key(expr.id) { - ret self.cat_method_ref(expr, expr_ty); + return self.cat_method_ref(expr, expr_ty); } let base_cmt = self.cat_autoderef(base); @@ -159,7 +159,7 @@ impl public_methods for borrowck_ctxt { ast::expr_index(base, _) { if self.method_map.contains_key(expr.id) { - ret self.cat_rvalue(expr, expr_ty); + return self.cat_rvalue(expr, expr_ty); } self.cat_index(expr, base) @@ -183,7 +183,7 @@ impl public_methods for borrowck_ctxt { ast::expr_lit(*) | ast::expr_break | ast::expr_mac(*) | ast::expr_again | ast::expr_rec(*) | ast::expr_struct(*) | ast::expr_unary_move(*) { - ret self.cat_rvalue(expr, expr_ty); + return self.cat_rvalue(expr, expr_ty); } } } @@ -297,7 +297,7 @@ impl public_methods for borrowck_ctxt { } fn cat_discr(cmt: cmt, alt_id: ast::node_id) -> cmt { - ret @{cat:cat_discr(cmt, alt_id) with *cmt}; + return @{cat:cat_discr(cmt, alt_id) with *cmt}; } /// inherited mutability: used in cases where the mutability of a @@ -388,7 +388,7 @@ impl public_methods for borrowck_ctxt { } }; - ret alt deref_kind(self.tcx, base_cmt.ty) { + return alt deref_kind(self.tcx, base_cmt.ty) { deref_ptr(ptr) { // (a) the contents are loanable if the base is loanable // and this is a *unique* vector @@ -461,7 +461,7 @@ impl private_methods for borrowck_ctxt { loop { ctr += 1u; alt self.cat_deref(base, cmt, ctr, false) { - none { ret cmt; } + none { return cmt; } some(cmt1) { cmt = cmt1; } } } @@ -476,7 +476,7 @@ fn field_mutbl(tcx: ty::ctxt, ty::ty_rec(fields) { for fields.each |f| { if f.ident == f_name { - ret some(f.mt.mutbl); + return some(f.mt.mutbl); } } } @@ -487,12 +487,12 @@ fn field_mutbl(tcx: ty::ctxt, ast::class_mutable { ast::m_mutbl } ast::class_immutable { ast::m_imm } }; - ret some(m); + return some(m); } } } _ { } } - ret none; + return none; } diff --git a/src/rustc/middle/borrowck/check_loans.rs b/src/rustc/middle/borrowck/check_loans.rs index 4306d457378..79c562ae5b8 100644 --- a/src/rustc/middle/borrowck/check_loans.rs +++ b/src/rustc/middle/borrowck/check_loans.rs @@ -85,7 +85,7 @@ impl methods for check_loan_ctxt { fn purity(scope_id: ast::node_id) -> option<purity_cause> { let default_purity = alt self.declared_purity { // an unsafe declaration overrides all - ast::unsafe_fn { ret none; } + ast::unsafe_fn { return none; } // otherwise, remember what was declared as the // default, but we must scan for requirements @@ -103,11 +103,11 @@ impl methods for check_loan_ctxt { loop { alt pure_map.find(scope_id) { none {} - some(e) {ret some(pc_cmt(e));} + some(e) {return some(pc_cmt(e));} } alt region_map.find(scope_id) { - none { ret default_purity; } + none { return default_purity; } some(next_scope_id) { scope_id = next_scope_id; } } } @@ -123,13 +123,13 @@ impl methods for check_loan_ctxt { for req_loan_map.find(scope_id).each |loanss| { for (*loanss).each |loans| { for (*loans).each |loan| { - if !f(loan) { ret; } + if !f(loan) { return; } } } } alt region_map.find(scope_id) { - none { ret; } + none { return; } some(next_scope_id) { scope_id = next_scope_id; } } } @@ -140,7 +140,7 @@ impl methods for check_loan_ctxt { f: fn(loan) -> bool) { for self.walk_loans(scope_id) |loan| { if loan.lp == lp { - if !f(loan) { ret; } + if !f(loan) { return; } } } } @@ -182,11 +182,14 @@ impl methods for check_loan_ctxt { let is_fn_arg = did.crate == ast::local_crate && (*self.fn_args).contains(did.node); - if is_fn_arg { ret; } // case (a) above + if is_fn_arg { return; } // case (a) above } ast::expr_fn_block(*) | ast::expr_fn(*) | ast::expr_loop_body(*) | ast::expr_do_body(*) { - if self.is_stack_closure(expr.id) { ret; } // case (b) above + if self.is_stack_closure(expr.id) { + // case (b) above + return; + } } _ {} } @@ -198,7 +201,7 @@ impl methods for check_loan_ctxt { alt ty::get(callee_ty).struct { ty::ty_fn(fn_ty) { alt fn_ty.purity { - ast::pure_fn { ret; } // case (c) above + ast::pure_fn { return; } // case (c) above ast::impure_fn | ast::unsafe_fn | ast::extern_fn { self.report_purity_error( pc, callee_span, @@ -207,7 +210,7 @@ impl methods for check_loan_ctxt { } } } - _ { ret; } // case (d) above + _ { return; } // case (d) above } } @@ -223,7 +226,7 @@ impl methods for check_loan_ctxt { } fn is_allowed_pure_arg(expr: @ast::expr) -> bool { - ret alt expr.node { + return alt expr.node { ast::expr_path(_) { let def = self.tcx().def_map.get(expr.id); let did = ast_util::def_id_of_def(def); @@ -239,7 +242,7 @@ impl methods for check_loan_ctxt { fn check_for_conflicting_loans(scope_id: ast::node_id) { let new_loanss = alt self.req_maps.req_loan_map.find(scope_id) { - none { ret; } + none { return; } some(loanss) { loanss } }; @@ -310,7 +313,7 @@ impl methods for check_loan_ctxt { self.bccx.span_err( ex.span, at.ing_form(self.bccx.cmt_to_str(cmt))); - ret; + return; } } } @@ -360,7 +363,7 @@ impl methods for check_loan_ctxt { loan.cmt.span, fmt!{"loan of %s granted here", self.bccx.cmt_to_str(loan.cmt)}); - ret; + return; } } } @@ -428,7 +431,7 @@ impl methods for check_loan_ctxt { self.bccx.span_err( cmt.span, fmt!{"moving out of %s", self.bccx.cmt_to_str(cmt)}); - ret; + return; } } @@ -436,7 +439,7 @@ impl methods for check_loan_ctxt { // check for a conflicting loan: let lp = alt cmt.lp { - none { ret; } + none { return; } some(lp) { lp } }; for self.walk_loans_of(cmt.id, lp) |loan| { @@ -448,7 +451,7 @@ impl methods for check_loan_ctxt { loan.cmt.span, fmt!{"loan of %s granted here", self.bccx.cmt_to_str(loan.cmt)}); - ret; + return; } } @@ -458,14 +461,14 @@ impl methods for check_loan_ctxt { fn check_last_use(expr: @ast::expr) { let cmt = self.bccx.cat_expr(expr); let lp = alt cmt.lp { - none { ret; } + none { return; } some(lp) { lp } }; for self.walk_loans_of(cmt.id, lp) |_loan| { debug!{"Removing last use entry %? due to outstanding loan", expr.id}; self.bccx.last_use_map.remove(expr.id); - ret; + return; } } diff --git a/src/rustc/middle/borrowck/gather_loans.rs b/src/rustc/middle/borrowck/gather_loans.rs index f08a06f3419..673cfa379a8 100644 --- a/src/rustc/middle/borrowck/gather_loans.rs +++ b/src/rustc/middle/borrowck/gather_loans.rs @@ -55,7 +55,7 @@ fn gather_loans(bccx: borrowck_ctxt, crate: @ast::crate) -> req_maps { visit_fn: req_loans_in_fn, with *visit::default_visitor()}); visit::visit_crate(*crate, glcx, v); - ret glcx.req_maps; + return glcx.req_maps; } fn req_loans_in_fn(fk: visit::fn_kind, diff --git a/src/rustc/middle/borrowck/preserve.rs b/src/rustc/middle/borrowck/preserve.rs index e1e97c0dc6f..99bdc44eb5d 100644 --- a/src/rustc/middle/borrowck/preserve.rs +++ b/src/rustc/middle/borrowck/preserve.rs @@ -310,7 +310,7 @@ impl private_methods for &preserve_ctxt { // would be sort of pointless to avoid rooting the inner // box by rooting an outer box, as it would just keep more // memory live than necessary, so we set root_ub to none. - ret err({cmt:cmt, code:err_root_not_permitted}); + return err({cmt:cmt, code:err_root_not_permitted}); } let root_region = ty::re_scope(self.root_ub); @@ -327,10 +327,10 @@ impl private_methods for &preserve_ctxt { #debug["Elected to root"]; let rk = {id: base.id, derefs: derefs}; self.bccx.root_map.insert(rk, scope_id); - ret ok(pc_ok); + return ok(pc_ok); } else { #debug["Unable to root"]; - ret err({cmt:cmt, + return err({cmt:cmt, code:err_out_of_root_scope(root_region, self.scope_region)}); } @@ -338,7 +338,7 @@ impl private_methods for &preserve_ctxt { // we won't be able to root long enough _ => { - ret err({cmt:cmt, + return err({cmt:cmt, code:err_out_of_root_scope(root_region, self.scope_region)}); } diff --git a/src/rustc/middle/capture.rs b/src/rustc/middle/capture.rs index b45d7d66e9e..2a08018ebba 100644 --- a/src/rustc/middle/capture.rs +++ b/src/rustc/middle/capture.rs @@ -121,5 +121,5 @@ fn compute_capture_vars(tcx: ty::ctxt, let mut result = ~[]; for cap_map.each_value |cap_var| { vec::push(result, cap_var); } - ret result; + return result; } diff --git a/src/rustc/middle/check_alt.rs b/src/rustc/middle/check_alt.rs index 4093c0fcc6e..3986cb38bbf 100644 --- a/src/rustc/middle/check_alt.rs +++ b/src/rustc/middle/check_alt.rs @@ -31,13 +31,13 @@ fn check_expr(tcx: ty::ctxt, ex: @expr, &&s: (), v: visit::vt<()>) { let pat_ty = node_id_to_type(tcx, scrut.id); if type_is_empty(tcx, pat_ty) && arms.is_empty() { // Vacuously exhaustive - ret; + return; } alt ty::get(pat_ty).struct { ty_enum(did, _) { if (*enum_variants(tcx, did)).is_empty() && arms.is_empty() { - ret; + return; } } _ { /* We assume only enum types can be uninhabited */ } @@ -79,7 +79,7 @@ fn raw_pat(p: @pat) -> @pat { fn check_exhaustive(tcx: ty::ctxt, sp: span, pats: ~[@pat]) { assert(pats.is_not_empty()); let ext = alt is_useful(tcx, vec::map(pats, |p| ~[p]), ~[wild()]) { - not_useful { ret; } // This is good, wildcard pattern isn't reachable + not_useful { return; } // This is good, wildcard pattern isn't reachable useful_ { none } useful(ty, ctor) { alt ty::get(ty).struct { @@ -132,8 +132,8 @@ enum ctor { // Note: is_useful doesn't work on empty types, as the paper notes. // So it assumes that v is non-empty. fn is_useful(tcx: ty::ctxt, m: matrix, v: ~[@pat]) -> useful { - if m.len() == 0u { ret useful_; } - if m[0].len() == 0u { ret not_useful; } + if m.len() == 0u { return useful_; } + if m[0].len() == 0u { return not_useful; } let real_pat = alt vec::find(m, |r| r[0].id != 0) { some(r) { r[0] } none { v[0] } }; @@ -160,7 +160,7 @@ fn is_useful(tcx: ty::ctxt, m: matrix, v: ~[@pat]) -> useful { alt is_useful_specialized(tcx, m, v, variant(va.id), va.args.len(), left_ty) { not_useful {} - u { ret u; } + u { return u; } } } not_useful @@ -234,9 +234,9 @@ fn missing_ctor(tcx: ty::ctxt, m: matrix, left_ty: ty::t) -> option<ctor> { alt ty::get(left_ty).struct { ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_tup(_) | ty::ty_rec(_) { for m.each |r| { - if !is_wild(tcx, r[0]) { ret none; } + if !is_wild(tcx, r[0]) { return none; } } - ret some(single); + return some(single); } ty::ty_enum(eid, _) { let mut found = ~[]; @@ -249,7 +249,7 @@ fn missing_ctor(tcx: ty::ctxt, m: matrix, left_ty: ty::t) -> option<ctor> { if found.len() != (*variants).len() { for vec::each(*variants) |v| { if !found.contains(variant(v.id)) { - ret some(variant(v.id)); + return some(variant(v.id)); } } fail; @@ -346,7 +346,7 @@ fn specialize(tcx: ty::ctxt, r: ~[@pat], ctor_id: ctor, arity: uint, let (c_lo, c_hi) = alt check ctor_id { val(v) { (v, v) } range(lo, hi) { (lo, hi) } - single { ret some(vec::tail(r)); } + single { return some(vec::tail(r)); } }; let v_lo = eval_const_expr(tcx, lo), v_hi = eval_const_expr(tcx, hi); @@ -373,7 +373,7 @@ fn check_local(tcx: ty::ctxt, loc: @local, &&s: (), v: visit::vt<()>) { fn is_refutable(tcx: ty::ctxt, pat: @pat) -> bool { alt tcx.def_map.find(pat.id) { some(def_variant(enum_id, var_id)) { - if vec::len(*ty::enum_variants(tcx, enum_id)) != 1u { ret true; } + if vec::len(*ty::enum_variants(tcx, enum_id)) != 1u { return true; } } _ {} } @@ -386,16 +386,16 @@ fn is_refutable(tcx: ty::ctxt, pat: @pat) -> bool { pat_lit(_) | pat_range(_, _) => { true } pat_rec(fields, _) => { for fields.each |it| { - if is_refutable(tcx, it.pat) { ret true; } + if is_refutable(tcx, it.pat) { return true; } } false } pat_tup(elts) => { - for elts.each |elt| { if is_refutable(tcx, elt) { ret true; } } + for elts.each |elt| { if is_refutable(tcx, elt) { return true; } } false } pat_enum(_, some(args)) => { - for args.each |p| { if is_refutable(tcx, p) { ret true; } }; + for args.each |p| { if is_refutable(tcx, p) { return true; } }; false } pat_enum(_,_) => { false } diff --git a/src/rustc/middle/check_const.rs b/src/rustc/middle/check_const.rs index 3be041f4e9a..7f1fd250c91 100644 --- a/src/rustc/middle/check_const.rs +++ b/src/rustc/middle/check_const.rs @@ -64,7 +64,7 @@ fn check_expr(sess: session, def_map: resolve3::DefMap, expr_unary(deref, _){ sess.span_err(e.span, ~"disallowed operator in constant expression"); - ret; + return; } expr_lit(@{node: lit_str(_), _}) { sess.span_err(e.span, @@ -106,7 +106,7 @@ fn check_expr(sess: session, def_map: resolve3::DefMap, _ { sess.span_err(e.span, ~"constant contains unimplemented expression type"); - ret; + return; } } } diff --git a/src/rustc/middle/freevars.rs b/src/rustc/middle/freevars.rs index d9765618d0f..29d44ede215 100644 --- a/src/rustc/middle/freevars.rs +++ b/src/rustc/middle/freevars.rs @@ -77,7 +77,7 @@ fn collect_freevars(def_map: resolve3::DefMap, blk: ast::blk) let v = visit::mk_vt(@{visit_item: ignore_item, visit_expr: walk_expr with *visit::default_visitor()}); v.visit_block(blk, 1, v); - ret @*refs; + return @*refs; } // Build a map from every function and for-each body to a set of the @@ -100,17 +100,17 @@ fn annotate_freevars(def_map: resolve3::DefMap, crate: @ast::crate) -> with *visit::default_simple_visitor()}); visit::visit_crate(*crate, (), visitor); - ret freevars; + return freevars; } fn get_freevars(tcx: ty::ctxt, fid: ast::node_id) -> freevar_info { alt tcx.freevars.find(fid) { none { fail ~"get_freevars: " + int::str(fid) + ~" has no freevars"; } - some(d) { ret d; } + some(d) { return d; } } } fn has_freevars(tcx: ty::ctxt, fid: ast::node_id) -> bool { - ret vec::len(*get_freevars(tcx, fid)) != 0u; + return vec::len(*get_freevars(tcx, fid)) != 0u; } // Local Variables: diff --git a/src/rustc/middle/kind.rs b/src/rustc/middle/kind.rs index 8707cabfdf7..dd83b01fbe0 100644 --- a/src/rustc/middle/kind.rs +++ b/src/rustc/middle/kind.rs @@ -100,7 +100,7 @@ fn with_appropriate_checker(cx: ctx, id: node_id, b: fn(check_fn)) { is_move: bool, var_t: ty::t, sp: span) { // all captured data must be sendable, regardless of whether it is // moved in or copied in. Note that send implies owned. - if !check_send(cx, var_t, sp) { ret; } + if !check_send(cx, var_t, sp) { return; } // copied in data must be copyable, but moved in data can be anything let is_implicit = fv.is_some(); @@ -115,7 +115,7 @@ fn with_appropriate_checker(cx: ctx, id: node_id, b: fn(check_fn)) { fn check_for_box(cx: ctx, id: node_id, fv: option<@freevar_entry>, is_move: bool, var_t: ty::t, sp: span) { // all captured data must be owned - if !check_owned(cx.tcx, var_t, sp) { ret; } + if !check_owned(cx.tcx, var_t, sp) { return; } // copied in data must be copyable, but moved in data can be anything let is_implicit = fv.is_some(); @@ -498,14 +498,14 @@ fn check_cast_for_escaping_regions( let target_ty = ty::expr_ty(cx.tcx, target); let target_substs = alt ty::get(target_ty).struct { ty::ty_trait(_, substs) => {substs} - _ => { ret; /* not a cast to a trait */ } + _ => { return; /* not a cast to a trait */ } }; // Check, based on the region associated with the trait, whether it can // possibly escape the enclosing fn item (note that all type parameters // must have been declared on the enclosing fn item): alt target_substs.self_r { - some(ty::re_scope(*)) => { ret; /* case (1) */ } + some(ty::re_scope(*)) => { return; /* case (1) */ } none | some(ty::re_static) | some(ty::re_free(*)) => {} some(ty::re_bound(*)) | some(ty::re_var(*)) => { cx.tcx.sess.span_bug( diff --git a/src/rustc/middle/lang_items.rs b/src/rustc/middle/lang_items.rs index d14d2d5a0c6..f007774641d 100644 --- a/src/rustc/middle/lang_items.rs +++ b/src/rustc/middle/lang_items.rs @@ -119,7 +119,7 @@ class LanguageItemCollector { fn match_and_collect_item(item_def_id: def_id, key: ~str, value: ~str) { if !str_eq(key, ~"lang") { - ret; // Didn't match. + return; // Didn't match. } alt self.item_refs.find(value) { diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs index 2d103398b2e..ca39157f3bf 100644 --- a/src/rustc/middle/lint.rs +++ b/src/rustc/middle/lint.rs @@ -481,7 +481,7 @@ fn check_fn(tcx: ty::ctxt, fk: visit::fn_kind, decl: ast::fn_decl, // don't complain about blocks, since they tend to get their modes // specified from the outside alt fk { - visit::fk_fn_block(*) => { ret; } + visit::fk_fn_block(*) => { return; } _ => {} } diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs index 8a65a1b0567..7f18dae0db4 100644 --- a/src/rustc/middle/liveness.rs +++ b/src/rustc/middle/liveness.rs @@ -149,7 +149,7 @@ fn check_crate(tcx: ty::ctxt, last_use_map); visit::visit_crate(*crate, initial_maps, visitor); tcx.sess.abort_if_errors(); - ret last_use_map; + return last_use_map; } impl of to_str::to_str for live_node { @@ -291,7 +291,7 @@ class ir_maps { vk_local(_, name) | vk_arg(_, name, _) {name} vk_field(name) {@(~"self." + *name)} vk_self {@~"self"} - vk_implicit_ret {@~"<implicit-ret>"} + vk_implicit_return {@~"<implicit-ret>"} } } @@ -367,7 +367,7 @@ fn visit_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, } // Special nodes and variables: - // - exit_ln represents the end of the fn, either by ret or fail + // - exit_ln represents the end of the fn, either by return or fail // - implicit_ret_var is a pseudo-variable that represents // an implicit return let specials = { @@ -701,7 +701,7 @@ class liveness { fn merge_from_succ(ln: live_node, succ_ln: live_node, first_merge: bool) -> bool { - if ln == succ_ln { ret false; } + if ln == succ_ln { return false; } let mut changed = false; do self.indices2(ln, succ_ln) |idx, succ_idx| { @@ -717,16 +717,16 @@ class liveness { debug!{"merge_from_succ(ln=%s, succ=%s, first_merge=%b, changed=%b)", ln.to_str(), self.ln_str(succ_ln), first_merge, changed}; - ret changed; + return changed; fn copy_if_invalid(src: live_node, &dst: live_node) -> bool { if src.is_valid() { if !dst.is_valid() { dst = src; - ret true; + return true; } } - ret false; + return false; } } @@ -837,11 +837,11 @@ class liveness { fn propagate_through_stmt(stmt: @stmt, succ: live_node) -> live_node { alt stmt.node { stmt_decl(decl, _) { - ret self.propagate_through_decl(decl, succ); + return self.propagate_through_decl(decl, succ); } stmt_expr(expr, _) | stmt_semi(expr, _) { - ret self.propagate_through_expr(expr, succ); + return self.propagate_through_expr(expr, succ); } } } @@ -1275,15 +1275,15 @@ class liveness { alt def { def_self(_) { // Note: the field_map is empty unless we are in a ctor - ret self.ir.field_map.find(fld).map(|var| { + return self.ir.field_map.find(fld).map(|var| { let ln = self.live_node(expr.id, expr.span); (ln, var) }); } - _ { ret none; } + _ { return none; } } } - _ { ret none; } + _ { return none; } } } @@ -1347,7 +1347,7 @@ class liveness { let r <- f(); self.break_ln = bl; self.cont_ln = cl; - ret r; + return r; } } @@ -1558,7 +1558,7 @@ impl check_methods for @liveness { if self.ir.method_map.contains_key(expr.id) { // actually an rvalue, since this calls a method - ret vt.visit_expr(expr, self, vt); + return vt.visit_expr(expr, self, vt); } alt expr.node { @@ -1671,20 +1671,20 @@ impl check_methods for @liveness { move_span, fmt!{"illegal move from argument `%s`, which is not \ copy or move mode", *name}); - ret; + return; } vk_field(name) { self.tcx.sess.span_err( move_span, fmt!{"illegal move from field `%s`", *name}); - ret; + return; } vk_self { self.tcx.sess.span_err( move_span, ~"illegal move from self (cannot move out of a field of \ self)"); - ret; + return; } vk_local(*) | vk_implicit_ret { self.tcx.sess.span_bug( @@ -1790,9 +1790,9 @@ impl check_methods for @liveness { sp, fmt!{"unused variable: `%s`", *name}); } } - ret true; + return true; } - ret false; + return false; } fn warn_about_dead_assign(sp: span, ln: live_node, var: variable) { diff --git a/src/rustc/middle/pat_util.rs b/src/rustc/middle/pat_util.rs index 8415b5e1a32..70a432d78c9 100644 --- a/src/rustc/middle/pat_util.rs +++ b/src/rustc/middle/pat_util.rs @@ -18,7 +18,7 @@ fn pat_id_map(dm: resolve3::DefMap, pat: @pat) -> pat_id_map { do pat_bindings(dm, pat) |p_id, _s, n| { map.insert(path_to_ident(n), p_id); }; - ret map; + return map; } fn pat_is_variant(dm: resolve3::DefMap, pat: @pat) -> bool { @@ -49,5 +49,5 @@ fn pat_bindings(dm: resolve3::DefMap, pat: @pat, fn pat_binding_ids(dm: resolve3::DefMap, pat: @pat) -> ~[node_id] { let mut found = ~[]; pat_bindings(dm, pat, |b_id, _sp, _pt| vec::push(found, b_id) ); - ret found; + return found; } diff --git a/src/rustc/middle/region.rs b/src/rustc/middle/region.rs index 809fd1c6fd6..ec0ad5cb770 100644 --- a/src/rustc/middle/region.rs +++ b/src/rustc/middle/region.rs @@ -89,11 +89,11 @@ fn scope_contains(region_map: region_map, superscope: ast::node_id, let mut subscope = subscope; while superscope != subscope { alt region_map.find(subscope) { - none { ret false; } + none { return false; } some(scope) { subscope = scope; } } } - ret true; + return true; } /// Determines whether one region is a subregion of another. This is @@ -129,7 +129,7 @@ fn nearest_common_ancestor(region_map: region_map, scope_a: ast::node_id, let mut scope = scope; loop { alt region_map.find(scope) { - none { ret result; } + none { return result; } some(superscope) { vec::push(result, superscope); scope = superscope; @@ -138,7 +138,7 @@ fn nearest_common_ancestor(region_map: region_map, scope_a: ast::node_id, } } - if scope_a == scope_b { ret some(scope_a); } + if scope_a == scope_b { return some(scope_a); } let a_ancestors = ancestors_of(region_map, scope_a); let b_ancestors = ancestors_of(region_map, scope_b); @@ -154,18 +154,18 @@ fn nearest_common_ancestor(region_map: region_map, scope_a: ast::node_id, // then the corresponding scope is a superscope of the other. if a_ancestors[a_index] != b_ancestors[b_index] { - ret none; + return none; } loop { // Loop invariant: a_ancestors[a_index] == b_ancestors[b_index] // for all indices between a_index and the end of the array - if a_index == 0u { ret some(scope_a); } - if b_index == 0u { ret some(scope_b); } + if a_index == 0u { return some(scope_a); } + if b_index == 0u { return some(scope_b); } a_index -= 1u; b_index -= 1u; if a_ancestors[a_index] != b_ancestors[b_index] { - ret some(a_ancestors[a_index + 1u]); + return some(a_ancestors[a_index + 1u]); } } } @@ -318,7 +318,7 @@ fn resolve_crate(sess: session, def_map: resolve3::DefMap, with *visit::default_visitor() }); visit::visit_crate(*crate, cx, visitor); - ret cx.region_map; + return cx.region_map; } // ___________________________________________________________________________ @@ -480,7 +480,7 @@ fn determine_rp_in_ty(ty: @ast::ty, // be region-parameterized. if cx.item_id is zero, then this type // is not a member of a type defn nor is it a constitutent of an // impl etc. So we can ignore it and its components. - if cx.item_id == 0 { ret; } + if cx.item_id == 0 { return; } // if this type directly references a region, either via a // region pointer like &r.ty or a region-parameterized path @@ -572,5 +572,5 @@ fn determine_rp_in_crate(sess: session, } // return final set - ret cx.region_paramd_items; + return cx.region_paramd_items; } diff --git a/src/rustc/middle/resolve3.rs b/src/rustc/middle/resolve3.rs index f66e3925fb0..ca52c5dcd34 100644 --- a/src/rustc/middle/resolve3.rs +++ b/src/rustc/middle/resolve3.rs @@ -231,7 +231,7 @@ enum EnumVariantOrConstResolution { type Atom = uint; fn Atom(n: uint) -> Atom { - ret n; + return n; } class AtomTable { @@ -249,7 +249,7 @@ class AtomTable { fn intern(string: @~str) -> Atom { alt self.atoms.find(string) { none { /* fall through */ } - some(atom) { ret atom; } + some(atom) { return atom; } } let atom = Atom(self.atom_count); @@ -257,17 +257,17 @@ class AtomTable { self.atoms.insert(string, atom); self.strings.push(string); - ret atom; + return atom; } fn atom_to_str(atom: Atom) -> @~str { - ret self.strings.get_elt(atom); + return self.strings.get_elt(atom); } fn atoms_to_strs(atoms: ~[Atom], f: fn(@~str) -> bool) { for atoms.each |atom| { if !f(self.atom_to_str(atom)) { - ret; + return; } } } @@ -287,13 +287,13 @@ class AtomTable { } // XXX: Shouldn't copy here. We need string builder functionality. - ret @result; + return @result; } } /// Creates a hash table of atoms. fn atom_hashmap<V:copy>() -> hashmap<Atom,V> { - ret hashmap::<Atom,V>(|a| a, |a, b| a == b); + return hashmap::<Atom,V>(|a| a, |a, b| a == b); } /** @@ -368,15 +368,15 @@ class ImportResolution { fn target_for_namespace(namespace: Namespace) -> option<Target> { alt namespace { - ModuleNS { ret copy self.module_target; } - TypeNS { ret copy self.type_target; } - ValueNS { ret copy self.value_target; } + ModuleNS { return copy self.module_target; } + TypeNS { return copy self.type_target; } + ValueNS { return copy self.value_target; } ImplNS { if (*self.impl_target).len() > 0u { - ret some(copy *(*self.impl_target).get_elt(0u)); + return some(copy *(*self.impl_target).get_elt(0u)); } - ret none; + return none; } } } @@ -453,7 +453,7 @@ class Module { } fn all_imports_resolved() -> bool { - ret self.imports.len() == self.resolved_import_count; + return self.imports.len() == self.resolved_import_count; } } @@ -462,8 +462,8 @@ class Module { pure fn is_none<T>(x: option<T>) -> bool { alt x { - none { ret true; } - some(_) { ret false; } + none { return true; } + some(_) { return false; } } } @@ -471,10 +471,10 @@ fn unused_import_lint_level(session: session) -> level { for session.opts.lint_opts.each |lint_option_pair| { let (lint_type, lint_level) = lint_option_pair; if lint_type == unused_imports { - ret lint_level; + return lint_level; } } - ret allow; + return allow; } // Records the definitions (at most one for each namespace) that a name is @@ -518,8 +518,8 @@ class NameBindings { /// Returns the module node if applicable. fn get_module_if_available() -> option<@Module> { alt self.module_def { - NoModuleDef { ret none; } - ModuleDef(module_) { ret some(module_); } + NoModuleDef { return none; } + ModuleDef(module_) { return some(module_); } } } @@ -534,40 +534,40 @@ class NameBindings { ~"get_module called on a node with no module definition!"; } ModuleDef(module_) { - ret module_; + return module_; } } } fn defined_in_namespace(namespace: Namespace) -> bool { alt namespace { - ModuleNS { ret self.module_def != NoModuleDef; } - TypeNS { ret self.type_def != none; } - ValueNS { ret self.value_def != none; } - ImplNS { ret self.impl_defs.len() >= 1u; } + ModuleNS { return self.module_def != NoModuleDef; } + TypeNS { return self.type_def != none; } + ValueNS { return self.value_def != none; } + ImplNS { return self.impl_defs.len() >= 1u; } } } fn def_for_namespace(namespace: Namespace) -> option<def> { alt namespace { TypeNS { - ret self.type_def; + return self.type_def; } ValueNS { - ret self.value_def; + return self.value_def; } ModuleNS { alt self.module_def { NoModuleDef { - ret none; + return none; } ModuleDef(module_) { alt module_.def_id { none { - ret none; + return none; } some(def_id) { - ret some(def_mod(def_id)); + return some(def_mod(def_id)); } } } @@ -578,9 +578,9 @@ class NameBindings { // necessarily the right def. if self.impl_defs.len() == 0u { - ret none; + return none; } - ret some(def_ty(self.impl_defs[0].did)); + return some(def_ty(self.impl_defs[0].did)); } } } @@ -766,7 +766,7 @@ class Resolver { -> @Module { alt reduced_graph_parent { ModuleReducedGraphParent(module_) { - ret module_; + return module_; } } } @@ -802,10 +802,10 @@ class Resolver { none { let child = @NameBindings(); module_.children.insert(name, child); - ret (child, new_parent); + return (child, new_parent); } some(child) { - ret (child, new_parent); + return (child, new_parent); } } } @@ -813,7 +813,7 @@ class Resolver { fn block_needs_anonymous_module(block: blk) -> bool { // If the block has view items, we need an anonymous module. if block.node.view_items.len() > 0u { - ret true; + return true; } // Check each statement. @@ -822,7 +822,7 @@ class Resolver { stmt_decl(declaration, _) { alt declaration.node { decl_item(_) { - ret true; + return true; } _ { // Keep searching. @@ -838,13 +838,13 @@ class Resolver { // If we found neither view items nor items, we don't need to create // an anonymous module. - ret false; + return false; } fn get_parent_link(parent: ReducedGraphParent, name: Atom) -> ParentLink { alt parent { ModuleReducedGraphParent(module_) { - ret ModuleParentLink(module_, name); + return ModuleParentLink(module_, name); } } } @@ -1483,7 +1483,7 @@ class Resolver { debug!{"(building reduced graph for impls in external \ module) no def ID for `%s`, skipping", self.module_to_str(module_)}; - ret; + return; } some(_) { // Continue. @@ -1623,7 +1623,7 @@ class Resolver { debug!{"(resolving imports for module) all imports resolved for \ %s", self.module_to_str(module_)}; - ret; + return; } let import_count = module_.imports.len(); @@ -1740,7 +1740,7 @@ class Resolver { } } - ret resolution_result; + return resolution_result; } fn resolve_single_import(module_: @Module, containing_module: @Module, @@ -1757,7 +1757,7 @@ class Resolver { if !self.name_is_exported(containing_module, source) { debug!{"(resolving single import) name `%s` is unexported", *(*self.atom_table).atom_to_str(source)}; - ret Failed; + return Failed; } // We need to resolve all four namespaces for this to succeed. @@ -1813,7 +1813,7 @@ class Resolver { if containing_module.glob_count > 0u { debug!{"(resolving single import) unresolved glob; \ bailing out"}; - ret Indeterminate; + return Indeterminate; } // Now search the exported imports within the containing @@ -1850,11 +1850,11 @@ class Resolver { alt (*import_resolution). target_for_namespace(namespace) { none { - ret UnboundResult; + return UnboundResult; } some(target) { import_resolution.used = true; - ret BoundResult(target.target_module, + return BoundResult(target.target_module, target.bindings); } } @@ -1865,9 +1865,9 @@ class Resolver { -> ImplNamespaceResult { if (*import_resolution.impl_target).len() == 0u { - ret UnboundImplResult; + return UnboundImplResult; } - ret BoundImplResult(import_resolution. + return BoundImplResult(import_resolution. impl_target); } @@ -1896,7 +1896,7 @@ class Resolver { // The import is unresolved. Bail out. debug!{"(resolving single import) unresolved import; \ bailing out"}; - ret Indeterminate; + return Indeterminate; } } } @@ -1958,7 +1958,7 @@ class Resolver { If this name wasn't found in any of the four namespaces, it's definitely unresolved */ - (none, none, none, v) if v.len() == 0 { ret Failed; } + (none, none, none, v) if v.len() == 0 { return Failed; } _ {} } @@ -1966,7 +1966,7 @@ class Resolver { import_resolution.outstanding_references -= 1u; debug!{"(resolving single import) successfully resolved import"}; - ret Success(()); + return Success(()); } /** @@ -1989,7 +1989,7 @@ class Resolver { if !(*containing_module).all_imports_resolved() { debug!{"(resolving glob import) target module has unresolved \ imports; bailing out"}; - ret Indeterminate; + return Indeterminate; } assert containing_module.glob_count == 0u; @@ -2125,7 +2125,7 @@ class Resolver { } debug!{"(resolving glob import) successfully resolved import"}; - ret Success(()); + return Success(()); } fn resolve_module_path_from_root(module_: @Module, @@ -2150,13 +2150,13 @@ class Resolver { Failed { self.session.span_err(span, ~"unresolved name"); - ret Failed; + return Failed; } Indeterminate { debug!{"(resolving module path for import) module \ resolution is indeterminate: %s", *(*self.atom_table).atom_to_str(name)}; - ret Indeterminate; + return Indeterminate; } Success(target) { alt target.bindings.module_def { @@ -2166,7 +2166,7 @@ class Resolver { fmt!{"not a module: %s", *(*self.atom_table). atom_to_str(name)}); - ret Failed; + return Failed; } ModuleDef(module_) { search_module = module_; @@ -2178,7 +2178,7 @@ class Resolver { index += 1u; } - ret Success(search_module); + return Success(search_module); } /** @@ -2207,19 +2207,19 @@ class Resolver { alt self.resolve_module_in_lexical_scope(module_, first_element) { Failed { self.session.span_err(span, ~"unresolved name"); - ret Failed; + return Failed; } Indeterminate { debug!{"(resolving module path for import) indeterminate; \ bailing"}; - ret Indeterminate; + return Indeterminate; } Success(resulting_module) { search_module = resulting_module; } } - ret self.resolve_module_path_from_root(search_module, + return self.resolve_module_path_from_root(search_module, module_path, 1u, xray, @@ -2244,7 +2244,7 @@ class Resolver { some(name_bindings) if (*name_bindings).defined_in_namespace(namespace) { - ret Success(Target(module_, name_bindings)); + return Success(Target(module_, name_bindings)); } some(_) | none { /* Not found; continue. */ } } @@ -2268,7 +2268,7 @@ class Resolver { } some(target) { import_resolution.used = true; - ret Success(copy target); + return Success(copy target); } } } @@ -2283,7 +2283,7 @@ class Resolver { // No more parents. This module was unresolved. debug!{"(resolving item in lexical scope) unresolved \ module"}; - ret Failed; + return Failed; } ModuleParentLink(parent_module_node, _) | BlockParentLink(parent_module_node, _) { @@ -2303,11 +2303,11 @@ class Resolver { debug!{"(resolving item in lexical scope) indeterminate \ higher scope; bailing"}; - ret Indeterminate; + return Indeterminate; } Success(target) { // We found the module. - ret Success(copy target); + return Success(copy target); } } } @@ -2322,28 +2322,28 @@ class Resolver { NoModuleDef { error!{"!!! (resolving module in lexical scope) module wasn't actually a module!"}; - ret Failed; + return Failed; } ModuleDef(module_) { - ret Success(module_); + return Success(module_); } } } Indeterminate { debug!{"(resolving module in lexical scope) indeterminate; \ bailing"}; - ret Indeterminate; + return Indeterminate; } Failed { debug!{"(resolving module in lexical scope) failed to \ resolve"}; - ret Failed; + return Failed; } } } fn name_is_exported(module_: @Module, name: Atom) -> bool { - ret module_.exported_names.size() == 0u || + return module_.exported_names.size() == 0u || module_.exported_names.contains_key(name); } @@ -2365,7 +2365,7 @@ class Resolver { if xray == NoXray && !self.name_is_exported(module_, name) { debug!{"(resolving name in module) name `%s` is unexported", *(*self.atom_table).atom_to_str(name)}; - ret Failed; + return Failed; } // First, check the direct children of the module. @@ -2374,7 +2374,7 @@ class Resolver { if (*name_bindings).defined_in_namespace(namespace) { debug!{"(resolving name in module) found node as child"}; - ret Success(Target(module_, name_bindings)); + return Success(Target(module_, name_bindings)); } some(_) | none { // Continue. @@ -2386,7 +2386,7 @@ class Resolver { if module_.glob_count > 0u { debug!{"(resolving name in module) module has glob; bailing out"}; - ret Indeterminate; + return Indeterminate; } // Otherwise, we check the list of resolved imports. @@ -2395,7 +2395,7 @@ class Resolver { if import_resolution.outstanding_references != 0u { debug!{"(resolving name in module) import unresolved; \ bailing out"}; - ret Indeterminate; + return Indeterminate; } alt (*import_resolution).target_for_namespace(namespace) { @@ -2408,7 +2408,7 @@ class Resolver { debug!{"(resolving name in module) resolved to \ import"}; import_resolution.used = true; - ret Success(copy target); + return Success(copy target); } } } @@ -2420,7 +2420,7 @@ class Resolver { // We're out of luck. debug!{"(resolving name in module) failed to resolve %s", *(*self.atom_table).atom_to_str(name)}; - ret Failed; + return Failed; } /** @@ -2468,7 +2468,7 @@ class Resolver { Indeterminate { debug!{"(resolving one-level renaming import) module result \ is indeterminate; bailing"}; - ret Indeterminate; + return Indeterminate; } Success(name_bindings) { debug!{"(resolving one-level renaming import) module result \ @@ -2491,7 +2491,7 @@ class Resolver { Indeterminate { debug!{"(resolving one-level renaming import) value result \ is indeterminate; bailing"}; - ret Indeterminate; + return Indeterminate; } Success(name_bindings) { debug!{"(resolving one-level renaming import) value result \ @@ -2514,7 +2514,7 @@ class Resolver { Indeterminate { debug!{"(resolving one-level renaming import) type result is \ indeterminate; bailing"}; - ret Indeterminate; + return Indeterminate; } Success(name_bindings) { debug!{"(resolving one-level renaming import) type result \ @@ -2554,7 +2554,7 @@ class Resolver { Indeterminate { debug!{"(resolving one-level renaming import) impl result is \ indeterminate; bailing"}; - ret Indeterminate; + return Indeterminate; } Success(name_bindings) { debug!{"(resolving one-level renaming import) impl result \ @@ -2569,7 +2569,7 @@ class Resolver { self.session.span_err(import_directive.span, ~"unresolved import"); - ret Failed; + return Failed; } // Otherwise, proceed and write in the bindings. @@ -2605,7 +2605,7 @@ class Resolver { } debug!{"(resolving one-level renaming import) successfully resolved"}; - ret Success(()); + return Success(()); } fn report_unresolved_imports(module_: @Module) { @@ -2663,7 +2663,7 @@ class Resolver { debug!{"(recording exports for module subtree) not recording \ exports for `%s`", self.module_to_str(module_)}; - ret; + return; } } @@ -2749,7 +2749,7 @@ class Resolver { debug!{"(building impl scopes for module subtree) not \ resolving implementations for `%s`", self.module_to_str(module_)}; - ret; + return; } } @@ -2903,7 +2903,7 @@ class Resolver { is_ty_param = false; } _ { - ret some(def_like); + return some(def_like); } } @@ -2947,7 +2947,7 @@ class Resolver { argument out of scope"); } - ret none; + return none; } } } @@ -2969,14 +2969,14 @@ class Resolver { argument out of scope"); } - ret none; + return none; } } rib_index += 1u; } - ret some(dl_def(def)); + return some(dl_def(def)); } fn search_ribs(ribs: @dvec<@Rib>, name: Atom, span: span, @@ -2992,7 +2992,7 @@ class Resolver { let rib = (*ribs).get_elt(i); alt rib.bindings.find(name) { some(def_like) { - ret self.upvarify(ribs, i, def_like, span, + return self.upvarify(ribs, i, def_like, span, allow_capturing_self); } none { @@ -3001,7 +3001,7 @@ class Resolver { } } - ret none; + return none; } // XXX: This shouldn't be unsafe! @@ -3595,7 +3595,7 @@ class Resolver { }; } fn check_consistent_bindings(arm: arm) { - if arm.pats.len() == 0 { ret; } + if arm.pats.len() == 0 { return; } let good = self.num_bindings(arm.pats[0]); for arm.pats.each() |p: @pat| { if self.num_bindings(p) != good { @@ -3890,13 +3890,13 @@ class Resolver { of name bindings with no def?!"; } some(def @ def_variant(*)) { - ret FoundEnumVariant(def); + return FoundEnumVariant(def); } some(def_const(*)) { - ret FoundConst; + return FoundConst; } some(_) { - ret EnumVariantOrConstNotFound; + return EnumVariantOrConstNotFound; } } } @@ -3906,7 +3906,7 @@ class Resolver { } Failed { - ret EnumVariantOrConstNotFound; + return EnumVariantOrConstNotFound; } } } @@ -3925,18 +3925,18 @@ class Resolver { } if path.global { - ret self.resolve_crate_relative_path(path, + return self.resolve_crate_relative_path(path, self.xray_context, namespace); } if path.idents.len() > 1u { - ret self.resolve_module_relative_path(path, + return self.resolve_module_relative_path(path, self.xray_context, namespace); } - ret self.resolve_identifier(path.idents.last(), + return self.resolve_identifier(path.idents.last(), namespace, check_ribs, path.span); @@ -3953,7 +3953,7 @@ class Resolver { namespace, span) { some(def) { - ret some(def); + return some(def); } none { // Continue. @@ -3961,7 +3961,7 @@ class Resolver { } } - ret self.resolve_item_by_identifier_in_lexical_scope(identifier, + return self.resolve_item_by_identifier_in_lexical_scope(identifier, namespace); } @@ -3976,7 +3976,7 @@ class Resolver { debug!{"(resolving definition of name in module) name `%s` is \ unexported", *(*self.atom_table).atom_to_str(name)}; - ret NoNameDefinition; + return NoNameDefinition; } // First, search children. @@ -3985,7 +3985,7 @@ class Resolver { alt (*child_name_bindings).def_for_namespace(namespace) { some(def) { // Found it. Stop the search here. - ret ChildNameDefinition(def); + return ChildNameDefinition(def); } none { // Continue. @@ -4006,23 +4006,23 @@ class Resolver { some(def) { // Found it. import_resolution.used = true; - ret ImportNameDefinition(def); + return ImportNameDefinition(def); } none { // This can happen with external impls, due to // the imperfect way we read the metadata. - ret NoNameDefinition; + return NoNameDefinition; } } } none { - ret NoNameDefinition; + return NoNameDefinition; } } } none { - ret NoNameDefinition; + return NoNameDefinition; } } } @@ -4037,7 +4037,7 @@ class Resolver { (*module_path_atoms).push((*self.atom_table).intern(ident)); } - ret module_path_atoms; + return module_path_atoms; } fn resolve_module_relative_path(path: @path, @@ -4058,7 +4058,7 @@ class Resolver { fmt!{"use of undeclared module `%s`", *(*self.atom_table).atoms_to_str ((*module_path_atoms).get())}); - ret none; + return none; } Indeterminate { @@ -4083,10 +4083,10 @@ class Resolver { ((*module_path_atoms).get()), *(*self.atom_table).atom_to_str (name)}); - ret none; + return none; } ChildNameDefinition(def) | ImportNameDefinition(def) { - ret some(def); + return some(def); } } } @@ -4112,7 +4112,7 @@ class Resolver { fmt!{"use of undeclared module `::%s`", *(*self.atom_table).atoms_to_str ((*module_path_atoms).get())}); - ret none; + return none; } Indeterminate { @@ -4137,10 +4137,10 @@ class Resolver { ((*module_path_atoms).get()), *(*self.atom_table).atom_to_str (name)}); - ret none; + return none; } ChildNameDefinition(def) | ImportNameDefinition(def) { - ret some(def); + return some(def); } } } @@ -4174,10 +4174,10 @@ class Resolver { local: %?", *(*self.atom_table).atom_to_str(name), def}; - ret some(def); + return some(def); } some(dl_field) | some(dl_impl(_)) | none { - ret none; + return none; } } } @@ -4203,7 +4203,7 @@ class Resolver { debug!{"(resolving item path in lexical scope) \ resolved `%s` to item", *(*self.atom_table).atom_to_str(name)}; - ret some(def); + return some(def); } } } @@ -4211,7 +4211,7 @@ class Resolver { fail ~"unexpected indeterminate result"; } Failed { - ret none; + return none; } } } @@ -4452,7 +4452,7 @@ class Resolver { } } - ret found_traits; + return found_traits; } fn add_trait_info_if_containing_method(found_traits: @dvec<def_id>, @@ -4494,7 +4494,7 @@ class Resolver { fn check_for_unused_imports_if_necessary() { if self.unused_import_lint_level == allow { - ret; + return; } let root_module = (*self.graph_root).get_module(); @@ -4517,7 +4517,7 @@ class Resolver { debug!{"(checking for unused imports in module subtree) not \ checking for unused imports for `%s`", self.module_to_str(module_)}; - ret; + return; } } @@ -4590,7 +4590,7 @@ class Resolver { } if atoms.len() == 0u { - ret ~"???"; + return ~"???"; } let mut string = ~""; @@ -4607,7 +4607,7 @@ class Resolver { i -= 1u; } - ret string; + return string; } fn dump_module(module_: @Module) { @@ -4696,7 +4696,7 @@ fn resolve_crate(session: session, lang_items: LanguageItems, crate: @crate) let resolver = @Resolver(session, lang_items, crate); (*resolver).resolve(resolver); - ret { + return { def_map: resolver.def_map, exp_map: resolver.export_map, impl_map: resolver.impl_map, diff --git a/src/rustc/middle/trans/alt.rs b/src/rustc/middle/trans/alt.rs index 62b7c247784..072ec43dbb9 100644 --- a/src/rustc/middle/trans/alt.rs +++ b/src/rustc/middle/trans/alt.rs @@ -54,17 +54,19 @@ fn trans_opt(bcx: block, o: opt) -> opt_result { let cell = empty_dest_cell(); bcx = tvec::trans_estr(bcx, s, ast::vstore_uniq, by_val(cell)); add_clean_temp(bcx, *cell, strty); - ret single_result(rslt(bcx, *cell)); + return single_result(rslt(bcx, *cell)); } _ { - ret single_result( + return single_result( rslt(bcx, consts::const_expr(ccx, l))); } } } - var(disr_val, _) { ret single_result(rslt(bcx, C_int(ccx, disr_val))); } + var(disr_val, _) { + return single_result(rslt(bcx, C_int(ccx, disr_val))); + } range(l1, l2) { - ret range_result(rslt(bcx, consts::const_expr(ccx, l1)), + return range_result(rslt(bcx, consts::const_expr(ccx, l1)), rslt(bcx, consts::const_expr(ccx, l2))); } } @@ -74,7 +76,7 @@ fn variant_opt(tcx: ty::ctxt, pat_id: ast::node_id) -> opt { let vdef = ast_util::variant_def_ids(tcx.def_map.get(pat_id)); let variants = ty::enum_variants(tcx, vdef.enm); for vec::each(*variants) |v| { - if vdef.var == v.id { ret var(v.disr_val, vdef); } + if vdef.var == v.id { return var(v.disr_val, vdef); } } core::unreachable(); } @@ -110,11 +112,11 @@ type match_ = ~[match_branch]; fn has_nested_bindings(m: match_, col: uint) -> bool { for vec::each(m) |br| { alt br.pats[col].node { - ast::pat_ident(_, _, some(_)) { ret true; } + ast::pat_ident(_, _, some(_)) { return true; } _ {} } } - ret false; + return false; } fn expand_nested_bindings(bcx: block, m: match_, col: uint, val: ValueRef) @@ -175,7 +177,7 @@ fn enter_match(bcx: block, dm: DefMap, m: match_, col: uint, val: ValueRef, none { } } } - ret result; + return result; } fn enter_default(bcx: block, dm: DefMap, m: match_, col: uint, val: ValueRef) @@ -275,7 +277,7 @@ fn enter_uniq(bcx: block, dm: DefMap, m: match_, col: uint, val: ValueRef) fn get_options(ccx: @crate_ctxt, m: match_, col: uint) -> ~[opt] { fn add_to_set(tcx: ty::ctxt, &&set: dvec<opt>, val: opt) { - if set.any(|l| opt_eq(tcx, l, val)) {ret;} + if set.any(|l| opt_eq(tcx, l, val)) {return;} set.push(val); } @@ -294,7 +296,7 @@ fn get_options(ccx: @crate_ctxt, m: match_, col: uint) -> ~[opt] { } } } - ret vec::from_mut(dvec::unwrap(found)); + return vec::from_mut(dvec::unwrap(found)); } fn extract_variant_args(bcx: block, pat_id: ast::node_id, @@ -320,7 +322,7 @@ fn extract_variant_args(bcx: block, pat_id: ast::node_id, GEP_enum(bcx, blobptr, vdefs_tg, vdefs_var, enum_ty_substs, i) }; - ret {vals: args, bcx: bcx}; + return {vals: args, bcx: bcx}; } fn collect_record_fields(m: match_, col: uint) -> ~[ast::ident] { @@ -337,7 +339,7 @@ fn collect_record_fields(m: match_, col: uint) -> ~[ast::ident] { _ { } } } - ret fields; + return fields; } fn root_pats_as_necessary(bcx: block, m: match_, col: uint, val: ValueRef) { @@ -354,7 +356,7 @@ fn root_pats_as_necessary(bcx: block, m: match_, col: uint, val: ValueRef) { let ty = node_id_type(bcx, pat_id); let val = load_if_immediate(bcx, val, ty); root_value(bcx, val, ty, scope_id); - ret; // if we kept going, we'd only be rooting same value again + return; // if we kept going, we'd only be rooting same value again } } } @@ -362,23 +364,23 @@ fn root_pats_as_necessary(bcx: block, m: match_, col: uint, val: ValueRef) { fn any_box_pat(m: match_, col: uint) -> bool { for vec::each(m) |br| { - alt br.pats[col].node { ast::pat_box(_) { ret true; } _ { } } + alt br.pats[col].node { ast::pat_box(_) { return true; } _ { } } } - ret false; + return false; } fn any_uniq_pat(m: match_, col: uint) -> bool { for vec::each(m) |br| { - alt br.pats[col].node { ast::pat_uniq(_) { ret true; } _ { } } + alt br.pats[col].node { ast::pat_uniq(_) { return true; } _ { } } } - ret false; + return false; } fn any_tup_pat(m: match_, col: uint) -> bool { for vec::each(m) |br| { - alt br.pats[col].node { ast::pat_tup(_) { ret true; } _ { } } + alt br.pats[col].node { ast::pat_tup(_) { return true; } _ { } } } - ret false; + return false; } type exit_node = {bound: bind_map, from: BasicBlockRef, to: BasicBlockRef}; @@ -403,13 +405,13 @@ fn pick_col(m: match_) -> uint { for vec::each(scores) |score| { // Irrefutable columns always go first, they'd only be duplicated in // the branches. - if score == 0u { ret i; } + if score == 0u { return i; } // If no irrefutable ones are found, we pick the one with the biggest // branching factor. if score > max_score { max_score = score; best_col = i; } i += 1u; } - ret best_col; + return best_col; } fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef], @@ -421,7 +423,7 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef], let _icx = bcx.insn_ctxt(~"alt::compile_submatch"); let mut bcx = bcx; let tcx = bcx.tcx(), dm = tcx.def_map; - if m.len() == 0u { Br(bcx, option::get(chk)()); ret; } + if m.len() == 0u { Br(bcx, option::get(chk)()); return; } if m[0].pats.len() == 0u { let data = m[0].data; alt data.guard { @@ -464,7 +466,7 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef], to: data.bodycx.llbb}); } Br(bcx, data.bodycx.llbb); - ret; + return; } let col = pick_col(m); @@ -496,7 +498,7 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef], } compile_submatch(bcx, enter_rec(bcx, dm, m, col, rec_fields, val), vec::append(rec_vals, vals_left), chk, exits); - ret; + return; } if any_tup_pat(m, col) { @@ -512,7 +514,7 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef], } compile_submatch(bcx, enter_tup(bcx, dm, m, col, val, n_tup_elts), vec::append(tup_vals, vals_left), chk, exits); - ret; + return; } // Unbox in case of a box field @@ -523,7 +525,7 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef], GEPi(bcx, box_no_addrspace, ~[0u, abi::box_field_body]); compile_submatch(bcx, enter_box(bcx, dm, m, col, val), vec::append(~[unboxed], vals_left), chk, exits); - ret; + return; } if any_uniq_pat(m, col) { @@ -533,7 +535,7 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef], GEPi(bcx, box_no_addrspace, ~[0u, abi::box_field_body]); compile_submatch(bcx, enter_uniq(bcx, dm, m, col, val), vec::append(~[unboxed], vals_left), chk, exits); - ret; + return; } // Decide what kind of branch we need @@ -676,7 +678,7 @@ fn make_phi_bindings(bcx: block, map: ~[exit_node], if !success { Unreachable(bcx); } - ret success; + return success; } // Copies by-value bindings into their homes. @@ -746,7 +748,7 @@ fn trans_alt_inner(scope_cx: block, expr: @ast::expr, arms: ~[ast::arm], let mut bodies = ~[], matches = ~[]; let {bcx, val, _} = trans_temp_expr(bcx, expr); - if bcx.unreachable { ret bcx; } + if bcx.unreachable { return bcx; } for vec::each(arms) |a| { let body = scope_block(bcx, a.body.info(), ~"case_body"); @@ -762,11 +764,11 @@ fn trans_alt_inner(scope_cx: block, expr: @ast::expr, arms: ~[ast::arm], fn mk_fail(bcx: block, sp: span, msg: ~str, done: @mut option<BasicBlockRef>) -> BasicBlockRef { - alt *done { some(bb) { ret bb; } _ { } } + alt *done { some(bb) { return bb; } _ { } } let fail_cx = sub_block(bcx, ~"case_fallthrough"); trans_fail(fail_cx, some(sp), msg); *done = some(fail_cx.llbb); - ret fail_cx.llbb; + return fail_cx.llbb; } let t = node_id_type(bcx, expr.id); let mk_fail = alt mode { @@ -819,7 +821,7 @@ fn bind_irrefutable_pat(bcx: block, pat: @ast::pat, val: ValueRef, // Necessary since bind_irrefutable_pat is called outside trans_alt alt pat.node { ast::pat_ident(_, _,inner) { - if pat_is_variant(bcx.tcx().def_map, pat) { ret bcx; } + if pat_is_variant(bcx.tcx().def_map, pat) { return bcx; } if make_copy { let ty = node_id_type(bcx, pat.id); let llty = type_of::type_of(ccx, ty); @@ -873,7 +875,7 @@ fn bind_irrefutable_pat(bcx: block, pat: @ast::pat, val: ValueRef, } ast::pat_wild | ast::pat_lit(_) | ast::pat_range(_, _) { } } - ret bcx; + return bcx; } // Local Variables: diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs index ef92891418a..c864dec860e 100644 --- a/src/rustc/middle/trans/base.rs +++ b/src/rustc/middle/trans/base.rs @@ -74,7 +74,7 @@ fn dest_str(ccx: @crate_ctxt, d: dest) -> ~str { } fn empty_dest_cell() -> @mut ValueRef { - ret @mut llvm::LLVMGetUndef(T_nil()); + return @mut llvm::LLVMGetUndef(T_nil()); } fn dup_for_join(dest: dest) -> dest { @@ -148,7 +148,7 @@ fn join_returns(parent_cx: block, in_cxs: ~[block], _ {} } } - ret out; + return out; } // Used to put an immediate value in a dest. @@ -158,7 +158,7 @@ fn store_in_dest(bcx: block, val: ValueRef, dest: dest) -> block { by_val(cell) { *cell = val; } save_in(addr) { Store(bcx, val, addr); } } - ret bcx; + return bcx; } fn get_dest_addr(dest: dest) -> ValueRef { @@ -182,11 +182,11 @@ fn decl_fn(llmod: ModuleRef, name: ~str, cc: lib::llvm::CallConv, llvm::LLVMGetOrInsertFunction(llmod, buf, llty) }); lib::llvm::SetFunctionCallConv(llfn, cc); - ret llfn; + return llfn; } fn decl_cdecl_fn(llmod: ModuleRef, name: ~str, llty: TypeRef) -> ValueRef { - ret decl_fn(llmod, name, lib::llvm::CCallConv, llty); + return decl_fn(llmod, name, lib::llvm::CCallConv, llty); } @@ -196,24 +196,24 @@ fn decl_internal_cdecl_fn(llmod: ModuleRef, name: ~str, llty: TypeRef) -> ValueRef { let llfn = decl_cdecl_fn(llmod, name, llty); lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage); - ret llfn; + return llfn; } fn get_extern_fn(externs: hashmap<~str, ValueRef>, llmod: ModuleRef, name: ~str, cc: lib::llvm::CallConv, ty: TypeRef) -> ValueRef { - if externs.contains_key(name) { ret externs.get(name); } + if externs.contains_key(name) { return externs.get(name); } let f = decl_fn(llmod, name, cc, ty); externs.insert(name, f); - ret f; + return f; } fn get_extern_const(externs: hashmap<~str, ValueRef>, llmod: ModuleRef, name: ~str, ty: TypeRef) -> ValueRef { - if externs.contains_key(name) { ret externs.get(name); } + if externs.contains_key(name) { return externs.get(name); } let c = str::as_c_str(name, |buf| llvm::LLVMAddGlobal(llmod, ty, buf)); externs.insert(name, c); - ret c; + return c; } fn get_simple_extern_fn(cx: block, @@ -225,7 +225,7 @@ fn get_simple_extern_fn(cx: block, let inputs = vec::from_elem(n_args as uint, ccx.int_type); let output = ccx.int_type; let t = T_fn(inputs, output); - ret get_extern_fn(externs, llmod, name, lib::llvm::CCallConv, t); + return get_extern_fn(externs, llmod, name, lib::llvm::CCallConv, t); } fn trans_foreign_call(cx: block, externs: hashmap<~str, ValueRef>, @@ -239,7 +239,7 @@ fn trans_foreign_call(cx: block, externs: hashmap<~str, ValueRef>, for vec::each(args) |a| { vec::push(call_args, a); } - ret Call(cx, llforeign, call_args); + return Call(cx, llforeign, call_args); } fn trans_free(cx: block, v: ValueRef) -> block { @@ -256,13 +256,13 @@ fn trans_unique_free(cx: block, v: ValueRef) -> block { fn umax(cx: block, a: ValueRef, b: ValueRef) -> ValueRef { let _icx = cx.insn_ctxt(~"umax"); let cond = ICmp(cx, lib::llvm::IntULT, a, b); - ret Select(cx, cond, b, a); + return Select(cx, cond, b, a); } fn umin(cx: block, a: ValueRef, b: ValueRef) -> ValueRef { let _icx = cx.insn_ctxt(~"umin"); let cond = ICmp(cx, lib::llvm::IntULT, a, b); - ret Select(cx, cond, a, b); + return Select(cx, cond, a, b); } fn alloca(cx: block, t: TypeRef) -> ValueRef { @@ -275,11 +275,11 @@ fn alloca_zeroed(cx: block, t: TypeRef) -> ValueRef { fn alloca_maybe_zeroed(cx: block, t: TypeRef, zero: bool) -> ValueRef { let _icx = cx.insn_ctxt(~"alloca"); - if cx.unreachable { ret llvm::LLVMGetUndef(t); } + if cx.unreachable { return llvm::LLVMGetUndef(t); } let initcx = raw_block(cx.fcx, false, cx.fcx.llstaticallocas); let p = Alloca(initcx, t); if zero { Store(initcx, C_null(t), p); } - ret p; + return p; } fn zero_mem(cx: block, llptr: ValueRef, t: ty::t) -> block { @@ -288,13 +288,14 @@ fn zero_mem(cx: block, llptr: ValueRef, t: ty::t) -> block { let ccx = cx.ccx(); let llty = type_of(ccx, t); Store(bcx, C_null(llty), llptr); - ret bcx; + return bcx; } fn arrayalloca(cx: block, t: TypeRef, v: ValueRef) -> ValueRef { let _icx = cx.insn_ctxt(~"arrayalloca"); - if cx.unreachable { ret llvm::LLVMGetUndef(t); } - ret ArrayAlloca(raw_block(cx.fcx, false, cx.fcx.llstaticallocas), t, v); + if cx.unreachable { return llvm::LLVMGetUndef(t); } + return ArrayAlloca( + raw_block(cx.fcx, false, cx.fcx.llstaticallocas), t, v); } // Given a pointer p, returns a pointer sz(p) (i.e., inc'd by sz bytes). @@ -376,7 +377,7 @@ fn malloc_raw_dyn(bcx: block, t: ty::t, heap: heap, let rval = alloca_zeroed(bcx, T_ptr(T_i8())); let bcx = trans_rtcall(bcx, rtcall, ~[tydesc, size], save_in(rval)); let retval = {bcx: bcx, val: PointerCast(bcx, Load(bcx, rval), llty)}; - ret retval; + return retval; } // malloc_raw: expects an unboxed type and returns a pointer to @@ -394,7 +395,7 @@ fn malloc_general_dyn(bcx: block, t: ty::t, heap: heap, size: ValueRef) let {bcx: bcx, val: llbox} = malloc_raw_dyn(bcx, t, heap, size); let non_gc_box = non_gc_box_cast(bcx, llbox); let body = GEPi(bcx, non_gc_box, ~[0u, abi::box_field_body]); - ret {bcx: bcx, box: llbox, body: body}; + return {bcx: bcx, box: llbox, body: body}; } fn malloc_general(bcx: block, t: ty::t, heap: heap) @@ -510,7 +511,7 @@ fn declare_tydesc(ccx: @crate_ctxt, t: ty::t) -> @tydesc_info { mut free_glue: none, mut visit_glue: none}; log(debug, ~"--- declare_tydesc " + ppaux::ty_to_str(ccx.tcx, t)); - ret inf; + return inf; } type glue_helper = fn@(block, ValueRef, ty::t); @@ -529,7 +530,7 @@ fn declare_generic_glue(ccx: @crate_ctxt, t: ty::t, llfnty: TypeRef, note_unique_llvm_symbol(ccx, fn_nm); let llfn = decl_cdecl_fn(ccx.llmod, fn_nm, llfnty); set_glue_inlining(llfn, t); - ret llfn; + return llfn; } fn make_generic_glue_inner(ccx: @crate_ctxt, t: ty::t, @@ -551,7 +552,7 @@ fn make_generic_glue_inner(ccx: @crate_ctxt, t: ty::t, let llval0 = BitCast(bcx, llrawptr0, llty); helper(bcx, llval0, t); finish_fn(fcx, lltop); - ret llfn; + return llfn; } fn make_generic_glue(ccx: @crate_ctxt, t: ty::t, llfn: ValueRef, @@ -559,7 +560,7 @@ fn make_generic_glue(ccx: @crate_ctxt, t: ty::t, llfn: ValueRef, -> ValueRef { let _icx = ccx.insn_ctxt(~"make_generic_glue"); if !ccx.sess.trans_stats() { - ret make_generic_glue_inner(ccx, t, llfn, helper); + return make_generic_glue_inner(ccx, t, llfn, helper); } let start = time::get_time(); @@ -567,7 +568,7 @@ fn make_generic_glue(ccx: @crate_ctxt, t: ty::t, llfn: ValueRef, let end = time::get_time(); log_fn_time(ccx, ~"glue " + name + ~" " + ty_to_short_str(ccx.tcx, t), start, end); - ret llval; + return llval; } fn emit_tydescs(ccx: @crate_ctxt) { @@ -712,7 +713,7 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) { ty::ty_evec(_, ty::vstore_box) | ty::ty_estr(ty::vstore_box) { make_free_glue(bcx, v, tvec::expand_boxed_vec_ty(bcx.tcx(), t)); - ret; + return; } ty::ty_fn(_) { closure::make_fn_glue(bcx, v, t, free_ty) @@ -879,13 +880,13 @@ fn compare_scalar_types(cx: block, lhs: ValueRef, rhs: ValueRef, let f = |a| compare_scalar_values(cx, lhs, rhs, a, op); alt ty::get(t).struct { - ty::ty_nil { ret rslt(cx, f(nil_type)); } - ty::ty_bool | ty::ty_ptr(_) { ret rslt(cx, f(unsigned_int)); } - ty::ty_int(_) { ret rslt(cx, f(signed_int)); } - ty::ty_uint(_) { ret rslt(cx, f(unsigned_int)); } - ty::ty_float(_) { ret rslt(cx, f(floating_point)); } + ty::ty_nil { return rslt(cx, f(nil_type)); } + ty::ty_bool | ty::ty_ptr(_) { return rslt(cx, f(unsigned_int)); } + ty::ty_int(_) { return rslt(cx, f(signed_int)); } + ty::ty_uint(_) { return rslt(cx, f(unsigned_int)); } + ty::ty_float(_) { return rslt(cx, f(floating_point)); } ty::ty_type { - ret rslt(trans_fail(cx, none, + return rslt(trans_fail(cx, none, ~"attempt to compare values of type type"), C_nil()); } @@ -912,8 +913,8 @@ fn compare_scalar_values(cx: block, lhs: ValueRef, rhs: ValueRef, // We don't need to do actual comparisons for nil. // () == () holds but () < () does not. alt op { - ast::eq | ast::le | ast::ge { ret C_bool(true); } - ast::ne | ast::lt | ast::gt { ret C_bool(false); } + ast::eq | ast::le | ast::ge { return C_bool(true); } + ast::ne | ast::lt | ast::gt { return C_bool(false); } // refinements would be nice _ { die(); } } @@ -928,7 +929,7 @@ fn compare_scalar_values(cx: block, lhs: ValueRef, rhs: ValueRef, ast::ge { lib::llvm::RealOGE } _ { die(); } }; - ret FCmp(cx, cmp, lhs, rhs); + return FCmp(cx, cmp, lhs, rhs); } signed_int { let cmp = alt op { @@ -940,7 +941,7 @@ fn compare_scalar_values(cx: block, lhs: ValueRef, rhs: ValueRef, ast::ge { lib::llvm::IntSGE } _ { die(); } }; - ret ICmp(cx, cmp, lhs, rhs); + return ICmp(cx, cmp, lhs, rhs); } unsigned_int { let cmp = alt op { @@ -952,7 +953,7 @@ fn compare_scalar_values(cx: block, lhs: ValueRef, rhs: ValueRef, ast::ge { lib::llvm::IntUGE } _ { die(); } }; - ret ICmp(cx, cmp, lhs, rhs); + return ICmp(cx, cmp, lhs, rhs); } } } @@ -961,7 +962,7 @@ type val_pair_fn = fn@(block, ValueRef, ValueRef) -> block; type val_and_ty_fn = fn@(block, ValueRef, ty::t) -> block; fn load_inbounds(cx: block, p: ValueRef, idxs: ~[uint]) -> ValueRef { - ret Load(cx, GEPi(cx, p, idxs)); + return Load(cx, GEPi(cx, p, idxs)); } fn store_inbounds(cx: block, v: ValueRef, p: ValueRef, @@ -979,7 +980,7 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t, tps: ~[ty::t], tid: ast::def_id, f: val_and_ty_fn) -> block { let _icx = cx.insn_ctxt(~"iter_variant"); - if variant.args.len() == 0u { ret cx; } + if variant.args.len() == 0u { return cx; } let fn_ty = variant.ctor_ty; let ccx = cx.ccx(); let mut cx = cx; @@ -996,7 +997,7 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t, } _ { cx.tcx().sess.bug(~"iter_variant: not a function type"); } } - ret cx; + return cx; } /* @@ -1027,7 +1028,7 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t, // Cast the enums to types we can GEP into. if n_variants == 1u { - ret iter_variant(cx, av, variants[0], + return iter_variant(cx, av, variants[0], substs.tps, tid, f); } @@ -1056,7 +1057,7 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t, substs.tps, tid, f); Br(variant_cx, next_cx.llbb); } - ret next_cx; + return next_cx; } ty::ty_class(did, substs) { // Take the drop bit into account @@ -1073,7 +1074,7 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t, } _ { cx.sess().unimpl(~"type in iter_structural_ty"); } } - ret cx; + return cx; } fn lazily_emit_all_tydesc_glue(ccx: @crate_ctxt, @@ -1154,7 +1155,7 @@ fn lazily_emit_tydesc_glue(ccx: @crate_ctxt, field: uint, fn call_tydesc_glue_full(++cx: block, v: ValueRef, tydesc: ValueRef, field: uint, static_ti: option<@tydesc_info>) { let _icx = cx.insn_ctxt(~"call_tydesc_glue_full"); - if cx.unreachable { ret; } + if cx.unreachable { return; } let mut static_glue_fn = none; alt static_ti { @@ -1196,7 +1197,7 @@ fn call_tydesc_glue(++cx: block, v: ValueRef, t: ty::t, field: uint) let _icx = cx.insn_ctxt(~"call_tydesc_glue"); let ti = get_tydesc(cx.ccx(), t); call_tydesc_glue_full(cx, v, ti.tydesc, field, some(ti)); - ret cx; + return cx; } fn call_cmp_glue(bcx: block, lhs: ValueRef, rhs: ValueRef, t: ty::t, @@ -1217,23 +1218,23 @@ fn call_cmp_glue(bcx: block, lhs: ValueRef, rhs: ValueRef, t: ty::t, let llcmpresultptr = alloca(bcx, T_i1()); Call(bcx, llfn, ~[llcmpresultptr, lltydesc, llrawlhsptr, llrawrhsptr, llop]); - ret Load(bcx, llcmpresultptr); + return Load(bcx, llcmpresultptr); } fn take_ty(cx: block, v: ValueRef, t: ty::t) -> block { let _icx = cx.insn_ctxt(~"take_ty"); if ty::type_needs_drop(cx.tcx(), t) { - ret call_tydesc_glue(cx, v, t, abi::tydesc_field_take_glue); + return call_tydesc_glue(cx, v, t, abi::tydesc_field_take_glue); } - ret cx; + return cx; } fn drop_ty(cx: block, v: ValueRef, t: ty::t) -> block { let _icx = cx.insn_ctxt(~"drop_ty"); if ty::type_needs_drop(cx.tcx(), t) { - ret call_tydesc_glue(cx, v, t, abi::tydesc_field_drop_glue); + return call_tydesc_glue(cx, v, t, abi::tydesc_field_drop_glue); } - ret cx; + return cx; } fn drop_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> block { @@ -1276,9 +1277,9 @@ fn take_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> result { fn free_ty(cx: block, v: ValueRef, t: ty::t) -> block { let _icx = cx.insn_ctxt(~"free_ty"); if ty::type_needs_drop(cx.tcx(), t) { - ret call_tydesc_glue(cx, v, t, abi::tydesc_field_free_glue); + return call_tydesc_glue(cx, v, t, abi::tydesc_field_free_glue); } - ret cx; + return cx; } fn call_memmove(cx: block, dst: ValueRef, src: ValueRef, @@ -1317,10 +1318,10 @@ enum copy_action { INIT, DROP_EXISTING, } // These are the types that are passed by pointer. fn type_is_structural_or_param(t: ty::t) -> bool { - if ty::type_is_structural(t) { ret true; } + if ty::type_is_structural(t) { return true; } alt ty::get(t).struct { - ty::ty_param(*) { ret true; } - _ { ret false; } + ty::ty_param(*) { return true; } + _ { return false; } } } @@ -1348,18 +1349,18 @@ fn copy_val_no_check(bcx: block, action: copy_action, dst: ValueRef, let mut bcx = bcx; if ty::type_is_scalar(t) { Store(bcx, src, dst); - ret bcx; + return bcx; } - if ty::type_is_nil(t) || ty::type_is_bot(t) { ret bcx; } + if ty::type_is_nil(t) || ty::type_is_bot(t) { return bcx; } if ty::type_is_boxed(t) || ty::type_is_unique(t) { if action == DROP_EXISTING { bcx = drop_ty(bcx, dst, t); } Store(bcx, src, dst); - ret take_ty(bcx, dst, t); + return take_ty(bcx, dst, t); } if type_is_structural_or_param(t) { if action == DROP_EXISTING { bcx = drop_ty(bcx, dst, t); } memmove_ty(bcx, dst, src, t); - ret take_ty(bcx, dst, t); + return take_ty(bcx, dst, t); } ccx.sess.bug(~"unexpected type in trans::copy_val_no_check: " + ppaux::ty_to_str(ccx.tcx, t)); @@ -1381,24 +1382,24 @@ fn move_val(cx: block, action: copy_action, dst: ValueRef, if ty::type_is_scalar(t) { if src.kind == lv_owned { src_val = Load(cx, src_val); } Store(cx, src_val, dst); - ret cx; + return cx; } else if ty::type_is_nil(t) || ty::type_is_bot(t) { - ret cx; + return cx; } else if ty::type_is_boxed(t) || ty::type_is_unique(t) { if src.kind == lv_owned { src_val = Load(cx, src_val); } if action == DROP_EXISTING { cx = drop_ty(cx, dst, t); } Store(cx, src_val, dst); - if src.kind == lv_owned { ret zero_mem(cx, src.val, t); } + if src.kind == lv_owned { return zero_mem(cx, src.val, t); } // If we're here, it must be a temporary. revoke_clean(cx, src_val); - ret cx; + return cx; } else if type_is_structural_or_param(t) { if action == DROP_EXISTING { cx = drop_ty(cx, dst, t); } memmove_ty(cx, dst, src_val, t); - if src.kind == lv_owned { ret zero_mem(cx, src_val, t); } + if src.kind == lv_owned { return zero_mem(cx, src_val, t); } // If we're here, it must be a temporary. revoke_clean(cx, src_val); - ret cx; + return cx; } cx.sess().bug(~"unexpected type in trans::move_val: " + ppaux::ty_to_str(tcx, t)); @@ -1415,14 +1416,14 @@ fn store_temp_expr(cx: block, action: copy_action, dst: ValueRef, } else { src.val }; - ret copy_val(cx, action, dst, v, t); + return copy_val(cx, action, dst, v, t); } - ret move_val(cx, action, dst, src, t); + return move_val(cx, action, dst, src, t); } fn trans_lit(cx: block, e: @ast::expr, lit: ast::lit, dest: dest) -> block { let _icx = cx.insn_ctxt(~"trans_lit"); - if dest == ignore { ret cx; } + if dest == ignore { return cx; } alt lit.node { ast::lit_str(s) { tvec::trans_estr(cx, s, ast::vstore_fixed(none), dest) } @@ -1440,7 +1441,7 @@ fn trans_boxed_expr(bcx: block, contents: @ast::expr, add_clean_free(bcx, box, heap); let bcx = trans_expr_save_in(bcx, contents, body); revoke_clean(bcx, box); - ret store_in_dest(bcx, box, dest); + return store_in_dest(bcx, box, dest); } fn trans_unary(bcx: block, op: ast::unop, e: @ast::expr, @@ -1450,7 +1451,7 @@ fn trans_unary(bcx: block, op: ast::unop, e: @ast::expr, alt bcx.ccx().maps.method_map.find(un_expr.id) { some(mentry) { let fty = node_id_type(bcx, un_expr.callee_id); - ret trans_call_inner( + return trans_call_inner( bcx, un_expr.info(), fty, expr_ty(bcx, un_expr), |bcx| impl::trans_method_callee(bcx, un_expr.callee_id, e, @@ -1460,7 +1461,7 @@ fn trans_unary(bcx: block, op: ast::unop, e: @ast::expr, _ {} } - if dest == ignore { ret trans_expr(bcx, e, ignore); } + if dest == ignore { return trans_expr(bcx, e, ignore); } let e_ty = expr_ty(bcx, e); alt op { ast::not { @@ -1496,7 +1497,7 @@ fn trans_addr_of(cx: block, e: @ast::expr, dest: dest) -> block { if (kind == lv_temporary && is_immediate) || kind == lv_owned_imm { val = do_spill(bcx, val, ety); } - ret store_in_dest(bcx, val, dest); + return store_in_dest(bcx, val, dest); } fn trans_compare(cx: block, op: ast::binop, lhs: ValueRef, @@ -1504,7 +1505,7 @@ fn trans_compare(cx: block, op: ast::binop, lhs: ValueRef, let _icx = cx.insn_ctxt(~"trans_compare"); if ty::type_is_scalar(rhs_t) { let rs = compare_scalar_types(cx, lhs, rhs, rhs_t, op); - ret rslt(rs.bcx, rs.val); + return rslt(rs.bcx, rs.val); } // Determine the operation we need. @@ -1598,7 +1599,7 @@ fn trans_eager_binop(cx: block, span: span, op: ast::binop, lhs: ValueRef, -> block { let mut cx = cx; let _icx = cx.insn_ctxt(~"trans_eager_binop"); - if dest == ignore { ret cx; } + if dest == ignore { return cx; } let intype = { if ty::type_is_bot(lhs_t) { rhs_t } else { lhs_t } @@ -1662,7 +1663,7 @@ fn trans_eager_binop(cx: block, span: span, op: ast::binop, lhs: ValueRef, cmpr.val } }; - ret store_in_dest(cx, val, dest); + return store_in_dest(cx, val, dest); } fn trans_assign_op(bcx: block, ex: @ast::expr, op: ast::binop, @@ -1694,7 +1695,7 @@ fn trans_assign_op(bcx: block, ex: @ast::expr, op: ast::binop, }, arg_exprs(~[src]), save_in(target)); - ret move_val(bcx, DROP_EXISTING, lhs_res.val, + return move_val(bcx, DROP_EXISTING, lhs_res.val, {bcx: bcx, val: target, kind: lv_owned}, dty); } @@ -1702,7 +1703,7 @@ fn trans_assign_op(bcx: block, ex: @ast::expr, op: ast::binop, } let {bcx, val: rhs_val} = trans_temp_expr(lhs_res.bcx, src); - ret trans_eager_binop(bcx, ex.span, + return trans_eager_binop(bcx, ex.span, op, Load(bcx, lhs_res.val), t, rhs_val, t, save_in(lhs_res.val)); } @@ -1784,7 +1785,7 @@ fn autoderef(cx: block, e_id: ast::node_id, // we should have, or we asked to deref as many times as we can assert derefs == max || max == uint::max_value; - ret {bcx: cx, val: v1, ty: t1}; + return {bcx: cx, val: v1, ty: t1}; } // refinement types would obviate the need for this @@ -1798,7 +1799,7 @@ fn trans_lazy_binop(bcx: block, op: lazy_binop_ty, a: @ast::expr, trans_temp_expr(bcx, a) } }; - if past_lhs.unreachable { ret past_lhs; } + if past_lhs.unreachable { return past_lhs; } let join = sub_block(bcx, ~"join"), before_rhs = sub_block(bcx, ~"rhs"); alt op { @@ -1811,11 +1812,11 @@ fn trans_lazy_binop(bcx: block, op: lazy_binop_ty, a: @ast::expr, } }; - if past_rhs.unreachable { ret store_in_dest(join, lhs, dest); } + if past_rhs.unreachable { return store_in_dest(join, lhs, dest); } Br(past_rhs, join.llbb); let phi = Phi(join, T_bool(), ~[lhs, rhs], ~[past_lhs.llbb, past_rhs.llbb]); - ret store_in_dest(join, phi, dest); + return store_in_dest(join, phi, dest); } fn trans_binary(bcx: block, op: ast::binop, lhs: @ast::expr, @@ -1825,7 +1826,7 @@ fn trans_binary(bcx: block, op: ast::binop, lhs: @ast::expr, alt bcx.ccx().maps.method_map.find(ex.id) { some(origin) { let fty = node_id_type(bcx, ex.callee_id); - ret trans_call_inner( + return trans_call_inner( bcx, ex.info(), fty, expr_ty(bcx, ex), |bcx| { @@ -1839,16 +1840,16 @@ fn trans_binary(bcx: block, op: ast::binop, lhs: @ast::expr, // First couple cases are lazy: alt op { ast::and { - ret trans_lazy_binop(bcx, lazy_and, lhs, rhs, dest); + return trans_lazy_binop(bcx, lazy_and, lhs, rhs, dest); } ast::or { - ret trans_lazy_binop(bcx, lazy_or, lhs, rhs, dest); + return trans_lazy_binop(bcx, lazy_or, lhs, rhs, dest); } _ { // Remaining cases are eager: let lhs_res = trans_temp_expr(bcx, lhs); let rhs_res = trans_temp_expr(lhs_res.bcx, rhs); - ret trans_eager_binop(rhs_res.bcx, ex.span, + return trans_eager_binop(rhs_res.bcx, ex.span, op, lhs_res.val, expr_ty(bcx, lhs), rhs_res.val, expr_ty(bcx, rhs), dest); @@ -1890,7 +1891,7 @@ fn trans_if(cx: block, cond: @ast::expr, thn: ast::blk, _ { else_cx } }; let else_bcx = trans_block_cleanups(else_bcx, else_cx); - ret join_returns(cx, + return join_returns(cx, ~[then_bcx, else_bcx], ~[then_dest, else_dest], dest); } @@ -1908,7 +1909,7 @@ fn trans_while(cx: block, cond: @ast::expr, body: ast::blk) CondBr(cond_bcx, cond_res.val, body_cx.llbb, next_cx.llbb); let body_end = trans_block(body_cx, body, ignore); cleanup_and_Br(body_end, body_cx, cond_cx.llbb); - ret next_cx; + return next_cx; } fn trans_loop(cx:block, body: ast::blk) -> block { @@ -1918,7 +1919,7 @@ fn trans_loop(cx:block, body: ast::blk) -> block { let body_end = trans_block(body_cx, body, ignore); cleanup_and_Br(body_end, body_cx, body_cx.llbb); Br(cx, body_cx.llbb); - ret next_cx; + return next_cx; } enum lval_kind { @@ -1943,19 +1944,19 @@ fn null_env_ptr(bcx: block) -> ValueRef { } fn lval_from_local_var(bcx: block, r: local_var_result) -> lval_result { - ret { bcx: bcx, val: r.val, kind: r.kind }; + return { bcx: bcx, val: r.val, kind: r.kind }; } fn lval_owned(bcx: block, val: ValueRef) -> lval_result { - ret {bcx: bcx, val: val, kind: lv_owned}; + return {bcx: bcx, val: val, kind: lv_owned}; } fn lval_temp(bcx: block, val: ValueRef) -> lval_result { - ret {bcx: bcx, val: val, kind: lv_temporary}; + return {bcx: bcx, val: val, kind: lv_temporary}; } fn lval_no_env(bcx: block, val: ValueRef, kind: lval_kind) -> lval_maybe_callee { - ret {bcx: bcx, val: val, kind: kind, env: is_closure}; + return {bcx: bcx, val: val, kind: kind, env: is_closure}; } fn trans_external_path(ccx: @crate_ctxt, did: ast::def_id, t: ty::t) @@ -1964,12 +1965,12 @@ fn trans_external_path(ccx: @crate_ctxt, did: ast::def_id, t: ty::t) alt ty::get(t).struct { ty::ty_fn(_) { let llty = type_of_fn_from_ty(ccx, t); - ret get_extern_fn(ccx.externs, ccx.llmod, name, + return get_extern_fn(ccx.externs, ccx.llmod, name, lib::llvm::CCallConv, llty); } _ { let llty = type_of(ccx, t); - ret get_extern_const(ccx.externs, ccx.llmod, name, llty); + return get_extern_const(ccx.externs, ccx.llmod, name, llty); } }; } @@ -2084,7 +2085,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, some(val) { debug!{"leaving monomorphic fn %s", ty::item_path_str(ccx.tcx, fn_id)}; - ret {val: val, must_cast: must_cast}; + return {val: val, must_cast: must_cast}; } none {} } @@ -2105,7 +2106,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, { (pt, i.ident, i.span) } ast_map::node_foreign_item(_, abi, _) { // Foreign externs don't have to be monomorphized. - ret {val: get_item_val(ccx, fn_id.node), + return {val: get_item_val(ccx, fn_id.node), must_cast: true}; } ast_map::node_ctor(nm, _, ct, _, pt) { (pt, nm, ct.span) } @@ -2330,7 +2331,7 @@ fn lval_static_fn_inner(bcx: block, fn_id: ast::def_id, id: ast::node_id, val = PointerCast(bcx, val, T_ptr(type_of_fn_from_ty( ccx, node_id_type(bcx, id)))); } - ret {bcx: bcx, val: val, kind: lv_owned, env: null_env}; + return {bcx: bcx, val: val, kind: lv_owned, env: null_env}; } let mut val = if fn_id.crate == ast::local_crate { @@ -2351,7 +2352,7 @@ fn lval_static_fn_inner(bcx: block, fn_id: ast::def_id, id: ast::node_id, ast::extern_fn { // Extern functions are just opaque pointers let val = PointerCast(bcx, val, T_ptr(T_i8())); - ret lval_no_env(bcx, val, lv_owned_imm); + return lval_no_env(bcx, val, lv_owned_imm); } _ { /* fall through */ } } @@ -2359,7 +2360,7 @@ fn lval_static_fn_inner(bcx: block, fn_id: ast::def_id, id: ast::node_id, _ { /* fall through */ } } - ret {bcx: bcx, val: val, kind: lv_owned, env: null_env}; + return {bcx: bcx, val: val, kind: lv_owned, env: null_env}; } fn lookup_discriminant(ccx: @crate_ctxt, vid: ast::def_id) -> ValueRef { @@ -2375,9 +2376,9 @@ fn lookup_discriminant(ccx: @crate_ctxt, vid: ast::def_id) -> ValueRef { lib::llvm::SetLinkage(gvar, lib::llvm::ExternalLinkage); llvm::LLVMSetGlobalConstant(gvar, True); ccx.discrims.insert(vid, gvar); - ret gvar; + return gvar; } - some(llval) { ret llval; } + some(llval) { return llval; } } } @@ -2398,15 +2399,15 @@ fn trans_local_var(cx: block, def: ast::def) -> local_var_result { alt def { ast::def_upvar(nid, _, _) { assert (cx.fcx.llupvars.contains_key(nid)); - ret { val: cx.fcx.llupvars.get(nid), kind: lv_owned }; + return { val: cx.fcx.llupvars.get(nid), kind: lv_owned }; } ast::def_arg(nid, _) { assert (cx.fcx.llargs.contains_key(nid)); - ret take_local(cx.fcx.llargs, nid); + return take_local(cx.fcx.llargs, nid); } ast::def_local(nid, _) | ast::def_binding(nid) { assert (cx.fcx.lllocals.contains_key(nid)); - ret take_local(cx.fcx.lllocals, nid); + return take_local(cx.fcx.lllocals, nid); } ast::def_self(sid) { let slf = alt copy cx.fcx.llself { @@ -2414,7 +2415,7 @@ fn trans_local_var(cx: block, def: ast::def) -> local_var_result { none { cx.sess().bug(~"trans_local_var: reference to self \ out of context"); } }; - ret {val: slf, kind: lv_owned}; + return {val: slf, kind: lv_owned}; } _ { cx.sess().unimpl(fmt!{"unsupported def type in trans_local_def: %?", @@ -2429,7 +2430,7 @@ fn trans_path(cx: block, id: ast::node_id) alt cx.tcx().def_map.find(id) { none { cx.sess().bug(~"trans_path: unbound node ID"); } some(df) { - ret trans_var(cx, df, id); + return trans_var(cx, df, id); } } } @@ -2439,12 +2440,12 @@ fn trans_var(cx: block, def: ast::def, id: ast::node_id)-> lval_maybe_callee { let ccx = cx.ccx(); alt def { ast::def_fn(did, _) { - ret lval_static_fn(cx, did, id); + return lval_static_fn(cx, did, id); } ast::def_variant(tid, vid) { if ty::enum_variant_with_id(ccx.tcx, tid, vid).args.len() > 0u { // N-ary variant. - ret lval_static_fn(cx, vid, id); + return lval_static_fn(cx, vid, id); } else { // Nullary variant. let enum_ty = node_id_type(cx, id); @@ -2453,22 +2454,22 @@ fn trans_var(cx: block, def: ast::def, id: ast::node_id)-> lval_maybe_callee { let lldiscrim_gv = lookup_discriminant(ccx, vid); let lldiscrim = Load(cx, lldiscrim_gv); Store(cx, lldiscrim, lldiscrimptr); - ret lval_no_env(cx, llenumptr, lv_temporary); + return lval_no_env(cx, llenumptr, lv_temporary); } } ast::def_const(did) { if did.crate == ast::local_crate { - ret lval_no_env(cx, get_item_val(ccx, did.node), lv_owned); + return lval_no_env(cx, get_item_val(ccx, did.node), lv_owned); } else { let tp = node_id_type(cx, id); let val = trans_external_path(ccx, did, tp); - ret lval_no_env(cx, load_if_immediate(cx, val, tp), + return lval_no_env(cx, load_if_immediate(cx, val, tp), lv_owned_imm); } } _ { let loc = trans_local_var(cx, def); - ret lval_no_env(cx, loc.val, loc.kind); + return lval_no_env(cx, loc.val, loc.kind); } } } @@ -2514,7 +2515,7 @@ fn trans_rec_field_inner(bcx: block, val: ValueRef, ty: ty::t, } else { GEPi(bcx, val, ~[0u, ix]) }; - ret {bcx: bcx, val: val, kind: lv_owned}; + return {bcx: bcx, val: val, kind: lv_owned}; } @@ -2564,7 +2565,7 @@ fn trans_index(cx: block, ex: @ast::expr, base: @ast::expr, trans_fail(bcx, some(ex.span), ~"bounds check") }; let elt = InBoundsGEP(bcx, base, ~[ix_val]); - ret lval_owned(bcx, PointerCast(bcx, elt, T_ptr(llunitty))); + return lval_owned(bcx, PointerCast(bcx, elt, T_ptr(llunitty))); } fn expr_is_borrowed(bcx: block, e: @ast::expr) -> bool { @@ -2579,13 +2580,13 @@ fn expr_is_lval(bcx: block, e: @ast::expr) -> bool { fn trans_callee(bcx: block, e: @ast::expr) -> lval_maybe_callee { let _icx = bcx.insn_ctxt(~"trans_callee"); alt e.node { - ast::expr_path(path) { ret trans_path(bcx, e.id); } + ast::expr_path(path) { return trans_path(bcx, e.id); } ast::expr_field(base, _, _) { // Lval means this is a record field, so not a method if !expr_is_lval(bcx, e) { alt bcx.ccx().maps.method_map.find(e.id) { some(origin) { // An impl method - ret impl::trans_method_callee(bcx, e.id, base, origin); + return impl::trans_method_callee(bcx, e.id, base, origin); } _ { bcx.ccx().sess.span_bug(e.span, ~"trans_callee: weird expr"); @@ -2596,7 +2597,7 @@ fn trans_callee(bcx: block, e: @ast::expr) -> lval_maybe_callee { _ {} } let lv = trans_temp_lval(bcx, e); - ret lval_no_env(lv.bcx, lv.val, lv.kind); + return lval_no_env(lv.bcx, lv.val, lv.kind); } // Use this when you know you are compiling an lval. @@ -2604,7 +2605,7 @@ fn trans_callee(bcx: block, e: @ast::expr) -> lval_maybe_callee { // represented as an alloca or heap, hence needs a 'load' to be used as an // immediate). fn trans_lval(cx: block, e: @ast::expr) -> lval_result { - ret alt cx.ccx().maps.root_map.find({id:e.id, derefs:0u}) { + return alt cx.ccx().maps.root_map.find({id:e.id, derefs:0u}) { // No need to root this lvalue. none { unrooted(cx, e) } @@ -2632,13 +2633,13 @@ fn trans_lval(cx: block, e: @ast::expr) -> lval_result { alt e.node { ast::expr_path(_) { let v = trans_path(cx, e.id); - ret lval_maybe_callee_to_lval(v, e.span); + return lval_maybe_callee_to_lval(v, e.span); } ast::expr_field(base, ident, _) { - ret trans_rec_field(cx, base, ident); + return trans_rec_field(cx, base, ident); } ast::expr_index(base, idx) { - ret trans_index(cx, e, base, idx); + return trans_index(cx, e, base, idx); } ast::expr_unary(ast::deref, base) { let ccx = cx.ccx(); @@ -2660,7 +2661,7 @@ fn trans_lval(cx: block, e: @ast::expr) -> lval_result { } ty::ty_ptr(_) | ty::ty_rptr(_,_) { sub.val } }; - ret lval_owned(sub.bcx, val); + return lval_owned(sub.bcx, val); } _ { cx.sess().span_bug(e.span, ~"non-lval in trans_lval"); } } @@ -2703,7 +2704,7 @@ fn int_cast(bcx: block, lldsttype: TypeRef, llsrctype: TypeRef, let _icx = bcx.insn_ctxt(~"int_cast"); let srcsz = llvm::LLVMGetIntTypeWidth(llsrctype); let dstsz = llvm::LLVMGetIntTypeWidth(lldsttype); - ret if dstsz == srcsz { + return if dstsz == srcsz { BitCast(bcx, llsrc, lldsttype) } else if srcsz > dstsz { TruncOrBitCast(bcx, llsrc, lldsttype) @@ -2717,7 +2718,7 @@ fn float_cast(bcx: block, lldsttype: TypeRef, llsrctype: TypeRef, let _icx = bcx.insn_ctxt(~"float_cast"); let srcsz = lib::llvm::float_width(llsrctype); let dstsz = lib::llvm::float_width(lldsttype); - ret if dstsz > srcsz { + return if dstsz > srcsz { FPExt(bcx, llsrc, lldsttype) } else if srcsz > dstsz { FPTrunc(bcx, llsrc, lldsttype) @@ -2746,7 +2747,7 @@ fn trans_cast(cx: block, e: @ast::expr, id: ast::node_id, let ccx = cx.ccx(); let t_out = node_id_type(cx, id); alt ty::get(t_out).struct { - ty::ty_trait(_, _) { ret impl::trans_cast(cx, e, id, dest); } + ty::ty_trait(_, _) { return impl::trans_cast(cx, e, id, dest); } _ {} } let e_res = trans_temp_expr(cx, e); @@ -2801,7 +2802,7 @@ fn trans_cast(cx: block, e: @ast::expr, id: ast::node_id, } _ { ccx.sess.bug(~"translating unsupported cast.") } }; - ret store_in_dest(e_res.bcx, newval, dest); + return store_in_dest(e_res.bcx, newval, dest); } fn trans_loop_body(bcx: block, e: @ast::expr, ret_flag: option<ValueRef>, @@ -2923,7 +2924,7 @@ fn trans_arg_expr(cx: block, arg: ty::arg, lldestty: TypeRef, e: @ast::expr, } debug!{"--- trans_arg_expr passing %s", val_str(bcx.ccx().tn, val)}; - ret rslt(bcx, val); + return rslt(bcx, val); } // when invoking a method, an argument of type @T or ~T can be implicltly @@ -2939,7 +2940,7 @@ fn adapt_borrowed_value(lv: lval_result, ty: ty::t} { let bcx = lv.bcx; if !expr_is_borrowed(bcx, e) { - ret {lv:lv, ty:e_ty}; + return {lv:lv, ty:e_ty}; } alt ty::get(e_ty).struct { @@ -2947,7 +2948,7 @@ fn adapt_borrowed_value(lv: lval_result, let box_ptr = load_value_from_lval_result(lv, e_ty); let body_ptr = GEPi(bcx, box_ptr, ~[0u, abi::box_field_body]); let rptr_ty = ty::mk_rptr(bcx.tcx(), ty::re_static, mt); - ret {lv: lval_temp(bcx, body_ptr), ty: rptr_ty}; + return {lv: lval_temp(bcx, body_ptr), ty: rptr_ty}; } ty::ty_estr(_) | ty::ty_evec(_, _) { @@ -2977,7 +2978,7 @@ fn adapt_borrowed_value(lv: lval_result, {ty: unit_ty, mutbl: ast::m_imm}, ty::vstore_slice(ty::re_static)); - ret {lv: lval_temp(bcx, p), ty: slice_ty}; + return {lv: lval_temp(bcx, p), ty: slice_ty}; } _ { @@ -3056,7 +3057,7 @@ fn trans_args(cx: block, llenv: ValueRef, args: call_args, fn_ty: ty::t, revoke_clean(bcx, c) } - ret {bcx: bcx, + return {bcx: bcx, args: llargs, retslot: llretslot}; } @@ -3180,31 +3181,31 @@ fn trans_call_inner( fn invoke(bcx: block, llfn: ValueRef, llargs: ~[ValueRef]) -> block { let _icx = bcx.insn_ctxt(~"invoke_"); - if bcx.unreachable { ret bcx; } + if bcx.unreachable { return bcx; } if need_invoke(bcx) { log(debug, ~"invoking"); let normal_bcx = sub_block(bcx, ~"normal return"); Invoke(bcx, llfn, llargs, normal_bcx.llbb, get_landing_pad(bcx)); - ret normal_bcx; + return normal_bcx; } else { log(debug, ~"calling"); Call(bcx, llfn, llargs); - ret bcx; + return bcx; } } fn need_invoke(bcx: block) -> bool { if (bcx.ccx().sess.opts.debugging_opts & session::no_landing_pads != 0) { - ret false; + return false; } // Avoid using invoke if we are already inside a landing pad. if bcx.is_lpad { - ret false; + return false; } if have_cached_lpad(bcx) { - ret true; + return true; } // Walk the scopes to look for cleanups @@ -3216,7 +3217,7 @@ fn need_invoke(bcx: block) -> bool { alt cleanup { clean(_, cleanup_type) | clean_temp(_, _, cleanup_type) { if cleanup_type == normal_exit_and_unwind { - ret true; + return true; } } } @@ -3226,7 +3227,7 @@ fn need_invoke(bcx: block) -> bool { } cur = alt cur.parent { some(next) { next } - none { ret false; } + none { return false; } } } } @@ -3239,7 +3240,7 @@ fn have_cached_lpad(bcx: block) -> bool { none { res = false; } } } - ret res; + return res; } fn in_lpad_scope_cx(bcx: block, f: fn(scope_info)) { @@ -3248,7 +3249,7 @@ fn in_lpad_scope_cx(bcx: block, f: fn(scope_info)) { alt bcx.kind { block_scope(inf) { if inf.cleanups.len() > 0u || is_none(bcx.parent) { - f(inf); ret; + f(inf); return; } } _ {} @@ -3271,7 +3272,8 @@ fn get_landing_pad(bcx: block) -> BasicBlockRef { } } } - alt cached { some(b) { ret b; } none {} } // Can't return from block above + // Can't return from block above + alt cached { some(b) { return b; } none {} } // The landing pad return type (the type being propagated). Not sure what // this represents but it's determined by the personality function and // this is what the EH proposal example uses. @@ -3303,7 +3305,7 @@ fn get_landing_pad(bcx: block) -> BasicBlockRef { // Unwind all parent scopes, and finish with a Resume instr cleanup_and_leave(pad_bcx, none, none); - ret pad_bcx.llbb; + return pad_bcx.llbb; } fn trans_tup(bcx: block, elts: ~[@ast::expr], dest: dest) -> block { @@ -3312,7 +3314,7 @@ fn trans_tup(bcx: block, elts: ~[@ast::expr], dest: dest) -> block { let addr = alt dest { ignore { for vec::each(elts) |ex| { bcx = trans_expr(bcx, ex, ignore); } - ret bcx; + return bcx; } save_in(pos) { pos } _ { bcx.tcx().sess.bug(~"trans_tup: weird dest"); } @@ -3326,7 +3328,7 @@ fn trans_tup(bcx: block, elts: ~[@ast::expr], dest: dest) -> block { vec::push(temp_cleanups, dst); } for vec::each(temp_cleanups) |cleanup| { revoke_clean(bcx, cleanup); } - ret bcx; + return bcx; } fn trans_rec(bcx: block, fields: ~[ast::field], @@ -3340,7 +3342,7 @@ fn trans_rec(bcx: block, fields: ~[ast::field], for vec::each(fields) |fld| { bcx = trans_expr(bcx, fld.node.expr, ignore); } - ret bcx; + return bcx; } save_in(pos) { pos } }; @@ -3377,7 +3379,7 @@ fn trans_rec(bcx: block, fields: ~[ast::field], // Now revoke the cleanups as we pass responsibility for the data // structure on to the caller for temp_cleanups.each |cleanup| { revoke_clean(bcx, cleanup); } - ret bcx; + return bcx; } fn trans_struct(block_context: block, span: span, fields: ~[ast::field], @@ -3399,7 +3401,7 @@ fn trans_struct(block_context: block, span: span, fields: ~[ast::field], field.node.expr, ignore); } - ret block_context; + return block_context; } save_in(destination_address) => { dest_address = destination_address; @@ -3470,7 +3472,7 @@ fn trans_expr_save_in(bcx: block, e: @ast::expr, dest: ValueRef) -> block { let t = expr_ty(bcx, e); let do_ignore = ty::type_is_bot(t) || ty::type_is_nil(t); - ret trans_expr(bcx, e, if do_ignore { ignore } else { save_in(dest) }); + return trans_expr(bcx, e, if do_ignore { ignore } else { save_in(dest) }); } // Call this to compile an expression that you need as an intermediate value, @@ -3482,22 +3484,22 @@ fn trans_temp_lval(bcx: block, e: @ast::expr) -> lval_result { let _icx = bcx.insn_ctxt(~"trans_temp_lval"); let mut bcx = bcx; if expr_is_lval(bcx, e) { - ret trans_lval(bcx, e); + return trans_lval(bcx, e); } else { let ty = expr_ty(bcx, e); if ty::type_is_nil(ty) || ty::type_is_bot(ty) { bcx = trans_expr(bcx, e, ignore); - ret {bcx: bcx, val: C_nil(), kind: lv_temporary}; + return {bcx: bcx, val: C_nil(), kind: lv_temporary}; } else if ty::type_is_immediate(ty) { let cell = empty_dest_cell(); bcx = trans_expr(bcx, e, by_val(cell)); add_clean_temp(bcx, *cell, ty); - ret {bcx: bcx, val: *cell, kind: lv_temporary}; + return {bcx: bcx, val: *cell, kind: lv_temporary}; } else { let scratch = alloc_ty(bcx, ty); let bcx = trans_expr_save_in(bcx, e, scratch); add_clean_temp(bcx, scratch, ty); - ret {bcx: bcx, val: scratch, kind: lv_temporary}; + return {bcx: bcx, val: scratch, kind: lv_temporary}; } } } @@ -3546,7 +3548,7 @@ fn add_root_cleanup(bcx: block, scope_id: ast::node_id, let mut bcx_sid = bcx; loop { bcx_sid = alt bcx_sid.node_info { - some({id, _}) if id == scope_id { ret bcx_sid; } + some({id, _}) if id == scope_id { return bcx_sid; } _ { alt bcx_sid.parent { none { @@ -3570,10 +3572,10 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { debuginfo::update_source_pos(bcx, e.span); if expr_is_lval(bcx, e) { - ret lval_to_dps(bcx, e, dest); + return lval_to_dps(bcx, e, dest); } - ret alt bcx.ccx().maps.root_map.find({id:e.id, derefs:0u}) { + return alt bcx.ccx().maps.root_map.find({id:e.id, derefs:0u}) { none { unrooted(bcx, e, dest) } some(scope_id) { debug!{"expression %d found in root map with scope %d", @@ -3599,39 +3601,41 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { let tcx = bcx.tcx(); alt e.node { ast::expr_if(cond, thn, els) { - ret trans_if(bcx, cond, thn, els, dest); + return trans_if(bcx, cond, thn, els, dest); } ast::expr_alt(expr, arms, mode) { - ret alt::trans_alt(bcx, e, expr, arms, mode, dest); + return alt::trans_alt(bcx, e, expr, arms, mode, dest); } ast::expr_block(blk) { - ret do with_scope(bcx, blk.info(), ~"block-expr body") |bcx| { + return do with_scope(bcx, blk.info(), ~"block-expr body") |bcx| { trans_block(bcx, blk, dest) }; } ast::expr_rec(args, base) { - ret trans_rec(bcx, args, base, e.id, dest); + return trans_rec(bcx, args, base, e.id, dest); } ast::expr_struct(_, fields) { - ret trans_struct(bcx, e.span, fields, e.id, dest); + return trans_struct(bcx, e.span, fields, e.id, dest); } - ast::expr_tup(args) { ret trans_tup(bcx, args, dest); } - ast::expr_vstore(e, v) { ret tvec::trans_vstore(bcx, e, v, dest); } - ast::expr_lit(lit) { ret trans_lit(bcx, e, *lit, dest); } + ast::expr_tup(args) { return trans_tup(bcx, args, dest); } + ast::expr_vstore(e, v) { + return tvec::trans_vstore(bcx, e, v, dest); + } + ast::expr_lit(lit) { return trans_lit(bcx, e, *lit, dest); } ast::expr_vec(args, _) { - ret tvec::trans_evec(bcx, args, ast::vstore_fixed(none), + return tvec::trans_evec(bcx, args, ast::vstore_fixed(none), e.id, dest); } ast::expr_binary(op, lhs, rhs) { - ret trans_binary(bcx, op, lhs, rhs, dest, e); + return trans_binary(bcx, op, lhs, rhs, dest, e); } ast::expr_unary(op, x) { assert op != ast::deref; // lvals are handled above - ret trans_unary(bcx, op, x, e, dest); + return trans_unary(bcx, op, x, e, dest); } - ast::expr_addr_of(_, x) { ret trans_addr_of(bcx, x, dest); } + ast::expr_addr_of(_, x) { return trans_addr_of(bcx, x, dest); } ast::expr_fn(proto, decl, body, cap_clause) { - ret closure::trans_expr_fn(bcx, proto, decl, body, e.id, + return closure::trans_expr_fn(bcx, proto, decl, body, e.id, cap_clause, none, dest); } ast::expr_fn_block(decl, body, cap_clause) { @@ -3640,41 +3644,41 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { debug!{"translating fn_block %s with type %s", expr_to_str(e), ppaux::ty_to_str(tcx, expr_ty(bcx, e))}; - ret closure::trans_expr_fn(bcx, proto, decl, body, + return closure::trans_expr_fn(bcx, proto, decl, body, e.id, cap_clause, none, dest); } } } ast::expr_loop_body(blk) { - ret trans_loop_body(bcx, e, none, dest); + return trans_loop_body(bcx, e, none, dest); } ast::expr_do_body(blk) { - ret trans_expr(bcx, blk, dest); + return trans_expr(bcx, blk, dest); } ast::expr_copy(a) | ast::expr_unary_move(a) { if !expr_is_lval(bcx, a) { - ret trans_expr(bcx, a, dest); + return trans_expr(bcx, a, dest); } - else { ret lval_to_dps(bcx, a, dest); } + else { return lval_to_dps(bcx, a, dest); } } - ast::expr_cast(val, _) { ret trans_cast(bcx, val, e.id, dest); } + ast::expr_cast(val, _) { return trans_cast(bcx, val, e.id, dest); } ast::expr_call(f, args, _) { - ret trans_call(bcx, e, f, arg_exprs(args), e.id, dest); + return trans_call(bcx, e, f, arg_exprs(args), e.id, dest); } ast::expr_field(base, _, _) { - if dest == ignore { ret trans_expr(bcx, base, ignore); } + if dest == ignore { return trans_expr(bcx, base, ignore); } let callee = trans_callee(bcx, e), ty = expr_ty(bcx, e); let lv = lval_maybe_callee_to_lval(callee, e.span); revoke_clean(lv.bcx, lv.val); memmove_ty(lv.bcx, get_dest_addr(dest), lv.val, ty); - ret lv.bcx; + return lv.bcx; } ast::expr_index(base, idx) { // If it is here, it's not an lval, so this is a user-defined // index op let origin = bcx.ccx().maps.method_map.get(e.id); let fty = node_id_type(bcx, e.callee_id); - ret trans_call_inner( + return trans_call_inner( bcx, e.info(), fty, expr_ty(bcx, e), |bcx| impl::trans_method_callee(bcx, e.callee_id, base, @@ -3685,35 +3689,35 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { // These return nothing ast::expr_break { assert dest == ignore; - ret trans_break(bcx); + return trans_break(bcx); } ast::expr_again { assert dest == ignore; - ret trans_cont(bcx); + return trans_cont(bcx); } ast::expr_ret(ex) { assert dest == ignore; - ret trans_ret(bcx, ex); + return trans_ret(bcx, ex); } ast::expr_fail(expr) { assert dest == ignore; - ret trans_fail_expr(bcx, some(e.span), expr); + return trans_fail_expr(bcx, some(e.span), expr); } ast::expr_log(_, lvl, a) { assert dest == ignore; - ret trans_log(e, lvl, bcx, a); + return trans_log(e, lvl, bcx, a); } ast::expr_assert(a) { assert dest == ignore; - ret trans_check_expr(bcx, e, a, ~"Assertion"); + return trans_check_expr(bcx, e, a, ~"Assertion"); } ast::expr_while(cond, body) { assert dest == ignore; - ret trans_while(bcx, cond, body); + return trans_while(bcx, cond, body); } ast::expr_loop(body) { assert dest == ignore; - ret trans_loop(bcx, body); + return trans_loop(bcx, body); } ast::expr_assign(dst, src) { assert dest == ignore; @@ -3722,7 +3726,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { assert kind == lv_owned; let is_last_use = bcx.ccx().maps.last_use_map.contains_key(src.id); - ret store_temp_expr(bcx, DROP_EXISTING, addr, src_r, + return store_temp_expr(bcx, DROP_EXISTING, addr, src_r, expr_ty(bcx, src), is_last_use); } ast::expr_move(dst, src) { @@ -3731,7 +3735,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { let src_r = trans_temp_lval(bcx, src); let {bcx, val: addr, kind} = trans_lval(src_r.bcx, dst); assert kind == lv_owned; - ret move_val(bcx, DROP_EXISTING, addr, src_r, + return move_val(bcx, DROP_EXISTING, addr, src_r, expr_ty(bcx, src)); } ast::expr_swap(dst, src) { @@ -3744,12 +3748,12 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { // Swap through a temporary. let bcx = move_val(rhs_res.bcx, INIT, tmp_alloc, lhs_res, t); let bcx = move_val(bcx, INIT, lhs_res.val, rhs_res, t); - ret move_val(bcx, INIT, rhs_res.val, + return move_val(bcx, INIT, rhs_res.val, lval_owned(bcx, tmp_alloc), t); } ast::expr_assign_op(op, dst, src) { assert dest == ignore; - ret trans_assign_op(bcx, e, op, dst, src); + return trans_assign_op(bcx, e, op, dst, src); } ast::expr_new(pool, alloc_id, val) { // First, call pool->alloc(tydesc) to get back a void*. @@ -3832,16 +3836,16 @@ fn lval_result_to_dps(lv: lval_result, ty: ty::t, } ignore {} } - ret bcx; + return bcx; } fn do_spill(bcx: block, v: ValueRef, t: ty::t) -> ValueRef { if ty::type_is_bot(t) { - ret C_null(T_ptr(T_i8())); + return C_null(T_ptr(T_i8())); } let llptr = alloc_ty(bcx, t); Store(bcx, v, llptr); - ret llptr; + return llptr; } // Since this function does *not* root, it is the caller's responsibility to @@ -3852,19 +3856,19 @@ fn do_spill(bcx: block, v: ValueRef, t: ty::t) -> ValueRef { fn do_spill_noroot(++cx: block, v: ValueRef) -> ValueRef { let llptr = alloca(cx, val_ty(v)); Store(cx, v, llptr); - ret llptr; + return llptr; } fn spill_if_immediate(cx: block, v: ValueRef, t: ty::t) -> ValueRef { let _icx = cx.insn_ctxt(~"spill_if_immediate"); - if ty::type_is_immediate(t) { ret do_spill(cx, v, t); } - ret v; + if ty::type_is_immediate(t) { return do_spill(cx, v, t); } + return v; } fn load_if_immediate(cx: block, v: ValueRef, t: ty::t) -> ValueRef { let _icx = cx.insn_ctxt(~"load_if_immediate"); - if ty::type_is_immediate(t) { ret Load(cx, v); } - ret v; + if ty::type_is_immediate(t) { return Load(cx, v); } + return v; } fn trans_log(log_ex: @ast::expr, lvl: @ast::expr, @@ -3872,7 +3876,7 @@ fn trans_log(log_ex: @ast::expr, lvl: @ast::expr, let _icx = bcx.insn_ctxt(~"trans_log"); let ccx = bcx.ccx(); if ty::type_is_bot(expr_ty(bcx, lvl)) { - ret trans_expr(bcx, lvl, ignore); + return trans_expr(bcx, lvl, ignore); } let modpath = vec::append( @@ -3946,21 +3950,21 @@ fn trans_fail_expr(bcx: block, sp_opt: option<span>, if ty::type_is_str(e_ty) { let body = tvec::get_bodyptr(bcx, expr_res.val); let data = tvec::get_dataptr(bcx, body); - ret trans_fail_value(bcx, sp_opt, data); + return trans_fail_value(bcx, sp_opt, data); } else if bcx.unreachable || ty::type_is_bot(e_ty) { - ret bcx; + return bcx; } else { bcx.sess().span_bug( expr.span, ~"fail called with unsupported type " + ppaux::ty_to_str(tcx, e_ty)); } } - _ { ret trans_fail(bcx, sp_opt, ~"explicit failure"); } + _ { return trans_fail(bcx, sp_opt, ~"explicit failure"); } } } fn trans_trace(bcx: block, sp_opt: option<span>, trace_str: ~str) { - if !bcx.sess().trace() { ret; } + if !bcx.sess().trace() { return; } let _icx = bcx.insn_ctxt(~"trans_trace"); add_comment(bcx, trace_str); let V_trace_str = C_cstr(bcx.ccx(), trace_str); @@ -3987,7 +3991,7 @@ fn trans_fail(bcx: block, sp_opt: option<span>, fail_str: ~str) -> block { let _icx = bcx.insn_ctxt(~"trans_fail"); let V_fail_str = C_cstr(bcx.ccx(), fail_str); - ret trans_fail_value(bcx, sp_opt, V_fail_str); + return trans_fail_value(bcx, sp_opt, V_fail_str); } fn trans_fail_value(bcx: block, sp_opt: option<span>, @@ -4011,7 +4015,7 @@ fn trans_fail_value(bcx: block, sp_opt: option<span>, let args = ~[V_str, V_filename, C_int(ccx, V_line)]; let bcx = trans_rtcall(bcx, ~"fail", args, ignore); Unreachable(bcx); - ret bcx; + return bcx; } fn trans_rtcall(bcx: block, name: ~str, args: ~[ValueRef], dest: dest) @@ -4023,7 +4027,7 @@ fn trans_rtcall(bcx: block, name: ~str, args: ~[ValueRef], dest: dest) csearch::get_type(bcx.ccx().tcx, did).ty }; let rty = ty::ty_fn_ret(fty); - ret trans_call_inner( + return trans_call_inner( bcx, none, fty, rty, |bcx| lval_static_fn_inner(bcx, did, 0, ~[], none), arg_vals(args), dest); @@ -4054,21 +4058,21 @@ fn trans_break_cont(bcx: block, to_end: bool) Store(bcx, C_bool(!to_end), bcx.fcx.llretptr); cleanup_and_leave(bcx, none, some(bcx.fcx.llreturn)); Unreachable(bcx); - ret bcx; + return bcx; } }; } cleanup_and_Br(bcx, unwind, target.llbb); Unreachable(bcx); - ret bcx; + return bcx; } fn trans_break(cx: block) -> block { - ret trans_break_cont(cx, true); + return trans_break_cont(cx, true); } fn trans_cont(cx: block) -> block { - ret trans_break_cont(cx, false); + return trans_break_cont(cx, false); } fn trans_ret(bcx: block, e: option<@ast::expr>) -> block { @@ -4097,7 +4101,7 @@ fn trans_ret(bcx: block, e: option<@ast::expr>) -> block { } cleanup_and_leave(bcx, none, some(bcx.fcx.llreturn)); Unreachable(bcx); - ret bcx; + return bcx; } fn build_return(bcx: block) { @@ -4130,7 +4134,7 @@ fn init_local(bcx: block, local: @ast::local) -> block { } // Make a note to drop this slot on the way out. add_clean(bcx, llptr, ty); - ret alt::bind_irrefutable_pat(bcx, local.node.pat, llptr, false); + return alt::bind_irrefutable_pat(bcx, local.node.pat, llptr, false); } fn trans_stmt(cx: block, s: ast::stmt) -> block { @@ -4163,7 +4167,7 @@ fn trans_stmt(cx: block, s: ast::stmt) -> block { } } - ret bcx; + return bcx; } // You probably don't want to use this one. See the @@ -4182,7 +4186,7 @@ fn new_block(cx: fn_ctxt, parent: option<block>, +kind: block_kind, do option::iter(parent) |cx| { if cx.unreachable { Unreachable(bcx); } }; - ret bcx; + return bcx; } fn simple_block_scope() -> block_kind { @@ -4192,20 +4196,20 @@ fn simple_block_scope() -> block_kind { // Use this when you're at the top block of a function or the like. fn top_scope_block(fcx: fn_ctxt, opt_node_info: option<node_info>) -> block { - ret new_block(fcx, none, simple_block_scope(), false, + return new_block(fcx, none, simple_block_scope(), false, ~"function top level", opt_node_info); } fn scope_block(bcx: block, opt_node_info: option<node_info>, n: ~str) -> block { - ret new_block(bcx.fcx, some(bcx), simple_block_scope(), bcx.is_lpad, + return new_block(bcx.fcx, some(bcx), simple_block_scope(), bcx.is_lpad, n, opt_node_info); } fn loop_scope_block(bcx: block, loop_break: block, n: ~str, opt_node_info: option<node_info>) -> block { - ret new_block(bcx.fcx, some(bcx), block_scope({ + return new_block(bcx.fcx, some(bcx), block_scope({ loop_break: some(loop_break), mut cleanups: ~[], mut cleanup_paths: ~[], @@ -4242,7 +4246,7 @@ fn trans_block_cleanups(bcx: block, cleanup_cx: block) -> block { fn trans_block_cleanups_(bcx: block, cleanup_cx: block, is_lpad: bool) -> block { let _icx = bcx.insn_ctxt(~"trans_block_cleanups"); - if bcx.unreachable { ret bcx; } + if bcx.unreachable { return bcx; } let mut bcx = bcx; alt check cleanup_cx.kind { block_scope({cleanups, _}) { @@ -4260,7 +4264,7 @@ fn trans_block_cleanups_(bcx: block, cleanup_cx: block, is_lpad: bool) -> } } } - ret bcx; + return bcx; } // In the last argument, some(block) mean jump to this block, and none means @@ -4285,7 +4289,7 @@ fn cleanup_and_leave(bcx: block, upto: option<BasicBlockRef>, for vec::find(inf.cleanup_paths, |cp| cp.target == leave).each |cp| { Br(bcx, cp.dest); - ret; + return; } let sub_cx = sub_block(bcx, ~"cleanup"); Br(bcx, sub_cx.llbb); @@ -4373,7 +4377,7 @@ fn alloc_ty(bcx: block, t: ty::t) -> ValueRef { if ty::type_has_params(t) { log(error, ppaux::ty_to_str(ccx.tcx, t)); } assert !ty::type_has_params(t); let val = alloca(bcx, llty); - ret val; + return val; } fn alloc_local(cx: block, local: @ast::local) -> block { @@ -4392,7 +4396,7 @@ fn alloc_local(cx: block, local: @ast::local) -> block { } } cx.fcx.lllocals.insert(local.node.id, local_mem(val)); - ret cx; + return cx; } fn trans_block(bcx: block, b: ast::blk, dest: dest) @@ -4412,7 +4416,7 @@ fn trans_block(bcx: block, b: ast::blk, dest: dest) } _ { assert dest == ignore || bcx.unreachable; } } - ret bcx; + return bcx; } // Creates the standard set of basic blocks for a function @@ -4438,7 +4442,7 @@ fn new_fn_ctxt_w_id(ccx: @crate_ctxt, path: path, param_substs: option<param_substs>, sp: option<span>) -> fn_ctxt { let llbbs = mk_standard_basic_blocks(llfndecl); - ret @{llfn: llfndecl, + return @{llfn: llfndecl, llenv: llvm::LLVMGetParam(llfndecl, 1u as c_uint), llretptr: llvm::LLVMGetParam(llfndecl, 0u as c_uint), mut llstaticallocas: llbbs.sa, @@ -4459,7 +4463,7 @@ fn new_fn_ctxt_w_id(ccx: @crate_ctxt, path: path, fn new_fn_ctxt(ccx: @crate_ctxt, path: path, llfndecl: ValueRef, sp: option<span>) -> fn_ctxt { - ret new_fn_ctxt_w_id(ccx, path, llfndecl, -1, none, sp); + return new_fn_ctxt_w_id(ccx, path, llfndecl, -1, none, sp); } // NB: must keep 4 fns in sync: @@ -4534,7 +4538,7 @@ fn copy_args_to_allocas(fcx: fn_ctxt, bcx: block, args: ~[ast::arg], } arg_n += 1u; } - ret bcx; + return bcx; } // Ties up the llstaticallocas -> llloadenv -> lltop edges, @@ -4886,7 +4890,7 @@ fn trans_mod(ccx: @crate_ctxt, m: ast::_mod) { fn get_pair_fn_ty(llpairty: TypeRef) -> TypeRef { // Bit of a kludge: pick the fn typeref out of the pair. - ret struct_elt(llpairty, 0u); + return struct_elt(llpairty, 0u); } fn register_fn(ccx: @crate_ctxt, sp: span, path: path, @@ -4965,14 +4969,14 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef, finish_fn(fcx, lltop); - ret llfdecl; + return llfdecl; } fn create_entry_fn(ccx: @crate_ctxt, rust_main: ValueRef) { #[cfg(windows)] - fn main_name() -> ~str { ret ~"WinMain@16"; } + fn main_name() -> ~str { return ~"WinMain@16"; } #[cfg(unix)] - fn main_name() -> ~str { ret ~"main"; } + fn main_name() -> ~str { return ~"main"; } let llfty = T_fn(~[ccx.int_type, ccx.int_type], ccx.int_type); let llfn = decl_cdecl_fn(ccx.llmod, main_name(), llfty); let llbb = str::as_c_str(~"top", |buf| { @@ -5002,7 +5006,7 @@ fn create_real_fn_pair(cx: block, llfnty: TypeRef, llfn: ValueRef, llenvptr: ValueRef) -> ValueRef { let pair = alloca(cx, T_fn_pair(cx.ccx(), llfnty)); fill_fn_pair(cx, pair, llfn, llenvptr); - ret pair; + return pair; } fn fill_fn_pair(bcx: block, pair: ValueRef, llfn: ValueRef, @@ -5191,11 +5195,11 @@ fn trans_constants(ccx: @crate_ctxt, crate: @ast::crate) { fn vp2i(cx: block, v: ValueRef) -> ValueRef { let ccx = cx.ccx(); - ret PtrToInt(cx, v, ccx.int_type); + return PtrToInt(cx, v, ccx.int_type); } fn p2i(ccx: @crate_ctxt, v: ValueRef) -> ValueRef { - ret llvm::LLVMConstPtrToInt(v, ccx.int_type); + return llvm::LLVMConstPtrToInt(v, ccx.int_type); } fn declare_intrinsics(llmod: ModuleRef) -> hashmap<~str, ValueRef> { @@ -5243,7 +5247,7 @@ fn declare_intrinsics(llmod: ModuleRef) -> hashmap<~str, ValueRef> { intrinsics.insert(~"llvm.memset.p0i8.i64", memset64); intrinsics.insert(~"llvm.trap", trap); intrinsics.insert(~"llvm.frameaddress", frameaddress); - ret intrinsics; + return intrinsics; } fn declare_dbg_intrinsics(llmod: ModuleRef, @@ -5360,7 +5364,7 @@ fn create_module_map(ccx: @crate_ctxt) -> ValueRef { let term = C_struct(~[C_int(ccx, 0), C_int(ccx, 0)]); vec::push(elts, term); llvm::LLVMSetInitializer(map, C_array(elttype, elts)); - ret map; + return map; } @@ -5381,7 +5385,7 @@ fn decl_crate_map(sess: session::session, mapmeta: link_meta, llvm::LLVMAddGlobal(llmod, maptype, buf) }); lib::llvm::SetLinkage(map, lib::llvm::ExternalLinkage); - ret map; + return map; } fn fill_crate_map(ccx: @crate_ctxt, map: ValueRef) { @@ -5411,7 +5415,7 @@ fn crate_ctxt_to_encode_parms(cx: @crate_ctxt) let encode_inlined_item = |a,b,c,d| astencode::encode_inlined_item(a, b, c, d, cx.maps); - ret { + return { diag: cx.sess.diagnostic(), tcx: cx.tcx, reachable: cx.reachable, @@ -5437,7 +5441,7 @@ fn crate_ctxt_to_encode_parms(cx: @crate_ctxt) vec::push(reexports, (path, def.id)); } } - ret reexports; + return reexports; } fn impl_map(cx: @crate_ctxt, @@ -5446,12 +5450,12 @@ fn crate_ctxt_to_encode_parms(cx: @crate_ctxt) for list::each(cx.maps.impl_map.get(id)) |impls| { vec::push_all(result, (*impls).map(|i| (i.ident, i.did))); } - ret result; + return result; } } fn write_metadata(cx: @crate_ctxt, crate: @ast::crate) { - if !cx.sess.building_library { ret; } + if !cx.sess.building_library { return; } let encode_parms = crate_ctxt_to_encode_parms(cx); let llmeta = C_bytes(encoder::encode_metadata(encode_parms, crate)); let llconst = C_struct(~[llmeta]); @@ -5631,7 +5635,7 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt, io::println(fmt!{"%-7u %s", v, k}); } } - ret (llmod, link_meta); + return (llmod, link_meta); } // // Local Variables: diff --git a/src/rustc/middle/trans/build.rs b/src/rustc/middle/trans/build.rs index 5fa90ecece2..d664d11d1e4 100644 --- a/src/rustc/middle/trans/build.rs +++ b/src/rustc/middle/trans/build.rs @@ -12,7 +12,7 @@ import driver::session::session; fn B(cx: block) -> BuilderRef { let b = cx.fcx.ccx.builder.B; llvm::LLVMPositionBuilderAtEnd(b, cx.llbb); - ret b; + return b; } fn count_insn(cx: block, category: ~str) { @@ -60,11 +60,11 @@ fn count_insn(cx: block, category: ~str) { // terminated, we're saying that trying to add any further statements in the // block is an error. On the other hand, if something is unreachable, that // means that the block was terminated in some way that we don't want to check -// for (fail/break/ret statements, call to diverging functions, etc), and +// for (fail/break/return statements, call to diverging functions, etc), and // further instructions to the block should simply be ignored. fn RetVoid(cx: block) { - if cx.unreachable { ret; } + if cx.unreachable { return; } assert (!cx.terminated); cx.terminated = true; count_insn(cx, ~"retvoid"); @@ -72,7 +72,7 @@ fn RetVoid(cx: block) { } fn Ret(cx: block, V: ValueRef) { - if cx.unreachable { ret; } + if cx.unreachable { return; } assert (!cx.terminated); cx.terminated = true; count_insn(cx, ~"ret"); @@ -80,7 +80,7 @@ fn Ret(cx: block, V: ValueRef) { } fn AggregateRet(cx: block, RetVals: ~[ValueRef]) { - if cx.unreachable { ret; } + if cx.unreachable { return; } assert (!cx.terminated); cx.terminated = true; unsafe { @@ -90,7 +90,7 @@ fn AggregateRet(cx: block, RetVals: ~[ValueRef]) { } fn Br(cx: block, Dest: BasicBlockRef) { - if cx.unreachable { ret; } + if cx.unreachable { return; } assert (!cx.terminated); cx.terminated = true; count_insn(cx, ~"br"); @@ -99,7 +99,7 @@ fn Br(cx: block, Dest: BasicBlockRef) { fn CondBr(cx: block, If: ValueRef, Then: BasicBlockRef, Else: BasicBlockRef) { - if cx.unreachable { ret; } + if cx.unreachable { return; } assert (!cx.terminated); cx.terminated = true; count_insn(cx, ~"condbr"); @@ -108,19 +108,19 @@ fn CondBr(cx: block, If: ValueRef, Then: BasicBlockRef, fn Switch(cx: block, V: ValueRef, Else: BasicBlockRef, NumCases: uint) -> ValueRef { - if cx.unreachable { ret _Undef(V); } + if cx.unreachable { return _Undef(V); } assert !cx.terminated; cx.terminated = true; - ret llvm::LLVMBuildSwitch(B(cx), V, Else, NumCases as c_uint); + return llvm::LLVMBuildSwitch(B(cx), V, Else, NumCases as c_uint); } fn AddCase(S: ValueRef, OnVal: ValueRef, Dest: BasicBlockRef) { - if llvm::LLVMIsUndef(S) == lib::llvm::True { ret; } + if llvm::LLVMIsUndef(S) == lib::llvm::True { return; } llvm::LLVMAddCase(S, OnVal, Dest); } fn IndirectBr(cx: block, Addr: ValueRef, NumDests: uint) { - if cx.unreachable { ret; } + if cx.unreachable { return; } assert (!cx.terminated); cx.terminated = true; count_insn(cx, ~"indirectbr"); @@ -131,12 +131,12 @@ fn IndirectBr(cx: block, Addr: ValueRef, NumDests: uint) { // lot more efficient) than doing str::as_c_str("", ...) every time. fn noname() -> *libc::c_char unsafe { const cnull: uint = 0u; - ret unsafe::reinterpret_cast(ptr::addr_of(cnull)); + return unsafe::reinterpret_cast(ptr::addr_of(cnull)); } fn Invoke(cx: block, Fn: ValueRef, Args: ~[ValueRef], Then: BasicBlockRef, Catch: BasicBlockRef) { - if cx.unreachable { ret; } + if cx.unreachable { return; } assert (!cx.terminated); cx.terminated = true; debug!{"Invoke(%s with arguments (%s))", @@ -153,7 +153,7 @@ fn Invoke(cx: block, Fn: ValueRef, Args: ~[ValueRef], fn FastInvoke(cx: block, Fn: ValueRef, Args: ~[ValueRef], Then: BasicBlockRef, Catch: BasicBlockRef) { - if cx.unreachable { ret; } + if cx.unreachable { return; } assert (!cx.terminated); cx.terminated = true; unsafe { @@ -166,7 +166,7 @@ fn FastInvoke(cx: block, Fn: ValueRef, Args: ~[ValueRef], } fn Unreachable(cx: block) { - if cx.unreachable { ret; } + if cx.unreachable { return; } cx.unreachable = true; if !cx.terminated { count_insn(cx, ~"unreachable"); @@ -175,223 +175,223 @@ fn Unreachable(cx: block) { } fn _Undef(val: ValueRef) -> ValueRef { - ret llvm::LLVMGetUndef(val_ty(val)); + return llvm::LLVMGetUndef(val_ty(val)); } /* Arithmetic */ fn Add(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"add"); - ret llvm::LLVMBuildAdd(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildAdd(B(cx), LHS, RHS, noname()); } fn NSWAdd(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"nswadd"); - ret llvm::LLVMBuildNSWAdd(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildNSWAdd(B(cx), LHS, RHS, noname()); } fn NUWAdd(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"nuwadd"); - ret llvm::LLVMBuildNUWAdd(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildNUWAdd(B(cx), LHS, RHS, noname()); } fn FAdd(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"fadd"); - ret llvm::LLVMBuildFAdd(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildFAdd(B(cx), LHS, RHS, noname()); } fn Sub(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"sub"); - ret llvm::LLVMBuildSub(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildSub(B(cx), LHS, RHS, noname()); } fn NSWSub(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"nwsub"); - ret llvm::LLVMBuildNSWSub(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildNSWSub(B(cx), LHS, RHS, noname()); } fn NUWSub(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"nuwsub"); - ret llvm::LLVMBuildNUWSub(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildNUWSub(B(cx), LHS, RHS, noname()); } fn FSub(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"sub"); - ret llvm::LLVMBuildFSub(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildFSub(B(cx), LHS, RHS, noname()); } fn Mul(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"mul"); - ret llvm::LLVMBuildMul(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildMul(B(cx), LHS, RHS, noname()); } fn NSWMul(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"nswmul"); - ret llvm::LLVMBuildNSWMul(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildNSWMul(B(cx), LHS, RHS, noname()); } fn NUWMul(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"nuwmul"); - ret llvm::LLVMBuildNUWMul(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildNUWMul(B(cx), LHS, RHS, noname()); } fn FMul(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"fmul"); - ret llvm::LLVMBuildFMul(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildFMul(B(cx), LHS, RHS, noname()); } fn UDiv(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"udiv"); - ret llvm::LLVMBuildUDiv(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildUDiv(B(cx), LHS, RHS, noname()); } fn SDiv(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"sdiv"); - ret llvm::LLVMBuildSDiv(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildSDiv(B(cx), LHS, RHS, noname()); } fn ExactSDiv(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"extractsdiv"); - ret llvm::LLVMBuildExactSDiv(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildExactSDiv(B(cx), LHS, RHS, noname()); } fn FDiv(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"fdiv"); - ret llvm::LLVMBuildFDiv(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildFDiv(B(cx), LHS, RHS, noname()); } fn URem(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"urem"); - ret llvm::LLVMBuildURem(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildURem(B(cx), LHS, RHS, noname()); } fn SRem(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"srem"); - ret llvm::LLVMBuildSRem(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildSRem(B(cx), LHS, RHS, noname()); } fn FRem(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"frem"); - ret llvm::LLVMBuildFRem(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildFRem(B(cx), LHS, RHS, noname()); } fn Shl(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"shl"); - ret llvm::LLVMBuildShl(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildShl(B(cx), LHS, RHS, noname()); } fn LShr(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"lshr"); - ret llvm::LLVMBuildLShr(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildLShr(B(cx), LHS, RHS, noname()); } fn AShr(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"ashr"); - ret llvm::LLVMBuildAShr(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildAShr(B(cx), LHS, RHS, noname()); } fn And(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"and"); - ret llvm::LLVMBuildAnd(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildAnd(B(cx), LHS, RHS, noname()); } fn Or(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"or"); - ret llvm::LLVMBuildOr(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildOr(B(cx), LHS, RHS, noname()); } fn Xor(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"xor"); - ret llvm::LLVMBuildXor(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildXor(B(cx), LHS, RHS, noname()); } fn BinOp(cx: block, Op: Opcode, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(LHS); } + if cx.unreachable { return _Undef(LHS); } count_insn(cx, ~"binop"); - ret llvm::LLVMBuildBinOp(B(cx), Op, LHS, RHS, noname()); + return llvm::LLVMBuildBinOp(B(cx), Op, LHS, RHS, noname()); } fn Neg(cx: block, V: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(V); } + if cx.unreachable { return _Undef(V); } count_insn(cx, ~"neg"); - ret llvm::LLVMBuildNeg(B(cx), V, noname()); + return llvm::LLVMBuildNeg(B(cx), V, noname()); } fn NSWNeg(cx: block, V: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(V); } + if cx.unreachable { return _Undef(V); } count_insn(cx, ~"nswneg"); - ret llvm::LLVMBuildNSWNeg(B(cx), V, noname()); + return llvm::LLVMBuildNSWNeg(B(cx), V, noname()); } fn NUWNeg(cx: block, V: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(V); } + if cx.unreachable { return _Undef(V); } count_insn(cx, ~"nuwneg"); - ret llvm::LLVMBuildNUWNeg(B(cx), V, noname()); + return llvm::LLVMBuildNUWNeg(B(cx), V, noname()); } fn FNeg(cx: block, V: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(V); } + if cx.unreachable { return _Undef(V); } count_insn(cx, ~"fneg"); - ret llvm::LLVMBuildFNeg(B(cx), V, noname()); + return llvm::LLVMBuildFNeg(B(cx), V, noname()); } fn Not(cx: block, V: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(V); } + if cx.unreachable { return _Undef(V); } count_insn(cx, ~"not"); - ret llvm::LLVMBuildNot(B(cx), V, noname()); + return llvm::LLVMBuildNot(B(cx), V, noname()); } /* Memory */ fn Malloc(cx: block, Ty: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_i8())); } + if cx.unreachable { return llvm::LLVMGetUndef(T_ptr(T_i8())); } count_insn(cx, ~"malloc"); - ret llvm::LLVMBuildMalloc(B(cx), Ty, noname()); + return llvm::LLVMBuildMalloc(B(cx), Ty, noname()); } fn ArrayMalloc(cx: block, Ty: TypeRef, Val: ValueRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_i8())); } + if cx.unreachable { return llvm::LLVMGetUndef(T_ptr(T_i8())); } count_insn(cx, ~"arraymalloc"); - ret llvm::LLVMBuildArrayMalloc(B(cx), Ty, Val, noname()); + return llvm::LLVMBuildArrayMalloc(B(cx), Ty, Val, noname()); } fn Alloca(cx: block, Ty: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(Ty)); } + if cx.unreachable { return llvm::LLVMGetUndef(T_ptr(Ty)); } count_insn(cx, ~"alloca"); - ret llvm::LLVMBuildAlloca(B(cx), Ty, noname()); + return llvm::LLVMBuildAlloca(B(cx), Ty, noname()); } fn ArrayAlloca(cx: block, Ty: TypeRef, Val: ValueRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(Ty)); } + if cx.unreachable { return llvm::LLVMGetUndef(T_ptr(Ty)); } count_insn(cx, ~"arrayalloca"); - ret llvm::LLVMBuildArrayAlloca(B(cx), Ty, Val, noname()); + return llvm::LLVMBuildArrayAlloca(B(cx), Ty, Val, noname()); } fn Free(cx: block, PointerVal: ValueRef) { - if cx.unreachable { ret; } + if cx.unreachable { return; } count_insn(cx, ~"free"); llvm::LLVMBuildFree(B(cx), PointerVal); } @@ -402,14 +402,14 @@ fn Load(cx: block, PointerVal: ValueRef) -> ValueRef { let ty = val_ty(PointerVal); let eltty = if llvm::LLVMGetTypeKind(ty) == lib::llvm::Array { llvm::LLVMGetElementType(ty) } else { ccx.int_type }; - ret llvm::LLVMGetUndef(eltty); + return llvm::LLVMGetUndef(eltty); } count_insn(cx, ~"load"); - ret llvm::LLVMBuildLoad(B(cx), PointerVal, noname()); + return llvm::LLVMBuildLoad(B(cx), PointerVal, noname()); } fn Store(cx: block, Val: ValueRef, Ptr: ValueRef) { - if cx.unreachable { ret; } + if cx.unreachable { return; } debug!{"Store %s -> %s", val_str(cx.ccx().tn, Val), val_str(cx.ccx().tn, Ptr)}; @@ -418,10 +418,10 @@ fn Store(cx: block, Val: ValueRef, Ptr: ValueRef) { } fn GEP(cx: block, Pointer: ValueRef, Indices: ~[ValueRef]) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); } + if cx.unreachable { return llvm::LLVMGetUndef(T_ptr(T_nil())); } unsafe { count_insn(cx, ~"gep"); - ret llvm::LLVMBuildGEP(B(cx), Pointer, vec::unsafe::to_ptr(Indices), + return llvm::LLVMBuildGEP(B(cx), Pointer, vec::unsafe::to_ptr(Indices), Indices.len() as c_uint, noname()); } } @@ -432,15 +432,15 @@ fn GEPi(cx: block, base: ValueRef, ixs: ~[uint]) -> ValueRef { let mut v: ~[ValueRef] = ~[]; for vec::each(ixs) |i| { vec::push(v, C_i32(i as i32)); } count_insn(cx, ~"gepi"); - ret InBoundsGEP(cx, base, v); + return InBoundsGEP(cx, base, v); } fn InBoundsGEP(cx: block, Pointer: ValueRef, Indices: ~[ValueRef]) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); } + if cx.unreachable { return llvm::LLVMGetUndef(T_ptr(T_nil())); } unsafe { count_insn(cx, ~"inboundsgep"); - ret llvm::LLVMBuildInBoundsGEP(B(cx), Pointer, + return llvm::LLVMBuildInBoundsGEP(B(cx), Pointer, vec::unsafe::to_ptr(Indices), Indices.len() as c_uint, noname()); @@ -448,168 +448,168 @@ fn InBoundsGEP(cx: block, Pointer: ValueRef, Indices: ~[ValueRef]) -> } fn StructGEP(cx: block, Pointer: ValueRef, Idx: uint) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); } + if cx.unreachable { return llvm::LLVMGetUndef(T_ptr(T_nil())); } count_insn(cx, ~"structgep"); - ret llvm::LLVMBuildStructGEP(B(cx), Pointer, Idx as c_uint, noname()); + return llvm::LLVMBuildStructGEP(B(cx), Pointer, Idx as c_uint, noname()); } fn GlobalString(cx: block, _Str: *libc::c_char) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_i8())); } + if cx.unreachable { return llvm::LLVMGetUndef(T_ptr(T_i8())); } count_insn(cx, ~"globalstring"); - ret llvm::LLVMBuildGlobalString(B(cx), _Str, noname()); + return llvm::LLVMBuildGlobalString(B(cx), _Str, noname()); } fn GlobalStringPtr(cx: block, _Str: *libc::c_char) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_i8())); } + if cx.unreachable { return llvm::LLVMGetUndef(T_ptr(T_i8())); } count_insn(cx, ~"globalstringptr"); - ret llvm::LLVMBuildGlobalStringPtr(B(cx), _Str, noname()); + return llvm::LLVMBuildGlobalStringPtr(B(cx), _Str, noname()); } /* Casts */ fn Trunc(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"trunc"); - ret llvm::LLVMBuildTrunc(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildTrunc(B(cx), Val, DestTy, noname()); } fn ZExt(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"zext"); - ret llvm::LLVMBuildZExt(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildZExt(B(cx), Val, DestTy, noname()); } fn SExt(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"sext"); - ret llvm::LLVMBuildSExt(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildSExt(B(cx), Val, DestTy, noname()); } fn FPToUI(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"fptoui"); - ret llvm::LLVMBuildFPToUI(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildFPToUI(B(cx), Val, DestTy, noname()); } fn FPToSI(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"fptosi"); - ret llvm::LLVMBuildFPToSI(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildFPToSI(B(cx), Val, DestTy, noname()); } fn UIToFP(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"uitofp"); - ret llvm::LLVMBuildUIToFP(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildUIToFP(B(cx), Val, DestTy, noname()); } fn SIToFP(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"sitofp"); - ret llvm::LLVMBuildSIToFP(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildSIToFP(B(cx), Val, DestTy, noname()); } fn FPTrunc(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"fptrunc"); - ret llvm::LLVMBuildFPTrunc(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildFPTrunc(B(cx), Val, DestTy, noname()); } fn FPExt(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"fpext"); - ret llvm::LLVMBuildFPExt(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildFPExt(B(cx), Val, DestTy, noname()); } fn PtrToInt(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"ptrtoint"); - ret llvm::LLVMBuildPtrToInt(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildPtrToInt(B(cx), Val, DestTy, noname()); } fn IntToPtr(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"inttoptr"); - ret llvm::LLVMBuildIntToPtr(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildIntToPtr(B(cx), Val, DestTy, noname()); } fn BitCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"bitcast"); - ret llvm::LLVMBuildBitCast(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildBitCast(B(cx), Val, DestTy, noname()); } fn ZExtOrBitCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"zextorbitcast"); - ret llvm::LLVMBuildZExtOrBitCast(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildZExtOrBitCast(B(cx), Val, DestTy, noname()); } fn SExtOrBitCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"sextorbitcast"); - ret llvm::LLVMBuildSExtOrBitCast(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildSExtOrBitCast(B(cx), Val, DestTy, noname()); } fn TruncOrBitCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"truncorbitcast"); - ret llvm::LLVMBuildTruncOrBitCast(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildTruncOrBitCast(B(cx), Val, DestTy, noname()); } fn Cast(cx: block, Op: Opcode, Val: ValueRef, DestTy: TypeRef, _Name: *u8) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"cast"); - ret llvm::LLVMBuildCast(B(cx), Op, Val, DestTy, noname()); + return llvm::LLVMBuildCast(B(cx), Op, Val, DestTy, noname()); } fn PointerCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"pointercast"); - ret llvm::LLVMBuildPointerCast(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildPointerCast(B(cx), Val, DestTy, noname()); } fn IntCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"intcast"); - ret llvm::LLVMBuildIntCast(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildIntCast(B(cx), Val, DestTy, noname()); } fn FPCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } + if cx.unreachable { return llvm::LLVMGetUndef(DestTy); } count_insn(cx, ~"fpcast"); - ret llvm::LLVMBuildFPCast(B(cx), Val, DestTy, noname()); + return llvm::LLVMBuildFPCast(B(cx), Val, DestTy, noname()); } /* Comparisons */ fn ICmp(cx: block, Op: IntPredicate, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_i1()); } + if cx.unreachable { return llvm::LLVMGetUndef(T_i1()); } count_insn(cx, ~"icmp"); - ret llvm::LLVMBuildICmp(B(cx), Op as c_uint, LHS, RHS, noname()); + return llvm::LLVMBuildICmp(B(cx), Op as c_uint, LHS, RHS, noname()); } fn FCmp(cx: block, Op: RealPredicate, LHS: ValueRef, RHS: ValueRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_i1()); } + if cx.unreachable { return llvm::LLVMGetUndef(T_i1()); } count_insn(cx, ~"fcmp"); - ret llvm::LLVMBuildFCmp(B(cx), Op as c_uint, LHS, RHS, noname()); + return llvm::LLVMBuildFCmp(B(cx), Op as c_uint, LHS, RHS, noname()); } /* Miscellaneous instructions */ fn EmptyPhi(cx: block, Ty: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(Ty); } + if cx.unreachable { return llvm::LLVMGetUndef(Ty); } count_insn(cx, ~"emptyphi"); - ret llvm::LLVMBuildPhi(B(cx), Ty, noname()); + return llvm::LLVMBuildPhi(B(cx), Ty, noname()); } fn Phi(cx: block, Ty: TypeRef, vals: ~[ValueRef], bbs: ~[BasicBlockRef]) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(Ty); } + if cx.unreachable { return llvm::LLVMGetUndef(Ty); } assert vals.len() == bbs.len(); let phi = EmptyPhi(cx, Ty); unsafe { @@ -617,12 +617,12 @@ fn Phi(cx: block, Ty: TypeRef, vals: ~[ValueRef], bbs: ~[BasicBlockRef]) llvm::LLVMAddIncoming(phi, vec::unsafe::to_ptr(vals), vec::unsafe::to_ptr(bbs), vals.len() as c_uint); - ret phi; + return phi; } } fn AddIncomingToPhi(phi: ValueRef, val: ValueRef, bb: BasicBlockRef) { - if llvm::LLVMIsUndef(phi) == lib::llvm::True { ret; } + if llvm::LLVMIsUndef(phi) == lib::llvm::True { return; } unsafe { let valptr = unsafe::reinterpret_cast(ptr::addr_of(val)); let bbptr = unsafe::reinterpret_cast(ptr::addr_of(bb)); @@ -636,7 +636,7 @@ fn _UndefReturn(cx: block, Fn: ValueRef) -> ValueRef { let retty = if llvm::LLVMGetTypeKind(ty) == lib::llvm::Integer { llvm::LLVMGetReturnType(ty) } else { ccx.int_type }; count_insn(cx, ~""); - ret llvm::LLVMGetUndef(retty); + return llvm::LLVMGetUndef(retty); } fn add_span_comment(bcx: block, sp: span, text: ~str) { @@ -666,7 +666,7 @@ fn add_comment(bcx: block, text: ~str) { } fn Call(cx: block, Fn: ValueRef, Args: ~[ValueRef]) -> ValueRef { - if cx.unreachable { ret _UndefReturn(cx, Fn); } + if cx.unreachable { return _UndefReturn(cx, Fn); } unsafe { count_insn(cx, ~"call"); @@ -674,103 +674,104 @@ fn Call(cx: block, Fn: ValueRef, Args: ~[ValueRef]) -> ValueRef { val_str(cx.ccx().tn, Fn), Args.map(|arg| val_str(cx.ccx().tn, arg))}; - ret llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args), + return llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args), Args.len() as c_uint, noname()); } } fn FastCall(cx: block, Fn: ValueRef, Args: ~[ValueRef]) -> ValueRef { - if cx.unreachable { ret _UndefReturn(cx, Fn); } + if cx.unreachable { return _UndefReturn(cx, Fn); } unsafe { count_insn(cx, ~"fastcall"); let v = llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args), Args.len() as c_uint, noname()); lib::llvm::SetInstructionCallConv(v, lib::llvm::FastCallConv); - ret v; + return v; } } fn CallWithConv(cx: block, Fn: ValueRef, Args: ~[ValueRef], Conv: CallConv) -> ValueRef { - if cx.unreachable { ret _UndefReturn(cx, Fn); } + if cx.unreachable { return _UndefReturn(cx, Fn); } unsafe { count_insn(cx, ~"callwithconv"); let v = llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args), Args.len() as c_uint, noname()); lib::llvm::SetInstructionCallConv(v, Conv); - ret v; + return v; } } fn Select(cx: block, If: ValueRef, Then: ValueRef, Else: ValueRef) -> ValueRef { - if cx.unreachable { ret _Undef(Then); } + if cx.unreachable { return _Undef(Then); } count_insn(cx, ~"select"); - ret llvm::LLVMBuildSelect(B(cx), If, Then, Else, noname()); + return llvm::LLVMBuildSelect(B(cx), If, Then, Else, noname()); } fn VAArg(cx: block, list: ValueRef, Ty: TypeRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(Ty); } + if cx.unreachable { return llvm::LLVMGetUndef(Ty); } count_insn(cx, ~"vaarg"); - ret llvm::LLVMBuildVAArg(B(cx), list, Ty, noname()); + return llvm::LLVMBuildVAArg(B(cx), list, Ty, noname()); } fn ExtractElement(cx: block, VecVal: ValueRef, Index: ValueRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_nil()); } + if cx.unreachable { return llvm::LLVMGetUndef(T_nil()); } count_insn(cx, ~"extractelement"); - ret llvm::LLVMBuildExtractElement(B(cx), VecVal, Index, noname()); + return llvm::LLVMBuildExtractElement(B(cx), VecVal, Index, noname()); } fn InsertElement(cx: block, VecVal: ValueRef, EltVal: ValueRef, Index: ValueRef) { - if cx.unreachable { ret; } + if cx.unreachable { return; } count_insn(cx, ~"insertelement"); llvm::LLVMBuildInsertElement(B(cx), VecVal, EltVal, Index, noname()); } fn ShuffleVector(cx: block, V1: ValueRef, V2: ValueRef, Mask: ValueRef) { - if cx.unreachable { ret; } + if cx.unreachable { return; } count_insn(cx, ~"shufflevector"); llvm::LLVMBuildShuffleVector(B(cx), V1, V2, Mask, noname()); } fn ExtractValue(cx: block, AggVal: ValueRef, Index: uint) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_nil()); } + if cx.unreachable { return llvm::LLVMGetUndef(T_nil()); } count_insn(cx, ~"extractvalue"); - ret llvm::LLVMBuildExtractValue(B(cx), AggVal, Index as c_uint, noname()); + return llvm::LLVMBuildExtractValue( + B(cx), AggVal, Index as c_uint, noname()); } fn InsertValue(cx: block, AggVal: ValueRef, EltVal: ValueRef, Index: uint) { - if cx.unreachable { ret; } + if cx.unreachable { return; } count_insn(cx, ~"insertvalue"); llvm::LLVMBuildInsertValue(B(cx), AggVal, EltVal, Index as c_uint, noname()); } fn IsNull(cx: block, Val: ValueRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_i1()); } + if cx.unreachable { return llvm::LLVMGetUndef(T_i1()); } count_insn(cx, ~"isnull"); - ret llvm::LLVMBuildIsNull(B(cx), Val, noname()); + return llvm::LLVMBuildIsNull(B(cx), Val, noname()); } fn IsNotNull(cx: block, Val: ValueRef) -> ValueRef { - if cx.unreachable { ret llvm::LLVMGetUndef(T_i1()); } + if cx.unreachable { return llvm::LLVMGetUndef(T_i1()); } count_insn(cx, ~"isnotnull"); - ret llvm::LLVMBuildIsNotNull(B(cx), Val, noname()); + return llvm::LLVMBuildIsNotNull(B(cx), Val, noname()); } fn PtrDiff(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { let ccx = cx.fcx.ccx; - if cx.unreachable { ret llvm::LLVMGetUndef(ccx.int_type); } + if cx.unreachable { return llvm::LLVMGetUndef(ccx.int_type); } count_insn(cx, ~"ptrdiff"); - ret llvm::LLVMBuildPtrDiff(B(cx), LHS, RHS, noname()); + return llvm::LLVMBuildPtrDiff(B(cx), LHS, RHS, noname()); } fn Trap(cx: block) { - if cx.unreachable { ret; } + if cx.unreachable { return; } let b = B(cx); let BB: BasicBlockRef = llvm::LLVMGetInsertBlock(b); let FN: ValueRef = llvm::LLVMGetBasicBlockParent(BB); @@ -791,7 +792,7 @@ fn LandingPad(cx: block, Ty: TypeRef, PersFn: ValueRef, NumClauses: uint) -> ValueRef { assert !cx.terminated && !cx.unreachable; count_insn(cx, ~"landingpad"); - ret llvm::LLVMBuildLandingPad(B(cx), Ty, PersFn, + return llvm::LLVMBuildLandingPad(B(cx), Ty, PersFn, NumClauses as c_uint, noname()); } @@ -804,7 +805,7 @@ fn Resume(cx: block, Exn: ValueRef) -> ValueRef { assert (!cx.terminated); cx.terminated = true; count_insn(cx, ~"resume"); - ret llvm::LLVMBuildResume(B(cx), Exn); + return llvm::LLVMBuildResume(B(cx), Exn); } // Atomic Operations diff --git a/src/rustc/middle/trans/closure.rs b/src/rustc/middle/trans/closure.rs index c216b890ace..804ee5ba83c 100644 --- a/src/rustc/middle/trans/closure.rs +++ b/src/rustc/middle/trans/closure.rs @@ -113,7 +113,7 @@ fn ev_to_str(ccx: @crate_ctxt, ev: environment_value) -> ~str { fn mk_tuplified_uniq_cbox_ty(tcx: ty::ctxt, cdata_ty: ty::t) -> ty::t { let cbox_ty = tuplify_box_ty(tcx, cdata_ty); - ret ty::mk_imm_uniq(tcx, cbox_ty); + return ty::mk_imm_uniq(tcx, cbox_ty); } // Given a closure ty, emits a corresponding tuple ty @@ -132,7 +132,7 @@ fn mk_closure_tys(tcx: ty::ctxt, } let cdata_ty = ty::mk_tup(tcx, bound_tys); debug!{"cdata_ty=%s", ty_to_str(tcx, cdata_ty)}; - ret cdata_ty; + return cdata_ty; } fn allocate_cbox(bcx: block, @@ -168,7 +168,7 @@ fn allocate_cbox(bcx: block, } }; - ret {bcx: bcx, val: val}; + return {bcx: bcx, val: val}; } type closure_result = { @@ -247,7 +247,7 @@ fn store_environment(bcx: block, } for vec::each(temp_cleanups) |cleanup| { revoke_clean(bcx, cleanup); } - ret {llbox: llbox, cdata_ty: cdata_ty, bcx: bcx}; + return {llbox: llbox, cdata_ty: cdata_ty, bcx: bcx}; } // Given a context and a list of upvars, build a closure. This just @@ -307,7 +307,7 @@ fn build_closure(bcx0: block, vec::push(env_vals, env_ref(nil_ret, ty::mk_nil_ptr(tcx), lv_owned)); } - ret store_environment(bcx, env_vals, ck); + return store_environment(bcx, env_vals, ck); } // Given an enclosing block context, a new function context, a closure type, @@ -361,7 +361,7 @@ fn trans_expr_fn(bcx: block, is_loop_body: option<option<ValueRef>>, dest: dest) -> block { let _icx = bcx.insn_ctxt(~"closure::trans_expr_fn"); - if dest == ignore { ret bcx; } + if dest == ignore { return bcx; } let ccx = bcx.ccx(); let fty = node_id_type(bcx, id); let llfnty = type_of_fn_from_ty(ccx, fty); @@ -399,7 +399,7 @@ fn trans_expr_fn(bcx: block, }; fill_fn_pair(bcx, get_dest_addr(dest), llfn, closure); - ret bcx; + return bcx; } fn make_fn_glue( @@ -421,7 +421,7 @@ fn make_fn_glue( } }; - ret alt ty::get(t).struct { + return alt ty::get(t).struct { ty::ty_fn({proto: ast::proto_bare, _}) | ty::ty_fn({proto: ast::proto_block, _}) | ty::ty_fn({proto: ast::proto_any, _}) { bcx } @@ -439,8 +439,11 @@ fn make_opaque_cbox_take_glue( // Easy cases: let _icx = bcx.insn_ctxt(~"closure::make_opaque_cbox_take_glue"); alt ck { - ty::ck_block { ret bcx; } - ty::ck_box { incr_refcnt_of_boxed(bcx, Load(bcx, cboxptr)); ret bcx; } + ty::ck_block { return bcx; } + ty::ck_box { + incr_refcnt_of_boxed(bcx, Load(bcx, cboxptr)); + return bcx; + } ty::ck_uniq { /* hard case: */ } } @@ -507,7 +510,7 @@ fn make_opaque_cbox_free_glue( -> block { let _icx = bcx.insn_ctxt(~"closure::make_opaque_cbox_free_glue"); alt ck { - ty::ck_block { ret bcx; } + ty::ck_block { return bcx; } ty::ck_box | ty::ck_uniq { /* hard cases: */ } } @@ -537,3 +540,4 @@ fn make_opaque_cbox_free_glue( } } } + diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs index bfb7676024a..ed977ec3bfb 100644 --- a/src/rustc/middle/trans/common.rs +++ b/src/rustc/middle/trans/common.rs @@ -24,7 +24,7 @@ import util::ppaux::ty_to_str; type namegen = fn@(~str) -> ~str; fn new_namegen() -> namegen { let i = @mut 0; - ret fn@(prefix: ~str) -> ~str { *i += 1; prefix + int::str(*i) }; + return fn@(prefix: ~str) -> ~str { *i += 1; prefix + int::str(*i) }; } type tydesc_info = @@ -247,7 +247,7 @@ fn cleanup_type(cx: ty::ctxt, ty: ty::t) -> cleantype { } fn add_clean(cx: block, val: ValueRef, ty: ty::t) { - if !ty::type_needs_drop(cx.tcx(), ty) { ret; } + if !ty::type_needs_drop(cx.tcx(), ty) { return; } debug!{"add_clean(%s, %s, %s)", cx.to_str(), val_str(cx.ccx().tn, val), ty_to_str(cx.ccx().tcx, ty)}; @@ -259,7 +259,7 @@ fn add_clean(cx: block, val: ValueRef, ty: ty::t) { } } fn add_clean_temp(cx: block, val: ValueRef, ty: ty::t) { - if !ty::type_needs_drop(cx.tcx(), ty) { ret; } + if !ty::type_needs_drop(cx.tcx(), ty) { return; } debug!{"add_clean_temp(%s, %s, %s)", cx.to_str(), val_str(cx.ccx().tn, val), ty_to_str(cx.ccx().tcx, ty)}; @@ -267,9 +267,9 @@ fn add_clean_temp(cx: block, val: ValueRef, ty: ty::t) { fn do_drop(bcx: block, val: ValueRef, ty: ty::t) -> block { if ty::type_is_immediate(ty) { - ret base::drop_ty_immediate(bcx, val, ty); + return base::drop_ty_immediate(bcx, val, ty); } else { - ret base::drop_ty(bcx, val, ty); + return base::drop_ty(bcx, val, ty); } } do in_scope_cx(cx) |info| { @@ -279,7 +279,7 @@ fn add_clean_temp(cx: block, val: ValueRef, ty: ty::t) { } } fn add_clean_temp_mem(cx: block, val: ValueRef, ty: ty::t) { - if !ty::type_needs_drop(cx.tcx(), ty) { ret; } + if !ty::type_needs_drop(cx.tcx(), ty) { return; } debug!{"add_clean_temp_mem(%s, %s, %s)", cx.to_str(), val_str(cx.ccx().tn, val), ty_to_str(cx.ccx().tcx, ty)}; @@ -429,12 +429,14 @@ fn rslt(bcx: block, val: ValueRef) -> result { } fn ty_str(tn: type_names, t: TypeRef) -> ~str { - ret lib::llvm::type_to_str(tn, t); + return lib::llvm::type_to_str(tn, t); } -fn val_ty(v: ValueRef) -> TypeRef { ret llvm::LLVMTypeOf(v); } +fn val_ty(v: ValueRef) -> TypeRef { return llvm::LLVMTypeOf(v); } -fn val_str(tn: type_names, v: ValueRef) -> ~str { ret ty_str(tn, val_ty(v)); } +fn val_str(tn: type_names, v: ValueRef) -> ~str { + return ty_str(tn, val_ty(v)); +} // Returns the nth element of the given LLVM structure type. fn struct_elt(llstructty: TypeRef, n: uint) -> TypeRef unsafe { @@ -442,14 +444,14 @@ fn struct_elt(llstructty: TypeRef, n: uint) -> TypeRef unsafe { assert (n < elt_count); let elt_tys = vec::from_elem(elt_count, T_nil()); llvm::LLVMGetStructElementTypes(llstructty, to_ptr(elt_tys)); - ret llvm::LLVMGetElementType(elt_tys[n]); + return llvm::LLVMGetElementType(elt_tys[n]); } fn in_scope_cx(cx: block, f: fn(scope_info)) { let mut cur = cx; loop { alt cur.kind { - block_scope(inf) { f(inf); ret; } + block_scope(inf) { f(inf); return; } _ {} } cur = block_parent(cur); @@ -502,35 +504,35 @@ fn T_void() -> TypeRef { // of 10 nil values will have 10-bit size -- but it doesn't seem like we // have any other options until it's fixed upstream. - ret llvm::LLVMVoidType(); + return llvm::LLVMVoidType(); } fn T_nil() -> TypeRef { // NB: See above in T_void(). - ret llvm::LLVMInt1Type(); + return llvm::LLVMInt1Type(); } -fn T_metadata() -> TypeRef { ret llvm::LLVMMetadataType(); } +fn T_metadata() -> TypeRef { return llvm::LLVMMetadataType(); } -fn T_i1() -> TypeRef { ret llvm::LLVMInt1Type(); } +fn T_i1() -> TypeRef { return llvm::LLVMInt1Type(); } -fn T_i8() -> TypeRef { ret llvm::LLVMInt8Type(); } +fn T_i8() -> TypeRef { return llvm::LLVMInt8Type(); } -fn T_i16() -> TypeRef { ret llvm::LLVMInt16Type(); } +fn T_i16() -> TypeRef { return llvm::LLVMInt16Type(); } -fn T_i32() -> TypeRef { ret llvm::LLVMInt32Type(); } +fn T_i32() -> TypeRef { return llvm::LLVMInt32Type(); } -fn T_i64() -> TypeRef { ret llvm::LLVMInt64Type(); } +fn T_i64() -> TypeRef { return llvm::LLVMInt64Type(); } -fn T_f32() -> TypeRef { ret llvm::LLVMFloatType(); } +fn T_f32() -> TypeRef { return llvm::LLVMFloatType(); } -fn T_f64() -> TypeRef { ret llvm::LLVMDoubleType(); } +fn T_f64() -> TypeRef { return llvm::LLVMDoubleType(); } -fn T_bool() -> TypeRef { ret T_i1(); } +fn T_bool() -> TypeRef { return T_i1(); } fn T_int(targ_cfg: @session::config) -> TypeRef { - ret alt targ_cfg.arch { + return alt targ_cfg.arch { session::arch_x86 { T_i32() } session::arch_x86_64 { T_i64() } session::arch_arm { T_i32() } @@ -567,40 +569,40 @@ fn T_float_ty(cx: @crate_ctxt, t: ast::float_ty) -> TypeRef { } fn T_float(targ_cfg: @session::config) -> TypeRef { - ret alt targ_cfg.arch { + return alt targ_cfg.arch { session::arch_x86 { T_f64() } session::arch_x86_64 { T_f64() } session::arch_arm { T_f64() } }; } -fn T_char() -> TypeRef { ret T_i32(); } +fn T_char() -> TypeRef { return T_i32(); } fn T_size_t(targ_cfg: @session::config) -> TypeRef { - ret T_int(targ_cfg); + return T_int(targ_cfg); } fn T_fn(inputs: ~[TypeRef], output: TypeRef) -> TypeRef unsafe { - ret llvm::LLVMFunctionType(output, to_ptr(inputs), + return llvm::LLVMFunctionType(output, to_ptr(inputs), inputs.len() as c_uint, False); } fn T_fn_pair(cx: @crate_ctxt, tfn: TypeRef) -> TypeRef { - ret T_struct(~[T_ptr(tfn), T_opaque_cbox_ptr(cx)]); + return T_struct(~[T_ptr(tfn), T_opaque_cbox_ptr(cx)]); } fn T_ptr(t: TypeRef) -> TypeRef { - ret llvm::LLVMPointerType(t, 0u as c_uint); + return llvm::LLVMPointerType(t, 0u as c_uint); } fn T_struct(elts: ~[TypeRef]) -> TypeRef unsafe { - ret llvm::LLVMStructType(to_ptr(elts), elts.len() as c_uint, False); + return llvm::LLVMStructType(to_ptr(elts), elts.len() as c_uint, False); } fn T_named_struct(name: ~str) -> TypeRef { let c = llvm::LLVMGetGlobalContext(); - ret str::as_c_str(name, |buf| llvm::LLVMStructCreateNamed(c, buf)); + return str::as_c_str(name, |buf| llvm::LLVMStructCreateNamed(c, buf)); } fn set_struct_body(t: TypeRef, elts: ~[TypeRef]) unsafe { @@ -608,7 +610,7 @@ fn set_struct_body(t: TypeRef, elts: ~[TypeRef]) unsafe { elts.len() as c_uint, False); } -fn T_empty_struct() -> TypeRef { ret T_struct(~[]); } +fn T_empty_struct() -> TypeRef { return T_struct(~[]); } // A vtable is, in reality, a vtable pointer followed by zero or more pointers // to tydescs and other vtables that it closes over. But the types and number @@ -635,7 +637,7 @@ fn T_task(targ_cfg: @session::config) -> TypeRef { ~[t_int, t_int, t_int, t_int, t_int, t_int, t_int, t_int]; set_struct_body(t, elems); - ret t; + return t; } fn T_tydesc_field(cx: @crate_ctxt, field: uint) -> TypeRef unsafe { @@ -647,15 +649,15 @@ fn T_tydesc_field(cx: @crate_ctxt, field: uint) -> TypeRef unsafe { llvm::LLVMGetStructElementTypes(cx.tydesc_type, to_ptr::<TypeRef>(tydesc_elts)); let t = llvm::LLVMGetElementType(tydesc_elts[field]); - ret t; + return t; } fn T_glue_fn(cx: @crate_ctxt) -> TypeRef { let s = ~"glue_fn"; - alt name_has_type(cx.tn, s) { some(t) { ret t; } _ {} } + alt name_has_type(cx.tn, s) { some(t) { return t; } _ {} } let t = T_tydesc_field(cx, abi::tydesc_field_drop_glue); associate_type(cx.tn, s, t); - ret t; + return t; } fn T_tydesc(targ_cfg: @session::config) -> TypeRef { @@ -672,27 +674,27 @@ fn T_tydesc(targ_cfg: @session::config) -> TypeRef { glue_fn_ty, glue_fn_ty, glue_fn_ty, glue_fn_ty, T_ptr(T_i8()), T_ptr(T_i8())]; set_struct_body(tydesc, elems); - ret tydesc; + return tydesc; } fn T_array(t: TypeRef, n: uint) -> TypeRef { - ret llvm::LLVMArrayType(t, n as c_uint); + return llvm::LLVMArrayType(t, n as c_uint); } // Interior vector. fn T_vec2(targ_cfg: @session::config, t: TypeRef) -> TypeRef { - ret T_struct(~[T_int(targ_cfg), // fill + return T_struct(~[T_int(targ_cfg), // fill T_int(targ_cfg), // alloc T_array(t, 0u)]); // elements } fn T_vec(ccx: @crate_ctxt, t: TypeRef) -> TypeRef { - ret T_vec2(ccx.sess.targ_cfg, t); + return T_vec2(ccx.sess.targ_cfg, t); } // Note that the size of this one is in bytes. fn T_opaque_vec(targ_cfg: @session::config) -> TypeRef { - ret T_vec2(targ_cfg, T_i8()); + return T_vec2(targ_cfg, T_i8()); } // Let T be the content of a box @T. tuplify_box_ty(t) returns the @@ -700,120 +702,120 @@ fn T_opaque_vec(targ_cfg: @session::config) -> TypeRef { // returns). fn tuplify_box_ty(tcx: ty::ctxt, t: ty::t) -> ty::t { let ptr = ty::mk_ptr(tcx, {ty: ty::mk_nil(tcx), mutbl: ast::m_imm}); - ret ty::mk_tup(tcx, ~[ty::mk_uint(tcx), ty::mk_type(tcx), + return ty::mk_tup(tcx, ~[ty::mk_uint(tcx), ty::mk_type(tcx), ptr, ptr, t]); } fn T_box_header_fields(cx: @crate_ctxt) -> ~[TypeRef] { let ptr = T_ptr(T_i8()); - ret ~[cx.int_type, T_ptr(cx.tydesc_type), ptr, ptr]; + return ~[cx.int_type, T_ptr(cx.tydesc_type), ptr, ptr]; } fn T_box_header(cx: @crate_ctxt) -> TypeRef { - ret T_struct(T_box_header_fields(cx)); + return T_struct(T_box_header_fields(cx)); } fn T_box(cx: @crate_ctxt, t: TypeRef) -> TypeRef { - ret T_struct(vec::append(T_box_header_fields(cx), ~[t])); + return T_struct(vec::append(T_box_header_fields(cx), ~[t])); } fn T_box_ptr(t: TypeRef) -> TypeRef { const box_addrspace: uint = 1u; - ret llvm::LLVMPointerType(t, box_addrspace as c_uint); + return llvm::LLVMPointerType(t, box_addrspace as c_uint); } fn T_opaque_box(cx: @crate_ctxt) -> TypeRef { - ret T_box(cx, T_i8()); + return T_box(cx, T_i8()); } fn T_opaque_box_ptr(cx: @crate_ctxt) -> TypeRef { - ret T_box_ptr(T_opaque_box(cx)); + return T_box_ptr(T_opaque_box(cx)); } fn T_unique(cx: @crate_ctxt, t: TypeRef) -> TypeRef { - ret T_struct(vec::append(T_box_header_fields(cx), ~[t])); + return T_struct(vec::append(T_box_header_fields(cx), ~[t])); } fn T_unique_ptr(t: TypeRef) -> TypeRef { const unique_addrspace: uint = 1u; - ret llvm::LLVMPointerType(t, unique_addrspace as c_uint); + return llvm::LLVMPointerType(t, unique_addrspace as c_uint); } fn T_port(cx: @crate_ctxt, _t: TypeRef) -> TypeRef { - ret T_struct(~[cx.int_type]); // Refcount + return T_struct(~[cx.int_type]); // Refcount } fn T_chan(cx: @crate_ctxt, _t: TypeRef) -> TypeRef { - ret T_struct(~[cx.int_type]); // Refcount + return T_struct(~[cx.int_type]); // Refcount } -fn T_taskptr(cx: @crate_ctxt) -> TypeRef { ret T_ptr(cx.task_type); } +fn T_taskptr(cx: @crate_ctxt) -> TypeRef { return T_ptr(cx.task_type); } // This type must never be used directly; it must always be cast away. fn T_typaram(tn: type_names) -> TypeRef { let s = ~"typaram"; - alt name_has_type(tn, s) { some(t) { ret t; } _ {} } + alt name_has_type(tn, s) { some(t) { return t; } _ {} } let t = T_i8(); associate_type(tn, s, t); - ret t; + return t; } -fn T_typaram_ptr(tn: type_names) -> TypeRef { ret T_ptr(T_typaram(tn)); } +fn T_typaram_ptr(tn: type_names) -> TypeRef { return T_ptr(T_typaram(tn)); } fn T_opaque_cbox_ptr(cx: @crate_ctxt) -> TypeRef { // closures look like boxes (even when they are fn~ or fn&) // see trans_closure.rs - ret T_opaque_box_ptr(cx); + return T_opaque_box_ptr(cx); } fn T_enum_discrim(cx: @crate_ctxt) -> TypeRef { - ret cx.int_type; + return cx.int_type; } fn T_opaque_enum(cx: @crate_ctxt) -> TypeRef { let s = ~"opaque_enum"; - alt name_has_type(cx.tn, s) { some(t) { ret t; } _ {} } + alt name_has_type(cx.tn, s) { some(t) { return t; } _ {} } let t = T_struct(~[T_enum_discrim(cx), T_i8()]); associate_type(cx.tn, s, t); - ret t; + return t; } fn T_opaque_enum_ptr(cx: @crate_ctxt) -> TypeRef { - ret T_ptr(T_opaque_enum(cx)); + return T_ptr(T_opaque_enum(cx)); } fn T_captured_tydescs(cx: @crate_ctxt, n: uint) -> TypeRef { - ret T_struct(vec::from_elem::<TypeRef>(n, T_ptr(cx.tydesc_type))); + return T_struct(vec::from_elem::<TypeRef>(n, T_ptr(cx.tydesc_type))); } fn T_opaque_trait(cx: @crate_ctxt) -> TypeRef { T_struct(~[T_ptr(cx.tydesc_type), T_opaque_box_ptr(cx)]) } -fn T_opaque_port_ptr() -> TypeRef { ret T_ptr(T_i8()); } +fn T_opaque_port_ptr() -> TypeRef { return T_ptr(T_i8()); } -fn T_opaque_chan_ptr() -> TypeRef { ret T_ptr(T_i8()); } +fn T_opaque_chan_ptr() -> TypeRef { return T_ptr(T_i8()); } // LLVM constant constructors. -fn C_null(t: TypeRef) -> ValueRef { ret llvm::LLVMConstNull(t); } +fn C_null(t: TypeRef) -> ValueRef { return llvm::LLVMConstNull(t); } fn C_integral(t: TypeRef, u: u64, sign_extend: Bool) -> ValueRef { - ret llvm::LLVMConstInt(t, u, sign_extend); + return llvm::LLVMConstInt(t, u, sign_extend); } fn C_floating(s: ~str, t: TypeRef) -> ValueRef { - ret str::as_c_str(s, |buf| llvm::LLVMConstRealOfString(t, buf)); + return str::as_c_str(s, |buf| llvm::LLVMConstRealOfString(t, buf)); } fn C_nil() -> ValueRef { // NB: See comment above in T_void(). - ret C_integral(T_i1(), 0u64, False); + return C_integral(T_i1(), 0u64, False); } fn C_bool(b: bool) -> ValueRef { @@ -821,29 +823,29 @@ fn C_bool(b: bool) -> ValueRef { } fn C_i32(i: i32) -> ValueRef { - ret C_integral(T_i32(), i as u64, True); + return C_integral(T_i32(), i as u64, True); } fn C_i64(i: i64) -> ValueRef { - ret C_integral(T_i64(), i as u64, True); + return C_integral(T_i64(), i as u64, True); } fn C_int(cx: @crate_ctxt, i: int) -> ValueRef { - ret C_integral(cx.int_type, i as u64, True); + return C_integral(cx.int_type, i as u64, True); } fn C_uint(cx: @crate_ctxt, i: uint) -> ValueRef { - ret C_integral(cx.int_type, i as u64, False); + return C_integral(cx.int_type, i as u64, False); } -fn C_u8(i: uint) -> ValueRef { ret C_integral(T_i8(), i as u64, False); } +fn C_u8(i: uint) -> ValueRef { return C_integral(T_i8(), i as u64, False); } // This is a 'c-like' raw string, which differs from // our boxed-and-length-annotated strings. fn C_cstr(cx: @crate_ctxt, s: ~str) -> ValueRef { alt cx.const_cstr_cache.find(s) { - some(llval) { ret llval; } + some(llval) { return llval; } none { } } @@ -859,7 +861,7 @@ fn C_cstr(cx: @crate_ctxt, s: ~str) -> ValueRef { cx.const_cstr_cache.insert(s, g); - ret g; + return g; } fn C_estr_slice(cx: @crate_ctxt, s: ~str) -> ValueRef { @@ -869,7 +871,7 @@ fn C_estr_slice(cx: @crate_ctxt, s: ~str) -> ValueRef { // Returns a Plain Old LLVM String: fn C_postr(s: ~str) -> ValueRef { - ret do str::as_c_str(s) |buf| { + return do str::as_c_str(s) |buf| { llvm::LLVMConstString(buf, str::len(s) as c_uint, False) }; } @@ -878,27 +880,27 @@ fn C_zero_byte_arr(size: uint) -> ValueRef unsafe { let mut i = 0u; let mut elts: ~[ValueRef] = ~[]; while i < size { vec::push(elts, C_u8(0u)); i += 1u; } - ret llvm::LLVMConstArray(T_i8(), vec::unsafe::to_ptr(elts), + return llvm::LLVMConstArray(T_i8(), vec::unsafe::to_ptr(elts), elts.len() as c_uint); } fn C_struct(elts: ~[ValueRef]) -> ValueRef unsafe { - ret llvm::LLVMConstStruct(vec::unsafe::to_ptr(elts), + return llvm::LLVMConstStruct(vec::unsafe::to_ptr(elts), elts.len() as c_uint, False); } fn C_named_struct(T: TypeRef, elts: ~[ValueRef]) -> ValueRef unsafe { - ret llvm::LLVMConstNamedStruct(T, vec::unsafe::to_ptr(elts), + return llvm::LLVMConstNamedStruct(T, vec::unsafe::to_ptr(elts), elts.len() as c_uint); } fn C_array(ty: TypeRef, elts: ~[ValueRef]) -> ValueRef unsafe { - ret llvm::LLVMConstArray(ty, vec::unsafe::to_ptr(elts), + return llvm::LLVMConstArray(ty, vec::unsafe::to_ptr(elts), elts.len() as c_uint); } fn C_bytes(bytes: ~[u8]) -> ValueRef unsafe { - ret llvm::LLVMConstString( + return llvm::LLVMConstString( unsafe::reinterpret_cast(vec::unsafe::to_ptr(bytes)), bytes.len() as c_uint, False); } @@ -911,7 +913,7 @@ fn C_shape(ccx: @crate_ctxt, bytes: ~[u8]) -> ValueRef { llvm::LLVMSetInitializer(llglobal, llshape); llvm::LLVMSetGlobalConstant(llglobal, True); lib::llvm::SetLinkage(llglobal, lib::llvm::InternalLinkage); - ret llvm::LLVMConstPointerCast(llglobal, T_ptr(T_i8())); + return llvm::LLVMConstPointerCast(llglobal, T_ptr(T_i8())); } fn get_param(fndecl: ValueRef, param: uint) -> ValueRef { @@ -945,18 +947,18 @@ fn hash_mono_id(&&mi: mono_id) -> uint { fn umax(cx: block, a: ValueRef, b: ValueRef) -> ValueRef { let cond = build::ICmp(cx, lib::llvm::IntULT, a, b); - ret build::Select(cx, cond, b, a); + return build::Select(cx, cond, b, a); } fn umin(cx: block, a: ValueRef, b: ValueRef) -> ValueRef { let cond = build::ICmp(cx, lib::llvm::IntULT, a, b); - ret build::Select(cx, cond, a, b); + return build::Select(cx, cond, a, b); } fn align_to(cx: block, off: ValueRef, align: ValueRef) -> ValueRef { let mask = build::Sub(cx, align, C_int(cx.ccx(), 1)); let bumped = build::Add(cx, off, mask); - ret build::And(cx, bumped, build::Not(cx, mask)); + return build::And(cx, bumped, build::Not(cx, mask)); } fn path_str(p: path) -> ~str { diff --git a/src/rustc/middle/trans/consts.rs b/src/rustc/middle/trans/consts.rs index c9e2582f5b2..aeb8c8ce74a 100644 --- a/src/rustc/middle/trans/consts.rs +++ b/src/rustc/middle/trans/consts.rs @@ -51,7 +51,7 @@ fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef { let ty = ty::expr_ty(cx.tcx, e1); let is_float = ty::type_is_fp(ty); let signed = ty::type_is_signed(ty); - ret alt b { + return alt b { ast::add { if is_float { llvm::LLVMConstFAdd(te1, te2) } else { llvm::LLVMConstAdd(te1, te2) } @@ -96,7 +96,7 @@ fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef { let te = const_expr(cx, e); let ty = ty::expr_ty(cx.tcx, e); let is_float = ty::type_is_fp(ty); - ret alt u { + return alt u { ast::box(_) | ast::uniq(_) | ast::deref { cx.sess.span_bug(e.span, diff --git a/src/rustc/middle/trans/debuginfo.rs b/src/rustc/middle/trans/debuginfo.rs index 98e7129abba..1f1da98b528 100644 --- a/src/rustc/middle/trans/debuginfo.rs +++ b/src/rustc/middle/trans/debuginfo.rs @@ -130,7 +130,7 @@ enum debug_metadata { fn cast_safely<T: copy, U>(val: T) -> U unsafe { let val2 = val; - ret unsafe::transmute(val2); + return unsafe::transmute(val2); } fn md_from_metadata<T>(val: debug_metadata) -> T unsafe { @@ -153,11 +153,11 @@ fn cached_metadata<T: copy>(cache: metadata_cache, mdtag: int, for items.each |item| { let md: T = md_from_metadata::<T>(item); if eq(md) { - ret option::some(md); + return option::some(md); } } } - ret option::none; + return option::none; } fn create_compile_unit(cx: @crate_ctxt) @@ -167,7 +167,7 @@ fn create_compile_unit(cx: @crate_ctxt) let tg = CompileUnitTag; alt cached_metadata::<@metadata<compile_unit_md>>(cache, tg, |md| md.data.name == crate_name) { - option::some(md) { ret md; } + option::some(md) { return md; } option::none {} } @@ -189,7 +189,7 @@ fn create_compile_unit(cx: @crate_ctxt) let mdval = @{node: unit_node, data: {name: crate_name}}; update_cache(cache, tg, compile_unit_metadata(mdval)); - ret mdval; + return mdval; } fn get_cache(cx: @crate_ctxt) -> metadata_cache { @@ -210,7 +210,7 @@ fn create_file(cx: @crate_ctxt, full_path: ~str) -> @metadata<file_md> { let tg = FileDescriptorTag; alt cached_metadata::<@metadata<file_md>>( cache, tg, |md| md.data.path == full_path) { - option::some(md) { ret md; } + option::some(md) { return md; } option::none {} } @@ -224,7 +224,7 @@ fn create_file(cx: @crate_ctxt, full_path: ~str) -> @metadata<file_md> { let val = llmdnode(file_md); let mdval = @{node: val, data: {path: full_path}}; update_cache(cache, tg, file_metadata(mdval)); - ret mdval; + return mdval; } fn line_from_span(cm: codemap::codemap, sp: span) -> uint { @@ -249,7 +249,7 @@ fn create_block(cx: block) -> @metadata<block_md> { /*alt cached_metadata::<@metadata<block_md>>( cache, tg, {|md| start == md.data.start && end == md.data.end}) { - option::some(md) { ret md; } + option::some(md) { return md; } option::none {} }*/ @@ -272,7 +272,7 @@ fn create_block(cx: block) -> @metadata<block_md> { let val = llmdnode(lldata); let mdval = @{node: val, data: {start: start, end: end}}; //update_cache(cache, tg, block_metadata(mdval)); - ret mdval; + return mdval; } fn size_and_align_of(cx: @crate_ctxt, t: ty::t) -> (int, int) { @@ -287,7 +287,7 @@ fn create_basic_type(cx: @crate_ctxt, t: ty::t, ty: ast::prim_ty, span: span) let tg = BasicTypeDescriptorTag; alt cached_metadata::<@metadata<tydesc_md>>( cache, tg, |md| ty::type_id(t) == md.data.hash) { - option::some(md) { ret md; } + option::some(md) { return md; } option::none {} } @@ -333,7 +333,7 @@ fn create_basic_type(cx: @crate_ctxt, t: ty::t, ty: ast::prim_ty, span: span) let mdval = @{node: llnode, data: {hash: ty::type_id(t)}}; update_cache(cache, tg, tydesc_metadata(mdval)); add_named_metadata(cx, ~"llvm.dbg.ty", llnode); - ret mdval; + return mdval; } fn create_pointer_type(cx: @crate_ctxt, t: ty::t, span: span, @@ -343,7 +343,7 @@ fn create_pointer_type(cx: @crate_ctxt, t: ty::t, span: span, /*let cache = cx.llmetadata; alt cached_metadata::<@metadata<tydesc_md>>( cache, tg, {|md| ty::hash_ty(t) == ty::hash_ty(md.data.hash)}) { - option::some(md) { ret md; } + option::some(md) { return md; } option::none {} }*/ let (size, align) = size_and_align_of(cx, t); @@ -355,7 +355,7 @@ fn create_pointer_type(cx: @crate_ctxt, t: ty::t, span: span, let mdval = @{node: llnode, data: {hash: ty::type_id(t)}}; //update_cache(cache, tg, tydesc_metadata(mdval)); add_named_metadata(cx, ~"llvm.dbg.ty", llnode); - ret mdval; + return mdval; } type struct_ctxt = { @@ -368,7 +368,7 @@ type struct_ctxt = { }; fn finish_structure(cx: @struct_ctxt) -> ValueRef { - ret create_composite_type(StructureTypeTag, cx.name, cx.file, cx.line, + return create_composite_type(StructureTypeTag, cx.name, cx.file, cx.line, cx.total_size, cx.align, 0, option::none, option::some(cx.members)); } @@ -382,7 +382,7 @@ fn create_structure(file: @metadata<file_md>, name: ~str, line: int) mut total_size: 0, align: 64 //XXX different alignment per arch? }; - ret cx; + return cx; } fn create_derived_type(type_tag: int, file: ValueRef, name: ~str, line: int, @@ -398,7 +398,7 @@ fn create_derived_type(type_tag: int, file: ValueRef, name: ~str, line: int, lli64(offset), lli32(0), ty]; - ret llmdnode(lldata); + return llmdnode(lldata); } fn add_member(cx: @struct_ctxt, name: ~str, line: int, size: int, align: int, @@ -426,7 +426,7 @@ fn create_record(cx: @crate_ctxt, t: ty::t, fields: ~[ast::ty_field], size as int, align as int, ty_md.node); } let mdval = @{node: finish_structure(scx), data:{hash: ty::type_id(t)}}; - ret mdval; + return mdval; } fn create_boxed_type(cx: @crate_ctxt, outer: ty::t, _inner: ty::t, @@ -436,7 +436,7 @@ fn create_boxed_type(cx: @crate_ctxt, outer: ty::t, _inner: ty::t, /*let cache = cx.llmetadata; alt cached_metadata::<@metadata<tydesc_md>>( cache, tg, {|md| ty::hash_ty(outer) == ty::hash_ty(md.data.hash)}) { - option::some(md) { ret md; } + option::some(md) { return md; } option::none {} }*/ let fname = filename_from_span(cx, span); @@ -455,7 +455,7 @@ fn create_boxed_type(cx: @crate_ctxt, outer: ty::t, _inner: ty::t, let mdval = @{node: llnode, data: {hash: ty::type_id(outer)}}; //update_cache(cache, tg, tydesc_metadata(mdval)); add_named_metadata(cx, ~"llvm.dbg.ty", llnode); - ret mdval; + return mdval; } fn create_composite_type(type_tag: int, name: ~str, file: ValueRef, line: int, @@ -485,7 +485,7 @@ fn create_composite_type(type_tag: int, name: ~str, file: ValueRef, line: int, lli32(0), // runtime language llnull() ]; - ret llmdnode(lldata); + return llmdnode(lldata); } fn create_vec(cx: @crate_ctxt, vec_t: ty::t, elem_t: ty::t, @@ -510,7 +510,7 @@ fn create_vec(cx: @crate_ctxt, vec_t: ty::t, elem_t: ty::t, add_member(scx, ~"data", 0, 0, // clang says the size should be 0 sys::min_align_of::<u8>() as int, data_ptr); let llnode = finish_structure(scx); - ret @{node: llnode, data: {hash: ty::type_id(vec_t)}}; + return @{node: llnode, data: {hash: ty::type_id(vec_t)}}; } fn create_ty(_cx: @crate_ctxt, _t: ty::t, _ty: @ast::ty) @@ -518,7 +518,7 @@ fn create_ty(_cx: @crate_ctxt, _t: ty::t, _ty: @ast::ty) /*let cache = get_cache(cx); alt cached_metadata::<@metadata<tydesc_md>>( cache, tg, {|md| t == md.data.hash}) { - option::some(md) { ret md; } + option::some(md) { return md; } option::none {} }*/ @@ -563,7 +563,7 @@ fn create_ty(_cx: @crate_ctxt, _t: ty::t, _ty: @ast::ty) cx.sess.span_bug(span, "t_to_ty: Can't handle this type"); } }; - ret @{node: ty, span: span}; + return @{node: ty, span: span}; } alt ty.node { @@ -574,7 +574,7 @@ fn create_ty(_cx: @crate_ctxt, _t: ty::t, _ty: @ast::ty) }; let md = create_ty(cx, inner_t, mt.ty); let box = create_boxed_type(cx, t, inner_t, ty.span, md); - ret create_pointer_type(cx, t, ty.span, box); + return create_pointer_type(cx, t, ty.span, box); } ast::ty_uniq(mt) { @@ -584,29 +584,29 @@ fn create_ty(_cx: @crate_ctxt, _t: ty::t, _ty: @ast::ty) _ { cx.sess.span_bug(ty.span, "t_to_ty was incoherent"); } }; let md = create_ty(cx, inner_t, mt.ty); - ret create_pointer_type(cx, t, ty.span, md); + return create_pointer_type(cx, t, ty.span, md); } ast::ty_infer { let inferred = t_to_ty(cx, t, ty.span); - ret create_ty(cx, t, inferred); + return create_ty(cx, t, inferred); } ast::ty_rec(fields) { - ret create_record(cx, t, fields, ty.span); + return create_record(cx, t, fields, ty.span); } ast::ty_vec(mt) { let inner_t = ty::sequence_element_type(cx.tcx, t); let inner_ast_t = t_to_ty(cx, inner_t, mt.ty.span); let v = create_vec(cx, t, inner_t, ty.span, inner_ast_t); - ret create_pointer_type(cx, t, ty.span, v); + return create_pointer_type(cx, t, ty.span, v); } ast::ty_path(_, id) { alt cx.tcx.def_map.get(id) { ast::def_prim_ty(pty) { - ret create_basic_type(cx, t, pty, ty.span); + return create_basic_type(cx, t, pty, ty.span); } _ {} } @@ -631,7 +631,7 @@ fn create_var(type_tag: int, context: ValueRef, name: ~str, file: ValueRef, ret_ty, lli32(0) ]; - ret llmdnode(lldata); + return llmdnode(lldata); } fn create_local_var(bcx: block, local: @ast::local) @@ -641,7 +641,7 @@ fn create_local_var(bcx: block, local: @ast::local) let tg = AutoVariableTag; alt cached_metadata::<@metadata<local_var_md>>( cache, tg, |md| md.data.id == local.node.id) { - option::some(md) { ret md; } + option::some(md) { return md; } option::none {} } @@ -681,7 +681,7 @@ fn create_local_var(bcx: block, local: @ast::local) let declargs = ~[llmdnode(~[llptr]), mdnode]; trans::build::Call(bcx, cx.intrinsics.get(~"llvm.dbg.declare"), declargs); - ret mdval; + return mdval; } fn create_arg(bcx: block, arg: ast::arg, sp: span) @@ -691,7 +691,7 @@ fn create_arg(bcx: block, arg: ast::arg, sp: span) let tg = ArgVariableTag; alt cached_metadata::<@metadata<argument_md>>( cache, ArgVariableTag, |md| md.data.id == arg.id) { - option::some(md) { ret md; } + option::some(md) { return md; } option::none {} } @@ -712,12 +712,12 @@ fn create_arg(bcx: block, arg: ast::arg, sp: span) let declargs = ~[llmdnode(~[llptr]), mdnode]; trans::build::Call(bcx, cx.intrinsics.get(~"llvm.dbg.declare"), declargs); - ret mdval; + return mdval; } fn update_source_pos(cx: block, s: span) { if !cx.sess().opts.debuginfo { - ret; + return; } let cm = cx.sess().codemap; let blockmd = create_block(cx); @@ -779,7 +779,7 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> { let cache = get_cache(cx); alt cached_metadata::<@metadata<subprogram_md>>( cache, SubprogramTag, |md| md.data.id == id) { - option::some(md) { ret md; } + option::some(md) { return md; } option::none {} } @@ -824,5 +824,5 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> { let mdval = @{node: val, data: {id: id}}; update_cache(cache, SubprogramTag, subprogram_metadata(mdval)); - ret mdval; + return mdval; } diff --git a/src/rustc/middle/trans/foreign.rs b/src/rustc/middle/trans/foreign.rs index 5313cee2323..129e737bb29 100644 --- a/src/rustc/middle/trans/foreign.rs +++ b/src/rustc/middle/trans/foreign.rs @@ -38,7 +38,7 @@ enum x86_64_reg_class { } fn is_sse(++c: x86_64_reg_class) -> bool { - ret alt c { + return alt c { sse_fs_class | sse_fv_class | sse_ds_class | sse_dv_class { true } _ { false } @@ -47,7 +47,7 @@ fn is_sse(++c: x86_64_reg_class) -> bool { fn is_ymm(cls: ~[x86_64_reg_class]) -> bool { let len = vec::len(cls); - ret (len > 2u && + return (len > 2u && is_sse(cls[0]) && cls[1] == sseup_class && cls[2] == sseup_class) || @@ -60,7 +60,7 @@ fn is_ymm(cls: ~[x86_64_reg_class]) -> bool { fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] { fn align(off: uint, ty: TypeRef) -> uint { let a = ty_align(ty); - ret (off + a - 1u) / a * a; + return (off + a - 1u) / a * a; } fn struct_tys(ty: TypeRef) -> ~[TypeRef] { @@ -69,11 +69,11 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] { do vec::as_buf(elts) |buf, _len| { llvm::LLVMGetStructElementTypes(ty, buf); } - ret elts; + return elts; } fn ty_align(ty: TypeRef) -> uint { - ret alt llvm::LLVMGetTypeKind(ty) as int { + return alt llvm::LLVMGetTypeKind(ty) as int { 8 /* integer */ { ((llvm::LLVMGetIntTypeWidth(ty) as uint) + 7u) / 8u } @@ -96,7 +96,7 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] { } fn ty_size(ty: TypeRef) -> uint { - ret alt llvm::LLVMGetTypeKind(ty) as int { + return alt llvm::LLVMGetTypeKind(ty) as int { 8 /* integer */ { ((llvm::LLVMGetIntTypeWidth(ty) as uint) + 7u) / 8u } @@ -130,11 +130,11 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] { i: uint, newv: x86_64_reg_class) { if cls[i] == newv { - ret; + return; } else if cls[i] == no_class { cls[i] = newv; } else if newv == no_class { - ret; + return; } else if cls[i] == memory_class || newv == memory_class { cls[i] = memory_class; } else if cls[i] == integer_class || newv == integer_class { @@ -180,7 +180,7 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] { unify(cls, ix + i, memory_class); i += 1u; } - ret; + return; } alt llvm::LLVMGetTypeKind(ty) as int { @@ -229,25 +229,25 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] { while i < e { if cls[i] != sseup_class { all_mem(cls); - ret; + return; } i += 1u; } } else { all_mem(cls); - ret + return } } else { while i < e { if cls[i] == memory_class { all_mem(cls); - ret; + return; } if cls[i] == x87up_class { // for darwin // cls[i] = sse_ds_class; all_mem(cls); - ret; + return; } if cls[i] == sseup_class { cls[i] = sse_int_class; @@ -268,11 +268,11 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] { let cls = vec::to_mut(vec::from_elem(words, no_class)); if words > 4u { all_mem(cls); - ret vec::from_mut(cls); + return vec::from_mut(cls); } classify(ty, cls, 0u, 0u); fixup(ty, cls); - ret vec::from_mut(cls); + return vec::from_mut(cls); } fn llreg_ty(cls: ~[x86_64_reg_class]) -> TypeRef { @@ -284,7 +284,7 @@ fn llreg_ty(cls: ~[x86_64_reg_class]) -> TypeRef { } len += 1u; } - ret len; + return len; } let mut tys = ~[]; @@ -315,7 +315,7 @@ fn llreg_ty(cls: ~[x86_64_reg_class]) -> TypeRef { } i += 1u; } - ret T_struct(tys); + return T_struct(tys); } type x86_64_llty = { @@ -334,7 +334,7 @@ fn x86_64_tys(atys: ~[TypeRef], rty: TypeRef, ret_def: bool) -> x86_64_tys { fn is_reg_ty(ty: TypeRef) -> bool { - ret alt llvm::LLVMGetTypeKind(ty) as int { + return alt llvm::LLVMGetTypeKind(ty) as int { 8 /* integer */ | 12 /* pointer */ | 2 /* float */ | @@ -344,13 +344,13 @@ fn x86_64_tys(atys: ~[TypeRef], } fn is_pass_byval(cls: ~[x86_64_reg_class]) -> bool { - ret cls[0] == memory_class || + return cls[0] == memory_class || cls[0] == x87_class || cls[0] == complex_x87_class; } fn is_ret_bysret(cls: ~[x86_64_reg_class]) -> bool { - ret cls[0] == memory_class; + return cls[0] == memory_class; } fn x86_64_ty(ty: TypeRef, @@ -369,7 +369,7 @@ fn x86_64_tys(atys: ~[TypeRef], llty = llreg_ty(cls); } } - ret ({ cast: cast, ty: llty }, ty_attr); + return ({ cast: cast, ty: llty }, ty_attr); } let mut arg_tys = ~[]; @@ -393,7 +393,7 @@ fn x86_64_tys(atys: ~[TypeRef], ty: T_void() }; } - ret { + return { arg_tys: arg_tys, ret_ty: ret_ty, attrs: attrs, @@ -417,13 +417,13 @@ fn decl_x86_64_fn(tys: x86_64_tys, _ {} } } - ret llfn; + return llfn; } fn link_name(i: @ast::foreign_item) -> ~str { alt attr::first_attr_value_str_by_name(i.attrs, ~"link_name") { - none { ret *i.ident; } - option::some(ln) { ret *ln; } + none { return *i.ident; } + option::some(ln) { return *ln; } } } @@ -458,7 +458,7 @@ fn c_stack_tys(ccx: @crate_ctxt, } else { option::none }; - ret @{ + return @{ arg_tys: llargtys, ret_ty: llretty, ret_def: ret_def, @@ -501,7 +501,7 @@ fn build_shim_fn_(ccx: @crate_ctxt, build_return(bcx); finish_fn(fcx, lltop); - ret llshimfn; + return llshimfn; } type wrap_arg_builder = fn(bcx: block, tys: @c_stack_tys, @@ -631,7 +631,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt, } } } - ret llargvals; + return llargvals; } fn build_ret(bcx: block, tys: @c_stack_tys, @@ -650,7 +650,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt, } } if x86_64.sret || !tys.ret_def { - ret; + return; } let n = vec::len(tys.arg_tys); let llretptr = GEPi(bcx, llargbundle, ~[0u, n]); @@ -681,7 +681,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt, let llbasefn = base_fn(ccx, lname, tys, cc); // Name the shim function let shim_name = lname + ~"__c_stack_shim"; - ret build_shim_fn_(ccx, shim_name, llbasefn, tys, cc, + return build_shim_fn_(ccx, shim_name, llbasefn, tys, cc, build_args, build_ret); } @@ -734,7 +734,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt, let _icx = bcx.insn_ctxt(~"foreign::wrap::build_args"); let mut i = 0u; let n = vec::len(tys.arg_tys); - let implicit_args = first_real_arg; // ret + env + let implicit_args = first_real_arg; // return + env while i < n { let llargval = get_param(llwrapfn, i + implicit_args); store_inbounds(bcx, llargval, llargbundle, ~[0u, i]); @@ -1005,7 +1005,7 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl, let llty = type_of_fn_from_ty(ccx, t); let llfndecl = decl_internal_cdecl_fn(ccx.llmod, ps, llty); trans_fn(ccx, path, decl, body, llfndecl, no_self, none, id); - ret llfndecl; + return llfndecl; } fn build_shim_fn(ccx: @crate_ctxt, path: ast_map::path, @@ -1028,7 +1028,7 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl, vec::push(llargvals, llargval); i += 1u; } - ret llargvals; + return llargvals; } fn build_ret(_bcx: block, _tys: @c_stack_tys, @@ -1040,7 +1040,7 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl, let shim_name = link::mangle_internal_name_by_path( ccx, vec::append_one(path, ast_map::path_name(@~"__rust_stack_shim"))); - ret build_shim_fn_(ccx, shim_name, llrustfn, tys, + return build_shim_fn_(ccx, shim_name, llrustfn, tys, lib::llvm::CCallConv, build_args, build_ret); } @@ -1111,7 +1111,7 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl, option::some(x86_64) { if x86_64.sret || !tys.ret_def { RetVoid(bcx); - ret; + return; } let n = vec::len(tys.arg_tys); let llretval = load_inbounds(bcx, llargbundle, ~[0u, n]); @@ -1153,7 +1153,7 @@ fn register_foreign_fn(ccx: @crate_ctxt, sp: span, let _icx = ccx.insn_ctxt(~"foreign::register_foreign_fn"); let t = ty::node_id_to_type(ccx.tcx, node_id); let (llargtys, llretty, ret_ty) = c_arg_and_ret_lltys(ccx, node_id); - ret if ccx.sess.targ_cfg.arch == arch_x86_64 { + return if ccx.sess.targ_cfg.arch == arch_x86_64 { let ret_def = !ty::type_is_bot(ret_ty) && !ty::type_is_nil(ret_ty); let x86_64 = x86_64_tys(llargtys, llretty, ret_def); do decl_x86_64_fn(x86_64) |fnty| { diff --git a/src/rustc/middle/trans/impl.rs b/src/rustc/middle/trans/impl.rs index b42dce15fd5..6f254f867f6 100644 --- a/src/rustc/middle/trans/impl.rs +++ b/src/rustc/middle/trans/impl.rs @@ -18,7 +18,7 @@ import std::map::hashmap; fn trans_impl(ccx: @crate_ctxt, path: path, name: ast::ident, methods: ~[@ast::method], tps: ~[ast::ty_param]) { let _icx = ccx.insn_ctxt(~"impl::trans_impl"); - if tps.len() > 0u { ret; } + if tps.len() > 0u { return; } let sub_path = vec::append_one(path, path_name(name)); for vec::each(methods) |m| { if m.tps.len() == 0u { @@ -45,7 +45,7 @@ fn trans_self_arg(bcx: block, base: @ast::expr, derefs: uint) -> result { // other arguments failing: assert temp_cleanups == ~[]; - ret result; + return result; } fn trans_method_callee(bcx: block, callee_id: ast::node_id, @@ -285,7 +285,7 @@ fn make_impl_vtable(ccx: @crate_ctxt, impl_id: ast::def_id, substs: ~[ty::t], fn trans_cast(bcx: block, val: @ast::expr, id: ast::node_id, dest: dest) -> block { let _icx = bcx.insn_ctxt(~"impl::trans_cast"); - if dest == ignore { ret trans_expr(bcx, val, ignore); } + if dest == ignore { return trans_expr(bcx, val, ignore); } let ccx = bcx.ccx(); let v_ty = expr_ty(bcx, val); let {bcx: bcx, box: llbox, body: body} = malloc_boxed(bcx, v_ty); diff --git a/src/rustc/middle/trans/reachable.rs b/src/rustc/middle/trans/reachable.rs index 0250b17f6fe..a1db7e7b4bd 100644 --- a/src/rustc/middle/trans/reachable.rs +++ b/src/rustc/middle/trans/reachable.rs @@ -59,9 +59,9 @@ fn traverse_export(cx: ctx, exp_id: node_id) { } fn traverse_def_id(cx: ctx, did: def_id) { - if did.crate != local_crate { ret; } + if did.crate != local_crate { return; } let n = alt cx.tcx.items.find(did.node) { - none { ret; } // This can happen for self, for example + none { return; } // This can happen for self, for example some(n) { n } }; alt n { @@ -85,7 +85,7 @@ fn traverse_public_mod(cx: ctx, m: _mod) { } fn traverse_public_item(cx: ctx, item: @item) { - if cx.rmap.contains_key(item.id) { ret; } + if cx.rmap.contains_key(item.id) { return; } cx.rmap.insert(item.id, ()); alt item.node { item_mod(m) { traverse_public_mod(cx, m); } @@ -151,7 +151,7 @@ fn mk_ty_visitor() -> visit::vt<ctx> { } fn traverse_ty(ty: @ty, cx: ctx, v: visit::vt<ctx>) { - if cx.rmap.contains_key(ty.id) { ret; } + if cx.rmap.contains_key(ty.id) { return; } cx.rmap.insert(ty.id, ()); alt ty.node { diff --git a/src/rustc/middle/trans/reflect.rs b/src/rustc/middle/trans/reflect.rs index 82cb96f660d..5b833a91538 100644 --- a/src/rustc/middle/trans/reflect.rs +++ b/src/rustc/middle/trans/reflect.rs @@ -37,7 +37,7 @@ impl methods for reflector { let tr = type_of::type_of(self.bcx.ccx(), t); let s = shape::llsize_of_real(self.bcx.ccx(), tr); let a = shape::llalign_of_min(self.bcx.ccx(), tr); - ret ~[self.c_uint(s), + return ~[self.c_uint(s), self.c_uint(a)]; } @@ -306,5 +306,5 @@ fn emit_calls_to_trait_visit_ty(bcx: block, t: ty::t, }); r.visit_ty(t); Br(r.bcx, final.llbb); - ret final; + return final; } diff --git a/src/rustc/middle/trans/shape.rs b/src/rustc/middle/trans/shape.rs index 152e6bfe0c3..33c2323b290 100644 --- a/src/rustc/middle/trans/shape.rs +++ b/src/rustc/middle/trans/shape.rs @@ -43,7 +43,7 @@ fn hash_nominal_id(&&ri: nominal_id) -> uint { h *= 33u; h += ty::type_id(t); } - ret h; + return h; } fn eq_nominal_id(&&mi: nominal_id, &&ni: nominal_id) -> bool { @@ -57,7 +57,7 @@ fn eq_nominal_id(&&mi: nominal_id, &&ni: nominal_id) -> bool { } fn new_nominal_id_hash<T: copy>() -> hashmap<nominal_id, T> { - ret hashmap(hash_nominal_id, eq_nominal_id); + return hashmap(hash_nominal_id, eq_nominal_id); } type enum_data = {did: ast::def_id, substs: ty::substs}; @@ -113,7 +113,7 @@ fn mk_global(ccx: @crate_ctxt, name: ~str, llval: ValueRef, internal: bool) -> lib::llvm::SetLinkage(llglobal, lib::llvm::InternalLinkage); } - ret llglobal; + return llglobal; } @@ -124,7 +124,7 @@ fn mk_global(ccx: @crate_ctxt, name: ~str, llval: ValueRef, internal: bool) -> fn round_up(size: u16, align: u8) -> u16 { assert (align >= 1u8); let alignment = align as u16; - ret size - 1u16 + alignment & !(alignment - 1u16); + return size - 1u16 + alignment & !(alignment - 1u16); } type size_align = {size: u16, align: u8}; @@ -149,7 +149,7 @@ fn enum_kind(ccx: @crate_ctxt, did: ast::def_id) -> enum_kind { // Returns the code corresponding to the pointer size on this architecture. fn s_int(tcx: ty_ctxt) -> u8 { - ret alt tcx.sess.targ_cfg.arch { + return alt tcx.sess.targ_cfg.arch { session::arch_x86 { shape_i32 } session::arch_x86_64 { shape_i64 } session::arch_arm { shape_i32 } @@ -157,7 +157,7 @@ fn s_int(tcx: ty_ctxt) -> u8 { } fn s_uint(tcx: ty_ctxt) -> u8 { - ret alt tcx.sess.targ_cfg.arch { + return alt tcx.sess.targ_cfg.arch { session::arch_x86 { shape_u32 } session::arch_x86_64 { shape_u64 } session::arch_arm { shape_u32 } @@ -165,7 +165,7 @@ fn s_uint(tcx: ty_ctxt) -> u8 { } fn s_float(tcx: ty_ctxt) -> u8 { - ret alt tcx.sess.targ_cfg.arch { + return alt tcx.sess.targ_cfg.arch { session::arch_x86 { shape_f64 } session::arch_x86_64 { shape_f64 } session::arch_arm { shape_f64 } @@ -173,15 +173,15 @@ fn s_float(tcx: ty_ctxt) -> u8 { } fn s_variant_enum_t(tcx: ty_ctxt) -> u8 { - ret s_int(tcx); + return s_int(tcx); } fn s_tydesc(_tcx: ty_ctxt) -> u8 { - ret shape_tydesc; + return shape_tydesc; } fn s_send_tydesc(_tcx: ty_ctxt) -> u8 { - ret shape_send_tydesc; + return shape_send_tydesc; } fn mk_ctxt(llmod: ModuleRef) -> ctxt { @@ -190,7 +190,7 @@ fn mk_ctxt(llmod: ModuleRef) -> ctxt { lib::llvm::llvm::LLVMAddGlobal(llmod, llshapetablesty, buf) }); - ret {mut next_tag_id: 0u16, + return {mut next_tag_id: 0u16, pad: 0u16, tag_id_to_index: new_nominal_id_hash(), tag_order: dvec(), @@ -367,7 +367,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> ~[u8] { fn shape_of_variant(ccx: @crate_ctxt, v: ty::variant_info) -> ~[u8] { let mut s = ~[]; for vec::each(v.args) |t| { s += shape_of(ccx, t); } - ret s; + return s; } fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef { @@ -456,7 +456,7 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef { header += data; header += lv_table; - ret mk_global(ccx, ~"tag_shapes", C_bytes(header), true); + return mk_global(ccx, ~"tag_shapes", C_bytes(header), true); /* tjc: Not annotating FIXMEs in this module because of #1498 */ fn largest_variants(ccx: @crate_ctxt, @@ -530,7 +530,7 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef { if candidates[i] { vec::push(result, i); } i += 1u; } - ret result; + return result; } fn compute_static_enum_size(ccx: @crate_ctxt, largest_variants: ~[uint], @@ -563,7 +563,7 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef { if max_align < align { max_align = align; } } - ret {size: max_size, align: max_align}; + return {size: max_size, align: max_align}; } } @@ -577,7 +577,7 @@ fn gen_resource_shapes(ccx: @crate_ctxt) -> ValueRef { dtors += ~[trans::base::get_res_dtor(ccx, ri.did, id, ri.tps)]; } } - ret mk_global(ccx, ~"resource_shapes", C_struct(dtors), true); + return mk_global(ccx, ~"resource_shapes", C_struct(dtors), true); } fn gen_shape_tables(ccx: @crate_ctxt) { @@ -614,13 +614,13 @@ type tag_metrics = { // Returns the number of bytes clobbered by a Store to this type. fn llsize_of_store(cx: @crate_ctxt, t: TypeRef) -> uint { - ret llvm::LLVMStoreSizeOfType(cx.td.lltd, t) as uint; + return llvm::LLVMStoreSizeOfType(cx.td.lltd, t) as uint; } // Returns the number of bytes between successive elements of type T in an // array of T. This is the "ABI" size. It includes any ABI-mandated padding. fn llsize_of_alloc(cx: @crate_ctxt, t: TypeRef) -> uint { - ret llvm::LLVMABISizeOfType(cx.td.lltd, t) as uint; + return llvm::LLVMABISizeOfType(cx.td.lltd, t) as uint; } // Returns, as near as we can figure, the "real" size of a type. As in, the @@ -644,7 +644,7 @@ fn llsize_of_real(cx: @crate_ctxt, t: TypeRef) -> uint { // (i.e. including alignment-padding), but goodness knows which alignment it // winds up using. Probably the ABI one? Not recommended. fn llsize_of(cx: @crate_ctxt, t: TypeRef) -> ValueRef { - ret llvm::LLVMConstIntCast(lib::llvm::llvm::LLVMSizeOf(t), cx.int_type, + return llvm::LLVMConstIntCast(lib::llvm::llvm::LLVMSizeOf(t), cx.int_type, False); } @@ -653,22 +653,22 @@ fn llsize_of(cx: @crate_ctxt, t: TypeRef) -> ValueRef { // packing the type into structs. This will be used for things like // allocations inside a stack frame, which LLVM has a free hand in. fn llalign_of_pref(cx: @crate_ctxt, t: TypeRef) -> uint { - ret llvm::LLVMPreferredAlignmentOfType(cx.td.lltd, t) as uint; + return llvm::LLVMPreferredAlignmentOfType(cx.td.lltd, t) as uint; } // Returns the minimum alignment of a type required by the plattform. // This is the alignment that will be used for struct fields, arrays, // and similar ABI-mandated things. fn llalign_of_min(cx: @crate_ctxt, t: TypeRef) -> uint { - ret llvm::LLVMABIAlignmentOfType(cx.td.lltd, t) as uint; + return llvm::LLVMABIAlignmentOfType(cx.td.lltd, t) as uint; } // Returns the "default" alignment of t, which is calculated by casting // null to a record containing a single-bit followed by a t value, then // doing gep(0,1) to get at the trailing (and presumably padded) t cell. fn llalign_of(cx: @crate_ctxt, t: TypeRef) -> ValueRef { - ret llvm::LLVMConstIntCast(lib::llvm::llvm::LLVMAlignOf(t), cx.int_type, - False); + return llvm::LLVMConstIntCast( + lib::llvm::llvm::LLVMAlignOf(t), cx.int_type, False); } // Computes the static size of a enum, without using mk_tup(), which is @@ -678,7 +678,7 @@ fn llalign_of(cx: @crate_ctxt, t: TypeRef) -> ValueRef { // Computes the size of the data part of an enum. fn static_size_of_enum(cx: @crate_ctxt, t: ty::t) -> uint { - if cx.enum_sizes.contains_key(t) { ret cx.enum_sizes.get(t); } + if cx.enum_sizes.contains_key(t) { return cx.enum_sizes.get(t); } alt ty::get(t).struct { ty::ty_enum(tid, substs) { // Compute max(variant sizes). @@ -695,7 +695,7 @@ fn static_size_of_enum(cx: @crate_ctxt, t: ty::t) -> uint { if max_size < this_size { max_size = this_size; } } cx.enum_sizes.insert(t, max_size); - ret max_size; + return max_size; } _ { cx.sess.bug(~"static_size_of_enum called on non-enum"); } } diff --git a/src/rustc/middle/trans/tvec.rs b/src/rustc/middle/trans/tvec.rs index bfd2f18bac9..213117f15f4 100644 --- a/src/rustc/middle/trans/tvec.rs +++ b/src/rustc/middle/trans/tvec.rs @@ -57,7 +57,7 @@ fn pointer_add(bcx: block, ptr: ValueRef, bytes: ValueRef) -> ValueRef { let _icx = bcx.insn_ctxt(~"tvec::pointer_add"); let old_ty = val_ty(ptr); let bptr = PointerCast(bcx, ptr, T_ptr(T_i8())); - ret PointerCast(bcx, InBoundsGEP(bcx, bptr, ~[bytes]), old_ty); + return PointerCast(bcx, InBoundsGEP(bcx, bptr, ~[bytes]), old_ty); } fn alloc_raw(bcx: block, unit_ty: ty::t, @@ -72,7 +72,7 @@ fn alloc_raw(bcx: block, unit_ty: ty::t, base::malloc_general_dyn(bcx, vecbodyty, heap, vecsize); Store(bcx, fill, GEPi(bcx, body, ~[0u, abi::vec_elt_fill])); Store(bcx, alloc, GEPi(bcx, body, ~[0u, abi::vec_elt_alloc])); - ret {bcx: bcx, val: box}; + return {bcx: bcx, val: box}; } fn alloc_uniq_raw(bcx: block, unit_ty: ty::t, fill: ValueRef, alloc: ValueRef) -> result { @@ -89,7 +89,7 @@ fn alloc_vec(bcx: block, unit_ty: ty::t, elts: uint, heap: heap) -> result { let alloc = if elts < 4u { Mul(bcx, C_int(ccx, 4), unit_sz) } else { fill }; let {bcx: bcx, val: vptr} = alloc_raw(bcx, unit_ty, fill, alloc, heap); - ret {bcx: bcx, val: vptr}; + return {bcx: bcx, val: vptr}; } fn duplicate_uniq(bcx: block, vptr: ValueRef, vec_ty: ty::t) -> result { @@ -106,7 +106,7 @@ fn duplicate_uniq(bcx: block, vptr: ValueRef, vec_ty: ty::t) -> result { let bcx = if ty::type_needs_drop(bcx.tcx(), unit_ty) { iter_vec_raw(bcx, new_data_ptr, vec_ty, fill, base::take_ty) } else { bcx }; - ret rslt(bcx, newptr); + return rslt(bcx, newptr); } fn make_drop_glue_unboxed(bcx: block, vptr: ValueRef, vec_ty: ty::t) -> @@ -127,7 +127,7 @@ fn trans_evec(bcx: block, args: ~[@ast::expr], for vec::each(args) |arg| { bcx = base::trans_expr(bcx, arg, base::ignore); } - ret bcx; + return bcx; } let vec_ty = node_id_type(bcx, id); @@ -205,13 +205,13 @@ fn trans_evec(bcx: block, args: ~[@ast::expr], alt vst { ast::vstore_fixed(_) { // We wrote into the destination in the fixed case. - ret bcx; + return bcx; } ast::vstore_slice(_) { - ret base::store_in_dest(bcx, Load(bcx, val), dest); + return base::store_in_dest(bcx, Load(bcx, val), dest); } _ { - ret base::store_in_dest(bcx, val, dest); + return base::store_in_dest(bcx, val, dest); } } } @@ -220,10 +220,10 @@ fn trans_vstore(bcx: block, e: @ast::expr, v: ast::vstore, dest: dest) -> block { alt e.node { ast::expr_lit(@{node: ast::lit_str(s), span: _}) { - ret trans_estr(bcx, s, v, dest); + return trans_estr(bcx, s, v, dest); } ast::expr_vec(es, mutbl) { - ret trans_evec(bcx, es, v, e.id, dest); + return trans_evec(bcx, es, v, e.id, dest); } _ { bcx.sess().span_bug(e.span, ~"vstore on non-sequence type"); @@ -269,7 +269,7 @@ fn get_base_and_len(cx: block, v: ValueRef, e_ty: ty::t) fn trans_estr(bcx: block, s: @~str, vstore: ast::vstore, dest: dest) -> block { let _icx = bcx.insn_ctxt(~"tvec::trans_estr"); - if dest == base::ignore { ret bcx; } + if dest == base::ignore { return bcx; } let ccx = bcx.ccx(); let c = alt vstore { @@ -338,7 +338,7 @@ fn iter_vec_raw(bcx: block, data_ptr: ValueRef, vec_ty: ty::t, ~[C_int(bcx.ccx(), 1)]), body_cx.llbb); Br(body_cx, header_cx.llbb); - ret next_cx; + return next_cx; } @@ -354,7 +354,7 @@ fn iter_vec_unboxed(bcx: block, body_ptr: ValueRef, vec_ty: ty::t, let _icx = bcx.insn_ctxt(~"tvec::iter_vec_unboxed"); let fill = get_fill(bcx, body_ptr); let dataptr = get_dataptr(bcx, body_ptr); - ret iter_vec_raw(bcx, dataptr, vec_ty, fill, f); + return iter_vec_raw(bcx, dataptr, vec_ty, fill, f); } // diff --git a/src/rustc/middle/trans/type_of.rs b/src/rustc/middle/trans/type_of.rs index d06bf94f5e1..79cd20bb36e 100644 --- a/src/rustc/middle/trans/type_of.rs +++ b/src/rustc/middle/trans/type_of.rs @@ -36,7 +36,7 @@ fn type_of_fn(cx: @crate_ctxt, inputs: ~[ty::arg], // ... then explicit args. vec::push_all(atys, type_of_explicit_args(cx, inputs)); - ret T_fn(atys, llvm::LLVMVoidType()); + return T_fn(atys, llvm::LLVMVoidType()); } // Given a function type and a count of ty params, construct an llvm type @@ -69,7 +69,7 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef { debug!{"type_of %?: %?", t, ty::get(t)}; // Check the cache. - if cx.lltypes.contains_key(t) { ret cx.lltypes.get(t); } + if cx.lltypes.contains_key(t) { return cx.lltypes.get(t); } // Replace any typedef'd types with their equivalent non-typedef // type. This ensures that all LLVM nominal types that contain @@ -188,7 +188,7 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef { } }; - ret llty; + return llty; } // This should only be called from type_of, above, because it @@ -221,7 +221,7 @@ fn type_of_enum(cx: @crate_ctxt, did: ast::def_id, t: ty::t) }; common::set_struct_body(named_llty, lltys); - ret named_llty; + return named_llty; } fn llvm_type_name(cx: @crate_ctxt, t: ty::t) -> ~str { @@ -233,7 +233,7 @@ fn llvm_type_name(cx: @crate_ctxt, t: ty::t) -> ~str { (~"class", did, substs.tps) } }; - ret fmt!{ + return fmt!{ "%s %s[#%d]", name, util::ppaux::parameterized( diff --git a/src/rustc/middle/trans/type_use.rs b/src/rustc/middle/trans/type_use.rs index 8ab6fbfc6eb..486ea2da835 100644 --- a/src/rustc/middle/trans/type_use.rs +++ b/src/rustc/middle/trans/type_use.rs @@ -36,7 +36,7 @@ type ctx = {ccx: @crate_ctxt, fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint) -> ~[type_uses] { alt ccx.type_use_cache.find(fn_id) { - some(uses) { ret uses; } + some(uses) { return uses; } none {} } let fn_id_loc = if fn_id.crate == local_crate { fn_id } @@ -57,7 +57,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint) if fn_id_loc.crate != local_crate { let uses = vec::from_mut(copy cx.uses); ccx.type_use_cache.insert(fn_id, uses); - ret uses; + return uses; } let map_node = alt ccx.tcx.items.find(fn_id_loc.node) { some(x) { x } diff --git a/src/rustc/middle/trans/uniq.rs b/src/rustc/middle/trans/uniq.rs index 27379552a8c..e51d4e4d454 100644 --- a/src/rustc/middle/trans/uniq.rs +++ b/src/rustc/middle/trans/uniq.rs @@ -28,7 +28,7 @@ fn content_ty(t: ty::t) -> ty::t { fn autoderef(bcx: block, v: ValueRef, t: ty::t) -> {v: ValueRef, t: ty::t} { let content_ty = content_ty(t); let v = opaque_box_body(bcx, content_ty, v); - ret {v: v, t: content_ty}; + return {v: v, t: content_ty}; } fn duplicate(bcx: block, v: ValueRef, t: ty::t) -> result { @@ -52,5 +52,5 @@ fn duplicate(bcx: block, v: ValueRef, t: ty::t) -> result { let td = Load(bcx, src_tydesc_ptr); Store(bcx, td, dst_tydesc_ptr); - ret rslt(bcx, dst_box); + return rslt(bcx, dst_box); } diff --git a/src/rustc/middle/tstate/ann.rs b/src/rustc/middle/tstate/ann.rs index 7729c3ffc1d..cbd255341f5 100644 --- a/src/rustc/middle/tstate/ann.rs +++ b/src/rustc/middle/tstate/ann.rs @@ -41,14 +41,18 @@ type pre_and_post_state = {prestate: prestate, poststate: poststate}; type ts_ann = {conditions: pre_and_post, states: pre_and_post_state}; -fn true_precond(num_vars: uint) -> precond { ret create_tritv(num_vars); } +fn true_precond(num_vars: uint) -> precond { return create_tritv(num_vars); } -fn true_postcond(num_vars: uint) -> postcond { ret true_precond(num_vars); } +fn true_postcond(num_vars: uint) -> postcond { + return true_precond(num_vars); +} -fn empty_prestate(num_vars: uint) -> prestate { ret true_precond(num_vars); } +fn empty_prestate(num_vars: uint) -> prestate { + return true_precond(num_vars); +} fn empty_poststate(num_vars: uint) -> poststate { - ret true_precond(num_vars); + return true_precond(num_vars); } fn false_postcond(num_vars: uint) -> postcond { @@ -58,23 +62,23 @@ fn false_postcond(num_vars: uint) -> postcond { } fn empty_pre_post(num_vars: uint) -> pre_and_post { - ret {precondition: empty_prestate(num_vars), + return {precondition: empty_prestate(num_vars), postcondition: empty_poststate(num_vars)}; } fn empty_states(num_vars: uint) -> pre_and_post_state { - ret {prestate: true_precond(num_vars), + return {prestate: true_precond(num_vars), poststate: true_postcond(num_vars)}; } fn empty_ann(num_vars: uint) -> ts_ann { - ret {conditions: empty_pre_post(num_vars), + return {conditions: empty_pre_post(num_vars), states: empty_states(num_vars)}; } -fn get_pre(&&p: pre_and_post) -> precond { ret p.precondition; } +fn get_pre(&&p: pre_and_post) -> precond { return p.precondition; } -fn get_post(&&p: pre_and_post) -> postcond { ret p.postcondition; } +fn get_post(&&p: pre_and_post) -> postcond { return p.postcondition; } fn difference(p1: precond, p2: precond) -> bool { p1.difference(p2) } @@ -86,7 +90,7 @@ fn pps_len(p: pre_and_post) -> uint { // gratuitous check assert (p.precondition.nbits == p.postcondition.nbits); - ret p.precondition.nbits; + return p.precondition.nbits; } fn require(i: uint, p: pre_and_post) { @@ -102,54 +106,54 @@ fn require_and_preserve(i: uint, p: pre_and_post) { fn set_in_postcond(i: uint, p: pre_and_post) -> bool { // sets the ith bit in p's post - ret set_in_postcond_(i, p.postcondition); + return set_in_postcond_(i, p.postcondition); } fn set_in_postcond_(i: uint, p: postcond) -> bool { let was_set = p.get(i); p.set(i, ttrue); - ret was_set != ttrue; + return was_set != ttrue; } fn set_in_poststate(i: uint, s: pre_and_post_state) -> bool { // sets the ith bit in p's post - ret set_in_poststate_(i, s.poststate); + return set_in_poststate_(i, s.poststate); } fn set_in_poststate_(i: uint, p: poststate) -> bool { let was_set = p.get(i); p.set(i, ttrue); - ret was_set != ttrue; + return was_set != ttrue; } fn clear_in_poststate(i: uint, s: pre_and_post_state) -> bool { // sets the ith bit in p's post - ret clear_in_poststate_(i, s.poststate); + return clear_in_poststate_(i, s.poststate); } fn clear_in_poststate_(i: uint, s: poststate) -> bool { let was_set = s.get(i); s.set(i, tfalse); - ret was_set != tfalse; + return was_set != tfalse; } fn clear_in_prestate(i: uint, s: pre_and_post_state) -> bool { // sets the ith bit in p's pre - ret clear_in_prestate_(i, s.prestate); + return clear_in_prestate_(i, s.prestate); } fn clear_in_prestate_(i: uint, s: prestate) -> bool { let was_set = s.get(i); s.set(i, tfalse); - ret was_set != tfalse; + return was_set != tfalse; } fn clear_in_postcond(i: uint, s: pre_and_post) -> bool { // sets the ith bit in p's post let was_set = s.postcondition.get(i); s.postcondition.set(i, tfalse); - ret was_set != tfalse; + return was_set != tfalse; } // Sets all the bits in a's precondition to equal the @@ -195,12 +199,12 @@ fn extend_poststate(p: poststate, newv: poststate) -> bool { fn relax_prestate(i: uint, p: prestate) -> bool { let was_set = p.get(i); p.set(i, dont_care); - ret was_set != dont_care; + return was_set != dont_care; } // Clears the given bit in p fn relax_poststate(i: uint, p: poststate) -> bool { - ret relax_prestate(i, p); + return relax_prestate(i, p); } // Clears the given bit in p @@ -212,14 +216,14 @@ fn clear(p: precond) { p.clear(); } // Sets all the bits in p to true fn set(p: precond) { p.set_all(); } -fn ann_precond(a: ts_ann) -> precond { ret a.conditions.precondition; } +fn ann_precond(a: ts_ann) -> precond { return a.conditions.precondition; } -fn ann_prestate(a: ts_ann) -> prestate { ret a.states.prestate; } +fn ann_prestate(a: ts_ann) -> prestate { return a.states.prestate; } -fn ann_poststate(a: ts_ann) -> poststate { ret a.states.poststate; } +fn ann_poststate(a: ts_ann) -> poststate { return a.states.poststate; } fn pp_clone(p: pre_and_post) -> pre_and_post { - ret {precondition: clone(p.precondition), + return {precondition: clone(p.precondition), postcondition: clone(p.postcondition)}; } diff --git a/src/rustc/middle/tstate/auxiliary.rs b/src/rustc/middle/tstate/auxiliary.rs index 0f8185a0ee9..aa249fc3604 100644 --- a/src/rustc/middle/tstate/auxiliary.rs +++ b/src/rustc/middle/tstate/auxiliary.rs @@ -31,7 +31,7 @@ enum oper_type { /* logging funs */ fn def_id_to_str(d: def_id) -> ~str { - ret int::str(d.crate) + ~"," + int::str(d.node); + return int::str(d.crate) + ~"," + int::str(d.node); } fn comma_str(args: ~[@constr_arg_use]) -> ~str { @@ -45,11 +45,11 @@ fn comma_str(args: ~[@constr_arg_use]) -> ~str { carg_lit(l) { rslt += lit_to_str(l); } } } - ret rslt; + return rslt; } fn constraint_to_str(tcx: ty::ctxt, c: sp_constr) -> ~str { - ret fmt!{"%s(%s) - arising from %s", + return fmt!{"%s(%s) - arising from %s", path_to_str(c.node.path), comma_str(c.node.args), codemap::span_to_str(c.span, tcx.sess.codemap)}; @@ -69,7 +69,7 @@ fn tritv_to_str(fcx: fn_ctxt, v: tritv::t) -> ~str { } } } - ret s; + return s; } fn log_tritv(fcx: fn_ctxt, v: tritv::t) { @@ -86,7 +86,7 @@ fn first_difference_string(fcx: fn_ctxt, expected: tritv::t, actual: tritv::t) break; } } - ret s; + return s; } fn log_tritv_err(fcx: fn_ctxt, v: tritv::t) { @@ -100,7 +100,7 @@ fn tos(v: ~[uint]) -> ~str { rslt += ~"0"; } else if i == 1u { rslt += ~"1"; } else { rslt += ~"?"; } } - ret rslt; + return rslt; } fn log_cond(v: ~[uint]) { log(debug, tos(v)); } @@ -146,7 +146,7 @@ fn log_states_err(pp: pre_and_post_state) { fn print_ident(i: ident) { log(debug, ~" " + *i + ~" "); } fn print_idents(&idents: ~[ident]) { - if vec::len::<ident>(idents) == 0u { ret; } + if vec::len::<ident>(idents) == 0u { return; } log(debug, ~"an ident: " + *vec::pop::<ident>(idents)); print_idents(idents); } @@ -241,7 +241,7 @@ type crate_ctxt = {tcx: ty::ctxt, node_anns: node_ann_table, fm: fn_info_map}; fn get_fn_info(ccx: crate_ctxt, id: node_id) -> fn_info { assert (ccx.fm.contains_key(id)); - ret ccx.fm.get(id); + return ccx.fm.get(id); } fn add_node(ccx: crate_ctxt, i: node_id, a: ts_ann) { @@ -254,8 +254,8 @@ fn add_node(ccx: crate_ctxt, i: node_id, a: ts_ann) { fn get_ts_ann(ccx: crate_ctxt, i: node_id) -> option<ts_ann> { if i as uint < vec::len(*ccx.node_anns) { - ret some::<ts_ann>(ccx.node_anns[i]); - } else { ret none::<ts_ann>; } + return some::<ts_ann>(ccx.node_anns[i]); + } else { return none::<ts_ann>; } } @@ -266,20 +266,20 @@ fn node_id_to_ts_ann(ccx: crate_ctxt, id: node_id) -> ts_ann { error!{"node_id_to_ts_ann: no ts_ann for node_id %d", id}; fail; } - some(tt) { ret tt; } + some(tt) { return tt; } } } fn node_id_to_poststate(ccx: crate_ctxt, id: node_id) -> poststate { debug!{"node_id_to_poststate"}; - ret node_id_to_ts_ann(ccx, id).states.poststate; + return node_id_to_ts_ann(ccx, id).states.poststate; } fn stmt_to_ann(ccx: crate_ctxt, s: stmt) -> ts_ann { debug!{"stmt_to_ann"}; alt s.node { stmt_decl(_, id) | stmt_expr(_, id) | stmt_semi(_, id) { - ret node_id_to_ts_ann(ccx, id); + return node_id_to_ts_ann(ccx, id); } } } @@ -288,25 +288,25 @@ fn stmt_to_ann(ccx: crate_ctxt, s: stmt) -> ts_ann { /* fails if e has no annotation */ fn expr_states(ccx: crate_ctxt, e: @expr) -> pre_and_post_state { debug!{"expr_states"}; - ret node_id_to_ts_ann(ccx, e.id).states; + return node_id_to_ts_ann(ccx, e.id).states; } /* fails if e has no annotation */ fn expr_pp(ccx: crate_ctxt, e: @expr) -> pre_and_post { debug!{"expr_pp"}; - ret node_id_to_ts_ann(ccx, e.id).conditions; + return node_id_to_ts_ann(ccx, e.id).conditions; } fn stmt_pp(ccx: crate_ctxt, s: stmt) -> pre_and_post { - ret stmt_to_ann(ccx, s).conditions; + return stmt_to_ann(ccx, s).conditions; } /* fails if b has no annotation */ fn block_pp(ccx: crate_ctxt, b: blk) -> pre_and_post { debug!{"block_pp"}; - ret node_id_to_ts_ann(ccx, b.node.id).conditions; + return node_id_to_ts_ann(ccx, b.node.id).conditions; } fn clear_pp(pp: pre_and_post) { @@ -321,84 +321,85 @@ fn clear_precond(ccx: crate_ctxt, id: node_id) { fn block_states(ccx: crate_ctxt, b: blk) -> pre_and_post_state { debug!{"block_states"}; - ret node_id_to_ts_ann(ccx, b.node.id).states; + return node_id_to_ts_ann(ccx, b.node.id).states; } fn stmt_states(ccx: crate_ctxt, s: stmt) -> pre_and_post_state { - ret stmt_to_ann(ccx, s).states; + return stmt_to_ann(ccx, s).states; } fn expr_precond(ccx: crate_ctxt, e: @expr) -> precond { - ret expr_pp(ccx, e).precondition; + return expr_pp(ccx, e).precondition; } fn expr_postcond(ccx: crate_ctxt, e: @expr) -> postcond { - ret expr_pp(ccx, e).postcondition; + return expr_pp(ccx, e).postcondition; } fn expr_prestate(ccx: crate_ctxt, e: @expr) -> prestate { - ret expr_states(ccx, e).prestate; + return expr_states(ccx, e).prestate; } fn expr_poststate(ccx: crate_ctxt, e: @expr) -> poststate { - ret expr_states(ccx, e).poststate; + return expr_states(ccx, e).poststate; } fn stmt_precond(ccx: crate_ctxt, s: stmt) -> precond { - ret stmt_pp(ccx, s).precondition; + return stmt_pp(ccx, s).precondition; } fn stmt_postcond(ccx: crate_ctxt, s: stmt) -> postcond { - ret stmt_pp(ccx, s).postcondition; + return stmt_pp(ccx, s).postcondition; } fn states_to_poststate(ss: pre_and_post_state) -> poststate { - ret ss.poststate; + return ss.poststate; } fn stmt_prestate(ccx: crate_ctxt, s: stmt) -> prestate { - ret stmt_states(ccx, s).prestate; + return stmt_states(ccx, s).prestate; } fn stmt_poststate(ccx: crate_ctxt, s: stmt) -> poststate { - ret stmt_states(ccx, s).poststate; + return stmt_states(ccx, s).poststate; } fn block_precond(ccx: crate_ctxt, b: blk) -> precond { - ret block_pp(ccx, b).precondition; + return block_pp(ccx, b).precondition; } fn block_postcond(ccx: crate_ctxt, b: blk) -> postcond { - ret block_pp(ccx, b).postcondition; + return block_pp(ccx, b).postcondition; } fn block_prestate(ccx: crate_ctxt, b: blk) -> prestate { - ret block_states(ccx, b).prestate; + return block_states(ccx, b).prestate; } fn block_poststate(ccx: crate_ctxt, b: blk) -> poststate { - ret block_states(ccx, b).poststate; + return block_states(ccx, b).poststate; } fn set_prestate_ann(ccx: crate_ctxt, id: node_id, pre: prestate) -> bool { debug!{"set_prestate_ann"}; - ret set_prestate(node_id_to_ts_ann(ccx, id), pre); + return set_prestate(node_id_to_ts_ann(ccx, id), pre); } fn extend_prestate_ann(ccx: crate_ctxt, id: node_id, pre: prestate) -> bool { debug!{"extend_prestate_ann"}; - ret extend_prestate(node_id_to_ts_ann(ccx, id).states.prestate, pre); + return extend_prestate(node_id_to_ts_ann(ccx, id).states.prestate, pre); } fn set_poststate_ann(ccx: crate_ctxt, id: node_id, post: poststate) -> bool { debug!{"set_poststate_ann"}; - ret set_poststate(node_id_to_ts_ann(ccx, id), post); + return set_poststate(node_id_to_ts_ann(ccx, id), post); } fn extend_poststate_ann(ccx: crate_ctxt, id: node_id, post: poststate) -> bool { debug!{"extend_poststate_ann"}; - ret extend_poststate(node_id_to_ts_ann(ccx, id).states.poststate, post); + return extend_poststate( + node_id_to_ts_ann(ccx, id).states.poststate, post); } fn set_pre_and_post(ccx: crate_ctxt, id: node_id, pre: precond, @@ -430,14 +431,14 @@ fn set_postcond_false(ccx: crate_ctxt, id: node_id) { } fn pure_exp(ccx: crate_ctxt, id: node_id, p: prestate) -> bool { - ret set_prestate_ann(ccx, id, p) | set_poststate_ann(ccx, id, p); + return set_prestate_ann(ccx, id, p) | set_poststate_ann(ccx, id, p); } -fn num_constraints(m: fn_info) -> uint { ret m.num_constraints; } +fn num_constraints(m: fn_info) -> uint { return m.num_constraints; } fn new_crate_ctxt(cx: ty::ctxt) -> crate_ctxt { let na: ~[mut ts_ann] = ~[mut]; - ret {tcx: cx, node_anns: @mut na, fm: int_hash::<fn_info>()}; + return {tcx: cx, node_anns: @mut na, fm: int_hash::<fn_info>()}; } /* Use e's type to determine whether it returns. @@ -445,15 +446,15 @@ fn new_crate_ctxt(cx: ty::ctxt) -> crate_ctxt { the answer is noreturn. */ fn controlflow_expr(ccx: crate_ctxt, e: @expr) -> ret_style { alt ty::get(ty::node_id_to_type(ccx.tcx, e.id)).struct { - ty::ty_fn(f) { ret f.ret_style; } - _ { ret return_val; } + ty::ty_fn(f) { return f.ret_style; } + _ { return return_val; } } } fn constraints_expr(cx: ty::ctxt, e: @expr) -> ~[@ty::constr] { alt ty::get(ty::node_id_to_type(cx, e.id)).struct { - ty::ty_fn(f) { ret f.constraints; } - _ { ret ~[]; } + ty::ty_fn(f) { return f.constraints; } + _ { return ~[]; } } } @@ -463,12 +464,12 @@ fn node_id_to_def_strict(cx: ty::ctxt, id: node_id) -> def { error!{"node_id_to_def: node_id %d has no def", id}; fail; } - some(d) { ret d; } + some(d) { return d; } } } fn node_id_to_def(ccx: crate_ctxt, id: node_id) -> option<def> { - ret ccx.tcx.def_map.find(id); + return ccx.tcx.def_map.find(id); } fn norm_a_constraint(id: def_id, c: constraint) -> ~[norm_constraint] { @@ -480,7 +481,7 @@ fn norm_a_constraint(id: def_id, c: constraint) -> ~[norm_constraint] { def_id: id, args: pd.node.args})}); } - ret rslt; + return rslt; } @@ -491,7 +492,7 @@ fn constraints(fcx: fn_ctxt) -> ~[norm_constraint] { for fcx.enclosing.constrs.each |key, val| { vec::push_all(rslt, norm_a_constraint(key, val)); }; - ret rslt; + return rslt; } // FIXME (#2539): Would rather take an immutable vec as an argument, @@ -499,12 +500,12 @@ fn constraints(fcx: fn_ctxt) -> ~[norm_constraint] { fn match_args(fcx: fn_ctxt, occs: @dvec<pred_args>, occ: ~[@constr_arg_use]) -> uint { debug!{"match_args: looking at %s", - constr_args_to_str(fn@(i: inst) -> ~str { ret *i.ident; }, occ)}; + constr_args_to_str(fn@(i: inst) -> ~str { *i.ident }, occ)}; for (*occs).each |pd| { log(debug, ~"match_args: candidate " + pred_args_to_str(pd)); - fn eq(p: inst, q: inst) -> bool { ret p.node == q.node; } - if ty::args_eq(eq, pd.node.args, occ) { ret pd.node.bit_num; } + fn eq(p: inst, q: inst) -> bool { return p.node == q.node; } + if ty::args_eq(eq, pd.node.args, occ) { return pd.node.bit_num; } } fcx.ccx.tcx.sess.bug(~"match_args: no match for occurring args"); } @@ -514,7 +515,7 @@ fn def_id_for_constr(tcx: ty::ctxt, t: node_id) -> def_id { none { tcx.sess.bug(~"node_id_for_constr: bad node_id " + int::str(t)); } - some(def_fn(i, _)) { ret i; } + some(def_fn(i, _)) { return i; } _ { tcx.sess.bug(~"node_id_for_constr: pred is not a function"); } } } @@ -525,7 +526,7 @@ fn expr_to_constr_arg(tcx: ty::ctxt, e: @expr) -> @constr_arg_use { alt tcx.def_map.find(e.id) { some(def_local(nid, _)) | some(def_arg(nid, _)) | some(def_binding(nid)) | some(def_upvar(nid, _, _)) { - ret @respan(p.span, + return @respan(p.span, carg_ident({ident: p.idents[0], node: nid})); } some(what) { @@ -540,7 +541,7 @@ fn expr_to_constr_arg(tcx: ty::ctxt, e: @expr) -> @constr_arg_use { } } } - expr_lit(l) { ret @respan(e.span, carg_lit(l)); } + expr_lit(l) { return @respan(e.span, carg_lit(l)); } _ { tcx.sess.span_fatal(e.span, ~"arguments to constrained functions must be " + @@ -562,7 +563,7 @@ fn expr_to_constr(tcx: ty::ctxt, e: @expr) -> sp_constr { expr_call(operator, args, _) { alt operator.node { expr_path(p) { - ret respan(e.span, + return respan(e.span, {path: p, def_id: def_id_for_constr(tcx, operator.id), args: exprs_to_constr_args(tcx, args)}); @@ -581,7 +582,7 @@ fn expr_to_constr(tcx: ty::ctxt, e: @expr) -> sp_constr { fn pred_args_to_str(p: pred_args) -> ~str { ~"<" + uint::str(p.node.bit_num) + ~", " + - constr_args_to_str(fn@(i: inst) -> ~str {ret *i.ident; }, + constr_args_to_str(fn@(i: inst) -> ~str {return *i.ident; }, p.node.args) + ~">" } @@ -592,7 +593,7 @@ fn substitute_constr_args(cx: ty::ctxt, actuals: ~[@expr], c: @ty::constr) -> for c.node.args.each |a| { vec::push(rslt, substitute_arg(cx, actuals, a)); } - ret {path: c.node.path, + return {path: c.node.path, def_id: c.node.id, args: rslt}; } @@ -603,13 +604,13 @@ fn substitute_arg(cx: ty::ctxt, actuals: ~[@expr], a: @constr_arg) -> alt a.node { carg_ident(i) { if i < num_actuals { - ret expr_to_constr_arg(cx, actuals[i]); + return expr_to_constr_arg(cx, actuals[i]); } else { cx.sess.span_fatal(a.span, ~"constraint argument out of bounds"); } } - carg_base { ret @respan(a.span, carg_base); } - carg_lit(l) { ret @respan(a.span, carg_lit(l)); } + carg_base { return @respan(a.span, carg_base); } + carg_lit(l) { return @respan(a.span, carg_lit(l)); } } } @@ -622,30 +623,30 @@ fn pred_args_matches(pattern: ~[constr_arg_general_<inst>], alt c.node { carg_ident(p) { alt n { - carg_ident(q) { if p.node != q.node { ret false; } } - _ { ret false; } + carg_ident(q) { if p.node != q.node { return false; } } + _ { return false; } } } - carg_base { if n != carg_base { ret false; } } + carg_base { if n != carg_base { return false; } } carg_lit(l) { alt n { - carg_lit(m) { if !const_eval::lit_eq(l, m) { ret false; } } - _ { ret false; } + carg_lit(m) { if !const_eval::lit_eq(l, m) { return false; } } + _ { return false; } } } } i += 1u; } - ret true; + return true; } fn find_instance_(pattern: ~[constr_arg_general_<inst>], descs: ~[pred_args]) -> option<uint> { for descs.each |d| { - if pred_args_matches(pattern, d) { ret some(d.node.bit_num); } + if pred_args_matches(pattern, d) { return some(d.node.bit_num); } } - ret none; + return none; } type inst = {ident: ident, node: node_id}; @@ -660,7 +661,7 @@ type subst = ~[{from: inst, to: inst}]; fn find_instances(_fcx: fn_ctxt, subst: subst, c: constraint) -> ~[{from: uint, to: uint}] { - if vec::len(subst) == 0u { ret ~[]; } + if vec::len(subst) == 0u { return ~[]; } let mut res = ~[]; do (*c.descs).swap |v| { let v <- vec::from_mut(v); @@ -676,14 +677,14 @@ fn find_instances(_fcx: fn_ctxt, subst: subst, } vec::to_mut(v) } - ret res; + return res; } fn find_in_subst(id: node_id, s: subst) -> option<inst> { for s.each |p| { - if id == p.from.node { ret some(p.to); } + if id == p.from.node { return some(p.to); } } - ret none; + return none; } fn find_in_subst_bool(s: subst, id: node_id) -> bool { @@ -721,7 +722,7 @@ fn replace(subst: subst, d: pred_args) -> ~[constr_arg_general_<inst>] { } } - ret rslt; + return rslt; } enum if_ty { if_check, plain_if, } @@ -738,7 +739,7 @@ fn local_node_id_to_def_id_strict(fcx: fn_ctxt, sp: span, i: node_id) -> alt local_node_id_to_def(fcx, i) { some(def_local(nid, _)) | some(def_arg(nid, _)) | some(def_upvar(nid, _, _)) { - ret local_def(nid); + return local_def(nid); } some(_) { fcx.ccx.tcx.sess.span_fatal(sp, @@ -800,7 +801,7 @@ fn copy_in_poststate_two(fcx: fn_ctxt, src_post: poststate, alt ty { oper_swap { subst = ~[{from: dest, to: src}, {from: src, to: dest}]; } oper_assign_op { - ret; // Don't do any propagation + return; // Don't do any propagation } _ { subst = ~[{from: src, to: dest}]; } } @@ -844,17 +845,17 @@ fn forget_in_poststate(fcx: fn_ctxt, p: poststate, dead_v: node_id) -> bool { changed |= clear_in_poststate_(c.bit_num, p); } } - ret changed; + return changed; } fn any_eq(v: ~[node_id], d: node_id) -> bool { - for v.each |i| { if i == d { ret true; } } + for v.each |i| { if i == d { return true; } } false } fn constraint_mentions(_fcx: fn_ctxt, c: norm_constraint, v: node_id) -> bool { - ret args_mention(c.c.node.args, any_eq, ~[v]); + return args_mention(c.c.node.args, any_eq, ~[v]); } fn args_mention<T>(args: ~[@constr_arg_use], @@ -862,9 +863,11 @@ fn args_mention<T>(args: ~[@constr_arg_use], s: ~[T]) -> bool { for args.each |a| { - alt a.node { carg_ident(p1) { if q(s, p1.node) { ret true; } } _ { } } + alt a.node { + carg_ident(p1) { if q(s, p1.node) { return true; } } _ { } + } } - ret false; + return false; } fn use_var(fcx: fn_ctxt, v: node_id) { @@ -906,13 +909,13 @@ fn args_to_constr_args(tcx: ty::ctxt, args: ~[arg], carg_lit(l) { carg_lit(l) } })); } - ret actuals; + return actuals; } fn ast_constr_to_ts_constr(tcx: ty::ctxt, args: ~[arg], c: @constr) -> tsconstr { let tconstr = ty::ast_constr_to_constr(tcx, c); - ret {path: tconstr.node.path, + return {path: tconstr.node.path, def_id: tconstr.node.id, args: args_to_constr_args(tcx, args, tconstr.node.args)}; } @@ -920,7 +923,7 @@ fn ast_constr_to_ts_constr(tcx: ty::ctxt, args: ~[arg], c: @constr) -> fn ast_constr_to_sp_constr(tcx: ty::ctxt, args: ~[arg], c: @constr) -> sp_constr { let tconstr = ast_constr_to_ts_constr(tcx, args, c); - ret respan(c.span, tconstr); + return respan(c.span, tconstr); } type binding = {lhs: ~[dest], rhs: option<initializer>}; @@ -936,7 +939,7 @@ fn local_to_bindings(tcx: ty::ctxt, loc: @local) -> binding { fn locals_to_bindings(tcx: ty::ctxt, locals: ~[@local]) -> ~[binding] { let mut rslt = ~[]; for locals.each |loc| { vec::push(rslt, local_to_bindings(tcx, loc)); } - ret rslt; + return rslt; } fn callee_modes(fcx: fn_ctxt, callee: node_id) -> ~[mode] { @@ -946,7 +949,7 @@ fn callee_modes(fcx: fn_ctxt, callee: node_id) -> ~[mode] { ty::ty_fn({inputs: args, _}) { let mut modes = ~[]; for args.each |arg| { vec::push(modes, arg.mode); } - ret modes; + return modes; } _ { // Shouldn't happen; callee should be ty_fn. @@ -973,7 +976,7 @@ fn arg_bindings(ops: ~[init_op], es: ~[@expr]) -> ~[binding] { {lhs: ~[call], rhs: some({op: op, expr: es[i]})}); i += 1u; } - ret bindings; + return bindings; } // diff --git a/src/rustc/middle/tstate/collect_locals.rs b/src/rustc/middle/tstate/collect_locals.rs index 448b7a5231f..c6f46ba3888 100644 --- a/src/rustc/middle/tstate/collect_locals.rs +++ b/src/rustc/middle/tstate/collect_locals.rs @@ -49,7 +49,7 @@ fn find_locals(tcx: ty::ctxt, with *visitor}; visit::visit_fn(fk, f_decl, f_body, sp, id, cx, visit::mk_vt(visitor)); - ret cx; + return cx; } fn add_constraint(tcx: ty::ctxt, c: sp_constr, next: uint, tbl: constr_map) -> @@ -68,7 +68,7 @@ fn add_constraint(tcx: ty::ctxt, c: sp_constr, next: uint, tbl: constr_map) -> tbl.insert(d_id, {path:p, descs:rslt}); } } - ret next + 1u; + return next + 1u; } fn contains_constrained_calls(tcx: ty::ctxt, body: blk) -> bool { @@ -83,7 +83,7 @@ fn contains_constrained_calls(tcx: ty::ctxt, body: blk) -> bool { let vtor = visit::default_visitor::<cx>(); let vtor = @{visit_expr: visit_expr with *vtor}; visit::visit_block(body, cx, visit::mk_vt(vtor)); - ret cx.has; + return cx.has; fn visit_expr(e: @expr, &&cx: cx, v: visit::vt<cx>) { import syntax::print::pprust; diff --git a/src/rustc/middle/tstate/pre_post_conditions.rs b/src/rustc/middle/tstate/pre_post_conditions.rs index 08f0736c1da..9315e69d289 100644 --- a/src/rustc/middle/tstate/pre_post_conditions.rs +++ b/src/rustc/middle/tstate/pre_post_conditions.rs @@ -48,7 +48,7 @@ fn find_pre_post_item(ccx: crate_ctxt, i: item) { } item_mod(m) { find_pre_post_mod(m); } item_foreign_mod(nm) { find_pre_post_foreign_mod(nm); } - item_ty(*) | item_enum(*) | item_trait(*) { ret; } + item_ty(*) | item_enum(*) | item_trait(*) { return; } item_class(*) { fail ~"find_pre_post_item: shouldn't be called on item_class"; } @@ -72,7 +72,7 @@ fn find_pre_post_exprs(fcx: fn_ctxt, args: ~[@expr], id: node_id) { for args.each |e| { do_one(fcx, e); } fn get_pp(ccx: crate_ctxt, &&e: @expr) -> pre_and_post { - ret expr_pp(ccx, e); + return expr_pp(ccx, e); } let pps = vec::map(args, |a| get_pp(fcx.ccx, a) ); @@ -396,7 +396,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { _ {} } find_pre_post_block(fcx, an_alt.body); - ret block_pp(fcx.ccx, an_alt.body); + return block_pp(fcx.ccx, an_alt.body); } let mut alt_pps = ~[]; for alts.each |a| { vec::push(alt_pps, do_an_alt(fcx, a)); } @@ -404,7 +404,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { &&next: pre_and_post) -> pre_and_post { union(pp.precondition, seq_preconds(fcx, ~[antec, next])); intersect(pp.postcondition, next.postcondition); - ret pp; + return pp; } let antec_pp = pp_clone(expr_pp(fcx.ccx, ex)); let e_pp = diff --git a/src/rustc/middle/tstate/states.rs b/src/rustc/middle/tstate/states.rs index 9c4285774f7..b134f3b71af 100644 --- a/src/rustc/middle/tstate/states.rs +++ b/src/rustc/middle/tstate/states.rs @@ -84,7 +84,7 @@ fn seq_states(fcx: fn_ctxt, pres: prestate, bindings: ~[binding]) -> } } } - ret {changed: changed, post: post}; + return {changed: changed, post: post}; } fn find_pre_post_state_sub(fcx: fn_ctxt, pres: prestate, e: @expr, @@ -100,7 +100,7 @@ fn find_pre_post_state_sub(fcx: fn_ctxt, pres: prestate, e: @expr, } changed = set_poststate_ann(fcx.ccx, parent, post) || changed; - ret changed; + return changed; } fn find_pre_post_state_two(fcx: fn_ctxt, pres: prestate, lhs: @expr, @@ -162,7 +162,7 @@ fn find_pre_post_state_two(fcx: fn_ctxt, pres: prestate, lhs: @expr, _ { } } changed = set_poststate_ann(fcx.ccx, parent, post) || changed; - ret changed; + return changed; } fn find_pre_post_state_call(fcx: fn_ctxt, pres: prestate, a: @expr, @@ -178,7 +178,7 @@ fn find_pre_post_state_call(fcx: fn_ctxt, pres: prestate, a: @expr, %u exprs vs. %u ops", vec::len(bs), vec::len(ops)}); } - ret find_pre_post_state_exprs(fcx, pres, id, ops, + return find_pre_post_state_exprs(fcx, pres, id, ops, bs, cf) || changed; } @@ -195,7 +195,7 @@ fn find_pre_post_state_exprs(fcx: fn_ctxt, pres: prestate, id: node_id, } _ { changed |= set_poststate_ann(fcx.ccx, id, rs.post); } } - ret changed; + return changed; } fn join_then_else(fcx: fn_ctxt, antec: @expr, conseq: blk, @@ -261,7 +261,7 @@ fn join_then_else(fcx: fn_ctxt, antec: @expr, conseq: blk, changed |= set_poststate_ann(fcx.ccx, id, poststate_res); } } - ret changed; + return changed; } fn find_pre_post_state_cap_clause(fcx: fn_ctxt, e_id: node_id, @@ -276,7 +276,7 @@ fn find_pre_post_state_cap_clause(fcx: fn_ctxt, e_id: node_id, forget_in_poststate(fcx, post, cap_item.id); } } - ret set_poststate_ann(ccx, e_id, post) || pres_changed; + return set_poststate_ann(ccx, e_id, post) || pres_changed; } fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { @@ -284,41 +284,41 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { alt e.node { expr_new(p, _, v) { - ret find_pre_post_state_two(fcx, pres, p, v, e.id, oper_pure); + return find_pre_post_state_two(fcx, pres, p, v, e.id, oper_pure); } expr_vstore(ee, _) { let mut changed = find_pre_post_state_expr(fcx, pres, ee); set_prestate_ann(fcx.ccx, e.id, expr_prestate(fcx.ccx, ee)); set_poststate_ann(fcx.ccx, e.id, expr_poststate(fcx.ccx, ee)); - ret changed; + return changed; } expr_vec(elts, _) { - ret find_pre_post_state_exprs(fcx, pres, e.id, + return find_pre_post_state_exprs(fcx, pres, e.id, vec::from_elem(vec::len(elts), init_assign), elts, return_val); } expr_call(operator, operands, _) { debug!{"hey it's a call: %s", expr_to_str(e)}; - ret find_pre_post_state_call(fcx, pres, operator, e.id, + return find_pre_post_state_call(fcx, pres, operator, e.id, callee_arg_init_ops(fcx, operator.id), operands, controlflow_expr(fcx.ccx, operator)); } - expr_path(_) { ret pure_exp(fcx.ccx, e.id, pres); } + expr_path(_) { return pure_exp(fcx.ccx, e.id, pres); } expr_log(_, lvl, ex) { - ret find_pre_post_state_two(fcx, pres, lvl, ex, e.id, oper_pure); + return find_pre_post_state_two(fcx, pres, lvl, ex, e.id, oper_pure); } expr_mac(_) { fcx.ccx.tcx.sess.bug(~"unexpanded macro"); } - expr_lit(l) { ret pure_exp(fcx.ccx, e.id, pres); } + expr_lit(l) { return pure_exp(fcx.ccx, e.id, pres); } expr_fn(_, _, _, cap_clause) { - ret find_pre_post_state_cap_clause(fcx, e.id, pres, cap_clause); + return find_pre_post_state_cap_clause(fcx, e.id, pres, cap_clause); } expr_fn_block(_, _, cap_clause) { - ret find_pre_post_state_cap_clause(fcx, e.id, pres, cap_clause); + return find_pre_post_state_cap_clause(fcx, e.id, pres, cap_clause); } expr_block(b) { - ret find_pre_post_state_block(fcx, pres, b) | + return find_pre_post_state_block(fcx, pres, b) | set_prestate_ann(fcx.ccx, e.id, pres) | set_poststate_ann(fcx.ccx, e.id, block_poststate(fcx.ccx, b)); } @@ -337,30 +337,31 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { set_poststate_ann(fcx.ccx, e.id, expr_poststate(fcx.ccx, base)) }); - ret changed; + return changed; } expr_tup(elts) { - ret find_pre_post_state_exprs(fcx, pres, e.id, + return find_pre_post_state_exprs(fcx, pres, e.id, vec::from_elem(vec::len(elts), init_assign), elts, return_val); } expr_move(lhs, rhs) { - ret find_pre_post_state_two(fcx, pres, lhs, rhs, e.id, oper_move); + return find_pre_post_state_two(fcx, pres, lhs, rhs, e.id, oper_move); } expr_assign(lhs, rhs) { - ret find_pre_post_state_two(fcx, pres, lhs, rhs, e.id, oper_assign); + return find_pre_post_state_two( + fcx, pres, lhs, rhs, e.id, oper_assign); } expr_swap(lhs, rhs) { - ret find_pre_post_state_two(fcx, pres, lhs, rhs, e.id, oper_swap); + return find_pre_post_state_two(fcx, pres, lhs, rhs, e.id, oper_swap); // Could be more precise and actually swap the role of // lhs and rhs in constraints } expr_ret(maybe_ret_val) { let mut changed = set_prestate_ann(fcx.ccx, e.id, pres); /* everything is true if execution continues after - a ret expression (since execution never continues locally - after a ret expression */ + a return expression (since execution never continues locally + after a return expression */ let post = false_postcond(num_constrs); set_poststate_ann(fcx.ccx, e.id, post); @@ -371,10 +372,10 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { changed |= find_pre_post_state_expr(fcx, pres, ret_val); } } - ret changed; + return changed; } expr_if(antec, conseq, maybe_alt) { - ret join_then_else(fcx, antec, conseq, maybe_alt, e.id, plain_if, + return join_then_else(fcx, antec, conseq, maybe_alt, e.id, plain_if, pres); } expr_binary(bop, l, r) { @@ -382,15 +383,15 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { let mut changed = find_pre_post_state_expr(fcx, pres, l); changed |= find_pre_post_state_expr(fcx, expr_poststate(fcx.ccx, l), r); - ret changed | set_prestate_ann(fcx.ccx, e.id, pres) | + return changed | set_prestate_ann(fcx.ccx, e.id, pres) | set_poststate_ann(fcx.ccx, e.id, expr_poststate(fcx.ccx, l)); } else { - ret find_pre_post_state_two(fcx, pres, l, r, e.id, oper_pure); + return find_pre_post_state_two(fcx, pres, l, r, e.id, oper_pure); } } expr_assign_op(op, lhs, rhs) { - ret find_pre_post_state_two(fcx, pres, lhs, rhs, e.id, + return find_pre_post_state_two(fcx, pres, lhs, rhs, e.id, oper_assign_op); } expr_while(test, body) { @@ -407,11 +408,11 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { or cont, we assume nothing about the poststate */ /* which is still unsound -- see ~[Break-unsound] */ if has_nonlocal_exits(body) { - ret changed | set_poststate_ann(fcx.ccx, e.id, pres); + return changed | set_poststate_ann(fcx.ccx, e.id, pres); } else { let e_post = expr_poststate(fcx.ccx, test); let b_post = block_poststate(fcx.ccx, body); - ret changed | + return changed | set_poststate_ann(fcx.ccx, e.id, intersect_states(e_post, b_post)); } @@ -433,14 +434,14 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { deinitialize everything before breaking */ let post = empty_poststate(num_constrs); post.kill(); - ret changed | set_poststate_ann(fcx.ccx, e.id, post); + return changed | set_poststate_ann(fcx.ccx, e.id, post); } else { - ret changed | set_poststate_ann(fcx.ccx, e.id, + return changed | set_poststate_ann(fcx.ccx, e.id, false_postcond(num_constrs)); } } expr_index(val, sub) { - ret find_pre_post_state_two(fcx, pres, val, sub, e.id, oper_pure); + return find_pre_post_state_two(fcx, pres, val, sub, e.id, oper_pure); } expr_alt(val, alts, _) { let mut changed = @@ -470,19 +471,19 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { a_post = e_post; } - ret changed | set_poststate_ann(fcx.ccx, e.id, a_post); + return changed | set_poststate_ann(fcx.ccx, e.id, a_post); } expr_field(x, _, _) | expr_loop_body(x) | expr_do_body(x) | expr_unary(_, x) | expr_addr_of(_, x) | expr_assert(x) | expr_cast(x, _) | expr_copy(x) { - ret find_pre_post_state_sub(fcx, pres, x, e.id, none); + return find_pre_post_state_sub(fcx, pres, x, e.id, none); } expr_fail(maybe_fail_val) { /* if execution continues after fail, then everything is true! woo! */ let post = false_postcond(num_constrs); - ret set_prestate_ann(fcx.ccx, e.id, pres) | + return set_prestate_ann(fcx.ccx, e.id, pres) | set_poststate_ann(fcx.ccx, e.id, post) | option::map_default( maybe_fail_val, false, @@ -492,13 +493,14 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { expr_check(_, p) { /* predicate p holds after this expression executes */ let c: sp_constr = expr_to_constr(fcx.ccx.tcx, p); - ret find_pre_post_state_sub(fcx, pres, p, e.id, some(c.node)); + return find_pre_post_state_sub(fcx, pres, p, e.id, some(c.node)); } expr_if_check(p, conseq, maybe_alt) { - ret join_then_else(fcx, p, conseq, maybe_alt, e.id, if_check, pres); + return join_then_else( + fcx, p, conseq, maybe_alt, e.id, if_check, pres); } - expr_break { ret pure_exp(fcx.ccx, e.id, pres); } - expr_again { ret pure_exp(fcx.ccx, e.id, pres); } + expr_break { return pure_exp(fcx.ccx, e.id, pres); } + expr_again { return pure_exp(fcx.ccx, e.id, pres); } } } @@ -529,10 +531,11 @@ fn find_pre_post_state_stmt(fcx: fn_ctxt, pres: prestate, s: @stmt) -> bool { debug!{"poststate = %s", stmt_ann.states.poststate.to_str()}; debug!{"changed = %s", bool::to_str(changed)}; - ret changed; + return changed; } decl_item(an_item) { - ret set_prestate(stmt_ann, pres) | set_poststate(stmt_ann, pres); + return set_prestate(stmt_ann, pres) + | set_poststate(stmt_ann, pres); /* the outer visitor will recurse into the item */ } } @@ -549,7 +552,7 @@ fn find_pre_post_state_stmt(fcx: fn_ctxt, pres: prestate, s: @stmt) -> bool { debug!{"poststate = %s", stmt_ann.states.poststate.to_str()}; debug!{"changed = %s", bool::to_str(changed)}; - ret changed; + return changed; } } } @@ -582,7 +585,7 @@ fn find_pre_post_state_block(fcx: fn_ctxt, pres0: prestate, b: blk) -> bool { set_prestate_ann(fcx.ccx, b.node.id, pres0); set_poststate_ann(fcx.ccx, b.node.id, post); - ret changed; + return changed; } fn find_pre_post_state_fn(fcx: fn_ctxt, @@ -607,7 +610,7 @@ fn find_pre_post_state_fn(fcx: fn_ctxt, fcx.ccx.tcx.sess.span_note(f_body.span, fcx.name); */ - ret changed; + return changed; } // // Local Variables: diff --git a/src/rustc/middle/tstate/tritv.rs b/src/rustc/middle/tstate/tritv.rs index 1e78b82fba8..ee2cf2d7a14 100644 --- a/src/rustc/middle/tstate/tritv.rs +++ b/src/rustc/middle/tstate/tritv.rs @@ -94,7 +94,7 @@ class t { fn doesntcare() -> bool { for uint::range(0, self.nbits) |i| { - if self.get(i) != dont_care { ret false; } + if self.get(i) != dont_care { return false; } } true } @@ -134,7 +134,7 @@ class t { changed = change(changed, old, newv); self.set(i, newv); } - ret changed; + return changed; } fn become(source: t) -> bool { @@ -155,7 +155,7 @@ class t { changed = change(changed, old, newv); self.set(i, newv); } - ret changed; + return changed; } new(len: uint) { diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs index 6ece1a4740e..ff52e34fdad 100644 --- a/src/rustc/middle/ty.rs +++ b/src/rustc/middle/ty.rs @@ -542,12 +542,12 @@ type node_type_table = @smallintmap::smallintmap<t>; fn mk_rcache() -> creader_cache { type val = {cnum: int, pos: uint, len: uint}; fn hash_cache_entry(k: val) -> uint { - ret (k.cnum as uint) + k.pos + k.len; + return (k.cnum as uint) + k.pos + k.len; } fn eq_cache_entries(a: val, b: val) -> bool { - ret a.cnum == b.cnum && a.pos == b.pos && a.len == b.len; + return a.cnum == b.cnum && a.pos == b.pos && a.len == b.len; } - ret map::hashmap(hash_cache_entry, eq_cache_entries); + return map::hashmap(hash_cache_entry, eq_cache_entries); } fn new_ty_hash<V: copy>() -> map::hashmap<t, V> { @@ -608,7 +608,7 @@ fn mk_t(cx: ctxt, st: sty) -> t { mk_t_with_id(cx, st, none) } fn mk_t_with_id(cx: ctxt, st: sty, o_def_id: option<ast::def_id>) -> t { let key = {struct: st, o_def_id: o_def_id}; alt cx.interner.find(key) { - some(t) { unsafe { ret unsafe::reinterpret_cast(t); } } + some(t) { unsafe { return unsafe::reinterpret_cast(t); } } _ {} } let mut flags = 0u; @@ -624,7 +624,7 @@ fn mk_t_with_id(cx: ctxt, st: sty, o_def_id: option<ast::def_id>) -> t { let mut f = 0u; for substs.tps.each |tt| { f |= get(tt).flags; } substs.self_r.iter(|r| f |= rflags(r)); - ret f; + return f; } alt st { ty_estr(vstore_slice(r)) { @@ -816,7 +816,7 @@ fn walk_ty(ty: t, f: fn(t)) { } fn maybe_walk_ty(ty: t, f: fn(t) -> bool) { - if !f(ty) { ret; } + if !f(ty) { return; } alt get(ty).struct { ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) | ty_estr(_) | ty_type | ty_opaque_box | ty_self | @@ -991,7 +991,7 @@ fn fold_regions( fn do_fold(cx: ctxt, ty: t, in_fn: bool, fldr: fn(region, bool) -> region) -> t { - if !type_has_regions(ty) { ret ty; } + if !type_has_regions(ty) { return ty; } fold_regions_and_ty( cx, ty, |r| fldr(r, in_fn), @@ -1005,7 +1005,7 @@ fn fold_region(cx: ctxt, t0: t, fldop: fn(region, bool) -> region) -> t { fn do_fold(cx: ctxt, t0: t, under_r: bool, fldop: fn(region, bool) -> region) -> t { let tb = get(t0); - if !tbox_has_flag(tb, has_regions) { ret t0; } + if !tbox_has_flag(tb, has_regions) { return t0; } alt tb.struct { ty_rptr(r, {ty: t1, mutbl: m}) { let m_r = fldop(r, under_r); @@ -1038,9 +1038,9 @@ fn fold_region(cx: ctxt, t0: t, fldop: fn(region, bool) -> region) -> t { // Substitute *only* type parameters. Used in trans where regions are erased. fn subst_tps(cx: ctxt, tps: ~[t], typ: t) -> t { - if tps.len() == 0u { ret typ; } + if tps.len() == 0u { return typ; } let tb = ty::get(typ); - if !tbox_has_flag(tb, has_params) { ret typ; } + if !tbox_has_flag(tb, has_params) { return typ; } alt tb.struct { ty_param(p) { tps[p.idx] } sty { fold_sty_to_ty(cx, sty, |t| subst_tps(cx, tps, t)) } @@ -1068,16 +1068,16 @@ fn subst(cx: ctxt, substs_to_str(cx, substs), ty_to_str(cx, typ)}; - if substs_is_noop(substs) { ret typ; } + if substs_is_noop(substs) { return typ; } let r = do_subst(cx, substs, typ); debug!{" r = %s", ty_to_str(cx, r)}; - ret r; + return r; fn do_subst(cx: ctxt, substs: substs, typ: t) -> t { let tb = get(typ); - if !tbox_has_flag(tb, needs_subst) { ret typ; } + if !tbox_has_flag(tb, needs_subst) { return typ; } alt tb.struct { ty_param(p) {substs.tps[p.idx]} ty_self {substs.self_ty.get()} @@ -1129,7 +1129,7 @@ fn type_is_structural(ty: t) -> bool { } fn type_is_copyable(cx: ctxt, ty: t) -> bool { - ret kind_can_be_copied(type_kind(cx, ty)); + return kind_can_be_copied(type_kind(cx, ty)); } fn type_is_sequence(ty: t) -> bool { @@ -1148,8 +1148,8 @@ fn type_is_str(ty: t) -> bool { fn sequence_element_type(cx: ctxt, ty: t) -> t { alt get(ty).struct { - ty_estr(_) { ret mk_mach_uint(cx, ast::ty_u8); } - ty_evec(mt, _) | ty_unboxed_vec(mt) { ret mt.ty; } + ty_estr(_) { return mk_mach_uint(cx, ast::ty_u8); } + ty_evec(mt, _) | ty_unboxed_vec(mt) { return mt.ty; } _ { cx.sess.bug( ~"sequence_element_type called on non-sequence value"); } @@ -1158,16 +1158,16 @@ fn sequence_element_type(cx: ctxt, ty: t) -> t { fn get_element_type(ty: t, i: uint) -> t { alt get(ty).struct { - ty_rec(flds) { ret flds[i].mt.ty; } - ty_tup(ts) { ret ts[i]; } + ty_rec(flds) { return flds[i].mt.ty; } + ty_tup(ts) { return ts[i]; } _ { fail ~"get_element_type called on invalid type"; } } } pure fn type_is_box(ty: t) -> bool { alt get(ty).struct { - ty_box(_) { ret true; } - _ { ret false; } + ty_box(_) { return true; } + _ { return false; } } } @@ -1189,26 +1189,26 @@ pure fn type_is_region_ptr(ty: t) -> bool { pure fn type_is_slice(ty: t) -> bool { alt get(ty).struct { ty_evec(_, vstore_slice(_)) | ty_estr(vstore_slice(_)) { true } - _ { ret false; } + _ { return false; } } } pure fn type_is_unique_box(ty: t) -> bool { alt get(ty).struct { - ty_uniq(_) { ret true; } - _ { ret false; } + ty_uniq(_) { return true; } + _ { return false; } } } pure fn type_is_unsafe_ptr(ty: t) -> bool { alt get(ty).struct { - ty_ptr(_) { ret true; } - _ { ret false; } + ty_ptr(_) { return true; } + _ { return false; } } } pure fn type_is_vec(ty: t) -> bool { - ret alt get(ty).struct { + return alt get(ty).struct { ty_evec(_, _) | ty_unboxed_vec(_) { true } ty_estr(_) { true } _ { false } @@ -1217,10 +1217,10 @@ pure fn type_is_vec(ty: t) -> bool { pure fn type_is_unique(ty: t) -> bool { alt get(ty).struct { - ty_uniq(_) { ret true; } + ty_uniq(_) { return true; } ty_evec(_, vstore_uniq) { true } ty_estr(vstore_uniq) { true } - _ { ret false; } + _ { return false; } } } @@ -1233,13 +1233,13 @@ pure fn type_is_scalar(ty: t) -> bool { } fn type_is_immediate(ty: t) -> bool { - ret type_is_scalar(ty) || type_is_boxed(ty) || + return type_is_scalar(ty) || type_is_boxed(ty) || type_is_unique(ty) || type_is_region_ptr(ty); } fn type_needs_drop(cx: ctxt, ty: t) -> bool { alt cx.needs_drop_cache.find(ty) { - some(result) { ret result; } + some(result) { return result; } none {/* fall through */ } } @@ -1293,7 +1293,7 @@ fn type_needs_drop(cx: ctxt, ty: t) -> bool { }; cx.needs_drop_cache.insert(ty, result); - ret result; + return result; } // Some things don't need cleanups during unwinding because the @@ -1302,7 +1302,7 @@ fn type_needs_drop(cx: ctxt, ty: t) -> bool { // cleanups. fn type_needs_unwind_cleanup(cx: ctxt, ty: t) -> bool { alt cx.needs_unwind_cleanup_cache.find(ty) { - some(result) { ret result; } + some(result) { return result; } none { } } @@ -1310,7 +1310,7 @@ fn type_needs_unwind_cleanup(cx: ctxt, ty: t) -> bool { let needs_unwind_cleanup = type_needs_unwind_cleanup_(cx, ty, tycache, false); cx.needs_unwind_cleanup_cache.insert(ty, needs_unwind_cleanup); - ret needs_unwind_cleanup; + return needs_unwind_cleanup; } fn type_needs_unwind_cleanup_(cx: ctxt, ty: t, @@ -1319,7 +1319,7 @@ fn type_needs_unwind_cleanup_(cx: ctxt, ty: t, // Prevent infinite recursion alt tycache.find(ty) { - some(_) { ret false; } + some(_) { return false; } none { tycache.insert(ty, ()); } } @@ -1373,7 +1373,7 @@ fn type_needs_unwind_cleanup_(cx: ctxt, ty: t, result } - ret needs_unwind_cleanup; + return needs_unwind_cleanup; } enum kind { kind_(u32) } @@ -1583,7 +1583,7 @@ fn mutable_type_kind(cx: ctxt, ty: mt) -> kind { fn type_kind(cx: ctxt, ty: t) -> kind { alt cx.kind_cache.find(ty) { - some(result) { ret result; } + some(result) { return result; } none {/* fall through */ } } @@ -1735,7 +1735,7 @@ fn type_kind(cx: ctxt, ty: t) -> kind { } cx.kind_cache.insert(ty, result); - ret result; + return result; } /// gives a rough estimate of how much space it takes to represent @@ -1816,7 +1816,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool { ty_to_str(cx, r_ty), ty_to_str(cx, ty), r}; - ret r; + return r; } fn subtypes_require(cx: ctxt, seen: @mut ~[def_id], @@ -1848,7 +1848,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool { ty_box(mt) | ty_uniq(mt) | ty_rptr(_, mt) { - ret type_requires(cx, seen, r_ty, mt.ty); + return type_requires(cx, seen, r_ty, mt.ty); } ty_ptr(mt) { @@ -1904,7 +1904,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool { ty_to_str(cx, ty), r}; - ret r; + return r; } let seen = @mut ~[]; @@ -1915,46 +1915,48 @@ fn type_structurally_contains(cx: ctxt, ty: t, test: fn(sty) -> bool) -> bool { let sty = get(ty).struct; debug!{"type_structurally_contains: %s", ty_to_str(cx, ty)}; - if test(sty) { ret true; } + if test(sty) { return true; } alt sty { ty_enum(did, substs) { for vec::each(*enum_variants(cx, did)) |variant| { for variant.args.each |aty| { let sty = subst(cx, substs, aty); - if type_structurally_contains(cx, sty, test) { ret true; } + if type_structurally_contains(cx, sty, test) { return true; } } } - ret false; + return false; } ty_rec(fields) { for fields.each |field| { - if type_structurally_contains(cx, field.mt.ty, test) { ret true; } + if type_structurally_contains(cx, field.mt.ty, test) { + return true; + } } - ret false; + return false; } ty_class(did, substs) { for lookup_class_fields(cx, did).each |field| { let ft = lookup_field_type(cx, did, field.id, substs); - if type_structurally_contains(cx, ft, test) { ret true; } + if type_structurally_contains(cx, ft, test) { return true; } } - ret false; + return false; } ty_tup(ts) { for ts.each |tt| { - if type_structurally_contains(cx, tt, test) { ret true; } + if type_structurally_contains(cx, tt, test) { return true; } } - ret false; + return false; } ty_evec(mt, vstore_fixed(_)) { - ret type_structurally_contains(cx, mt.ty, test); + return type_structurally_contains(cx, mt.ty, test); } - _ { ret false; } + _ { return false; } } } fn type_structurally_contains_uniques(cx: ctxt, ty: t) -> bool { - ret type_structurally_contains(cx, ty, |sty| { + return type_structurally_contains(cx, ty, |sty| { alt sty { ty_uniq(_) | ty_evec(_, vstore_uniq) | @@ -1979,7 +1981,7 @@ fn type_is_fp(ty: t) -> bool { } fn type_is_numeric(ty: t) -> bool { - ret type_is_integral(ty) || type_is_fp(ty); + return type_is_integral(ty) || type_is_fp(ty); } fn type_is_signed(ty: t) -> bool { @@ -2044,13 +2046,13 @@ fn type_is_pod(cx: ctxt, ty: t) -> bool { } } - ret result; + return result; } fn type_is_enum(ty: t) -> bool { alt get(ty).struct { - ty_enum(_, _) { ret true; } - _ { ret false;} + ty_enum(_, _) { return true; } + _ { return false;} } } @@ -2061,18 +2063,18 @@ fn type_is_c_like_enum(cx: ctxt, ty: t) -> bool { ty_enum(did, substs) { let variants = enum_variants(cx, did); let some_n_ary = vec::any(*variants, |v| vec::len(v.args) > 0u); - ret !some_n_ary; + return !some_n_ary; } - _ { ret false;} + _ { return false;} } } fn type_param(ty: t) -> option<uint> { alt get(ty).struct { - ty_param(p) { ret some(p.idx); } + ty_param(p) { return some(p.idx); } _ {/* fall through */ } } - ret none; + return none; } // Returns the type and mutability of *t. @@ -2110,7 +2112,7 @@ fn type_autoderef(cx: ctxt, t: t) -> t { let mut t = t; loop { alt deref(cx, t, false) { - none { ret t; } + none { return t; } some(mt) { t = mt.ty; } } } @@ -2243,13 +2245,13 @@ fn node_id_to_type(cx: ctxt, id: ast::node_id) -> t { fn node_id_to_type_params(cx: ctxt, id: ast::node_id) -> ~[t] { alt cx.node_type_substs.find(id) { - none { ret ~[]; } - some(ts) { ret ts; } + none { return ~[]; } + some(ts) { return ts; } } } fn node_id_has_type_params(cx: ctxt, id: ast::node_id) -> bool { - ret cx.node_type_substs.contains_key(id); + return cx.node_type_substs.contains_key(id); } // Type accessors for substructures of types @@ -2283,8 +2285,8 @@ fn ty_fn_ret_style(fty: t) -> ast::ret_style { fn is_fn_ty(fty: t) -> bool { alt get(fty).struct { - ty_fn(_) { ret true; } - _ { ret false; } + ty_fn(_) { return true; } + _ { return false; } } } @@ -2301,14 +2303,14 @@ fn is_pred_ty(fty: t) -> bool { fn ty_var_id(typ: t) -> tv_vid { alt get(typ).struct { - ty_var(vid) { ret vid; } + ty_var(vid) { return vid; } _ { error!{"ty_var_id called on non-var ty"}; fail; } } } fn ty_var_integral_id(typ: t) -> tvi_vid { alt get(typ).struct { - ty_var_integral(vid) { ret vid; } + ty_var_integral(vid) { return vid; } _ { error!{"ty_var_integral_id called on ty other than \ ty_var_integral"}; fail; } @@ -2317,14 +2319,14 @@ fn ty_var_integral_id(typ: t) -> tvi_vid { // Type accessors for AST nodes fn block_ty(cx: ctxt, b: ast::blk) -> t { - ret node_id_to_type(cx, b.node.id); + return node_id_to_type(cx, b.node.id); } // Returns the type of a pattern as a monotype. Like @expr_ty, this function // doesn't provide type parameter substitutions. fn pat_ty(cx: ctxt, pat: @ast::pat) -> t { - ret node_id_to_type(cx, pat.id); + return node_id_to_type(cx, pat.id); } @@ -2335,17 +2337,17 @@ fn pat_ty(cx: ctxt, pat: @ast::pat) -> t { // instead of "fn(t) -> T with T = int". If this isn't what you want, see // expr_ty_params_and_ty() below. fn expr_ty(cx: ctxt, expr: @ast::expr) -> t { - ret node_id_to_type(cx, expr.id); + return node_id_to_type(cx, expr.id); } fn expr_ty_params_and_ty(cx: ctxt, expr: @ast::expr) -> {params: ~[t], ty: t} { - ret {params: node_id_to_type_params(cx, expr.id), + return {params: node_id_to_type_params(cx, expr.id), ty: node_id_to_type(cx, expr.id)}; } fn expr_has_ty_params(cx: ctxt, expr: @ast::expr) -> bool { - ret node_id_has_type_params(cx, expr.id); + return node_id_has_type_params(cx, expr.id); } fn expr_is_lval(method_map: typeck::method_map, e: @ast::expr) -> bool { @@ -2361,15 +2363,15 @@ fn expr_is_lval(method_map: typeck::method_map, e: @ast::expr) -> bool { fn stmt_node_id(s: @ast::stmt) -> ast::node_id { alt s.node { ast::stmt_decl(_, id) | stmt_expr(_, id) | stmt_semi(_, id) { - ret id; + return id; } } } fn field_idx(id: ast::ident, fields: ~[field]) -> option<uint> { let mut i = 0u; - for fields.each |f| { if f.ident == id { ret some(i); } i += 1u; } - ret none; + for fields.each |f| { if f.ident == id { return some(i); } i += 1u; } + return none; } fn get_field(rec_ty: t, id: ast::ident) -> field { @@ -2386,8 +2388,8 @@ fn get_fields(rec_ty:t) -> ~[field] { fn method_idx(id: ast::ident, meths: ~[method]) -> option<uint> { let mut i = 0u; - for meths.each |m| { if m.ident == id { ret some(i); } i += 1u; } - ret none; + for meths.each |m| { if m.ident == id { return some(i); } i += 1u; } + return none; } /// Returns a vector containing the indices of all type parameters that appear @@ -2419,7 +2421,7 @@ fn occurs_check(tcx: ctxt, sp: span, vid: tv_vid, rt: t) { } // Fast path - if !type_needs_infer(rt) { ret; } + if !type_needs_infer(rt) { return; } // Occurs check! if vec::contains(vars_in_type(rt), vid) { @@ -2539,7 +2541,7 @@ fn type_err_to_str(cx: ctxt, err: type_err) -> ~str { } alt err { - terr_mismatch { ret ~"types differ"; } + terr_mismatch { return ~"types differ"; } terr_ret_style_mismatch(expect, actual) { fn to_str(s: ast::ret_style) -> ~str { alt s { @@ -2547,69 +2549,71 @@ fn type_err_to_str(cx: ctxt, err: type_err) -> ~str { ast::return_val { ~"return-by-value" } } } - ret to_str(actual) + ~" function found where " + to_str(expect) + + return to_str(actual) + ~" function found where " + to_str(expect) + ~" function was expected"; } terr_purity_mismatch(f1, f2) { - ret fmt!{"expected %s fn but found %s fn", + return fmt!{"expected %s fn but found %s fn", purity_to_str(f1), purity_to_str(f2)}; } terr_proto_mismatch(e, a) { - ret fmt!{"closure protocol mismatch (%s vs %s)", + return fmt!{"closure protocol mismatch (%s vs %s)", proto_to_str(e), proto_to_str(a)}; } - terr_mutability { ret ~"values differ in mutability"; } - terr_box_mutability { ret ~"boxed values differ in mutability"; } - terr_vec_mutability { ret ~"vectors differ in mutability"; } - terr_ptr_mutability { ret ~"pointers differ in mutability"; } - terr_ref_mutability { ret ~"references differ in mutability"; } + terr_mutability { return ~"values differ in mutability"; } + terr_box_mutability { return ~"boxed values differ in mutability"; } + terr_vec_mutability { return ~"vectors differ in mutability"; } + terr_ptr_mutability { return ~"pointers differ in mutability"; } + terr_ref_mutability { return ~"references differ in mutability"; } terr_ty_param_size(e_sz, a_sz) { - ret ~"expected a type with " + uint::to_str(e_sz, 10u) + + return ~"expected a type with " + uint::to_str(e_sz, 10u) + ~" type params but found one with " + uint::to_str(a_sz, 10u) + ~" type params"; } terr_tuple_size(e_sz, a_sz) { - ret ~"expected a tuple with " + uint::to_str(e_sz, 10u) + + return ~"expected a tuple with " + uint::to_str(e_sz, 10u) + ~" elements but found one with " + uint::to_str(a_sz, 10u) + ~" elements"; } terr_record_size(e_sz, a_sz) { - ret ~"expected a record with " + uint::to_str(e_sz, 10u) + + return ~"expected a record with " + uint::to_str(e_sz, 10u) + ~" fields but found one with " + uint::to_str(a_sz, 10u) + ~" fields"; } - terr_record_mutability { ret ~"record elements differ in mutability"; } + terr_record_mutability { + return ~"record elements differ in mutability"; + } terr_record_fields(e_fld, a_fld) { - ret ~"expected a record with field `" + *e_fld + + return ~"expected a record with field `" + *e_fld + ~"` but found one with field `" + *a_fld + ~"`"; } - terr_arg_count { ret ~"incorrect number of function parameters"; } + terr_arg_count { return ~"incorrect number of function parameters"; } terr_mode_mismatch(e_mode, a_mode) { - ret ~"expected argument mode " + mode_to_str(e_mode) + + return ~"expected argument mode " + mode_to_str(e_mode) + ~" but found " + mode_to_str(a_mode); } terr_regions_differ(subregion, superregion) { - ret fmt!{"%s does not necessarily outlive %s", + return fmt!{"%s does not necessarily outlive %s", explain_region(cx, subregion), explain_region(cx, superregion)}; } terr_vstores_differ(k, e_vs, a_vs) { - ret fmt!{"%s storage differs: expected %s but found %s", + return fmt!{"%s storage differs: expected %s but found %s", terr_vstore_kind_to_str(k), vstore_to_str(cx, e_vs), vstore_to_str(cx, a_vs)}; } terr_in_field(err, fname) { - ret fmt!{"in field `%s`, %s", *fname, type_err_to_str(cx, *err)}; + return fmt!{"in field `%s`, %s", *fname, type_err_to_str(cx, *err)}; } terr_sorts(exp, act) { - ret fmt!{"%s vs %s", ty_sort_str(cx, exp), ty_sort_str(cx, act)}; + return fmt!{"%s vs %s", ty_sort_str(cx, exp), ty_sort_str(cx, act)}; } terr_self_substs { - ret ~"inconsistent self substitution"; // XXX this is more of a bug + return ~"inconsistent self substitution"; // XXX this is more of a bug } terr_no_integral_type { - ret ~"couldn't determine an appropriate integral type for integer \ + return ~"couldn't determine an appropriate integral type for integer \ literal"; } } @@ -2629,7 +2633,7 @@ fn store_trait_methods(cx: ctxt, id: ast::node_id, ms: @~[method]) { fn trait_methods(cx: ctxt, id: ast::def_id) -> @~[method] { alt cx.trait_method_cache.find(id) { - some(ms) { ret ms; } + some(ms) { return ms; } _ {} } // Local traits are supposed to have been added explicitly. @@ -2789,7 +2793,7 @@ fn type_is_empty(cx: ctxt, t: t) -> bool { fn enum_variants(cx: ctxt, id: ast::def_id) -> @~[variant_info] { alt cx.enum_var_cache.find(id) { - some(variants) { ret variants; } + some(variants) { return variants; } _ { /* fallthrough */ } } @@ -2844,7 +2848,7 @@ fn enum_variant_with_id(cx: ctxt, enum_id: ast::def_id, let mut i = 0u; while i < vec::len::<variant_info>(*variants) { let variant = variants[i]; - if ast_util::def_eq(variant.id, variant_id) { ret variant; } + if ast_util::def_eq(variant.id, variant_id) { return variant; } i += 1u; } cx.sess.bug(~"enum_variant_with_id(): no variant exists with that ID"); @@ -2855,14 +2859,14 @@ fn enum_variant_with_id(cx: ctxt, enum_id: ast::def_id, // the type cache. Returns the type parameters and type. fn lookup_item_type(cx: ctxt, did: ast::def_id) -> ty_param_bounds_and_ty { alt cx.tcache.find(did) { - some(tpt) { ret tpt; } + some(tpt) { return tpt; } none { // The item is in this crate. The caller should have added it to the // type cache already assert did.crate != ast::local_crate; let tyt = csearch::get_type(cx, did); cx.tcache.insert(did, tyt); - ret tyt; + return tyt; } } } @@ -2908,7 +2912,7 @@ fn lookup_class_fields(cx: ctxt, did: ast::def_id) -> ~[field_ty] { } } else { - ret csearch::get_class_fields(cx, did); + return csearch::get_class_fields(cx, did); } } @@ -2962,7 +2966,7 @@ fn lookup_class_method_by_name(cx:ctxt, did: ast::def_id, name: ident, let ms = lookup_class_method_ids(cx, did); for ms.each |m| { if m.name == name { - ret ast_util::local_def(m.id); + return ast_util::local_def(m.id); } } cx.sess.span_fatal(sp, fmt!{"Class doesn't have a method \ @@ -3087,7 +3091,7 @@ fn is_binopable(_cx: ctxt, ty: t, op: ast::binop) -> bool { /*bot*/ ~[f, f, f, f, t, t, f, f], /*struct*/ ~[t, t, t, t, t, t, t, t]]; - ret tbl[tycat(ty)][opcat(op)]; + return tbl[tycat(ty)][opcat(op)]; } fn ty_params_to_tys(tcx: ty::ctxt, tps: ~[ast::ty_param]) -> ~[t] { @@ -3099,7 +3103,7 @@ fn ty_params_to_tys(tcx: ty::ctxt, tps: ~[ast::ty_param]) -> ~[t] { /// Returns an equivalent type with all the typedefs and self regions removed. fn normalize_ty(cx: ctxt, t: t) -> t { alt cx.normalized_cache.find(t) { - some(t) { ret t; } + some(t) { return t; } none { } } @@ -3136,7 +3140,7 @@ fn normalize_ty(cx: ctxt, t: t) -> t { let sty = fold_sty(get(t).struct, |t| { normalize_ty(cx, t) }); let t_norm = mk_t(cx, sty); cx.normalized_cache.insert(t, t_norm); - ret t_norm; + return t_norm; } // Local Variables: diff --git a/src/rustc/middle/typeck.rs b/src/rustc/middle/typeck.rs index bf7069f87e2..adc47d5fad4 100644 --- a/src/rustc/middle/typeck.rs +++ b/src/rustc/middle/typeck.rs @@ -228,13 +228,13 @@ fn require_same_types( fn arg_is_argv_ty(_tcx: ty::ctxt, a: ty::arg) -> bool { alt ty::get(a.ty).struct { ty::ty_evec(mt, vstore_uniq) { - if mt.mutbl != ast::m_imm { ret false; } + if mt.mutbl != ast::m_imm { return false; } alt ty::get(mt.ty).struct { - ty::ty_estr(vstore_uniq) { ret true; } - _ { ret false; } + ty::ty_estr(vstore_uniq) { return true; } + _ { return false; } } } - _ { ret false; } + _ { return false; } } } @@ -253,7 +253,7 @@ fn check_main_fn_ty(ccx: @crate_ctxt, ast::item_fn(_,ps,_) if vec::is_not_empty(ps) { tcx.sess.span_err(main_span, ~"main function is not allowed to have type parameters"); - ret; + return; } _ {} } diff --git a/src/rustc/middle/typeck/astconv.rs b/src/rustc/middle/typeck/astconv.rs index 1dd8cde5084..632a29ba8e8 100644 --- a/src/rustc/middle/typeck/astconv.rs +++ b/src/rustc/middle/typeck/astconv.rs @@ -142,7 +142,7 @@ fn ast_path_to_ty<AC: ast_conv, RS: region_scope copy owned>( ast_path_to_substs_and_ty(self, rscope, did, path); write_ty_to_tcx(tcx, path_id, ty); write_substs_to_tcx(tcx, path_id, substs.tps); - ret {substs: substs, ty: ty}; + return {substs: substs, ty: ty}; } const NO_REGIONS: uint = 1u; @@ -157,7 +157,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy owned>( fn ast_mt_to_mt<AC: ast_conv, RS: region_scope copy owned>( self: AC, rscope: RS, mt: ast::mt) -> ty::mt { - ret {ty: ast_ty_to_ty(self, rscope, mt.ty), mutbl: mt.mutbl}; + return {ty: ast_ty_to_ty(self, rscope, mt.ty), mutbl: mt.mutbl}; } // Handle @, ~, and & being able to mean estrs and evecs. @@ -172,13 +172,13 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy owned>( // to convert to an e{vec,str}, there can't be a mutability argument _ if a_seq_ty.mutbl != ast::m_imm {} ast::ty_vec(mt) { - ret ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, mt), vst); + return ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, mt), vst); } ast::ty_path(path, id) { alt tcx.def_map.find(id) { some(ast::def_prim_ty(ast::ty_str)) { check_path_args(tcx, path, NO_TPS | NO_REGIONS); - ret ty::mk_estr(tcx, vst); + return ty::mk_estr(tcx, vst); } _ {} } @@ -187,7 +187,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy owned>( } let seq_ty = ast_mt_to_mt(self, rscope, a_seq_ty); - ret constr(seq_ty); + return constr(seq_ty); } fn check_path_args(tcx: ty::ctxt, @@ -213,7 +213,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy owned>( let tcx = self.tcx(); alt tcx.ast_ty_to_ty_cache.find(ast_ty) { - some(ty::atttce_resolved(ty)) { ret ty; } + some(ty::atttce_resolved(ty)) { return ty; } some(ty::atttce_unresolved) { tcx.sess.span_fatal(ast_ty.span, ~"illegal recursive type; \ insert an enum in the cycle, \ @@ -348,7 +348,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy owned>( }; tcx.ast_ty_to_ty_cache.insert(ast_ty, ty::atttce_resolved(typ)); - ret typ; + return typ; } fn ty_of_arg<AC: ast_conv, RS: region_scope copy owned>( diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs index 440ec24092e..862bf2cfaa4 100644 --- a/src/rustc/middle/typeck/check.rs +++ b/src/rustc/middle/typeck/check.rs @@ -157,9 +157,9 @@ impl methods of get_and_find_region for isr_alist { fn find(br: ty::bound_region) -> option<ty::region> { for list::each(self) |isr| { let (isr_br, isr_r) = isr; - if isr_br == br { ret some(isr_r); } + if isr_br == br { return some(isr_r); } } - ret none; + return none; } } @@ -653,7 +653,7 @@ impl methods for @fn_ctxt { self.region_lb = lb; let v <- f(); self.region_lb = old_region_lb; - ret v; + return v; } } @@ -681,7 +681,7 @@ fn do_autoderef(fcx: @fn_ctxt, sp: span, t: ty::t) -> ty::t { // reported on the enum definition as well because the enum is not // instantiable. if vec::contains(enum_dids, did) { - ret t1; + return t1; } vec::push(enum_dids, did); } @@ -690,7 +690,7 @@ fn do_autoderef(fcx: @fn_ctxt, sp: span, t: ty::t) -> ty::t { // Otherwise, deref if type is derefable: alt ty::deref_sty(fcx.ccx.tcx, sty, false) { - none { ret t1; } + none { return t1; } some(mt) { t1 = mt.ty; } } }; @@ -726,7 +726,7 @@ fn check_expr_with(fcx: @fn_ctxt, expr: @ast::expr, expected: ty::t) -> bool { fn check_expr(fcx: @fn_ctxt, expr: @ast::expr, expected: option<ty::t>) -> bool { - ret do check_expr_with_unifier(fcx, expr, expected) { + return do check_expr_with_unifier(fcx, expr, expected) { for expected.each |t| { demand::suptype(fcx, expr.span, t, fcx.expr_ty(expr)); } @@ -898,7 +898,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, let mut bot = check_expr(fcx, lhs, none); bot |= check_expr_with(fcx, rhs, fcx.expr_ty(lhs)); fcx.write_ty(id, ty::mk_nil(fcx.ccx.tcx)); - ret bot; + return bot; } // A generic function for doing all of the checking for call expressions @@ -928,7 +928,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, ty::ty_fn(f) { bot |= (f.ret_style == ast::noreturn); fcx.write_ty(call_expr_id, f.output); - ret bot; + return bot; } _ { fcx.ccx.tcx.sess.span_fatal(sp, ~"calling non-function"); } } @@ -945,7 +945,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, let bot = check_decl_local(fcx, local); check_block_no_value(fcx, body); fcx.write_nil(node_id); - ret bot; + return bot; } // A generic function for checking the then and else in an if @@ -969,7 +969,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, } }; fcx.write_ty(id, if_t); - ret if_bot; + return if_bot; } fn lookup_op_method(fcx: @fn_ctxt, op_ex: @ast::expr, @@ -1000,7 +1000,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, let lhs_bot = check_expr(fcx, lhs, none); let lhs_t = fcx.expr_ty(lhs); let lhs_t = structurally_resolved_type(fcx, lhs.span, lhs_t); - ret alt (op, ty::get(lhs_t).struct) { + return alt (op, ty::get(lhs_t).struct) { (_, _) if ty::type_is_integral(lhs_t) && ast_util::is_shift_binop(op) { // Shift is a special case: rhs can be any integral type @@ -1049,7 +1049,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, alt lookup_op_method(fcx, ex, lhs_expr, lhs_resolved_t, name, ~[rhs]) { - some(pair) { ret pair; } + some(pair) { return pair; } _ {} } } @@ -1242,7 +1242,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, } } } - ret bot; + return bot; } @@ -1421,8 +1421,9 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, alt fcx.mk_eqty(ret_ty, ty::mk_nil(tcx)) { result::ok(_) { /* fall through */ } result::err(_) { - tcx.sess.span_err(expr.span, - ~"`ret;` in function returning non-nil"); } + tcx.sess.span_err( + expr.span, + ~"`return;` in function returning non-nil"); } } } some(e) { check_expr_with(fcx, e, ret_ty); } @@ -1902,7 +1903,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, unifier(); debug!{"<< bot=%b", bot}; - ret bot; + return bot; } fn require_integral(fcx: @fn_ctxt, sp: span, t: ty::t) { @@ -1916,7 +1917,7 @@ fn require_integral(fcx: @fn_ctxt, sp: span, t: ty::t) { fn check_decl_initializer(fcx: @fn_ctxt, nid: ast::node_id, init: ast::initializer) -> bool { let lty = ty::mk_var(fcx.ccx.tcx, lookup_local(fcx, init.expr.span, nid)); - ret check_expr_with(fcx, init.expr, lty); + return check_expr_with(fcx, init.expr, lty); } fn check_decl_local(fcx: @fn_ctxt, local: @ast::local) -> bool { @@ -1941,7 +1942,7 @@ fn check_decl_local(fcx: @fn_ctxt, local: @ast::local) -> bool { pat_region: region }; alt::check_pat(pcx, local.node.pat, t); - ret bot; + return bot; } fn check_stmt(fcx: @fn_ctxt, stmt: @ast::stmt) -> bool { @@ -1967,7 +1968,7 @@ fn check_stmt(fcx: @fn_ctxt, stmt: @ast::stmt) -> bool { } } fcx.write_nil(node_id); - ret bot; + return bot; } fn check_block_no_value(fcx: @fn_ctxt, blk: ast::blk) -> bool { @@ -1977,7 +1978,7 @@ fn check_block_no_value(fcx: @fn_ctxt, blk: ast::blk) -> bool { let nilty = ty::mk_nil(fcx.ccx.tcx); demand::suptype(fcx, blk.span, nilty, blkty); } - ret bot; + return bot; } fn check_block(fcx0: @fn_ctxt, blk: ast::blk) -> bool { @@ -2160,17 +2161,17 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) -> ast::def_arg(nid, _) { assert (fcx.locals.contains_key(nid)); let typ = ty::mk_var(fcx.ccx.tcx, lookup_local(fcx, sp, nid)); - ret no_params(typ); + return no_params(typ); } ast::def_local(nid, _) { assert (fcx.locals.contains_key(nid)); let typ = ty::mk_var(fcx.ccx.tcx, lookup_local(fcx, sp, nid)); - ret no_params(typ); + return no_params(typ); } ast::def_self(_) { alt fcx.self_info { some(self_info) { - ret no_params(self_info.self_ty); + return no_params(self_info.self_ty); } none { fcx.ccx.tcx.sess.span_bug(sp, ~"def_self with no self_info"); @@ -2179,7 +2180,7 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) -> } ast::def_fn(id, ast::extern_fn) { // extern functions are just u8 pointers - ret { + return { bounds: @~[], rp: false, ty: ty::mk_ptr( @@ -2194,26 +2195,26 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) -> ast::def_fn(id, ast::unsafe_fn) { // Unsafe functions can only be touched in an unsafe context fcx.require_unsafe(sp, ~"access to unsafe function"); - ret ty::lookup_item_type(fcx.ccx.tcx, id); + return ty::lookup_item_type(fcx.ccx.tcx, id); } ast::def_fn(id, _) | ast::def_const(id) | ast::def_variant(_, id) | ast::def_class(id, _) { - ret ty::lookup_item_type(fcx.ccx.tcx, id); + return ty::lookup_item_type(fcx.ccx.tcx, id); } ast::def_binding(nid) { assert (fcx.locals.contains_key(nid)); let typ = ty::mk_var(fcx.ccx.tcx, lookup_local(fcx, sp, nid)); - ret no_params(typ); + return no_params(typ); } ast::def_ty(_) | ast::def_prim_ty(_) { fcx.ccx.tcx.sess.span_fatal(sp, ~"expected value but found type"); } ast::def_upvar(_, inner, _) { - ret ty_param_bounds_and_ty_for_def(fcx, sp, *inner); + return ty_param_bounds_and_ty_for_def(fcx, sp, *inner); } ast::def_ty_param(did, n) { - ret no_params(ty::mk_param(fcx.ccx.tcx, n, did)); + return no_params(ty::mk_param(fcx.ccx.tcx, n, did)); } ast::def_mod(*) | ast::def_foreign_mod(*) { fcx.ccx.tcx.sess.span_fatal(sp, ~"expected value but found module"); @@ -2288,7 +2289,7 @@ fn instantiate_path(fcx: @fn_ctxt, // resolution is possible, then an error is reported. fn structurally_resolved_type(fcx: @fn_ctxt, sp: span, tp: ty::t) -> ty::t { alt infer::resolve_type(fcx.infcx, tp, force_tvar) { - result::ok(t_s) if !ty::type_is_var(t_s) { ret t_s; } + result::ok(t_s) if !ty::type_is_var(t_s) { return t_s; } _ { fcx.ccx.tcx.sess.span_fatal (sp, ~"the type of this value must be known in this context"); @@ -2303,17 +2304,17 @@ fn structure_of(fcx: @fn_ctxt, sp: span, typ: ty::t) -> ty::sty { fn type_is_integral(fcx: @fn_ctxt, sp: span, typ: ty::t) -> bool { let typ_s = structurally_resolved_type(fcx, sp, typ); - ret ty::type_is_integral(typ_s); + return ty::type_is_integral(typ_s); } fn type_is_scalar(fcx: @fn_ctxt, sp: span, typ: ty::t) -> bool { let typ_s = structurally_resolved_type(fcx, sp, typ); - ret ty::type_is_scalar(typ_s); + return ty::type_is_scalar(typ_s); } fn type_is_c_like_enum(fcx: @fn_ctxt, sp: span, typ: ty::t) -> bool { let typ_s = structurally_resolved_type(fcx, sp, typ); - ret ty::type_is_c_like_enum(fcx.ccx.tcx, typ_s); + return ty::type_is_c_like_enum(fcx.ccx.tcx, typ_s); } fn ast_expr_vstore_to_vstore(fcx: @fn_ctxt, e: @ast::expr, n: uint, @@ -2350,7 +2351,7 @@ fn check_bounds_are_used(ccx: @crate_ctxt, tps: ~[ast::ty_param], ty: ty::t) { // make a vector of booleans initially false, set to true when used - if tps.len() == 0u { ret; } + if tps.len() == 0u { return; } let tps_used = vec::to_mut(vec::from_elem(tps.len(), false)); ty::walk_regions_and_ty( @@ -2437,7 +2438,7 @@ fn check_intrinsic_type(ccx: @crate_ctxt, it: @ast::foreign_item) { other { tcx.sess.span_err(it.span, ~"unrecognized intrinsic function: `" + other + ~"`"); - ret; + return; } }; let fty = ty::mk_fn(tcx, {purity: ast::impure_fn, diff --git a/src/rustc/middle/typeck/check/alt.rs b/src/rustc/middle/typeck/check/alt.rs index 5cc8a953722..b0106f44cfc 100644 --- a/src/rustc/middle/typeck/check/alt.rs +++ b/src/rustc/middle/typeck/check/alt.rs @@ -40,7 +40,7 @@ fn check_alt(fcx: @fn_ctxt, bot |= !arm_non_bot; if !arm_non_bot { result_ty = ty::mk_bot(tcx); } fcx.write_ty(expr.id, result_ty); - ret bot; + return bot; } type pat_ctxt = { @@ -197,7 +197,7 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) { ex_f_count, f_count}); } fn matches(name: ast::ident, f: ty::field) -> bool { - ret str::eq(*name, *f.ident); + return str::eq(*name, *f.ident); } for fields.each |f| { alt vec::find(ex_fields, |a| matches(f.ident, a)) { diff --git a/src/rustc/middle/typeck/check/method.rs b/src/rustc/middle/typeck/check/method.rs index 08f36bdb256..efd2756a607 100644 --- a/src/rustc/middle/typeck/check/method.rs +++ b/src/rustc/middle/typeck/check/method.rs @@ -160,7 +160,7 @@ class lookup { } } - if self.candidates.len() == 0u { ret none; } + if self.candidates.len() == 0u { return none; } if self.candidates.len() > 1u { self.tcx().sess.span_err( @@ -359,7 +359,7 @@ class lookup { // multiple-methods-in-scope errors. if self.fcx.ccx.trait_map.contains_key(self.expr.id) { - ret; + return; } let impls_vecs = self.fcx.ccx.impl_map.get(self.expr.id); @@ -376,7 +376,7 @@ class lookup { // we want to find the innermost scope that has any // matches and then ignore outer scopes - if added_any {ret;} + if added_any {return;} } } @@ -428,7 +428,7 @@ class lookup { } } - ret added_any; + return added_any; } fn add_candidates_from_m(self_substs: ty::substs, @@ -563,7 +563,7 @@ class lookup { self.fcx.write_ty_substs(self.node_id, cand.fty, all_substs); - ret cand.entry; + return cand.entry; } } diff --git a/src/rustc/middle/typeck/check/regionck.rs b/src/rustc/middle/typeck/check/regionck.rs index 50e2d5db973..6e9293dd8e9 100644 --- a/src/rustc/middle/typeck/check/regionck.rs +++ b/src/rustc/middle/typeck/check/regionck.rs @@ -93,7 +93,7 @@ fn visit_local(l: @ast::local, &&rcx: @rcx, v: rvt) { let e = rcx.errors_reported; v.visit_pat(l.node.pat, rcx, v); if e != rcx.errors_reported { - ret; // if decl has errors, skip initializer expr + return; // if decl has errors, skip initializer expr } v.visit_ty(l.node.ty, rcx, v); @@ -131,7 +131,7 @@ fn visit_expr(e: @ast::expr, &&rcx: @rcx, v: rvt) { // uses will also be enclosed (and otherwise, an error will // have been reported at the def'n site). alt lookup_def(rcx.fcx, e.span, e.id) { - ast::def_local(*) | ast::def_arg(*) | ast::def_upvar(*) { ret; } + ast::def_local(*) | ast::def_arg(*) | ast::def_upvar(*) { return; } _ { } } } @@ -151,7 +151,7 @@ fn visit_expr(e: @ast::expr, &&rcx: @rcx, v: rvt) { // check_cast_for_escaping_regions() in kind.rs explaining how // it goes about doing that. alt rcx.resolve_node_type(e.id) { - result::err(_) => { ret; /* typeck will fail anyhow */ } + result::err(_) => { return; /* typeck will fail anyhow */ } result::ok(target_ty) => { alt ty::get(target_ty).struct { ty::ty_trait(_, substs) { @@ -173,7 +173,7 @@ fn visit_expr(e: @ast::expr, &&rcx: @rcx, v: rvt) { _ { } } - if !visit_node(e.id, e.span, rcx) { ret; } + if !visit_node(e.id, e.span, rcx) { return; } visit::visit_expr(e, rcx, v); } @@ -192,7 +192,7 @@ fn visit_node(id: ast::node_id, span: span, rcx: @rcx) -> bool { // is going to fail anyway, so just stop here and let typeck // report errors later on in the writeback phase. let ty = alt rcx.resolve_node_type(id) { - result::err(_) { ret true; } + result::err(_) { return true; } result::ok(ty) { ty } }; @@ -206,7 +206,7 @@ fn visit_node(id: ast::node_id, span: span, rcx: @rcx) -> bool { ppaux::region_to_str(tcx, encl_region)}; // Otherwise, look at the type and see if it is a region pointer. - ret constrain_regions_in_type(rcx, encl_region, span, ty); + return constrain_regions_in_type(rcx, encl_region, span, ty); } fn constrain_regions_in_type( @@ -220,7 +220,7 @@ fn constrain_regions_in_type( rcx.fcx.ccx.tcx, ty, |r| constrain_region(rcx, encl_region, span, r), |t| ty::type_has_regions(t)); - ret (e == rcx.errors_reported); + return (e == rcx.errors_reported); fn constrain_region(rcx: @rcx, encl_region: ty::region, @@ -238,7 +238,7 @@ fn constrain_regions_in_type( // (e.g., the `&` in `fn(&T)`). Such regions need not be // constrained by `encl_region` as they are placeholders // for regions that are as-yet-unknown. - ret; + return; } _ {} } diff --git a/src/rustc/middle/typeck/check/regionmanip.rs b/src/rustc/middle/typeck/check/regionmanip.rs index 5bbe9bb1867..a2bfc9c3ffa 100644 --- a/src/rustc/middle/typeck/check/regionmanip.rs +++ b/src/rustc/middle/typeck/check/regionmanip.rs @@ -56,7 +56,7 @@ fn replace_bound_regions_in_fn_ty( none { none } }; - ret {isr: isr, + return {isr: isr, self_info: new_self_info, fn_ty: alt check ty::get(t_fn).struct { ty::ty_fn(o) {o} }}; @@ -169,7 +169,7 @@ fn replace_bound_regions_in_fn_ty( */ fn region_of(fcx: @fn_ctxt, expr: @ast::expr) -> ty::region { debug!{"region_of(expr=%s)", expr_to_str(expr)}; - ret alt expr.node { + return alt expr.node { ast::expr_path(path) { def(fcx, expr, lookup_def(fcx, path.span, expr.id))} ast::expr_field(base, _, _) { diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs index 6baa89e0638..a4b8bf021e1 100644 --- a/src/rustc/middle/typeck/check/vtable.rs +++ b/src/rustc/middle/typeck/check/vtable.rs @@ -81,7 +81,7 @@ fn lookup_vtable(fcx: @fn_ctxt, sp: span, ty: ty::t, trait_ty: ty::t, debug!{"(checking vtable) @0 relating ty to trait ty with did %?", idid}; relate_trait_tys(fcx, sp, trait_ty, ity); - ret vtable_param(n, n_bound); + return vtable_param(n, n_bound); } } } @@ -110,7 +110,7 @@ fn lookup_vtable(fcx: @fn_ctxt, sp: span, ty: ty::t, trait_ty: ty::t, } } } - ret vtable_trait(did, substs.tps); + return vtable_trait(did, substs.tps); } _ { @@ -178,11 +178,11 @@ fn lookup_vtable(fcx: @fn_ctxt, sp: span, ty: ty::t, trait_ty: ty::t, alt found.len() { 0u { /* fallthrough */ } - 1u { ret found[0]; } + 1u { return found[0]; } _ { fcx.ccx.tcx.sess.span_err( sp, ~"multiple applicable methods in scope"); - ret found[0]; + return found[0]; } } } diff --git a/src/rustc/middle/typeck/check/writeback.rs b/src/rustc/middle/typeck/check/writeback.rs index d9615c88583..726cc2a7c70 100644 --- a/src/rustc/middle/typeck/check/writeback.rs +++ b/src/rustc/middle/typeck/check/writeback.rs @@ -9,9 +9,9 @@ export resolve_type_vars_in_expr; fn resolve_type_vars_in_type(fcx: @fn_ctxt, sp: span, typ: ty::t) -> option<ty::t> { - if !ty::type_needs_infer(typ) { ret some(typ); } + if !ty::type_needs_infer(typ) { return some(typ); } alt resolve_type(fcx.infcx, typ, resolve_all | force_all) { - result::ok(new_type) { ret some(new_type); } + result::ok(new_type) { return some(new_type); } result::err(e) { if !fcx.ccx.tcx.sess.has_errors() { fcx.ccx.tcx.sess.span_err( @@ -20,7 +20,7 @@ fn resolve_type_vars_in_type(fcx: @fn_ctxt, sp: span, typ: ty::t) -> for this expression: %s", infer::fixup_err_to_str(e)}) } - ret none; + return none; } } } @@ -31,7 +31,7 @@ fn resolve_type_vars_for_node(wbcx: wb_ctxt, sp: span, id: ast::node_id) alt resolve_type_vars_in_type(fcx, sp, n_ty) { none { wbcx.success = false; - ret none; + return none; } some(t) { @@ -44,14 +44,14 @@ fn resolve_type_vars_for_node(wbcx: wb_ctxt, sp: span, id: ast::node_id) for substs.tps.each |subst| { alt resolve_type_vars_in_type(fcx, sp, subst) { some(t) { vec::push(new_tps, t); } - none { wbcx.success = false; ret none; } + none { wbcx.success = false; return none; } } } write_substs_to_tcx(tcx, id, new_tps); } none {} } - ret some(t); + return some(t); } } } @@ -73,12 +73,12 @@ type wb_ctxt = type wb_vt = visit::vt<wb_ctxt>; fn visit_stmt(s: @ast::stmt, wbcx: wb_ctxt, v: wb_vt) { - if !wbcx.success { ret; } + if !wbcx.success { return; } resolve_type_vars_for_node(wbcx, s.span, ty::stmt_node_id(s)); visit::visit_stmt(s, wbcx, v); } fn visit_expr(e: @ast::expr, wbcx: wb_ctxt, v: wb_vt) { - if !wbcx.success { ret; } + if !wbcx.success { return; } resolve_type_vars_for_node(wbcx, e.span, e.id); alt e.node { ast::expr_fn(_, decl, _, _) | @@ -113,12 +113,12 @@ fn visit_expr(e: @ast::expr, wbcx: wb_ctxt, v: wb_vt) { visit::visit_expr(e, wbcx, v); } fn visit_block(b: ast::blk, wbcx: wb_ctxt, v: wb_vt) { - if !wbcx.success { ret; } + if !wbcx.success { return; } resolve_type_vars_for_node(wbcx, b.span, b.node.id); visit::visit_block(b, wbcx, v); } fn visit_pat(p: @ast::pat, wbcx: wb_ctxt, v: wb_vt) { - if !wbcx.success { ret; } + if !wbcx.success { return; } resolve_type_vars_for_node(wbcx, p.span, p.id); debug!{"Type for pattern binding %s (id %d) resolved to %s", pat_to_str(p), p.id, @@ -128,7 +128,7 @@ fn visit_pat(p: @ast::pat, wbcx: wb_ctxt, v: wb_vt) { visit::visit_pat(p, wbcx, v); } fn visit_local(l: @ast::local, wbcx: wb_ctxt, v: wb_vt) { - if !wbcx.success { ret; } + if !wbcx.success { return; } let var_id = lookup_local(wbcx.fcx, l.span, l.node.id); let var_ty = ty::mk_var(wbcx.fcx.tcx(), var_id); alt resolve_type(wbcx.fcx.infcx, var_ty, resolve_all | force_all) { @@ -170,7 +170,7 @@ fn resolve_type_vars_in_expr(fcx: @fn_ctxt, e: @ast::expr) -> bool { if wbcx.success { infer::resolve_borrowings(fcx.infcx); } - ret wbcx.success; + return wbcx.success; } fn resolve_type_vars_in_fn(fcx: @fn_ctxt, @@ -185,5 +185,5 @@ fn resolve_type_vars_in_fn(fcx: @fn_ctxt, if wbcx.success { infer::resolve_borrowings(fcx.infcx); } - ret wbcx.success; + return wbcx.success; } diff --git a/src/rustc/middle/typeck/coherence.rs b/src/rustc/middle/typeck/coherence.rs index af074ddb7ab..4de713030d9 100644 --- a/src/rustc/middle/typeck/coherence.rs +++ b/src/rustc/middle/typeck/coherence.rs @@ -90,14 +90,14 @@ fn get_base_type_def_id(inference_context: infer_ctxt, alt get_base_type(inference_context, span, original_type) { none { - ret none; + return none; } some(base_type) { alt get(base_type).struct { ty_enum(def_id, _) | ty_class(def_id, _) | ty_trait(def_id, _) { - ret some(def_id); + return some(def_id); } _ { fail ~"get_base_type() returned a type that wasn't an \ @@ -319,7 +319,8 @@ class CoherenceChecker { let monotype_a = self.universally_quantify_polytype(polytype_a); let monotype_b = self.universally_quantify_polytype(polytype_b); - ret mk_subty(self.inference_context, monotype_a, monotype_b).is_ok() + return + mk_subty(self.inference_context, monotype_a, monotype_b).is_ok() || mk_subty(self.inference_context, monotype_b, monotype_a).is_ok(); } @@ -341,13 +342,13 @@ class CoherenceChecker { tps: type_parameters }; - ret subst(self.crate_context.tcx, substitutions, polytype.ty); + return subst(self.crate_context.tcx, substitutions, polytype.ty); } fn get_self_type_for_implementation(implementation: @Impl) -> ty_param_bounds_and_ty { - ret self.crate_context.tcx.tcache.get(implementation.did); + return self.crate_context.tcx.tcache.get(implementation.did); } // Privileged scope checking @@ -480,7 +481,7 @@ class CoherenceChecker { } } - ret results; + return results; } // Converts an implementation in the AST to an Impl structure. @@ -497,7 +498,7 @@ class CoherenceChecker { }); } - ret @{ + return @{ did: local_def(item.id), ident: item.ident, methods: methods @@ -521,7 +522,7 @@ class CoherenceChecker { } } - ret @{ + return @{ did: local_def(item.id), ident: item.ident, methods: methods @@ -539,7 +540,7 @@ class CoherenceChecker { assert implementation.did.crate == local_crate; alt self.crate_context.tcx.items.find(implementation.did.node) { some(node_item(item, _)) { - ret item.span; + return item.span; } _ { self.crate_context.tcx.sess.bug(~"span_of_impl() called on \ diff --git a/src/rustc/middle/typeck/collect.rs b/src/rustc/middle/typeck/collect.rs index 3cbd82cc683..aab71d1b72b 100644 --- a/src/rustc/middle/typeck/collect.rs +++ b/src/rustc/middle/typeck/collect.rs @@ -190,7 +190,7 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span, if impl_m.tps != if_m.tps { tcx.sess.span_err(sp, ~"method `" + *if_m.ident + ~"` has an incompatible set of type parameters"); - ret; + return; } if vec::len(impl_m.fty.inputs) != vec::len(if_m.fty.inputs) { @@ -199,7 +199,7 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span, *if_m.ident, vec::len(impl_m.fty.inputs), vec::len(if_m.fty.inputs)}); - ret; + return; } // Perform substitutions so that the trait/impl methods are expressed @@ -230,7 +230,7 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span, require_same_types( tcx, none, sp, impl_fty, if_fty, || ~"method `" + *if_m.ident + ~"` has an incompatible type"); - ret; + return; // Replaces bound references to the self region with `with_r`. fn replace_bound_self(tcx: ty::ctxt, ty: ty::t, @@ -485,7 +485,7 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item) let def_id = local_def(it.id); let tcx = ccx.tcx; alt tcx.tcache.find(def_id) { - some(tpt) { ret tpt; } + some(tpt) { return tpt; } _ {} } let rp = tcx.region_paramd_items.contains_key(it.id); @@ -494,7 +494,7 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item) let typ = ccx.to_ty(empty_rscope, t); let tpt = no_params(typ); tcx.tcache.insert(local_def(it.id), tpt); - ret tpt; + return tpt; } ast::item_fn(decl, tps, _) { let bounds = ty_param_bounds(ccx, tps); @@ -506,11 +506,11 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item) debug!{"type of %s (id %d) is %s", *it.ident, it.id, ty_to_str(tcx, tpt.ty)}; ccx.tcx.tcache.insert(local_def(it.id), tpt); - ret tpt; + return tpt; } ast::item_ty(t, tps) { alt tcx.tcache.find(local_def(it.id)) { - some(tpt) { ret tpt; } + some(tpt) { return tpt; } none { } } @@ -530,7 +530,7 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item) }; tcx.tcache.insert(local_def(it.id), tpt); - ret tpt; + return tpt; } ast::item_enum(_, tps) { // Create a new generic polytype. @@ -538,21 +538,21 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item) let t = ty::mk_enum(tcx, local_def(it.id), substs); let tpt = {bounds: bounds, rp: rp, ty: t}; tcx.tcache.insert(local_def(it.id), tpt); - ret tpt; + return tpt; } ast::item_trait(tps, ms) { let {bounds, substs} = mk_substs(ccx, tps, rp); let t = ty::mk_trait(tcx, local_def(it.id), substs); let tpt = {bounds: bounds, rp: rp, ty: t}; tcx.tcache.insert(local_def(it.id), tpt); - ret tpt; + return tpt; } ast::item_class(tps, _, _, _, _) { let {bounds,substs} = mk_substs(ccx, tps, rp); let t = ty::mk_class(tcx, local_def(it.id), substs); let tpt = {bounds: bounds, rp: rp, ty: t}; tcx.tcache.insert(local_def(it.id), tpt); - ret tpt; + return tpt; } ast::item_impl(*) | ast::item_mod(_) | ast::item_foreign_mod(_) { fail; } @@ -564,7 +564,7 @@ fn ty_of_foreign_item(ccx: @crate_ctxt, it: @ast::foreign_item) -> ty::ty_param_bounds_and_ty { alt it.node { ast::foreign_item_fn(fn_decl, params) { - ret ty_of_foreign_fn_decl(ccx, fn_decl, params, + return ty_of_foreign_fn_decl(ccx, fn_decl, params, local_def(it.id)); } } @@ -627,7 +627,7 @@ fn ty_of_foreign_fn_decl(ccx: @crate_ctxt, ret_style: ast::return_val}); let tpt = {bounds: bounds, rp: false, ty: t_fn}; ccx.tcx.tcache.insert(def_id, tpt); - ret tpt; + return tpt; } fn mk_ty_params(ccx: @crate_ctxt, atps: ~[ast::ty_param]) diff --git a/src/rustc/middle/typeck/infer.rs b/src/rustc/middle/typeck/infer.rs index 68420c32de4..b1ad11327a7 100644 --- a/src/rustc/middle/typeck/infer.rs +++ b/src/rustc/middle/typeck/infer.rs @@ -233,17 +233,17 @@ fn single_type_contained_in(tcx: ty::ctxt, a: int_ty_set) -> option<ty::t> { debug!{"single_type_contained_in(a=%s)", uint::to_str(*a, 10u)}; - if *a == INT_TY_SET_i8 { ret some(ty::mk_i8(tcx)); } - if *a == INT_TY_SET_u8 { ret some(ty::mk_u8(tcx)); } - if *a == INT_TY_SET_i16 { ret some(ty::mk_i16(tcx)); } - if *a == INT_TY_SET_u16 { ret some(ty::mk_u16(tcx)); } - if *a == INT_TY_SET_i32 { ret some(ty::mk_i32(tcx)); } - if *a == INT_TY_SET_u32 { ret some(ty::mk_u32(tcx)); } - if *a == INT_TY_SET_i64 { ret some(ty::mk_i64(tcx)); } - if *a == INT_TY_SET_u64 { ret some(ty::mk_u64(tcx)); } - if *a == INT_TY_SET_i { ret some(ty::mk_int(tcx)); } - if *a == INT_TY_SET_u { ret some(ty::mk_uint(tcx)); } - ret none; + if *a == INT_TY_SET_i8 { return some(ty::mk_i8(tcx)); } + if *a == INT_TY_SET_u8 { return some(ty::mk_u8(tcx)); } + if *a == INT_TY_SET_i16 { return some(ty::mk_i16(tcx)); } + if *a == INT_TY_SET_u16 { return some(ty::mk_u16(tcx)); } + if *a == INT_TY_SET_i32 { return some(ty::mk_i32(tcx)); } + if *a == INT_TY_SET_u32 { return some(ty::mk_u32(tcx)); } + if *a == INT_TY_SET_i64 { return some(ty::mk_i64(tcx)); } + if *a == INT_TY_SET_u64 { return some(ty::mk_u64(tcx)); } + if *a == INT_TY_SET_i { return some(ty::mk_int(tcx)); } + if *a == INT_TY_SET_u { return some(ty::mk_uint(tcx)); } + return none; } fn convert_integral_ty_to_int_ty_set(tcx: ty::ctxt, t: ty::t) @@ -594,7 +594,7 @@ impl transaction_methods for infer_ctxt { self.tvb.bindings = ~[]; self.rb.bindings = ~[]; - ret r; + return r; } /// Execute `f`, unroll bindings on failure @@ -615,7 +615,7 @@ impl transaction_methods for infer_ctxt { while self.borrowings.len() != bl { self.borrowings.pop(); } } } - ret r; + return r; } /// Execute `f` then unroll any bindings it creates @@ -625,7 +625,7 @@ impl transaction_methods for infer_ctxt { let r <- f(); rollback_to(self.tvb, 0u); rollback_to(self.rb, 0u); - ret r; + return r; } } @@ -635,7 +635,7 @@ impl methods for infer_ctxt { *self.ty_var_counter += 1u; self.tvb.vals.insert(id, root({lb: none, ub: none}, 0u)); - ret tv_vid(id); + return tv_vid(id); } fn next_ty_var() -> ty::t { @@ -652,7 +652,7 @@ impl methods for infer_ctxt { self.tvib.vals.insert(id, root(int_ty_set_all(), 0u)); - ret tvi_vid(id); + return tvi_vid(id); } fn next_ty_var_integral() -> ty::t { @@ -663,7 +663,7 @@ impl methods for infer_ctxt { let id = *self.region_var_counter; *self.region_var_counter += 1u; self.rb.vals.insert(id, root(bnds, 0)); - ret region_vid(id); + return region_vid(id); } fn next_region_var_with_scope_lb(scope_id: ast::node_id) -> ty::region { @@ -686,15 +686,15 @@ impl methods for infer_ctxt { fn resolve_type_vars_if_possible(typ: ty::t) -> ty::t { alt resolve_type(self, typ, resolve_all) { - result::ok(new_type) { ret new_type; } - result::err(_) { ret typ; } + result::ok(new_type) { return new_type; } + result::err(_) { return typ; } } } fn resolve_region_if_possible(oldr: ty::region) -> ty::region { alt resolve_region(self, oldr, resolve_all) { - result::ok(newr) { ret newr; } - result::err(_) { ret oldr; } + result::ok(newr) { return newr; } + result::err(_) { return oldr; } } } } @@ -859,7 +859,7 @@ impl unify_methods for infer_ctxt { a_id.to_str(), a_bounds.to_str(self), b_id.to_str(), b_bounds.to_str(self)}; - if a_id == b_id { ret uok(); } + if a_id == b_id { return uok(); } // If both A's UB and B's LB have already been bound to types, // see if we can make those types subtypes. @@ -867,7 +867,7 @@ impl unify_methods for infer_ctxt { (some(a_ub), some(b_lb)) { let r = self.try(|| a_ub.sub(self, b_lb)); alt r { - ok(()) { ret result::ok(()); } + ok(()) { return result::ok(()); } err(_) { /*fallthrough */ } } } @@ -921,13 +921,13 @@ impl unify_methods for infer_ctxt { // If we're already dealing with the same two variables, // there's nothing to do. - if a_id == b_id { ret uok(); } + if a_id == b_id { return uok(); } // Otherwise, take the intersection of the two sets of // possible types. let intersection = intersection(a_pt, b_pt); if *intersection == INT_TY_SET_EMPTY { - ret err(ty::terr_no_integral_type); + return err(ty::terr_no_integral_type); } // Rank optimization @@ -985,7 +985,7 @@ impl unify_methods for infer_ctxt { intersection(a_pt, convert_integral_ty_to_int_ty_set( self.tcx, b)); if *intersection == INT_TY_SET_EMPTY { - ret err(ty::terr_no_integral_type); + return err(ty::terr_no_integral_type); } self.set(vb, a_id, root(intersection, nde_a.rank)); uok() @@ -1021,7 +1021,7 @@ impl unify_methods for infer_ctxt { intersection(b_pt, convert_integral_ty_to_int_ty_set( self.tcx, a)); if *intersection == INT_TY_SET_EMPTY { - ret err(ty::terr_no_integral_type); + return err(ty::terr_no_integral_type); } self.set(vb, b_id, root(intersection, nde_b.rank)); uok() @@ -1156,9 +1156,9 @@ impl methods for resolve_state { debug!{"Resolved to %s (modes=%x)", ty_to_str(self.infcx.tcx, rty), self.modes}; - ret ok(rty); + return ok(rty); } - some(e) { ret err(e); } + some(e) { return err(e); } } } @@ -1174,7 +1174,7 @@ impl methods for resolve_state { fn resolve_type(typ: ty::t) -> ty::t { debug!{"resolve_type(%s)", typ.to_str(self.infcx)}; indent(fn&() -> ty::t { - if !ty::type_needs_infer(typ) { ret typ; } + if !ty::type_needs_infer(typ) { return typ; } alt ty::get(typ).struct { ty::ty_var(vid) { @@ -1219,7 +1219,7 @@ impl methods for resolve_state { fn resolve_region_var(rid: region_vid) -> ty::region { if !self.should(resolve_rvar) { - ret ty::re_var(rid) + return ty::re_var(rid) } let nde = self.infcx.get(self.infcx.rb, rid); let bounds = nde.possible_types; @@ -1247,7 +1247,7 @@ impl methods for resolve_state { fn resolve_ty_var(vid: tv_vid) -> ty::t { if vec::contains(self.v_seen, vid) { self.err = some(cyclic_ty(vid)); - ret ty::mk_var(self.infcx.tcx, vid); + return ty::mk_var(self.infcx.tcx, vid); } else { vec::push(self.v_seen, vid); let tcx = self.infcx.tcx; @@ -1273,13 +1273,13 @@ impl methods for resolve_state { } }; vec::pop(self.v_seen); - ret t1; + return t1; } } fn resolve_ty_var_integral(vid: tvi_vid) -> ty::t { if !self.should(resolve_ivar) { - ret ty::mk_var_integral(self.infcx.tcx, vid); + return ty::mk_var_integral(self.infcx.tcx, vid); } let nde = self.infcx.get(self.infcx.tvib, vid); @@ -1938,7 +1938,7 @@ impl of combine for sub { debug!{"mts(%s <: %s)", a.to_str(*self), b.to_str(*self)}; if a.mutbl != b.mutbl && b.mutbl != m_const { - ret err(ty::terr_mutability); + return err(ty::terr_mutability); } alt b.mutbl { @@ -1975,7 +1975,7 @@ impl of combine for sub { fn tys(a: ty::t, b: ty::t) -> cres<ty::t> { debug!{"%s.tys(%s, %s)", self.tag(), a.to_str(*self), b.to_str(*self)}; - if a == b { ret ok(a); } + if a == b { return ok(a); } do indent { alt (ty::get(a).struct, ty::get(b).struct) { (ty::ty_bot, _) { @@ -2146,7 +2146,7 @@ impl of combine for lub { } fn contraregions(a: ty::region, b: ty::region) -> cres<ty::region> { - ret glb(self.infcx()).regions(a, b); + return glb(self.infcx()).regions(a, b); } fn regions(a: ty::region, b: ty::region) -> cres<ty::region> { @@ -2489,7 +2489,7 @@ fn lattice_tys<L:lattice_ops combine>( debug!{"%s.lattice_tys(%s, %s)", self.tag(), a.to_str(self.infcx()), b.to_str(self.infcx())}; - if a == b { ret ok(a); } + if a == b { return ok(a); } do indent { alt (ty::get(a).struct, ty::get(b).struct) { (ty::ty_bot, _) { self.ty_bot(b) } @@ -2568,7 +2568,7 @@ fn lattice_vars<V:copy vid, T:copy to_str st, L:lattice_ops combine>( b_vid.to_str(), b_bounds.to_str(self.infcx())}; if a_vid == b_vid { - ret ok(a_t); + return ok(a_t); } // If both A and B have an UB type, then we can just compute the @@ -2577,7 +2577,7 @@ fn lattice_vars<V:copy vid, T:copy to_str st, L:lattice_ops combine>( alt (a_bnd, b_bnd) { (some(a_ty), some(b_ty)) { alt self.infcx().try(|| c_ts(a_ty, b_ty) ) { - ok(t) { ret ok(t); } + ok(t) { return ok(t); } err(_) { /*fallthrough */ } } } @@ -2610,7 +2610,7 @@ fn lattice_var_t<V:copy vid, T:copy to_str st, L:lattice_ops combine>( some(a_bnd) { // If a has an upper bound, return the LUB(a.ub, b) debug!{"bnd=some(%s)", a_bnd.to_str(self.infcx())}; - ret c_ts(a_bnd, b); + return c_ts(a_bnd, b); } none { // If a does not have an upper bound, make b the upper bound of a diff --git a/src/rustc/util/common.rs b/src/rustc/util/common.rs index b9f4d3d76ae..ff4baccc42e 100644 --- a/src/rustc/util/common.rs +++ b/src/rustc/util/common.rs @@ -11,7 +11,7 @@ fn indent<R>(op: fn() -> R) -> R { debug!{">>"}; let r <- op(); debug!{"<< (Result = %?)", r}; - ret r; + return r; } class _indenter { @@ -27,12 +27,12 @@ fn indenter() -> _indenter { type flag = hashmap<~str, ()>; -fn field_expr(f: ast::field) -> @ast::expr { ret f.node.expr; } +fn field_expr(f: ast::field) -> @ast::expr { return f.node.expr; } fn field_exprs(fields: ~[ast::field]) -> ~[@ast::expr] { let mut es = ~[]; for fields.each |f| { vec::push(es, f.node.expr); } - ret es; + return es; } // Takes a predicate p, returns true iff p is true for any subexpressions @@ -52,7 +52,7 @@ fn loop_query(b: ast::blk, p: fn@(ast::expr_) -> bool) -> bool { let v = visit::mk_vt(@{visit_expr: visit_expr with *visit::default_visitor()}); visit::visit_block(b, rs, v); - ret *rs; + return *rs; } fn has_nonlocal_exits(b: ast::blk) -> bool { @@ -68,7 +68,7 @@ fn may_break(b: ast::blk) -> bool { } fn local_rhs_span(l: @ast::local, def: span) -> span { - alt l.node.init { some(i) { ret i.expr.span; } _ { ret def; } } + alt l.node.init { some(i) { return i.expr.span; } _ { return def; } } } fn is_main_name(path: syntax::ast_map::path) -> bool { diff --git a/src/rustc/util/ppaux.rs b/src/rustc/util/ppaux.rs index f6f0cf8b363..7fb7d4c83cb 100644 --- a/src/rustc/util/ppaux.rs +++ b/src/rustc/util/ppaux.rs @@ -25,7 +25,7 @@ import driver::session::session; /// that attempts to explain a lifetime in a way it might plausibly be /// understood. fn explain_region(cx: ctxt, region: ty::region) -> ~str { - ret alt region { + return alt region { re_scope(node_id) => { let scope_str = alt cx.items.find(node_id) { some(ast_map::node_block(blk)) => { @@ -167,7 +167,7 @@ fn mt_to_str(cx: ctxt, m: mt) -> ~str { ast::m_imm { ~"" } ast::m_const { ~"const " } }; - ret mstr + ty_to_str(cx, m.ty); + return mstr + ty_to_str(cx, m.ty); } fn vstore_to_str(cx: ctxt, vs: ty::vstore) -> ~str { @@ -234,25 +234,25 @@ fn ty_to_str(cx: ctxt, typ: t) -> ~str { ast::return_val { s += ty_to_str(cx, output); } } } - ret s; + return s; } fn method_to_str(cx: ctxt, m: method) -> ~str { - ret fn_to_str( + return fn_to_str( cx, m.fty.purity, m.fty.proto, some(m.ident), m.fty.inputs, m.fty.output, m.fty.ret_style) + ~";"; } fn field_to_str(cx: ctxt, f: field) -> ~str { - ret *f.ident + ~": " + mt_to_str(cx, f.mt); + return *f.ident + ~": " + mt_to_str(cx, f.mt); } // if there is an id, print that instead of the structural type: for ty::type_def_id(typ).each |def_id| { // note that this typedef cannot have type parameters - ret ast_map::path_to_str(ty::item_path(cx, def_id)); + return ast_map::path_to_str(ty::item_path(cx, def_id)); } // pretty print the structural type representation: - ret alt ty::get(typ).struct { + return alt ty::get(typ).struct { ty_nil { ~"()" } ty_bot { ~"_|_" } ty_bool { ~"bool" } @@ -340,7 +340,7 @@ fn parameterized(cx: ctxt, fn ty_to_short_str(cx: ctxt, typ: t) -> ~str { let mut s = encoder::encoded_ty(cx, typ); if str::len(s) >= 32u { s = str::slice(s, 0u, 32u); } - ret s; + return s; } // Local Variables: |