From 7295a6da92ac4bfcbc714848bd611dae54df0b67 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Philipp=20Br=C3=BCschweiler?= Date: Thu, 27 Jun 2013 15:04:22 +0200 Subject: [PATCH] Remove many shared pointers Mostly just low-haning fruit, i.e. function arguments that were @ even though & would work just as well. Reduces librustc.so size by 200k when compiling without -O, by 100k when compiling with -O. --- src/librustc/driver/driver.rs | 24 ++-- src/librustc/driver/session.rs | 2 +- src/librustc/front/config.rs | 13 +- src/librustc/front/std_inject.rs | 4 +- src/librustc/front/test.rs | 2 +- src/librustc/metadata/creader.rs | 30 ++--- src/librustc/middle/borrowck/mod.rs | 6 +- src/librustc/middle/check_const.rs | 2 +- src/librustc/middle/check_loop.rs | 2 +- src/librustc/middle/check_match.rs | 32 ++--- src/librustc/middle/const_eval.rs | 20 +-- src/librustc/middle/effect.rs | 2 +- src/librustc/middle/entry.rs | 2 +- src/librustc/middle/freevars.rs | 2 +- src/librustc/middle/kind.rs | 13 +- src/librustc/middle/lang_items.rs | 135 ++++++++++----------- src/librustc/middle/lint.rs | 12 +- src/librustc/middle/liveness.rs | 18 +-- src/librustc/middle/moves.rs | 4 +- src/librustc/middle/pat_util.rs | 2 +- src/librustc/middle/privacy.rs | 2 +- src/librustc/middle/region.rs | 104 +++++++--------- src/librustc/middle/trans/_match.rs | 8 +- src/librustc/middle/trans/base.rs | 17 ++- src/librustc/middle/trans/block.rs | 0 src/librustc/middle/trans/closure.rs | 2 +- src/librustc/middle/trans/common.rs | 13 +- src/librustc/middle/trans/consts.rs | 17 +-- src/librustc/middle/trans/controlflow.rs | 2 +- src/librustc/middle/trans/datum.rs | 2 +- src/librustc/middle/trans/expr.rs | 28 ++--- src/librustc/middle/trans/foreign.rs | 14 +-- src/librustc/middle/trans/glue.rs | 21 ++-- src/librustc/middle/trans/meth.rs | 8 +- src/librustc/middle/trans/reflect.rs | 92 +++++++------- src/librustc/middle/trans/tvec.rs | 12 +- src/librustc/middle/trans/type_use.rs | 16 +-- src/librustc/middle/ty.rs | 20 +-- src/librustc/middle/typeck/astconv.rs | 2 +- src/librustc/middle/typeck/check/method.rs | 4 +- src/librustc/middle/typeck/check/mod.rs | 2 +- src/librustc/middle/typeck/coherence.rs | 14 +-- src/librustc/middle/typeck/collect.rs | 26 ++-- src/librustc/middle/typeck/mod.rs | 18 +-- src/librustpkg/util.rs | 2 +- src/libsyntax/ast_map.rs | 2 +- src/libsyntax/ast_util.rs | 6 +- src/libsyntax/ext/deriving/cmp/totaleq.rs | 2 - src/libsyntax/ext/expand.rs | 4 +- src/libsyntax/visit.rs | 28 ++--- 50 files changed, 388 insertions(+), 427 deletions(-) delete mode 100644 src/librustc/middle/trans/block.rs diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index f6b05711c13db..8caf7d9a8e92e 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -181,12 +181,12 @@ pub fn compile_rest(sess: Session, let time_passes = sess.time_passes(); - let mut crate_opt = curr; + let mut crate = curr.unwrap(); if phases.from == cu_parse || phases.from == cu_everything { *sess.building_library = session::building_library( - sess.opts.crate_type, crate_opt.unwrap(), sess.opts.test); + sess.opts.crate_type, crate, sess.opts.test); // strip before expansion to allow macros to depend on // configuration variables e.g/ in @@ -195,27 +195,25 @@ pub fn compile_rest(sess: Session, // mod bar { macro_rules! baz!(() => {{}}) } // // baz! should not use this definition unless foo is enabled. - crate_opt = Some(time(time_passes, ~"configuration 1", || - front::config::strip_unconfigured_items(crate_opt.unwrap()))); + crate = time(time_passes, ~"configuration 1", || + front::config::strip_unconfigured_items(crate)); - crate_opt = Some(time(time_passes, ~"expansion", || + crate = time(time_passes, ~"expansion", || syntax::ext::expand::expand_crate(sess.parse_sess, copy cfg, - crate_opt.unwrap()))); + crate)); // strip again, in case expansion added anything with a #[cfg]. - crate_opt = Some(time(time_passes, ~"configuration 2", || - front::config::strip_unconfigured_items(crate_opt.unwrap()))); + crate = time(time_passes, ~"configuration 2", || + front::config::strip_unconfigured_items(crate)); - crate_opt = Some(time(time_passes, ~"maybe building test harness", || - front::test::modify_for_testing(sess, crate_opt.unwrap()))); + crate = time(time_passes, ~"maybe building test harness", || + front::test::modify_for_testing(sess, crate)); } - if phases.to == cu_expand { return (crate_opt, None); } + if phases.to == cu_expand { return (Some(crate), None); } assert!(phases.from != cu_no_trans); - let mut crate = crate_opt.unwrap(); - let (llcx, llmod, link_meta) = { crate = time(time_passes, ~"extra injection", || front::std_inject::maybe_inject_libstd_ref(sess, crate)); diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs index 73e8cfea8ca20..b5eb351a8a589 100644 --- a/src/librustc/driver/session.rs +++ b/src/librustc/driver/session.rs @@ -349,7 +349,7 @@ pub fn expect(sess: Session, } pub fn building_library(req_crate_type: crate_type, - crate: @ast::crate, + crate: &ast::crate, testing: bool) -> bool { match req_crate_type { bin_crate => false, diff --git a/src/librustc/front/config.rs b/src/librustc/front/config.rs index 71375966a28b7..43098b98ea3b5 100644 --- a/src/librustc/front/config.rs +++ b/src/librustc/front/config.rs @@ -24,11 +24,11 @@ struct Context { // any items that do not belong in the current configuration pub fn strip_unconfigured_items(crate: @ast::crate) -> @ast::crate { do strip_items(crate) |attrs| { - in_cfg(/*bad*/copy crate.node.config, attrs) + in_cfg(crate.node.config, attrs) } } -pub fn strip_items(crate: @ast::crate, in_cfg: in_cfg_pred) +pub fn strip_items(crate: &ast::crate, in_cfg: in_cfg_pred) -> @ast::crate { let ctxt = @Context { in_cfg: in_cfg }; @@ -44,8 +44,7 @@ pub fn strip_items(crate: @ast::crate, in_cfg: in_cfg_pred) .. *fold::default_ast_fold()}; let fold = fold::make_fold(precursor); - let res = @fold.fold_crate(&*crate); - return res; + @fold.fold_crate(crate) } fn filter_item(cx: @Context, item: @ast::item) -> @@ -183,12 +182,12 @@ fn trait_method_in_cfg(cx: @Context, meth: &ast::trait_method) -> bool { // Determine if an item should be translated in the current crate // configuration based on the item's attributes -fn in_cfg(cfg: ast::crate_cfg, attrs: ~[ast::attribute]) -> bool { +fn in_cfg(cfg: &[@ast::meta_item], attrs: &[ast::attribute]) -> bool { metas_in_cfg(cfg, attr::attr_metas(attrs)) } -pub fn metas_in_cfg(cfg: ast::crate_cfg, - metas: ~[@ast::meta_item]) -> bool { +pub fn metas_in_cfg(cfg: &[@ast::meta_item], + metas: &[@ast::meta_item]) -> bool { // The "cfg" attributes on the item let cfg_metas = attr::find_meta_items_by_name(metas, "cfg"); diff --git a/src/librustc/front/std_inject.rs b/src/librustc/front/std_inject.rs index 38a21af65b93f..a86e7c5e39b3a 100644 --- a/src/librustc/front/std_inject.rs +++ b/src/librustc/front/std_inject.rs @@ -30,11 +30,11 @@ pub fn maybe_inject_libstd_ref(sess: Session, crate: @ast::crate) } } -fn use_std(crate: @ast::crate) -> bool { +fn use_std(crate: &ast::crate) -> bool { !attr::attrs_contains_name(crate.node.attrs, "no_std") } -fn inject_libstd_ref(sess: Session, crate: @ast::crate) -> @ast::crate { +fn inject_libstd_ref(sess: Session, crate: &ast::crate) -> @ast::crate { fn spanned(x: T) -> codemap::spanned { codemap::spanned { node: x, span: dummy_sp() } } diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index c9eb97b44cd70..97f1b3997ddc4 100644 --- a/src/librustc/front/test.rs +++ b/src/librustc/front/test.rs @@ -92,7 +92,7 @@ fn generate_test_harness(sess: session::Session, return res; } -fn strip_test_functions(crate: @ast::crate) -> @ast::crate { +fn strip_test_functions(crate: &ast::crate) -> @ast::crate { // When not compiling with --test we should not compile the // #[test] functions do config::strip_items(crate) |attrs| { diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 2743cd1ddc1e7..5e36b8fddcc71 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -18,7 +18,6 @@ use metadata::filesearch::FileSearch; use metadata::loader; use core::hashmap::HashMap; -use core::vec; use syntax::attr; use syntax::codemap::{span, dummy_sp}; use syntax::diagnostic::span_handler; @@ -30,7 +29,7 @@ use syntax::ast; // Traverses an AST, reading all the information about use'd crates and extern // libraries necessary for later resolving, typechecking, linking, etc. pub fn read_crates(diag: @span_handler, - crate: @ast::crate, + crate: &ast::crate, cstore: @mut cstore::CStore, filesearch: @FileSearch, os: loader::os, @@ -53,8 +52,8 @@ pub fn read_crates(diag: @span_handler, .. *visit::default_simple_visitor()}); visit_crate(e, crate); visit::visit_crate(crate, ((), v)); - dump_crates(e.crate_cache); - warn_if_multiple_versions(e, diag, e.crate_cache); + dump_crates(*e.crate_cache); + warn_if_multiple_versions(e, diag, *e.crate_cache); } struct cache_entry { @@ -64,7 +63,7 @@ struct cache_entry { metas: @~[@ast::meta_item] } -fn dump_crates(crate_cache: @mut ~[cache_entry]) { +fn dump_crates(crate_cache: &[cache_entry]) { debug!("resolved crates:"); for crate_cache.iter().advance |entry| { debug!("cnum: %?", entry.cnum); @@ -75,11 +74,9 @@ fn dump_crates(crate_cache: @mut ~[cache_entry]) { fn warn_if_multiple_versions(e: @mut Env, diag: @span_handler, - crate_cache: @mut ~[cache_entry]) { + crate_cache: &[cache_entry]) { use core::either::*; - let crate_cache = &mut *crate_cache; - if crate_cache.len() != 0u { let name = loader::crate_name_from_metas( *crate_cache[crate_cache.len() - 1].metas @@ -111,7 +108,7 @@ fn warn_if_multiple_versions(e: @mut Env, } } - warn_if_multiple_versions(e, diag, @mut non_matches); + warn_if_multiple_versions(e, diag, non_matches); } } @@ -126,7 +123,7 @@ struct Env { intr: @ident_interner } -fn visit_crate(e: @mut Env, c: &ast::crate) { +fn visit_crate(e: &Env, c: &ast::crate) { let cstore = e.cstore; let link_args = attr::find_attrs_by_name(c.node.attrs, "link_args"); @@ -152,7 +149,7 @@ fn visit_view_item(e: @mut Env, i: @ast::view_item) { } } -fn visit_item(e: @mut Env, i: @ast::item) { +fn visit_item(e: &Env, i: @ast::item) { match i.node { ast::item_foreign_mod(ref fm) => { if fm.abis.is_rust() || fm.abis.is_intrinsic() { @@ -204,14 +201,13 @@ fn visit_item(e: @mut Env, i: @ast::item) { } } -fn metas_with(ident: @str, key: @str, metas: ~[@ast::meta_item]) +fn metas_with(ident: @str, key: @str, mut metas: ~[@ast::meta_item]) -> ~[@ast::meta_item] { let name_items = attr::find_meta_items_by_name(metas, key); if name_items.is_empty() { - vec::append_one(metas, attr::mk_name_value_item_str(key, ident)) - } else { - metas + metas.push(attr::mk_name_value_item_str(key, ident)); } + metas } fn metas_with_ident(ident: @str, metas: ~[@ast::meta_item]) @@ -219,11 +215,11 @@ fn metas_with_ident(ident: @str, metas: ~[@ast::meta_item]) metas_with(ident, @"name", metas) } -fn existing_match(e: @mut Env, metas: &[@ast::meta_item], hash: @str) +fn existing_match(e: &Env, metas: &[@ast::meta_item], hash: &str) -> Option { for e.crate_cache.iter().advance |c| { if loader::metadata_matches(*c.metas, metas) - && (hash.is_empty() || c.hash == hash) { + && (hash.is_empty() || c.hash.as_slice() == hash) { return Some(c.cnum); } } diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index 745e792eec755..f22edd2e1d64c 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -58,7 +58,7 @@ pub fn check_crate( moves_map: moves::MovesMap, moved_variables_set: moves::MovedVariablesSet, capture_map: moves::CaptureMap, - crate: @ast::crate) -> (root_map, write_guard_map) + crate: &ast::crate) -> (root_map, write_guard_map) { let bccx = @BorrowckCtxt { tcx: tcx, @@ -507,7 +507,7 @@ impl BorrowckCtxt { pub fn report_use_of_moved_value(&self, use_span: span, use_kind: MovedValueUseKind, - lp: @LoanPath, + lp: &LoanPath, move: &move_data::Move, moved_lp: @LoanPath) { let verb = match use_kind { @@ -570,7 +570,7 @@ impl BorrowckCtxt { pub fn report_reassigned_immutable_variable(&self, span: span, - lp: @LoanPath, + lp: &LoanPath, assign: &move_data::Assignment) { self.tcx.sess.span_err( diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 2fa25b10f6051..2c6ba79e96e45 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -21,7 +21,7 @@ use syntax::codemap; use syntax::{visit, ast_util, ast_map}; pub fn check_crate(sess: Session, - crate: @crate, + crate: &crate, ast_map: ast_map::map, def_map: resolve::DefMap, method_map: typeck::method_map, diff --git a/src/librustc/middle/check_loop.rs b/src/librustc/middle/check_loop.rs index 2ed7b7adecc1a..190602e815d3d 100644 --- a/src/librustc/middle/check_loop.rs +++ b/src/librustc/middle/check_loop.rs @@ -19,7 +19,7 @@ pub struct Context { can_ret: bool } -pub fn check_crate(tcx: ty::ctxt, crate: @crate) { +pub fn check_crate(tcx: ty::ctxt, crate: &crate) { visit::visit_crate(crate, (Context { in_loop: false, can_ret: true }, visit::mk_vt(@visit::Visitor { diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index b4c8a6b19c29f..e2ab3247c19c1 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -36,7 +36,7 @@ pub struct MatchCheckCtxt { pub fn check_crate(tcx: ty::ctxt, method_map: method_map, moves_map: moves::MovesMap, - crate: @crate) { + crate: &crate) { let cx = @MatchCheckCtxt {tcx: tcx, method_map: method_map, moves_map: moves_map}; @@ -50,7 +50,7 @@ pub fn check_crate(tcx: ty::ctxt, tcx.sess.abort_if_errors(); } -pub fn expr_is_non_moving_lvalue(cx: @MatchCheckCtxt, expr: @expr) -> bool { +pub fn expr_is_non_moving_lvalue(cx: &MatchCheckCtxt, expr: &expr) -> bool { if !ty::expr_is_lval(cx.tcx, cx.method_map, expr) { return false; } @@ -108,7 +108,7 @@ pub fn check_expr(cx: @MatchCheckCtxt, ex: @expr, (s, v): ((), visit::vt<()>)) { } // Check for unreachable patterns -pub fn check_arms(cx: @MatchCheckCtxt, arms: &[arm]) { +pub fn check_arms(cx: &MatchCheckCtxt, arms: &[arm]) { let mut seen = ~[]; for arms.iter().advance |arm| { for arm.pats.iter().advance |pat| { @@ -131,7 +131,7 @@ pub fn raw_pat(p: @pat) -> @pat { } } -pub fn check_exhaustive(cx: @MatchCheckCtxt, sp: span, pats: ~[@pat]) { +pub fn check_exhaustive(cx: &MatchCheckCtxt, sp: span, pats: ~[@pat]) { assert!((!pats.is_empty())); let ext = match is_useful(cx, &pats.map(|p| ~[*p]), [wild()]) { not_useful => { @@ -205,7 +205,7 @@ pub enum ctor { // Note: is_useful doesn't work on empty types, as the paper notes. // So it assumes that v is non-empty. -pub fn is_useful(cx: @MatchCheckCtxt, m: &matrix, v: &[@pat]) -> useful { +pub fn is_useful(cx: &MatchCheckCtxt, m: &matrix, v: &[@pat]) -> useful { if m.len() == 0u { return useful_; } if m[0].len() == 0u { return not_useful; } let real_pat = match m.iter().find_(|r| r[0].id != 0) { @@ -281,7 +281,7 @@ pub fn is_useful(cx: @MatchCheckCtxt, m: &matrix, v: &[@pat]) -> useful { } } -pub fn is_useful_specialized(cx: @MatchCheckCtxt, +pub fn is_useful_specialized(cx: &MatchCheckCtxt, m: &matrix, v: &[@pat], ctor: ctor, @@ -297,7 +297,7 @@ pub fn is_useful_specialized(cx: @MatchCheckCtxt, } } -pub fn pat_ctor_id(cx: @MatchCheckCtxt, p: @pat) -> Option { +pub fn pat_ctor_id(cx: &MatchCheckCtxt, p: @pat) -> Option { let pat = raw_pat(p); match pat.node { pat_wild => { None } @@ -333,7 +333,7 @@ pub fn pat_ctor_id(cx: @MatchCheckCtxt, p: @pat) -> Option { } } -pub fn is_wild(cx: @MatchCheckCtxt, p: @pat) -> bool { +pub fn is_wild(cx: &MatchCheckCtxt, p: @pat) -> bool { let pat = raw_pat(p); match pat.node { pat_wild => { true } @@ -347,7 +347,7 @@ pub fn is_wild(cx: @MatchCheckCtxt, p: @pat) -> bool { } } -pub fn missing_ctor(cx: @MatchCheckCtxt, +pub fn missing_ctor(cx: &MatchCheckCtxt, m: &matrix, left_ty: ty::t) -> Option { @@ -449,7 +449,7 @@ pub fn missing_ctor(cx: @MatchCheckCtxt, } } -pub fn ctor_arity(cx: @MatchCheckCtxt, ctor: &ctor, ty: ty::t) -> uint { +pub fn ctor_arity(cx: &MatchCheckCtxt, ctor: &ctor, ty: ty::t) -> uint { match ty::get(ty).sty { ty::ty_tup(ref fs) => fs.len(), ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_rptr(*) => 1u, @@ -476,7 +476,7 @@ pub fn wild() -> @pat { @pat {id: 0, node: pat_wild, span: dummy_sp()} } -pub fn specialize(cx: @MatchCheckCtxt, +pub fn specialize(cx: &MatchCheckCtxt, r: &[@pat], ctor_id: &ctor, arity: uint, @@ -743,12 +743,12 @@ pub fn specialize(cx: @MatchCheckCtxt, } } -pub fn default(cx: @MatchCheckCtxt, r: &[@pat]) -> Option<~[@pat]> { +pub fn default(cx: &MatchCheckCtxt, r: &[@pat]) -> Option<~[@pat]> { if is_wild(cx, r[0]) { Some(vec::to_owned(r.tail())) } else { None } } -pub fn check_local(cx: @MatchCheckCtxt, +pub fn check_local(cx: &MatchCheckCtxt, loc: @local, (s, v): ((), visit::vt<()>)) { @@ -766,7 +766,7 @@ pub fn check_local(cx: @MatchCheckCtxt, check_legality_of_move_bindings(cx, is_lvalue, false, [ loc.node.pat ]); } -pub fn check_fn(cx: @MatchCheckCtxt, +pub fn check_fn(cx: &MatchCheckCtxt, kind: &visit::fn_kind, decl: &fn_decl, body: &blk, @@ -783,7 +783,7 @@ pub fn check_fn(cx: @MatchCheckCtxt, } } -pub fn is_refutable(cx: @MatchCheckCtxt, pat: &pat) -> bool { +pub fn is_refutable(cx: &MatchCheckCtxt, pat: &pat) -> bool { match cx.tcx.def_map.find(&pat.id) { Some(&def_variant(enum_id, _)) => { if ty::enum_variants(cx.tcx, enum_id).len() != 1u { @@ -821,7 +821,7 @@ pub fn is_refutable(cx: @MatchCheckCtxt, pat: &pat) -> bool { // Legality of move bindings checking -pub fn check_legality_of_move_bindings(cx: @MatchCheckCtxt, +pub fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, is_lvalue: bool, has_guard: bool, pats: &[@pat]) { diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 299d71b2567a1..df7de540ea9ad 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -75,7 +75,7 @@ pub fn join_all(cs: &[constness]) -> constness { cs.iter().fold(integral_const, |a, b| join(a, *b)) } -pub fn classify(e: @expr, +pub fn classify(e: &expr, tcx: ty::ctxt) -> constness { let did = ast_util::local_def(e.id); @@ -164,7 +164,7 @@ pub fn classify(e: @expr, } } -pub fn lookup_const(tcx: ty::ctxt, e: @expr) -> Option<@expr> { +pub fn lookup_const(tcx: ty::ctxt, e: &expr) -> Option<@expr> { match tcx.def_map.find(&e.id) { Some(&ast::def_static(def_id, false)) => lookup_const_by_id(tcx, def_id), _ => None @@ -203,7 +203,7 @@ pub fn lookup_const_by_id(tcx: ty::ctxt, } } -pub fn lookup_constness(tcx: ty::ctxt, e: @expr) -> constness { +pub fn lookup_constness(tcx: ty::ctxt, e: &expr) -> constness { match lookup_const(tcx, e) { Some(rhs) => { let ty = ty::expr_ty(tcx, rhs); @@ -217,7 +217,7 @@ pub fn lookup_constness(tcx: ty::ctxt, e: @expr) -> constness { } } -pub fn process_crate(crate: @ast::crate, +pub fn process_crate(crate: &ast::crate, tcx: ty::ctxt) { let v = visit::mk_simple_visitor(@visit::SimpleVisitor { visit_expr_post: |e| { classify(e, tcx); }, @@ -239,14 +239,14 @@ pub enum const_val { const_bool(bool) } -pub fn eval_const_expr(tcx: middle::ty::ctxt, e: @expr) -> const_val { +pub fn eval_const_expr(tcx: middle::ty::ctxt, e: &expr) -> const_val { match eval_const_expr_partial(tcx, e) { Ok(r) => r, Err(s) => tcx.sess.span_fatal(e.span, s) } } -pub fn eval_const_expr_partial(tcx: middle::ty::ctxt, e: @expr) +pub fn eval_const_expr_partial(tcx: middle::ty::ctxt, e: &expr) -> Result { use middle::ty; fn fromb(b: bool) -> Result { Ok(const_int(b as i64)) } @@ -406,7 +406,7 @@ pub fn eval_const_expr_partial(tcx: middle::ty::ctxt, e: @expr) } } -pub fn lit_to_const(lit: @lit) -> const_val { +pub fn lit_to_const(lit: &lit) -> const_val { match lit.node { lit_str(s) => const_str(s), lit_int(n, _) => const_int(n), @@ -434,14 +434,14 @@ pub fn compare_const_vals(a: &const_val, b: &const_val) -> Option { } } -pub fn compare_lit_exprs(tcx: middle::ty::ctxt, a: @expr, b: @expr) -> Option { +pub fn compare_lit_exprs(tcx: middle::ty::ctxt, a: &expr, b: &expr) -> Option { compare_const_vals(&eval_const_expr(tcx, a), &eval_const_expr(tcx, b)) } -pub fn lit_expr_eq(tcx: middle::ty::ctxt, a: @expr, b: @expr) -> Option { +pub fn lit_expr_eq(tcx: middle::ty::ctxt, a: &expr, b: &expr) -> Option { compare_lit_exprs(tcx, a, b).map(|&val| val == 0) } -pub fn lit_eq(a: @lit, b: @lit) -> Option { +pub fn lit_eq(a: &lit, b: &lit) -> Option { compare_const_vals(&lit_to_const(a), &lit_to_const(b)).map(|&val| val == 0) } diff --git a/src/librustc/middle/effect.rs b/src/librustc/middle/effect.rs index 513b2015a834a..654cc25c15e8c 100644 --- a/src/librustc/middle/effect.rs +++ b/src/librustc/middle/effect.rs @@ -47,7 +47,7 @@ fn type_is_unsafe_function(ty: ty::t) -> bool { pub fn check_crate(tcx: ty::ctxt, method_map: method_map, - crate: @ast::crate) { + crate: &ast::crate) { let context = @mut Context { method_map: method_map, unsafe_context: SafeContext, diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs index 06feb9e7ba958..904a7ec8c871d 100644 --- a/src/librustc/middle/entry.rs +++ b/src/librustc/middle/entry.rs @@ -41,7 +41,7 @@ struct EntryContext { type EntryVisitor = vt<@mut EntryContext>; -pub fn find_entry_point(session: Session, crate: @crate, ast_map: ast_map::map) { +pub fn find_entry_point(session: Session, crate: &crate, ast_map: ast_map::map) { // FIXME #4404 android JNI hacks if *session.building_library && diff --git a/src/librustc/middle/freevars.rs b/src/librustc/middle/freevars.rs index e18143042b0ee..c2f663ae23cd8 100644 --- a/src/librustc/middle/freevars.rs +++ b/src/librustc/middle/freevars.rs @@ -88,7 +88,7 @@ fn collect_freevars(def_map: resolve::DefMap, blk: &ast::blk) // efficient as it fully recomputes the free variables at every // node of interest rather than building up the free variables in // one pass. This could be improved upon if it turns out to matter. -pub fn annotate_freevars(def_map: resolve::DefMap, crate: @ast::crate) -> +pub fn annotate_freevars(def_map: resolve::DefMap, crate: &ast::crate) -> freevar_map { let freevars = @mut HashMap::new(); diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs index a1f595fc8969f..ef96fa979727a 100644 --- a/src/librustc/middle/kind.rs +++ b/src/librustc/middle/kind.rs @@ -17,7 +17,6 @@ use middle::typeck; use util::ppaux::{Repr, ty_to_str}; use util::ppaux::UserString; -use core::vec; use syntax::ast::*; use syntax::attr::attrs_contains_name; use syntax::codemap::span; @@ -63,7 +62,7 @@ pub struct Context { pub fn check_crate(tcx: ty::ctxt, method_map: typeck::method_map, - crate: @crate) { + crate: &crate) { let ctx = Context { tcx: tcx, method_map: method_map, @@ -163,7 +162,7 @@ fn check_item(item: @item, (cx, visitor): (Context, visit::vt)) { // closure. fn with_appropriate_checker(cx: Context, id: node_id, b: &fn(checker: &fn(Context, @freevar_entry))) { - fn check_for_uniq(cx: Context, fv: @freevar_entry, bounds: ty::BuiltinBounds) { + fn check_for_uniq(cx: Context, fv: &freevar_entry, bounds: ty::BuiltinBounds) { // all captured data must be owned, regardless of whether it is // moved in or copied in. let id = ast_util::def_id_of_def(fv.def).node; @@ -175,7 +174,7 @@ fn with_appropriate_checker(cx: Context, id: node_id, check_freevar_bounds(cx, fv.span, var_t, bounds); } - fn check_for_box(cx: Context, fv: @freevar_entry, bounds: ty::BuiltinBounds) { + fn check_for_box(cx: Context, fv: &freevar_entry, bounds: ty::BuiltinBounds) { // all captured data must be owned let id = ast_util::def_id_of_def(fv.def).node; let var_t = ty::node_id_to_type(cx.tcx, id); @@ -186,7 +185,7 @@ fn with_appropriate_checker(cx: Context, id: node_id, check_freevar_bounds(cx, fv.span, var_t, bounds); } - fn check_for_block(cx: Context, fv: @freevar_entry, bounds: ty::BuiltinBounds) { + fn check_for_block(cx: Context, fv: &freevar_entry, bounds: ty::BuiltinBounds) { let id = ast_util::def_id_of_def(fv.def).node; let var_t = ty::node_id_to_type(cx.tcx, id); check_freevar_bounds(cx, fv.span, var_t, bounds); @@ -496,8 +495,8 @@ pub fn check_durable(tcx: ty::ctxt, ty: ty::t, sp: span) -> bool { /// FIXME(#5723)---This code should probably move into regionck. pub fn check_cast_for_escaping_regions( cx: Context, - source: @expr, - target: @expr) + source: &expr, + target: &expr) { // Determine what type we are casting to; if it is not an trait, then no // worries. diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 9d4064e99bdb1..cd6070cc638f0 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -281,80 +281,79 @@ impl LanguageItems { } } -fn LanguageItemCollector(crate: @crate, - session: Session) - -> LanguageItemCollector { - let mut item_refs = HashMap::new(); - - item_refs.insert(@"const", ConstTraitLangItem as uint); - item_refs.insert(@"copy", CopyTraitLangItem as uint); - item_refs.insert(@"owned", OwnedTraitLangItem as uint); - item_refs.insert(@"sized", SizedTraitLangItem as uint); - - item_refs.insert(@"drop", DropTraitLangItem as uint); - - item_refs.insert(@"add", AddTraitLangItem as uint); - item_refs.insert(@"sub", SubTraitLangItem as uint); - item_refs.insert(@"mul", MulTraitLangItem as uint); - item_refs.insert(@"div", DivTraitLangItem as uint); - item_refs.insert(@"rem", RemTraitLangItem as uint); - item_refs.insert(@"neg", NegTraitLangItem as uint); - item_refs.insert(@"not", NotTraitLangItem as uint); - item_refs.insert(@"bitxor", BitXorTraitLangItem as uint); - item_refs.insert(@"bitand", BitAndTraitLangItem as uint); - item_refs.insert(@"bitor", BitOrTraitLangItem as uint); - item_refs.insert(@"shl", ShlTraitLangItem as uint); - item_refs.insert(@"shr", ShrTraitLangItem as uint); - item_refs.insert(@"index", IndexTraitLangItem as uint); - - item_refs.insert(@"eq", EqTraitLangItem as uint); - item_refs.insert(@"ord", OrdTraitLangItem as uint); - - item_refs.insert(@"str_eq", StrEqFnLangItem as uint); - item_refs.insert(@"uniq_str_eq", UniqStrEqFnLangItem as uint); - item_refs.insert(@"annihilate", AnnihilateFnLangItem as uint); - item_refs.insert(@"log_type", LogTypeFnLangItem as uint); - item_refs.insert(@"fail_", FailFnLangItem as uint); - item_refs.insert(@"fail_bounds_check", - FailBoundsCheckFnLangItem as uint); - item_refs.insert(@"exchange_malloc", ExchangeMallocFnLangItem as uint); - item_refs.insert(@"exchange_free", ExchangeFreeFnLangItem as uint); - item_refs.insert(@"malloc", MallocFnLangItem as uint); - item_refs.insert(@"free", FreeFnLangItem as uint); - item_refs.insert(@"borrow_as_imm", BorrowAsImmFnLangItem as uint); - item_refs.insert(@"borrow_as_mut", BorrowAsMutFnLangItem as uint); - item_refs.insert(@"return_to_mut", ReturnToMutFnLangItem as uint); - item_refs.insert(@"check_not_borrowed", - CheckNotBorrowedFnLangItem as uint); - item_refs.insert(@"strdup_uniq", StrDupUniqFnLangItem as uint); - item_refs.insert(@"record_borrow", RecordBorrowFnLangItem as uint); - item_refs.insert(@"unrecord_borrow", UnrecordBorrowFnLangItem as uint); - item_refs.insert(@"start", StartFnLangItem as uint); - item_refs.insert(@"ty_desc", TyDescStructLangItem as uint); - item_refs.insert(@"ty_visitor", TyVisitorTraitLangItem as uint); - item_refs.insert(@"opaque", OpaqueStructLangItem as uint); - - LanguageItemCollector { - crate: crate, - session: session, - items: LanguageItems::new(), - item_refs: item_refs - } -} - -struct LanguageItemCollector { +struct LanguageItemCollector<'self> { items: LanguageItems, - crate: @crate, + crate: &'self crate, session: Session, item_refs: HashMap<@str, uint>, } -impl LanguageItemCollector { +impl<'self> LanguageItemCollector<'self> { + + pub fn new<'a>(crate: &'a crate, session: Session) -> LanguageItemCollector<'a> { + let mut item_refs = HashMap::new(); + + item_refs.insert(@"const", ConstTraitLangItem as uint); + item_refs.insert(@"copy", CopyTraitLangItem as uint); + item_refs.insert(@"owned", OwnedTraitLangItem as uint); + item_refs.insert(@"sized", SizedTraitLangItem as uint); + + item_refs.insert(@"drop", DropTraitLangItem as uint); + + item_refs.insert(@"add", AddTraitLangItem as uint); + item_refs.insert(@"sub", SubTraitLangItem as uint); + item_refs.insert(@"mul", MulTraitLangItem as uint); + item_refs.insert(@"div", DivTraitLangItem as uint); + item_refs.insert(@"rem", RemTraitLangItem as uint); + item_refs.insert(@"neg", NegTraitLangItem as uint); + item_refs.insert(@"not", NotTraitLangItem as uint); + item_refs.insert(@"bitxor", BitXorTraitLangItem as uint); + item_refs.insert(@"bitand", BitAndTraitLangItem as uint); + item_refs.insert(@"bitor", BitOrTraitLangItem as uint); + item_refs.insert(@"shl", ShlTraitLangItem as uint); + item_refs.insert(@"shr", ShrTraitLangItem as uint); + item_refs.insert(@"index", IndexTraitLangItem as uint); + + item_refs.insert(@"eq", EqTraitLangItem as uint); + item_refs.insert(@"ord", OrdTraitLangItem as uint); + + item_refs.insert(@"str_eq", StrEqFnLangItem as uint); + item_refs.insert(@"uniq_str_eq", UniqStrEqFnLangItem as uint); + item_refs.insert(@"annihilate", AnnihilateFnLangItem as uint); + item_refs.insert(@"log_type", LogTypeFnLangItem as uint); + item_refs.insert(@"fail_", FailFnLangItem as uint); + item_refs.insert(@"fail_bounds_check", + FailBoundsCheckFnLangItem as uint); + item_refs.insert(@"exchange_malloc", ExchangeMallocFnLangItem as uint); + item_refs.insert(@"exchange_free", ExchangeFreeFnLangItem as uint); + item_refs.insert(@"malloc", MallocFnLangItem as uint); + item_refs.insert(@"free", FreeFnLangItem as uint); + item_refs.insert(@"borrow_as_imm", BorrowAsImmFnLangItem as uint); + item_refs.insert(@"borrow_as_mut", BorrowAsMutFnLangItem as uint); + item_refs.insert(@"return_to_mut", ReturnToMutFnLangItem as uint); + item_refs.insert(@"check_not_borrowed", + CheckNotBorrowedFnLangItem as uint); + item_refs.insert(@"strdup_uniq", StrDupUniqFnLangItem as uint); + item_refs.insert(@"record_borrow", RecordBorrowFnLangItem as uint); + item_refs.insert(@"unrecord_borrow", UnrecordBorrowFnLangItem as uint); + item_refs.insert(@"start", StartFnLangItem as uint); + item_refs.insert(@"ty_desc", TyDescStructLangItem as uint); + item_refs.insert(@"ty_visitor", TyVisitorTraitLangItem as uint); + item_refs.insert(@"opaque", OpaqueStructLangItem as uint); + + LanguageItemCollector { + crate: crate, + session: session, + items: LanguageItems::new(), + item_refs: item_refs + } + } + pub fn match_and_collect_meta_item(&mut self, item_def_id: def_id, - meta_item: @meta_item) { + meta_item: &meta_item) { match meta_item.node { meta_name_value(key, literal) => { match literal.node { @@ -386,7 +385,7 @@ impl LanguageItemCollector { pub fn match_and_collect_item(&mut self, item_def_id: def_id, - key: @str, + key: &str, value: @str) { if "lang" != key { return; // Didn't match. @@ -455,10 +454,10 @@ impl LanguageItemCollector { } } -pub fn collect_language_items(crate: @crate, +pub fn collect_language_items(crate: &crate, session: Session) -> LanguageItems { - let mut collector = LanguageItemCollector(crate, session); + let mut collector = LanguageItemCollector::new(crate, session); collector.collect(); let LanguageItemCollector { items, _ } = collector; session.abort_if_errors(); diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index 6da10b7c27749..ccbd006edec34 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -701,7 +701,7 @@ fn lint_type_limits() -> visit::vt<@mut Context> { }) } -fn check_item_default_methods(cx: &Context, item: @ast::item) { +fn check_item_default_methods(cx: &Context, item: &ast::item) { match item.node { ast::item_trait(_, _, ref methods) => { for methods.iter().advance |method| { @@ -718,8 +718,8 @@ fn check_item_default_methods(cx: &Context, item: @ast::item) { } } -fn check_item_ctypes(cx: &Context, it: @ast::item) { - fn check_ty(cx: &Context, ty: @ast::Ty) { +fn check_item_ctypes(cx: &Context, it: &ast::item) { + fn check_ty(cx: &Context, ty: &ast::Ty) { match ty.node { ast::ty_path(_, _, id) => { match cx.tcx.def_map.get_copy(&id) { @@ -797,7 +797,7 @@ fn check_type(cx: &Context, span: span, ty: ty::t) { } } -fn check_item_heap(cx: &Context, it: @ast::item) { +fn check_item_heap(cx: &Context, it: &ast::item) { match it.node { ast::item_fn(*) | ast::item_ty(*) | @@ -851,7 +851,7 @@ fn lint_path_statement() -> visit::vt<@mut Context> { }) } -fn check_item_non_camel_case_types(cx: &Context, it: @ast::item) { +fn check_item_non_camel_case_types(cx: &Context, it: &ast::item) { fn is_camel_case(cx: ty::ctxt, ident: ast::ident) -> bool { let ident = cx.sess.str_of(ident); assert!(!ident.is_empty()); @@ -973,7 +973,7 @@ fn lint_session() -> visit::vt<@mut Context> { fn lint_unnecessary_allocations() -> visit::vt<@mut Context> { // Warn if string and vector literals with sigils are immediately borrowed. // Those can have the sigil removed. - fn check(cx: &Context, e: @ast::expr) { + fn check(cx: &Context, e: &ast::expr) { match e.node { ast::expr_vstore(e2, ast::expr_vstore_uniq) | ast::expr_vstore(e2, ast::expr_vstore_box) => { diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index d8308c516b056..86b8b2943198e 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -150,7 +150,7 @@ fn live_node_kind_to_str(lnk: LiveNodeKind, cx: ty::ctxt) -> ~str { pub fn check_crate(tcx: ty::ctxt, method_map: typeck::method_map, capture_map: moves::CaptureMap, - crate: @crate) { + crate: &crate) { let visitor = visit::mk_vt(@visit::Visitor { visit_fn: visit_fn, visit_local: visit_local, @@ -322,7 +322,7 @@ impl IrMaps { self.capture_info_map.insert(node_id, @cs); } - pub fn captures(&mut self, expr: @expr) -> @~[CaptureInfo] { + pub fn captures(&mut self, expr: &expr) -> @~[CaptureInfo] { match self.capture_info_map.find(&expr.id) { Some(&caps) => caps, None => { @@ -596,7 +596,7 @@ impl Liveness { } } - pub fn variable_from_path(&self, expr: @expr) -> Option { + pub fn variable_from_path(&self, expr: &expr) -> Option { match expr.node { expr_path(_) => { let def = self.tcx.def_map.get_copy(&expr.id); @@ -923,7 +923,7 @@ impl Liveness { } } - pub fn propagate_through_stmt(&self, stmt: @stmt, succ: LiveNode) + pub fn propagate_through_stmt(&self, stmt: &stmt, succ: LiveNode) -> LiveNode { match stmt.node { stmt_decl(decl, _) => { @@ -940,7 +940,7 @@ impl Liveness { } } - pub fn propagate_through_decl(&self, decl: @decl, succ: LiveNode) + pub fn propagate_through_decl(&self, decl: &decl, succ: LiveNode) -> LiveNode { match decl.node { decl_local(ref local) => { @@ -950,7 +950,7 @@ impl Liveness { } } - pub fn propagate_through_local(&self, local: @local, succ: LiveNode) + pub fn propagate_through_local(&self, local: &local, succ: LiveNode) -> LiveNode { // Note: we mark the variable as defined regardless of whether // there is an initializer. Initially I had thought to only mark @@ -1293,7 +1293,7 @@ impl Liveness { } // see comment on propagate_through_lvalue() - pub fn write_lvalue(&self, expr: @expr, succ: LiveNode, acc: uint) + pub fn write_lvalue(&self, expr: &expr, succ: LiveNode, acc: uint) -> LiveNode { match expr.node { expr_path(_) => self.access_path(expr, succ, acc), @@ -1306,7 +1306,7 @@ impl Liveness { } } - pub fn access_path(&self, expr: @expr, succ: LiveNode, acc: uint) + pub fn access_path(&self, expr: &expr, succ: LiveNode, acc: uint) -> LiveNode { let def = self.tcx.def_map.get_copy(&expr.id); match moves::moved_variable_node_id_from_def(def) { @@ -1324,7 +1324,7 @@ impl Liveness { } pub fn propagate_through_loop(&self, - expr: @expr, + expr: &expr, cond: Option<@expr>, body: &blk, succ: LiveNode) diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs index 0050239e06630..68307a49d3b67 100644 --- a/src/librustc/middle/moves.rs +++ b/src/librustc/middle/moves.rs @@ -190,7 +190,7 @@ enum UseMode { pub fn compute_moves(tcx: ty::ctxt, method_map: method_map, - crate: @crate) -> MoveMaps + crate: &crate) -> MoveMaps { let visitor = visit::mk_vt(@visit::Visitor { visit_expr: compute_modes_for_expr, @@ -521,7 +521,7 @@ impl VisitContext { } pub fn use_overloaded_operator(&self, - expr: @expr, + expr: &expr, receiver_expr: @expr, arg_exprs: &[@expr], visitor: vt) diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs index 5bd39e8586374..654d77b2a794b 100644 --- a/src/librustc/middle/pat_util.rs +++ b/src/librustc/middle/pat_util.rs @@ -29,7 +29,7 @@ pub fn pat_id_map(dm: resolve::DefMap, pat: @pat) -> PatIdMap { map } -pub fn pat_is_variant_or_struct(dm: resolve::DefMap, pat: @pat) -> bool { +pub fn pat_is_variant_or_struct(dm: resolve::DefMap, pat: &pat) -> bool { match pat.node { pat_enum(_, _) | pat_ident(_, _, None) | pat_struct(*) => { match dm.find(&pat.id) { diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 94771b4ed0b31..c3241dca1b87a 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -40,7 +40,7 @@ use syntax::visit; pub fn check_crate<'mm>(tcx: ty::ctxt, method_map: &'mm method_map, - crate: @ast::crate) { + crate: &ast::crate) { let privileged_items = @mut ~[]; // Adds an item to its scope. diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 7d3e895a0edd5..00a44904fed1e 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -34,8 +34,6 @@ use syntax::parse::token; use syntax::parse::token::special_idents; use syntax::{ast, visit}; -pub type parent = Option; - /** The region maps encode information about region relationships. @@ -68,10 +66,10 @@ pub struct Context { region_maps: @mut RegionMaps, // Scope where variables should be parented to - var_parent: parent, + var_parent: Option, // Innermost enclosing expression - parent: parent, + parent: Option, } impl RegionMaps { @@ -313,20 +311,8 @@ impl RegionMaps { } } -/// Extracts that current parent from cx, failing if there is none. -pub fn parent_id(cx: Context, span: span) -> ast::node_id { - match cx.parent { - None => { - cx.sess.span_bug(span, "crate should not be parent here"); - } - Some(parent_id) => { - parent_id - } - } -} - /// Records the current parent (if any) as the parent of `child_id`. -pub fn parent_to_expr(cx: Context, child_id: ast::node_id, sp: span) { +fn parent_to_expr(cx: Context, child_id: ast::node_id, sp: span) { debug!("region::parent_to_expr(span=%?)", cx.sess.codemap.span_to_str(sp)); for cx.parent.iter().advance |parent_id| { @@ -334,7 +320,7 @@ pub fn parent_to_expr(cx: Context, child_id: ast::node_id, sp: span) { } } -pub fn resolve_block(blk: &ast::blk, (cx, visitor): (Context, visit::vt)) { +fn resolve_block(blk: &ast::blk, (cx, visitor): (Context, visit::vt)) { // Record the parent of this block. parent_to_expr(cx, blk.node.id, blk.span); @@ -345,17 +331,17 @@ pub fn resolve_block(blk: &ast::blk, (cx, visitor): (Context, visit::vt visit::visit_block(blk, (new_cx, visitor)); } -pub fn resolve_arm(arm: &ast::arm, (cx, visitor): (Context, visit::vt)) { +fn resolve_arm(arm: &ast::arm, (cx, visitor): (Context, visit::vt)) { visit::visit_arm(arm, (cx, visitor)); } -pub fn resolve_pat(pat: @ast::pat, (cx, visitor): (Context, visit::vt)) { +fn resolve_pat(pat: @ast::pat, (cx, visitor): (Context, visit::vt)) { assert_eq!(cx.var_parent, cx.parent); parent_to_expr(cx, pat.id, pat.span); visit::visit_pat(pat, (cx, visitor)); } -pub fn resolve_stmt(stmt: @ast::stmt, (cx, visitor): (Context, visit::vt)) { +fn resolve_stmt(stmt: @ast::stmt, (cx, visitor): (Context, visit::vt)) { match stmt.node { ast::stmt_decl(*) => { visit::visit_stmt(stmt, (cx, visitor)); @@ -370,7 +356,7 @@ pub fn resolve_stmt(stmt: @ast::stmt, (cx, visitor): (Context, visit::vt)) { +fn resolve_expr(expr: @ast::expr, (cx, visitor): (Context, visit::vt)) { parent_to_expr(cx, expr.id, expr.span); let mut new_cx = cx; @@ -409,27 +395,27 @@ pub fn resolve_expr(expr: @ast::expr, (cx, visitor): (Context, visit::vt)) { +fn resolve_local(local: @ast::local, + (cx, visitor) : (Context, + visit::vt)) { assert_eq!(cx.var_parent, cx.parent); parent_to_expr(cx, local.node.id, local.span); visit::visit_local(local, (cx, visitor)); } -pub fn resolve_item(item: @ast::item, (cx, visitor): (Context, visit::vt)) { +fn resolve_item(item: @ast::item, (cx, visitor): (Context, visit::vt)) { // Items create a new outer block scope as far as we're concerned. let new_cx = Context {var_parent: None, parent: None, ..cx}; visit::visit_item(item, (new_cx, visitor)); } -pub fn resolve_fn(fk: &visit::fn_kind, - decl: &ast::fn_decl, - body: &ast::blk, - sp: span, - id: ast::node_id, - (cx, visitor): (Context, - visit::vt)) { +fn resolve_fn(fk: &visit::fn_kind, + decl: &ast::fn_decl, + body: &ast::blk, + sp: span, + id: ast::node_id, + (cx, visitor): (Context, + visit::vt)) { debug!("region::resolve_fn(id=%?, \ span=%?, \ body.node.id=%?, \ @@ -468,7 +454,7 @@ pub fn resolve_fn(fk: &visit::fn_kind, pub fn resolve_crate(sess: Session, def_map: resolve::DefMap, - crate: @ast::crate) -> @mut RegionMaps + crate: &ast::crate) -> @mut RegionMaps { let region_maps = @mut RegionMaps { scope_map: HashMap::new(), @@ -522,14 +508,12 @@ pub struct region_dep { id: ast::node_id } -pub type dep_map = @mut HashMap; - pub struct DetermineRpCtxt { sess: Session, ast_map: ast_map::map, def_map: resolve::DefMap, region_paramd_items: region_paramd_items, - dep_map: dep_map, + dep_map: @mut HashMap, worklist: ~[ast::node_id], // the innermost enclosing item id @@ -619,14 +603,8 @@ impl DetermineRpCtxt { ast_map::node_id_to_str(self.ast_map, self.item_id, token::get_ident_interner()), copy self.ambient_variance); - let vec = match self.dep_map.find(&from) { - Some(&vec) => vec, - None => { - let vec = @mut ~[]; - let dep_map = self.dep_map; - dep_map.insert(from, vec); - vec - } + let vec = do self.dep_map.find_or_insert_with(from) |_| { + @mut ~[] }; let dep = region_dep { ambient_variance: self.ambient_variance, @@ -715,21 +693,21 @@ impl DetermineRpCtxt { } } -pub fn determine_rp_in_item(item: @ast::item, - (cx, visitor): (@mut DetermineRpCtxt, - visit::vt<@mut DetermineRpCtxt>)) { +fn determine_rp_in_item(item: @ast::item, + (cx, visitor): (@mut DetermineRpCtxt, + visit::vt<@mut DetermineRpCtxt>)) { do cx.with(item.id, true) { visit::visit_item(item, (cx, visitor)); } } -pub fn determine_rp_in_fn(fk: &visit::fn_kind, - decl: &ast::fn_decl, - body: &ast::blk, - _: span, - _: ast::node_id, - (cx, visitor): (@mut DetermineRpCtxt, - visit::vt<@mut DetermineRpCtxt>)) { +fn determine_rp_in_fn(fk: &visit::fn_kind, + decl: &ast::fn_decl, + body: &ast::blk, + _: span, + _: ast::node_id, + (cx, visitor): (@mut DetermineRpCtxt, + visit::vt<@mut DetermineRpCtxt>)) { do cx.with(cx.item_id, false) { do cx.with_ambient_variance(rv_contravariant) { for decl.inputs.iter().advance |a| { @@ -743,17 +721,17 @@ pub fn determine_rp_in_fn(fk: &visit::fn_kind, } } -pub fn determine_rp_in_ty_method(ty_m: &ast::ty_method, - (cx, visitor): (@mut DetermineRpCtxt, - visit::vt<@mut DetermineRpCtxt>)) { +fn determine_rp_in_ty_method(ty_m: &ast::ty_method, + (cx, visitor): (@mut DetermineRpCtxt, + visit::vt<@mut DetermineRpCtxt>)) { do cx.with(cx.item_id, false) { visit::visit_ty_method(ty_m, (cx, visitor)); } } -pub fn determine_rp_in_ty(ty: @ast::Ty, - (cx, visitor): (@mut DetermineRpCtxt, - visit::vt<@mut DetermineRpCtxt>)) { +fn determine_rp_in_ty(ty: @ast::Ty, + (cx, visitor): (@mut DetermineRpCtxt, + visit::vt<@mut DetermineRpCtxt>)) { // we are only interested in types that will require an item to // 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 @@ -883,7 +861,7 @@ pub fn determine_rp_in_ty(ty: @ast::Ty, } } -pub fn determine_rp_in_struct_field( +fn determine_rp_in_struct_field( cm: @ast::struct_field, (cx, visitor): (@mut DetermineRpCtxt, visit::vt<@mut DetermineRpCtxt>)) { @@ -893,7 +871,7 @@ pub fn determine_rp_in_struct_field( pub fn determine_rp_in_crate(sess: Session, ast_map: ast_map::map, def_map: resolve::DefMap, - crate: @ast::crate) + crate: &ast::crate) -> region_paramd_items { let cx = @mut DetermineRpCtxt { sess: sess, diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index 63b39b8fe763e..a2cbc4d6fe05e 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -406,8 +406,6 @@ pub fn expand_nested_bindings<'r>(bcx: block, } } -pub type enter_pat<'self> = &'self fn(@ast::pat) -> Option<~[@ast::pat]>; - pub fn assert_is_binding_or_wild(bcx: block, p: @ast::pat) { if !pat_is_binding_or_wild(bcx.tcx().def_map, p) { bcx.sess().span_bug( @@ -417,6 +415,8 @@ pub fn assert_is_binding_or_wild(bcx: block, p: @ast::pat) { } } +pub type enter_pat<'self> = &'self fn(@ast::pat) -> Option<~[@ast::pat]>; + pub fn enter_match<'r>(bcx: block, dm: DefMap, m: &[@Match<'r>], @@ -1048,7 +1048,7 @@ pub fn any_tuple_struct_pat(bcx: block, m: &[@Match], col: uint) -> bool { pub type mk_fail = @fn() -> BasicBlockRef; pub fn pick_col(m: &[@Match]) -> uint { - fn score(p: @ast::pat) -> uint { + fn score(p: &ast::pat) -> uint { match p.node { ast::pat_lit(_) | ast::pat_enum(_, _) | ast::pat_range(_, _) => 1u, ast::pat_ident(_, _, Some(p)) => score(p), @@ -1609,7 +1609,7 @@ pub fn compile_submatch(bcx: block, } pub fn trans_match(bcx: block, - match_expr: @ast::expr, + match_expr: &ast::expr, discr_expr: @ast::expr, arms: ~[ast::arm], dest: Dest) -> block { diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index b4e6245f629d7..a0628bc8e87c4 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -160,7 +160,7 @@ pub fn decl_cdecl_fn(llmod: ModuleRef, name: &str, ty: Type) -> ValueRef { // Only use this if you are going to actually define the function. It's // not valid to simply declare a function as internal. -pub fn decl_internal_cdecl_fn(llmod: ModuleRef, name: ~str, ty: Type) -> ValueRef { +pub fn decl_internal_cdecl_fn(llmod: ModuleRef, name: &str, ty: Type) -> ValueRef { let llfn = decl_cdecl_fn(llmod, name, ty); lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage); return llfn; @@ -592,8 +592,7 @@ pub fn compare_scalar_values(cx: block, } } -pub type val_pair_fn = @fn(block, ValueRef, ValueRef) -> block; -pub type val_and_ty_fn = @fn(block, ValueRef, ty::t) -> block; +pub type val_and_ty_fn<'self> = &'self fn(block, ValueRef, ty::t) -> block; pub fn load_inbounds(cx: block, p: ValueRef, idxs: &[uint]) -> ValueRef { return Load(cx, GEPi(cx, p, idxs)); @@ -1032,13 +1031,13 @@ pub fn build_return(bcx: block) { Br(bcx, bcx.fcx.llreturn); } -pub fn ignore_lhs(_bcx: block, local: @ast::local) -> bool { +pub fn ignore_lhs(_bcx: block, local: &ast::local) -> bool { match local.node.pat.node { ast::pat_wild => true, _ => false } } -pub fn init_local(bcx: block, local: @ast::local) -> block { +pub fn init_local(bcx: block, local: &ast::local) -> block { debug!("init_local(bcx=%s, local.id=%?)", bcx.to_str(), local.node.id); @@ -1378,7 +1377,7 @@ pub fn block_locals(b: &ast::blk, it: &fn(@ast::local)) { } } -pub fn alloc_local(cx: block, local: @ast::local) -> block { +pub fn alloc_local(cx: block, local: &ast::local) -> block { let _icx = push_ctxt("alloc_local"); let t = node_id_type(cx, local.node.id); let simple_name = match local.node.pat.node { @@ -2379,7 +2378,7 @@ pub fn fill_fn_pair(bcx: block, pair: ValueRef, llfn: ValueRef, Store(bcx, llenvblobptr, env_cell); } -pub fn item_path(ccx: &CrateContext, i: @ast::item) -> path { +pub fn item_path(ccx: &CrateContext, i: &ast::item) -> path { let base = match ccx.tcx.items.get_copy(&i.id) { ast_map::node_item(_, p) => p, // separate map for paths? @@ -2544,7 +2543,7 @@ pub fn register_method(ccx: @mut CrateContext, } // The constant translation pass. -pub fn trans_constant(ccx: @mut CrateContext, it: @ast::item) { +pub fn trans_constant(ccx: &mut CrateContext, it: @ast::item) { let _icx = push_ctxt("trans_constant"); match it.node { ast::item_enum(ref enum_definition, _) => { @@ -2894,7 +2893,7 @@ pub fn write_abi_version(ccx: &mut CrateContext) { } pub fn trans_crate(sess: session::Session, - crate: @ast::crate, + crate: &ast::crate, tcx: ty::ctxt, output: &Path, emap2: resolve::ExportMap2, diff --git a/src/librustc/middle/trans/block.rs b/src/librustc/middle/trans/block.rs deleted file mode 100644 index e69de29bb2d1d..0000000000000 diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs index 227e22131636b..3ce52a63171eb 100644 --- a/src/librustc/middle/trans/closure.rs +++ b/src/librustc/middle/trans/closure.rs @@ -468,7 +468,7 @@ pub fn make_closure_glue( cx: block, v: ValueRef, t: ty::t, - glue_fn: @fn(block, v: ValueRef, t: ty::t) -> block) -> block { + glue_fn: &fn(block, v: ValueRef, t: ty::t) -> block) -> block { let _icx = push_ctxt("closure::make_closure_glue"); let bcx = cx; let tcx = cx.tcx(); diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index 272d7b234aa57..79d83fbc85703 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -411,7 +411,6 @@ pub fn add_clean_free(cx: block, ptr: ValueRef, heap: heap) { // drop glue checks whether it is zero. pub fn revoke_clean(cx: block, val: ValueRef) { do in_scope_cx(cx) |scope_info| { - let scope_info = &mut *scope_info; // FIXME(#5074) workaround borrowck let cleanup_pos = scope_info.cleanups.iter().position_( |cu| match *cu { clean_temp(v, _, _) if v == val => true, @@ -473,7 +472,7 @@ pub trait get_node_info { fn info(&self) -> Option; } -impl get_node_info for @ast::expr { +impl get_node_info for ast::expr { fn info(&self) -> Option { Some(NodeInfo {id: self.id, callee_id: self.get_callee_id(), @@ -573,7 +572,7 @@ pub fn val_ty(v: ValueRef) -> Type { } } -pub fn in_scope_cx(cx: block, f: &fn(si: @mut scope_info)) { +pub fn in_scope_cx(cx: block, f: &fn(si: &mut scope_info)) { let mut cur = cx; loop { match cur.kind { @@ -612,11 +611,11 @@ impl block_ { e.repr(self.tcx()) } - pub fn expr_is_lval(&self, e: @ast::expr) -> bool { + pub fn expr_is_lval(&self, e: &ast::expr) -> bool { ty::expr_is_lval(self.tcx(), self.ccx().maps.method_map, e) } - pub fn expr_kind(&self, e: @ast::expr) -> ty::ExprKind { + pub fn expr_kind(&self, e: &ast::expr) -> ty::ExprKind { ty::expr_kind(self.tcx(), self.ccx().maps.method_map, e) } @@ -995,11 +994,11 @@ pub fn node_id_type(bcx: block, id: ast::node_id) -> ty::t { monomorphize_type(bcx, t) } -pub fn expr_ty(bcx: block, ex: @ast::expr) -> ty::t { +pub fn expr_ty(bcx: block, ex: &ast::expr) -> ty::t { node_id_type(bcx, ex.id) } -pub fn expr_ty_adjusted(bcx: block, ex: @ast::expr) -> ty::t { +pub fn expr_ty_adjusted(bcx: block, ex: &ast::expr) -> ty::t { let tcx = bcx.tcx(); let t = ty::expr_ty_adjusted(tcx, ex); monomorphize_type(bcx, t) diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index 98eb858be55fd..d7b6e9cf5a372 100644 --- a/src/librustc/middle/trans/consts.rs +++ b/src/librustc/middle/trans/consts.rs @@ -35,7 +35,7 @@ use core::libc::c_uint; use core::str; use syntax::{ast, ast_util, ast_map}; -pub fn const_lit(cx: @mut CrateContext, e: @ast::expr, lit: ast::lit) +pub fn const_lit(cx: &mut CrateContext, e: &ast::expr, lit: ast::lit) -> ValueRef { let _icx = push_ctxt("trans_lit"); match lit.node { @@ -82,7 +82,7 @@ pub fn const_ptrcast(cx: &mut CrateContext, a: ValueRef, t: Type) -> ValueRef { } } -pub fn const_vec(cx: @mut CrateContext, e: @ast::expr, es: &[@ast::expr]) +pub fn const_vec(cx: @mut CrateContext, e: &ast::expr, es: &[@ast::expr]) -> (ValueRef, ValueRef, Type) { unsafe { let vec_ty = ty::expr_ty(cx.tcx, e); @@ -101,7 +101,7 @@ pub fn const_vec(cx: @mut CrateContext, e: @ast::expr, es: &[@ast::expr]) } } -fn const_addr_of(cx: @mut CrateContext, cv: ValueRef) -> ValueRef { +fn const_addr_of(cx: &mut CrateContext, cv: ValueRef) -> ValueRef { unsafe { let gv = do "const".as_c_str |name| { llvm::LLVMAddGlobal(cx.llmod, val_ty(cv).to_ref(), name) @@ -113,7 +113,7 @@ fn const_addr_of(cx: @mut CrateContext, cv: ValueRef) -> ValueRef { } } -fn const_deref_ptr(cx: @mut CrateContext, v: ValueRef) -> ValueRef { +fn const_deref_ptr(cx: &mut CrateContext, v: ValueRef) -> ValueRef { let v = match cx.const_globals.find(&(v as int)) { Some(&v) => v, None => v @@ -124,13 +124,13 @@ fn const_deref_ptr(cx: @mut CrateContext, v: ValueRef) -> ValueRef { } } -fn const_deref_newtype(cx: @mut CrateContext, v: ValueRef, t: ty::t) +fn const_deref_newtype(cx: &mut CrateContext, v: ValueRef, t: ty::t) -> ValueRef { let repr = adt::represent_type(cx, t); adt::const_get_field(cx, repr, v, 0, 0) } -fn const_deref(cx: @mut CrateContext, v: ValueRef, t: ty::t, explicit: bool) +fn const_deref(cx: &mut CrateContext, v: ValueRef, t: ty::t, explicit: bool) -> (ValueRef, ty::t) { match ty::deref(cx.tcx, t, explicit) { Some(ref mt) => { @@ -247,7 +247,7 @@ pub fn const_expr(cx: @mut CrateContext, e: @ast::expr) -> ValueRef { llconst } -fn const_expr_unadjusted(cx: @mut CrateContext, e: @ast::expr) -> ValueRef { +fn const_expr_unadjusted(cx: @mut CrateContext, e: &ast::expr) -> ValueRef { unsafe { let _icx = push_ctxt("const_expr"); return match e.node { @@ -393,7 +393,8 @@ fn const_expr_unadjusted(cx: @mut CrateContext, e: @ast::expr) -> ValueRef { let llunitty = type_of::type_of(cx, unit_ty); let unit_sz = machine::llsize_of(cx, llunitty); - (const_deref_ptr(cx, const_get_elt(cx, bv, [0])), + let e1 = const_get_elt(cx, bv, [0]); + (const_deref_ptr(cx, e1), llvm::LLVMConstUDiv(const_get_elt(cx, bv, [1]), unit_sz)) }, diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs index f101a8657322e..862f455aeb6bd 100644 --- a/src/librustc/middle/trans/controlflow.rs +++ b/src/librustc/middle/trans/controlflow.rs @@ -178,7 +178,7 @@ pub fn trans_loop(bcx:block, return next_bcx; } -pub fn trans_log(log_ex: @ast::expr, +pub fn trans_log(log_ex: &ast::expr, lvl: @ast::expr, bcx: block, e: @ast::expr) -> block { diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs index 32d0f8887b90d..de56d9a05f15f 100644 --- a/src/librustc/middle/trans/datum.rs +++ b/src/librustc/middle/trans/datum.rs @@ -723,7 +723,7 @@ impl Datum { } /// expr: The deref expression. - pub fn deref(&self, bcx: block, expr: @ast::expr, derefs: uint) + pub fn deref(&self, bcx: block, expr: &ast::expr, derefs: uint) -> DatumBlock { match self.try_deref(bcx, expr.span, expr.id, derefs, false) { (Some(lvres), bcx) => DatumBlock { bcx: bcx, datum: lvres }, diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 0e64d7582ac5d..02f276cd0503c 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -254,7 +254,7 @@ pub fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock { fn auto_slice(bcx: block, autoderefs: uint, - expr: @ast::expr, + expr: &ast::expr, datum: Datum) -> DatumBlock { // This is not the most efficient thing possible; since slices // are two words it'd be better if this were compiled in @@ -280,7 +280,7 @@ pub fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock { DatumBlock {bcx: bcx, datum: scratch} } - fn add_env(bcx: block, expr: @ast::expr, datum: Datum) -> DatumBlock { + fn add_env(bcx: block, expr: &ast::expr, datum: Datum) -> DatumBlock { // This is not the most efficient thing possible; since closures // are two words it'd be better if this were compiled in // 'dest' mode, but I can't find a nice way to structure the @@ -301,7 +301,7 @@ pub fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock { fn auto_slice_and_ref(bcx: block, autoderefs: uint, - expr: @ast::expr, + expr: &ast::expr, datum: Datum) -> DatumBlock { let DatumBlock { bcx, datum } = auto_slice(bcx, autoderefs, expr, datum); auto_ref(bcx, datum) @@ -705,7 +705,7 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr, } } -fn trans_def_dps_unadjusted(bcx: block, ref_expr: @ast::expr, +fn trans_def_dps_unadjusted(bcx: block, ref_expr: &ast::expr, def: ast::def, dest: Dest) -> block { let _icx = push_ctxt("trans_def_dps_unadjusted"); let ccx = bcx.ccx(); @@ -752,7 +752,7 @@ fn trans_def_dps_unadjusted(bcx: block, ref_expr: @ast::expr, } fn trans_def_datum_unadjusted(bcx: block, - ref_expr: @ast::expr, + ref_expr: &ast::expr, def: ast::def) -> DatumBlock { let _icx = push_ctxt("trans_def_datum_unadjusted"); @@ -776,7 +776,7 @@ fn trans_def_datum_unadjusted(bcx: block, } fn fn_data_to_datum(bcx: block, - ref_expr: @ast::expr, + ref_expr: &ast::expr, def_id: ast::def_id, fn_data: callee::FnData) -> DatumBlock { /*! @@ -873,7 +873,7 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock { } fn trans_index(bcx: block, - index_expr: @ast::expr, + index_expr: &ast::expr, base: @ast::expr, idx: @ast::expr) -> DatumBlock { //! Translates `base[idx]`. @@ -936,7 +936,7 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock { } fn trans_def_lvalue(bcx: block, - ref_expr: @ast::expr, + ref_expr: &ast::expr, def: ast::def) -> DatumBlock { @@ -1263,7 +1263,7 @@ fn trans_immediate_lit(bcx: block, expr: @ast::expr, } fn trans_unary_datum(bcx: block, - un_expr: @ast::expr, + un_expr: &ast::expr, op: ast::unop, sub_expr: @ast::expr) -> DatumBlock { let _icx = push_ctxt("trans_unary_datum"); @@ -1337,7 +1337,7 @@ fn trans_unary_datum(bcx: block, } } -fn trans_addr_of(bcx: block, expr: @ast::expr, +fn trans_addr_of(bcx: block, expr: &ast::expr, subexpr: @ast::expr) -> DatumBlock { let _icx = push_ctxt("trans_addr_of"); let mut bcx = bcx; @@ -1349,7 +1349,7 @@ fn trans_addr_of(bcx: block, expr: @ast::expr, // Important to get types for both lhs and rhs, because one might be _|_ // and the other not. fn trans_eager_binop(bcx: block, - binop_expr: @ast::expr, + binop_expr: &ast::expr, binop_ty: ty::t, op: ast::binop, lhs_datum: &Datum, @@ -1447,7 +1447,7 @@ fn trans_eager_binop(bcx: block, enum lazy_binop_ty { lazy_and, lazy_or } fn trans_lazy_binop(bcx: block, - binop_expr: @ast::expr, + binop_expr: &ast::expr, op: lazy_binop_ty, a: @ast::expr, b: @ast::expr) -> DatumBlock { @@ -1492,7 +1492,7 @@ fn trans_lazy_binop(bcx: block, } fn trans_binary(bcx: block, - binop_expr: @ast::expr, + binop_expr: &ast::expr, op: ast::binop, lhs: @ast::expr, rhs: @ast::expr) -> DatumBlock @@ -1518,7 +1518,7 @@ fn trans_binary(bcx: block, } fn trans_overloaded_op(bcx: block, - expr: @ast::expr, + expr: &ast::expr, callee_id: ast::node_id, rcvr: @ast::expr, args: ~[@ast::expr], diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs index a5a6c1434c63f..6263ffb318eb2 100644 --- a/src/librustc/middle/trans/foreign.rs +++ b/src/librustc/middle/trans/foreign.rs @@ -55,7 +55,7 @@ fn abi_info(ccx: @mut CrateContext) -> @cabi::ABIInfo { } } -pub fn link_name(ccx: &CrateContext, i: @ast::foreign_item) -> @str { +pub fn link_name(ccx: &CrateContext, i: &ast::foreign_item) -> @str { match attr::first_attr_value_str_by_name(i.attrs, "link_name") { None => ccx.sess.str_of(i.ident), Some(ln) => ln, @@ -89,7 +89,7 @@ struct LlvmSignature { sret: bool, } -fn foreign_signature(ccx: @mut CrateContext, fn_sig: &ty::FnSig) +fn foreign_signature(ccx: &mut CrateContext, fn_sig: &ty::FnSig) -> LlvmSignature { /*! * The ForeignSignature is the LLVM types of the arguments/return type @@ -138,7 +138,7 @@ type shim_ret_builder<'self> = llretval: ValueRef); fn build_shim_fn_(ccx: @mut CrateContext, - shim_name: ~str, + shim_name: &str, llbasefn: ValueRef, tys: &ShimTypes, cc: lib::llvm::CallConv, @@ -357,7 +357,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext, } fn build_shim_fn(ccx: @mut CrateContext, - foreign_item: @ast::foreign_item, + foreign_item: &ast::foreign_item, tys: &ShimTypes, cc: lib::llvm::CallConv) -> ValueRef { @@ -419,7 +419,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext, // over the place fn build_direct_fn(ccx: @mut CrateContext, decl: ValueRef, - item: @ast::foreign_item, + item: &ast::foreign_item, tys: &ShimTypes, cc: lib::llvm::CallConv) { debug!("build_direct_fn(%s)", link_name(ccx, item)); @@ -446,7 +446,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext, // over the place fn build_fast_ffi_fn(ccx: @mut CrateContext, decl: ValueRef, - item: @ast::foreign_item, + item: &ast::foreign_item, tys: &ShimTypes, cc: lib::llvm::CallConv) { debug!("build_fast_ffi_fn(%s)", link_name(ccx, item)); @@ -541,7 +541,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext, pub fn trans_intrinsic(ccx: @mut CrateContext, decl: ValueRef, - item: @ast::foreign_item, + item: &ast::foreign_item, path: ast_map::path, substs: @param_substs, attributes: &[ast::attribute], diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs index 1f16a735c7c60..0172b70546593 100644 --- a/src/librustc/middle/trans/glue.rs +++ b/src/librustc/middle/trans/glue.rs @@ -205,7 +205,7 @@ pub fn simplified_glue_type(tcx: ty::ctxt, field: uint, t: ty::t) -> ty::t { pub fn lazily_emit_simplified_tydesc_glue(ccx: @mut CrateContext, field: uint, - ti: @mut tydesc_info) -> bool { + ti: &mut tydesc_info) -> bool { let _icx = push_ctxt("lazily_emit_simplified_tydesc_glue"); let simpl = simplified_glue_type(ccx.tcx, field, ti.ty); if simpl != ti.ty { @@ -244,7 +244,7 @@ pub fn lazily_emit_tydesc_glue(ccx: @mut CrateContext, None => { debug!("+++ lazily_emit_tydesc_glue TAKE %s", ppaux::ty_to_str(ccx.tcx, ti.ty)); - let glue_fn = declare_generic_glue(ccx, ti.ty, llfnty, ~"take"); + let glue_fn = declare_generic_glue(ccx, ti.ty, llfnty, "take"); ti.take_glue = Some(glue_fn); make_generic_glue(ccx, ti.ty, glue_fn, make_take_glue, "take"); debug!("--- lazily_emit_tydesc_glue TAKE %s", @@ -257,7 +257,7 @@ pub fn lazily_emit_tydesc_glue(ccx: @mut CrateContext, None => { debug!("+++ lazily_emit_tydesc_glue DROP %s", ppaux::ty_to_str(ccx.tcx, ti.ty)); - let glue_fn = declare_generic_glue(ccx, ti.ty, llfnty, ~"drop"); + let glue_fn = declare_generic_glue(ccx, ti.ty, llfnty, "drop"); ti.drop_glue = Some(glue_fn); make_generic_glue(ccx, ti.ty, glue_fn, make_drop_glue, "drop"); debug!("--- lazily_emit_tydesc_glue DROP %s", @@ -270,7 +270,7 @@ pub fn lazily_emit_tydesc_glue(ccx: @mut CrateContext, None => { debug!("+++ lazily_emit_tydesc_glue FREE %s", ppaux::ty_to_str(ccx.tcx, ti.ty)); - let glue_fn = declare_generic_glue(ccx, ti.ty, llfnty, ~"free"); + let glue_fn = declare_generic_glue(ccx, ti.ty, llfnty, "free"); ti.free_glue = Some(glue_fn); make_generic_glue(ccx, ti.ty, glue_fn, make_free_glue, "free"); debug!("--- lazily_emit_tydesc_glue FREE %s", @@ -283,7 +283,7 @@ pub fn lazily_emit_tydesc_glue(ccx: @mut CrateContext, None => { debug!("+++ lazily_emit_tydesc_glue VISIT %s", ppaux::ty_to_str(ccx.tcx, ti.ty)); - let glue_fn = declare_generic_glue(ccx, ti.ty, llfnty, ~"visit"); + let glue_fn = declare_generic_glue(ccx, ti.ty, llfnty, "visit"); ti.visit_glue = Some(glue_fn); make_generic_glue(ccx, ti.ty, glue_fn, make_visit_glue, "visit"); debug!("--- lazily_emit_tydesc_glue VISIT %s", @@ -627,12 +627,12 @@ pub fn make_take_glue(bcx: block, v: ValueRef, t: ty::t) { ty::ty_opaque_closure_ptr(ck) => { closure::make_opaque_cbox_take_glue(bcx, ck, v) } - ty::ty_struct(did, ref substs) => { + ty::ty_struct(did, _) => { let tcx = bcx.tcx(); let bcx = iter_structural_ty(bcx, v, t, take_ty); match ty::ty_dtor(tcx, did) { - ty::TraitDtor(dtor, false) => { + ty::TraitDtor(_, false) => { // Zero out the struct unsafe { let ty = Type::from_ref(llvm::LLVMTypeOf(v)); @@ -700,12 +700,11 @@ pub fn declare_tydesc(ccx: &mut CrateContext, t: ty::t) -> @mut tydesc_info { return inf; } -pub type glue_helper = @fn(block, ValueRef, ty::t); +pub type glue_helper<'self> = &'self fn(block, ValueRef, ty::t); -pub fn declare_generic_glue(ccx: @mut CrateContext, t: ty::t, llfnty: Type, - name: ~str) -> ValueRef { +pub fn declare_generic_glue(ccx: &mut CrateContext, t: ty::t, llfnty: Type, + name: &str) -> ValueRef { let _icx = push_ctxt("declare_generic_glue"); - let name = name; let fn_nm = mangle_internal_name_by_type_and_seq(ccx, t, (~"glue_" + name)).to_managed(); debug!("%s is for type %s", fn_nm, ppaux::ty_to_str(ccx.tcx, t)); note_unique_llvm_symbol(ccx, fn_nm); diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs index 96f8a1976a68c..ebcc3d811eba7 100644 --- a/src/librustc/middle/trans/meth.rs +++ b/src/librustc/middle/trans/meth.rs @@ -357,7 +357,7 @@ pub fn method_from_methods(ms: &[@ast::method], name: ast::ident) ms.iter().find_(|m| m.ident == name).map(|m| ast_util::local_def(m.id)) } -pub fn method_with_name_or_default(ccx: @mut CrateContext, +pub fn method_with_name_or_default(ccx: &mut CrateContext, impl_id: ast::def_id, name: ast::ident) -> ast::def_id { let imp = ccx.impl_method_cache.find_copy(&(impl_id, name)); @@ -742,8 +742,8 @@ pub fn get_vtable(bcx: block, } /// Helper function to declare and initialize the vtable. -pub fn make_vtable(ccx: @mut CrateContext, - tydesc: @mut tydesc_info, +pub fn make_vtable(ccx: &mut CrateContext, + tydesc: &tydesc_info, ptrs: &[ValueRef]) -> ValueRef { unsafe { @@ -770,7 +770,7 @@ pub fn make_vtable(ccx: @mut CrateContext, pub fn make_impl_vtable(bcx: block, impl_id: ast::def_id, self_ty: ty::t, - substs: ~[ty::t], + substs: &[ty::t], vtables: typeck::vtable_res) -> ValueRef { let ccx = bcx.ccx(); diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs index 24c7333469765..16695ad59a077 100644 --- a/src/librustc/middle/trans/reflect.rs +++ b/src/librustc/middle/trans/reflect.rs @@ -86,7 +86,7 @@ impl Reflector { self.c_tydesc(mt.ty)] } - pub fn visit(&mut self, ty_name: ~str, args: &[ValueRef]) { + pub fn visit(&mut self, ty_name: &str, args: &[ValueRef]) { let tcx = self.bcx.tcx(); let mth_idx = ty::method_idx( tcx.sess.ident_of(~"visit_" + ty_name), @@ -122,7 +122,7 @@ impl Reflector { } pub fn bracketed(&mut self, - bracket_name: ~str, + bracket_name: &str, extra: &[ValueRef], inner: &fn(&mut Reflector)) { self.visit(~"enter_" + bracket_name, extra); @@ -146,7 +146,7 @@ impl Reflector { } } - pub fn leaf(&mut self, name: ~str) { + pub fn leaf(&mut self, name: &str) { self.visit(name, []); } @@ -156,27 +156,27 @@ impl Reflector { debug!("reflect::visit_ty %s", ty_to_str(bcx.ccx().tcx, t)); match ty::get(t).sty { - ty::ty_bot => self.leaf(~"bot"), - ty::ty_nil => self.leaf(~"nil"), - ty::ty_bool => self.leaf(~"bool"), - ty::ty_int(ast::ty_i) => self.leaf(~"int"), - ty::ty_int(ast::ty_char) => self.leaf(~"char"), - ty::ty_int(ast::ty_i8) => self.leaf(~"i8"), - ty::ty_int(ast::ty_i16) => self.leaf(~"i16"), - ty::ty_int(ast::ty_i32) => self.leaf(~"i32"), - ty::ty_int(ast::ty_i64) => self.leaf(~"i64"), - ty::ty_uint(ast::ty_u) => self.leaf(~"uint"), - ty::ty_uint(ast::ty_u8) => self.leaf(~"u8"), - ty::ty_uint(ast::ty_u16) => self.leaf(~"u16"), - ty::ty_uint(ast::ty_u32) => self.leaf(~"u32"), - ty::ty_uint(ast::ty_u64) => self.leaf(~"u64"), - ty::ty_float(ast::ty_f) => self.leaf(~"float"), - ty::ty_float(ast::ty_f32) => self.leaf(~"f32"), - ty::ty_float(ast::ty_f64) => self.leaf(~"f64"), + ty::ty_bot => self.leaf("bot"), + ty::ty_nil => self.leaf("nil"), + ty::ty_bool => self.leaf("bool"), + ty::ty_int(ast::ty_i) => self.leaf("int"), + ty::ty_int(ast::ty_char) => self.leaf("char"), + ty::ty_int(ast::ty_i8) => self.leaf("i8"), + ty::ty_int(ast::ty_i16) => self.leaf("i16"), + ty::ty_int(ast::ty_i32) => self.leaf("i32"), + ty::ty_int(ast::ty_i64) => self.leaf("i64"), + ty::ty_uint(ast::ty_u) => self.leaf("uint"), + ty::ty_uint(ast::ty_u8) => self.leaf("u8"), + ty::ty_uint(ast::ty_u16) => self.leaf("u16"), + ty::ty_uint(ast::ty_u32) => self.leaf("u32"), + ty::ty_uint(ast::ty_u64) => self.leaf("u64"), + ty::ty_float(ast::ty_f) => self.leaf("float"), + ty::ty_float(ast::ty_f32) => self.leaf("f32"), + ty::ty_float(ast::ty_f64) => self.leaf("f64"), ty::ty_unboxed_vec(ref mt) => { let values = self.c_mt(mt); - self.visit(~"vec", values) + self.visit("vec", values) } ty::ty_estr(vst) => { @@ -190,28 +190,28 @@ impl Reflector { } ty::ty_box(ref mt) => { let extra = self.c_mt(mt); - self.visit(~"box", extra) + self.visit("box", extra) } ty::ty_uniq(ref mt) => { let extra = self.c_mt(mt); - self.visit(~"uniq", extra) + self.visit("uniq", extra) } ty::ty_ptr(ref mt) => { let extra = self.c_mt(mt); - self.visit(~"ptr", extra) + self.visit("ptr", extra) } ty::ty_rptr(_, ref mt) => { let extra = self.c_mt(mt); - self.visit(~"rptr", extra) + self.visit("rptr", extra) } ty::ty_tup(ref tys) => { let extra = ~[self.c_uint(tys.len())] + self.c_size_and_align(t); - do self.bracketed(~"tup", extra) |this| { + do self.bracketed("tup", extra) |this| { for tys.iter().enumerate().advance |(i, t)| { let extra = ~[this.c_uint(i), this.c_tydesc(*t)]; - this.visit(~"tup_field", extra); + this.visit("tup_field", extra); } } } @@ -226,9 +226,9 @@ impl Reflector { self.c_uint(sigilval), self.c_uint(fty.sig.inputs.len()), self.c_uint(retval)]; - self.visit(~"enter_fn", extra); + self.visit("enter_fn", extra); self.visit_sig(retval, &fty.sig); - self.visit(~"leave_fn", extra); + self.visit("leave_fn", extra); } // FIXME (#2594): fetch constants out of intrinsic:: for the @@ -241,9 +241,9 @@ impl Reflector { self.c_uint(sigilval), self.c_uint(fty.sig.inputs.len()), self.c_uint(retval)]; - self.visit(~"enter_fn", extra); + self.visit("enter_fn", extra); self.visit_sig(retval, &fty.sig); - self.visit(~"leave_fn", extra); + self.visit("leave_fn", extra); } ty::ty_struct(did, ref substs) => { @@ -253,13 +253,13 @@ impl Reflector { let extra = ~[self.c_uint(fields.len())] + self.c_size_and_align(t); - do self.bracketed(~"class", extra) |this| { + do self.bracketed("class", extra) |this| { for fields.iter().enumerate().advance |(i, field)| { let extra = ~[this.c_uint(i), this.c_slice( bcx.ccx().sess.str_of(field.ident))] + this.c_mt(&field.mt); - this.visit(~"class_field", extra); + this.visit("class_field", extra); } } } @@ -309,14 +309,14 @@ impl Reflector { let enum_args = ~[self.c_uint(variants.len()), make_get_disr()] + self.c_size_and_align(t); - do self.bracketed(~"enum", enum_args) |this| { + do self.bracketed("enum", enum_args) |this| { for variants.iter().enumerate().advance |(i, v)| { let name = ccx.sess.str_of(v.name); let variant_args = ~[this.c_uint(i), this.c_int(v.disr_val), this.c_uint(v.args.len()), this.c_slice(name)]; - do this.bracketed(~"enum_variant", variant_args) |this| { + do this.bracketed("enum_variant", variant_args) |this| { for v.args.iter().enumerate().advance |(j, a)| { let bcx = this.bcx; let null = C_null(llptrty); @@ -325,7 +325,7 @@ impl Reflector { let field_args = ~[this.c_uint(j), offset, this.c_tydesc(*a)]; - this.visit(~"enum_variant_field", field_args); + this.visit("enum_variant_field", field_args); } } } @@ -333,20 +333,20 @@ impl Reflector { } // Miscallaneous extra types - ty::ty_trait(_, _, _, _, _) => self.leaf(~"trait"), - ty::ty_infer(_) => self.leaf(~"infer"), - ty::ty_err => self.leaf(~"err"), + ty::ty_trait(_, _, _, _, _) => self.leaf("trait"), + ty::ty_infer(_) => self.leaf("infer"), + ty::ty_err => self.leaf("err"), ty::ty_param(ref p) => { let extra = ~[self.c_uint(p.idx)]; - self.visit(~"param", extra) + self.visit("param", extra) } - ty::ty_self(*) => self.leaf(~"self"), - ty::ty_type => self.leaf(~"type"), - ty::ty_opaque_box => self.leaf(~"opaque_box"), + ty::ty_self(*) => self.leaf("self"), + ty::ty_type => self.leaf("type"), + ty::ty_opaque_box => self.leaf("opaque_box"), ty::ty_opaque_closure_ptr(ck) => { let ckval = ast_sigil_constant(ck); let extra = ~[self.c_uint(ckval)]; - self.visit(~"closure_ptr", extra) + self.visit("closure_ptr", extra) } } } @@ -357,11 +357,11 @@ impl Reflector { let extra = ~[self.c_uint(i), self.c_uint(modeval), self.c_tydesc(*arg)]; - self.visit(~"fn_input", extra); + self.visit("fn_input", extra); } let extra = ~[self.c_uint(retval), self.c_tydesc(sig.output)]; - self.visit(~"fn_output", extra); + self.visit("fn_output", extra); } } diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs index df8de7b7cd5aa..1344bed96eec6 100644 --- a/src/librustc/middle/trans/tvec.rs +++ b/src/librustc/middle/trans/tvec.rs @@ -164,7 +164,7 @@ impl VecTypes { pub fn trans_fixed_vstore(bcx: block, vstore_expr: @ast::expr, - content_expr: @ast::expr, + content_expr: &ast::expr, dest: expr::Dest) -> block { //! @@ -286,7 +286,7 @@ pub fn trans_lit_str(bcx: block, pub fn trans_uniq_or_managed_vstore(bcx: block, heap: heap, vstore_expr: @ast::expr, - content_expr: @ast::expr) -> DatumBlock { + content_expr: &ast::expr) -> DatumBlock { //! // // @[...] or ~[...] (also @"..." or ~"...") allocate boxes in the @@ -346,7 +346,7 @@ pub fn trans_uniq_or_managed_vstore(bcx: block, heap: heap, vstore_expr: @ast::e pub fn write_content(bcx: block, vt: &VecTypes, vstore_expr: @ast::expr, - content_expr: @ast::expr, + content_expr: &ast::expr, dest: Dest) -> block { let _icx = push_ctxt("tvec::write_content"); @@ -471,7 +471,7 @@ pub fn write_content(bcx: block, } } -pub fn vec_types_from_expr(bcx: block, vec_expr: @ast::expr) -> VecTypes { +pub fn vec_types_from_expr(bcx: block, vec_expr: &ast::expr) -> VecTypes { let vec_ty = node_id_type(bcx, vec_expr.id); vec_types(bcx, vec_ty) } @@ -488,7 +488,7 @@ pub fn vec_types(bcx: block, vec_ty: ty::t) -> VecTypes { llunit_size: llunit_size} } -pub fn elements_required(bcx: block, content_expr: @ast::expr) -> uint { +pub fn elements_required(bcx: block, content_expr: &ast::expr) -> uint { //! Figure out the number of elements we need to store this content match content_expr.node { @@ -542,8 +542,6 @@ pub fn get_base_and_len(bcx: block, } } -pub type val_and_ty_fn = @fn(block, ValueRef, ty::t) -> Result; - pub type iter_vec_block<'self> = &'self fn(block, ValueRef, ty::t) -> block; pub fn iter_vec_raw(bcx: block, data_ptr: ValueRef, vec_ty: ty::t, diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs index 8cd776c99d697..c636b7f48761f 100644 --- a/src/librustc/middle/trans/type_use.rs +++ b/src/librustc/middle/trans/type_use.rs @@ -79,7 +79,7 @@ pub fn type_uses_for(ccx: @mut CrateContext, fn_id: def_id, n_tps: uint) ty::ty_bare_fn(ty::BareFnTy {sig: ref sig, _}) | ty::ty_closure(ty::ClosureTy {sig: ref sig, _}) => { for sig.inputs.iter().advance |arg| { - type_needs(cx, use_repr, *arg); + type_needs(&cx, use_repr, *arg); } } _ => () @@ -100,7 +100,7 @@ pub fn type_uses_for(ccx: @mut CrateContext, fn_id: def_id, n_tps: uint) ast_map::node_item(@ast::item { node: item_fn(_, _, _, _, ref body), _ }, _) | ast_map::node_method(@ast::method {body: ref body, _}, _, _) => { - handle_body(cx, body); + handle_body(&cx, body); } ast_map::node_trait_method(*) => { // This will be a static trait method. For now, we just assume @@ -177,7 +177,7 @@ pub fn type_uses_for(ccx: @mut CrateContext, fn_id: def_id, n_tps: uint) uses } -pub fn type_needs(cx: Context, use_: uint, ty: ty::t) { +pub fn type_needs(cx: &Context, use_: uint, ty: ty::t) { // Optimization -- don't descend type if all params already have this use let len = { let uses = &*cx.uses; @@ -191,7 +191,7 @@ pub fn type_needs(cx: Context, use_: uint, ty: ty::t) { } } -pub fn type_needs_inner(cx: Context, +pub fn type_needs_inner(cx: &Context, use_: uint, ty: ty::t, enums_seen: @List) { @@ -233,11 +233,11 @@ pub fn type_needs_inner(cx: Context, } } -pub fn node_type_needs(cx: Context, use_: uint, id: node_id) { +pub fn node_type_needs(cx: &Context, use_: uint, id: node_id) { type_needs(cx, use_, ty::node_id_to_type(cx.ccx.tcx, id)); } -pub fn mark_for_method_call(cx: Context, e_id: node_id, callee_id: node_id) { +pub fn mark_for_method_call(cx: &Context, e_id: node_id, callee_id: node_id) { let mut opt_static_did = None; { let r = cx.ccx.maps.method_map.find(&e_id); @@ -275,7 +275,7 @@ pub fn mark_for_method_call(cx: Context, e_id: node_id, callee_id: node_id) { } } -pub fn mark_for_expr(cx: Context, e: @expr) { +pub fn mark_for_expr(cx: &Context, e: &expr) { match e.node { expr_vstore(_, _) | expr_vec(_, _) | expr_struct(*) | expr_tup(_) | expr_unary(_, box(_), _) | expr_unary(_, uniq(_), _) | @@ -379,7 +379,7 @@ pub fn mark_for_expr(cx: Context, e: @expr) { } } -pub fn handle_body(cx: Context, body: &blk) { +pub fn handle_body(cx: &Context, body: &blk) { let v = visit::mk_vt(@visit::Visitor { visit_expr: |e, (cx, v)| { visit::visit_expr(e, (cx, v)); diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 242c617a0e876..d34befddad5f7 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -3017,7 +3017,7 @@ pub fn block_ty(cx: ctxt, b: &ast::blk) -> t { // Returns the type of a pattern as a monotype. Like @expr_ty, this function // doesn't provide type parameter substitutions. -pub fn pat_ty(cx: ctxt, pat: @ast::pat) -> t { +pub fn pat_ty(cx: ctxt, pat: &ast::pat) -> t { return node_id_to_type(cx, pat.id); } @@ -3033,11 +3033,11 @@ pub fn pat_ty(cx: ctxt, pat: @ast::pat) -> t { // ask for the type of "id" in "id(3)", it will return "fn(&int) -> int" // instead of "fn(t) -> T with T = int". If this isn't what you want, see // expr_ty_params_and_ty() below. -pub fn expr_ty(cx: ctxt, expr: @ast::expr) -> t { +pub fn expr_ty(cx: ctxt, expr: &ast::expr) -> t { return node_id_to_type(cx, expr.id); } -pub fn expr_ty_adjusted(cx: ctxt, expr: @ast::expr) -> t { +pub fn expr_ty_adjusted(cx: ctxt, expr: &ast::expr) -> t { /*! * * Returns the type of `expr`, considering any `AutoAdjustment` @@ -3191,7 +3191,7 @@ pub struct ParamsTy { } pub fn expr_ty_params_and_ty(cx: ctxt, - expr: @ast::expr) + expr: &ast::expr) -> ParamsTy { ParamsTy { params: node_id_to_type_params(cx, expr.id), @@ -3199,7 +3199,7 @@ pub fn expr_ty_params_and_ty(cx: ctxt, } } -pub fn expr_has_ty_params(cx: ctxt, expr: @ast::expr) -> bool { +pub fn expr_has_ty_params(cx: ctxt, expr: &ast::expr) -> bool { return node_id_has_type_params(cx, expr.id); } @@ -3235,7 +3235,7 @@ pub fn method_call_type_param_defs( } } -pub fn resolve_expr(tcx: ctxt, expr: @ast::expr) -> ast::def { +pub fn resolve_expr(tcx: ctxt, expr: &ast::expr) -> ast::def { match tcx.def_map.find(&expr.id) { Some(&def) => def, None => { @@ -3247,7 +3247,7 @@ pub fn resolve_expr(tcx: ctxt, expr: @ast::expr) -> ast::def { pub fn expr_is_lval(tcx: ctxt, method_map: typeck::method_map, - e: @ast::expr) -> bool { + e: &ast::expr) -> bool { match expr_kind(tcx, method_map, e) { LvalueExpr => true, RvalueDpsExpr | RvalueDatumExpr | RvalueStmtExpr => false @@ -3268,7 +3268,7 @@ pub enum ExprKind { pub fn expr_kind(tcx: ctxt, method_map: typeck::method_map, - expr: @ast::expr) -> ExprKind { + expr: &ast::expr) -> ExprKind { if method_map.contains_key(&expr.id) { // Overloaded operations are generally calls, and hence they are // generated via DPS. However, assign_op (e.g., `x += y`) is an @@ -3388,7 +3388,7 @@ pub fn expr_kind(tcx: ctxt, } } -pub fn stmt_node_id(s: @ast::stmt) -> ast::node_id { +pub fn stmt_node_id(s: &ast::stmt) -> ast::node_id { match s.node { ast::stmt_decl(_, id) | stmt_expr(_, id) | stmt_semi(_, id) => { return id; @@ -4374,7 +4374,7 @@ pub fn normalize_ty(cx: ctxt, t: t) -> t { } // Returns the repeat count for a repeating vector expression. -pub fn eval_repeat_count(tcx: ctxt, count_expr: @ast::expr) -> uint { +pub fn eval_repeat_count(tcx: ctxt, count_expr: &ast::expr) -> uint { match const_eval::eval_const_expr_partial(tcx, count_expr) { Ok(ref const_val) => match *const_val { const_eval::const_int(count) => if count < 0 { diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 997061a61ba63..b7242e64f230b 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -248,7 +248,7 @@ pub static NO_TPS: uint = 2; // internal notion of a type. `getter` is a function that returns the type // corresponding to a definition ID: pub fn ast_ty_to_ty( - this: &AC, rscope: &RS, ast_ty: @ast::Ty) -> ty::t { + this: &AC, rscope: &RS, ast_ty: &ast::Ty) -> ty::t { fn ast_mt_to_mt( this: &AC, rscope: &RS, mt: &ast::mt) -> ty::mt { diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index 338342f9307d0..777b11186c6ff 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -329,11 +329,9 @@ impl<'self> LookupContext<'self> { let opt_applicable_traits = trait_map.find(&self.expr.id); for opt_applicable_traits.iter().advance |applicable_traits| { for applicable_traits.iter().advance |trait_did| { - let coherence_info = self.fcx.ccx.coherence_info; - // Look for explicit implementations. let opt_impl_infos = - coherence_info.extension_methods.find(trait_did); + self.fcx.ccx.coherence_info.extension_methods.find(trait_did); for opt_impl_infos.iter().advance |impl_infos| { for impl_infos.iter().advance |impl_info| { self.push_candidates_from_impl( diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index a38a2dced93b6..97e0cd4baf844 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -284,7 +284,7 @@ pub fn blank_fn_ctxt(ccx: @mut CrateCtxt, } } -pub fn check_item_types(ccx: @mut CrateCtxt, crate: @ast::crate) { +pub fn check_item_types(ccx: @mut CrateCtxt, crate: &ast::crate) { let visit = visit::mk_simple_visitor(@visit::SimpleVisitor { visit_item: |a| check_item(ccx, a), .. *visit::default_simple_visitor() diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index bd99a8e150b7c..6da9895534b03 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/src/librustc/middle/typeck/coherence.rs @@ -197,7 +197,7 @@ pub struct CoherenceChecker { } impl CoherenceChecker { - pub fn check_coherence(self, crate: @crate) { + pub fn check_coherence(self, crate: &crate) { // Check implementations and traits. This populates the tables // containing the inherent methods and extension methods. It also // builds up the trait inheritance table. @@ -455,7 +455,7 @@ impl CoherenceChecker { } pub fn check_implementation_coherence(&self) { - let coherence_info = self.crate_context.coherence_info; + let coherence_info = &self.crate_context.coherence_info; for coherence_info.extension_methods.each_key |&trait_id| { self.check_implementation_coherence_of(trait_id); } @@ -514,7 +514,7 @@ impl CoherenceChecker { } pub fn iter_impls_of_trait(&self, trait_def_id: def_id, f: &fn(@Impl)) { - let coherence_info = self.crate_context.coherence_info; + let coherence_info = &self.crate_context.coherence_info; let extension_methods = &*coherence_info.extension_methods; match extension_methods.find(&trait_def_id) { @@ -631,7 +631,7 @@ impl CoherenceChecker { } // Privileged scope checking - pub fn check_privileged_scopes(self, crate: @crate) { + pub fn check_privileged_scopes(self, crate: &crate) { visit_crate(crate, ((), mk_vt(@Visitor { visit_item: |item, (_context, visitor)| { match item.node { @@ -978,7 +978,7 @@ impl CoherenceChecker { // pub fn populate_destructor_table(&self) { - let coherence_info = self.crate_context.coherence_info; + let coherence_info = &self.crate_context.coherence_info; let tcx = self.crate_context.tcx; let drop_trait = tcx.lang_items.drop_trait(); let impls_opt = coherence_info.extension_methods.find(&drop_trait); @@ -1102,7 +1102,7 @@ fn subst_receiver_types_in_method_ty(tcx: ty::ctxt, ) } -pub fn check_coherence(crate_context: @mut CrateCtxt, crate: @crate) { - let coherence_checker = @CoherenceChecker(crate_context); +pub fn check_coherence(crate_context: @mut CrateCtxt, crate: &crate) { + let coherence_checker = CoherenceChecker(crate_context); coherence_checker.check_coherence(crate); } diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index 7812a0ed0ebac..0e118adb8f42e 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -61,8 +61,8 @@ use syntax::visit; use syntax::opt_vec::OptVec; use syntax::opt_vec; -pub fn collect_item_types(ccx: @mut CrateCtxt, crate: @ast::crate) { - fn collect_intrinsic_type(ccx: @mut CrateCtxt, +pub fn collect_item_types(ccx: @mut CrateCtxt, crate: &ast::crate) { + fn collect_intrinsic_type(ccx: &CrateCtxt, lang_item: ast::def_id) { let ty::ty_param_bounds_and_ty { ty: ty, _ } = ccx.get_item_ty(lang_item); @@ -83,7 +83,7 @@ pub fn collect_item_types(ccx: @mut CrateCtxt, crate: @ast::crate) { impl CrateCtxt { fn to_ty( - &self, rs: &RS, ast_ty: @ast::Ty) -> ty::t + &self, rs: &RS, ast_ty: &ast::Ty) -> ty::t { ast_ty_to_ty(self, rs, ast_ty) } @@ -632,7 +632,7 @@ pub fn check_methods_against_trait(ccx: &CrateCtxt, generics: &ast::Generics, rp: Option, selfty: ty::t, - a_trait_ty: @ast::trait_ref, + a_trait_ty: &ast::trait_ref, impl_ms: &[ConvertedMethod]) { let tcx = ccx.tcx; @@ -670,7 +670,7 @@ pub fn check_methods_against_trait(ccx: &CrateCtxt, pub fn convert_field(ccx: &CrateCtxt, rp: Option, type_param_defs: @~[ty::TypeParameterDef], - v: @ast::struct_field, + v: &ast::struct_field, generics: &ast::Generics) { let region_parameterization = RegionParameterization::from_variance_and_generics(rp, generics); @@ -736,7 +736,7 @@ pub fn convert_methods(ccx: &CrateCtxt, }); fn ty_of_method(ccx: &CrateCtxt, - m: @ast::method, + m: &ast::method, rp: Option, untransformed_rcvr_ty: ty::t, rcvr_generics: &ast::Generics, @@ -785,7 +785,7 @@ pub fn ensure_no_ty_param_bounds(ccx: &CrateCtxt, } } -pub fn convert(ccx: &CrateCtxt, it: @ast::item) { +pub fn convert(ccx: &CrateCtxt, it: &ast::item) { let tcx = ccx.tcx; let rp = tcx.region_paramd_items.find(&it.id).map_consume(|x| *x); debug!("convert: item %s with id %d rp %?", @@ -875,7 +875,7 @@ pub fn convert(ccx: &CrateCtxt, it: @ast::item) { pub fn convert_struct(ccx: &CrateCtxt, rp: Option, - struct_def: @ast::struct_def, + struct_def: &ast::struct_def, generics: &ast::Generics, tpt: ty::ty_param_bounds_and_ty, id: ast::node_id) { @@ -914,7 +914,7 @@ pub fn convert_struct(ccx: &CrateCtxt, } } -pub fn convert_foreign(ccx: &CrateCtxt, i: @ast::foreign_item) { +pub fn convert_foreign(ccx: &CrateCtxt, i: &ast::foreign_item) { // As above, this call populates the type table with the converted // type of the foreign item. We simply write it into the node type // table. @@ -937,7 +937,7 @@ pub fn convert_foreign(ccx: &CrateCtxt, i: @ast::foreign_item) { } pub fn instantiate_trait_ref(ccx: &CrateCtxt, - ast_trait_ref: @ast::trait_ref, + ast_trait_ref: &ast::trait_ref, rp: Option, generics: &ast::Generics, self_ty: ty::t) -> @ty::TraitRef @@ -983,7 +983,7 @@ fn get_trait_def(ccx: &CrateCtxt, trait_id: ast::def_id) -> @ty::TraitDef { } } -pub fn trait_def_of_item(ccx: &CrateCtxt, it: @ast::item) -> @ty::TraitDef { +pub fn trait_def_of_item(ccx: &CrateCtxt, it: &ast::item) -> @ty::TraitDef { let def_id = local_def(it.id); let tcx = ccx.tcx; match tcx.trait_defs.find(&def_id) { @@ -1011,7 +1011,7 @@ pub fn trait_def_of_item(ccx: &CrateCtxt, it: @ast::item) -> @ty::TraitDef { } } -pub fn ty_of_item(ccx: &CrateCtxt, it: @ast::item) +pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::item) -> ty::ty_param_bounds_and_ty { let def_id = local_def(it.id); let tcx = ccx.tcx; @@ -1103,7 +1103,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: @ast::item) } pub fn ty_of_foreign_item(ccx: &CrateCtxt, - it: @ast::foreign_item, + it: &ast::foreign_item, abis: AbiSet) -> ty::ty_param_bounds_and_ty { match it.node { diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index 99fa745fa8b0b..d834998d4ee23 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -182,7 +182,7 @@ pub struct CrateCtxt { trait_map: resolve::TraitMap, method_map: method_map, vtable_map: vtable_map, - coherence_info: @coherence::CoherenceInfo, + coherence_info: coherence::CoherenceInfo, tcx: ty::ctxt } @@ -220,7 +220,7 @@ pub fn lookup_def_tcx(tcx: ty::ctxt, sp: span, id: ast::node_id) -> ast::def { } } -pub fn lookup_def_ccx(ccx: @mut CrateCtxt, sp: span, id: ast::node_id) +pub fn lookup_def_ccx(ccx: &CrateCtxt, sp: span, id: ast::node_id) -> ast::def { lookup_def_tcx(ccx.tcx, sp, id) } @@ -276,11 +276,11 @@ trait get_and_find_region { } impl get_and_find_region for isr_alist { - fn get(&self, br: ty::bound_region) -> ty::Region { + pub fn get(&self, br: ty::bound_region) -> ty::Region { self.find(br).get() } - fn find(&self, br: ty::bound_region) -> Option { + pub fn find(&self, br: ty::bound_region) -> Option { for list::each(*self) |isr| { let (isr_br, isr_r) = *isr; if isr_br == br { return Some(isr_r); } @@ -289,7 +289,7 @@ impl get_and_find_region for isr_alist { } } -fn check_main_fn_ty(ccx: @mut CrateCtxt, +fn check_main_fn_ty(ccx: &CrateCtxt, main_id: ast::node_id, main_span: span) { let tcx = ccx.tcx; @@ -330,7 +330,7 @@ fn check_main_fn_ty(ccx: @mut CrateCtxt, } } -fn check_start_fn_ty(ccx: @mut CrateCtxt, +fn check_start_fn_ty(ccx: &CrateCtxt, start_id: ast::node_id, start_span: span) { let tcx = ccx.tcx; @@ -379,7 +379,7 @@ fn check_start_fn_ty(ccx: @mut CrateCtxt, } } -fn check_for_entry_fn(ccx: @mut CrateCtxt) { +fn check_for_entry_fn(ccx: &CrateCtxt) { let tcx = ccx.tcx; if !*tcx.sess.building_library { match *tcx.sess.entry_fn { @@ -395,14 +395,14 @@ fn check_for_entry_fn(ccx: @mut CrateCtxt) { pub fn check_crate(tcx: ty::ctxt, trait_map: resolve::TraitMap, - crate: @ast::crate) + crate: &ast::crate) -> (method_map, vtable_map) { let time_passes = tcx.sess.time_passes(); let ccx = @mut CrateCtxt { trait_map: trait_map, method_map: @mut HashMap::new(), vtable_map: @mut HashMap::new(), - coherence_info: @coherence::CoherenceInfo(), + coherence_info: coherence::CoherenceInfo(), tcx: tcx }; diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs index 6d39495002a4e..aba7a01f869c9 100644 --- a/src/librustpkg/util.rs +++ b/src/librustpkg/util.rs @@ -331,7 +331,7 @@ pub fn find_and_install_dependencies(ctxt: &Ctx, debug!("In find_and_install_dependencies..."); let my_workspace = copy *workspace; let my_ctxt = copy *ctxt; - for c.each_view_item() |vi: @ast::view_item| { + for c.each_view_item() |vi: &ast::view_item| { debug!("A view item!"); match vi.node { // ignore metadata, I guess diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index d381f934d9ad1..3abbe3970540e 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -124,7 +124,7 @@ pub fn mk_ast_map_visitor() -> vt { }); } -pub fn map_crate(diag: @span_handler, c: @crate) -> map { +pub fn map_crate(diag: @span_handler, c: &crate) -> map { let cx = @mut Ctx { map: @mut HashMap::new(), path: ~[], diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index fd8fbc72e57fb..9ba7cb3c818ea 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -565,11 +565,11 @@ pub fn walk_pat(pat: @pat, it: &fn(@pat) -> bool) -> bool { } pub trait EachViewItem { - pub fn each_view_item(&self, f: @fn(@ast::view_item) -> bool) -> bool; + pub fn each_view_item(&self, f: @fn(&ast::view_item) -> bool) -> bool; } impl EachViewItem for ast::crate { - fn each_view_item(&self, f: @fn(@ast::view_item) -> bool) -> bool { + fn each_view_item(&self, f: @fn(&ast::view_item) -> bool) -> bool { let broke = @mut false; let vtor: visit::vt<()> = visit::mk_simple_visitor(@visit::SimpleVisitor { visit_view_item: |vi| { *broke = f(vi); }, ..*visit::default_simple_visitor() @@ -579,7 +579,7 @@ impl EachViewItem for ast::crate { } } -pub fn view_path_id(p: @view_path) -> node_id { +pub fn view_path_id(p: &view_path) -> node_id { match p.node { view_path_simple(_, _, id) | view_path_glob(_, id) | diff --git a/src/libsyntax/ext/deriving/cmp/totaleq.rs b/src/libsyntax/ext/deriving/cmp/totaleq.rs index ccfb34a3a2f54..70ac4d3d4c18d 100644 --- a/src/libsyntax/ext/deriving/cmp/totaleq.rs +++ b/src/libsyntax/ext/deriving/cmp/totaleq.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::prelude::*; - use ast::{meta_item, item, expr}; use codemap::span; use ext::base::ExtCtxt; diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 7fc784320ac1d..15f915ba4d8da 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -644,7 +644,7 @@ pub fn core_macros() -> @str { } pub fn expand_crate(parse_sess: @mut parse::ParseSess, - cfg: ast::crate_cfg, c: @crate) -> @crate { + cfg: ast::crate_cfg, c: &crate) -> @crate { // adding *another* layer of indirection here so that the block // visitor can swap out one exts table for another for the duration // of the block. The cleaner alternative would be to thread the @@ -695,7 +695,7 @@ pub fn expand_crate(parse_sess: @mut parse::ParseSess, // as it registers all the core macros as expanders. f.fold_item(cm); - @f.fold_crate(&*c) + @f.fold_crate(c) } // given a function from idents to idents, produce diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index f0a993dbb9423..9fcffc110130e 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -39,7 +39,7 @@ pub enum fn_kind<'self> { // fn foo(&self) fk_method(ident, &'self Generics, &'self method), - // fn@(x, y) { ... } + // @fn(x, y) { ... } fk_anon(ast::Sigil), // |x, y| ... @@ -129,9 +129,9 @@ pub fn visit_mod(m: &_mod, _sp: span, _id: node_id, (e, v): (E, vt)) for m.items.iter().advance |i| { (v.visit_item)(*i, (copy e, v)); } } -pub fn visit_view_item(_vi: @view_item, (_e, _v): (E, vt)) { } +pub fn visit_view_item(_vi: &view_item, (_e, _v): (E, vt)) { } -pub fn visit_local(loc: @local, (e, v): (E, vt)) { +pub fn visit_local(loc: &local, (e, v): (E, vt)) { (v.visit_pat)(loc.node.pat, (copy e, v)); (v.visit_ty)(loc.node.ty, (copy e, v)); match loc.node.init { @@ -140,11 +140,11 @@ pub fn visit_local(loc: @local, (e, v): (E, vt)) { } } -fn visit_trait_ref(tref: @ast::trait_ref, (e, v): (E, vt)) { +fn visit_trait_ref(tref: &ast::trait_ref, (e, v): (E, vt)) { visit_path(tref.path, (e, v)); } -pub fn visit_item(i: @item, (e, v): (E, vt)) { +pub fn visit_item(i: &item, (e, v): (E, vt)) { match i.node { item_static(t, _, ex) => { (v.visit_ty)(t, (copy e, v)); @@ -230,9 +230,9 @@ pub fn visit_enum_def(enum_definition: &ast::enum_def, } } -pub fn skip_ty(_t: @Ty, (_e,_v): (E, vt)) {} +pub fn skip_ty(_t: &Ty, (_e,_v): (E, vt)) {} -pub fn visit_ty(t: @Ty, (e, v): (E, vt)) { +pub fn visit_ty(t: &Ty, (e, v): (E, vt)) { match t.node { ty_box(mt) | ty_uniq(mt) | ty_vec(mt) | ty_ptr(mt) | ty_rptr(_, mt) => { @@ -268,11 +268,11 @@ pub fn visit_ty(t: @Ty, (e, v): (E, vt)) { } } -pub fn visit_path(p: @Path, (e, v): (E, vt)) { +pub fn visit_path(p: &Path, (e, v): (E, vt)) { for p.types.iter().advance |tp| { (v.visit_ty)(*tp, (copy e, v)); } } -pub fn visit_pat(p: @pat, (e, v): (E, vt)) { +pub fn visit_pat(p: &pat, (e, v): (E, vt)) { match p.node { pat_enum(path, ref children) => { visit_path(path, (copy e, v)); @@ -322,7 +322,7 @@ pub fn visit_pat(p: @pat, (e, v): (E, vt)) { } } -pub fn visit_foreign_item(ni: @foreign_item, (e, v): (E, vt)) { +pub fn visit_foreign_item(ni: &foreign_item, (e, v): (E, vt)) { match ni.node { foreign_item_fn(ref fd, _, ref generics) => { visit_fn_decl(fd, (copy e, v)); @@ -410,11 +410,11 @@ pub fn visit_struct_def( } } -pub fn visit_struct_field(sf: @struct_field, (e, v): (E, vt)) { +pub fn visit_struct_field(sf: &struct_field, (e, v): (E, vt)) { (v.visit_ty)(sf.node.ty, (e, v)); } -pub fn visit_struct_method(m: @method, (e, v): (E, vt)) { +pub fn visit_struct_method(m: &method, (e, v): (E, vt)) { visit_method_helper(m, (e, v)); } @@ -428,7 +428,7 @@ pub fn visit_block(b: &blk, (e, v): (E, vt)) { visit_expr_opt(b.node.expr, (e, v)); } -pub fn visit_stmt(s: @stmt, (e, v): (E, vt)) { +pub fn visit_stmt(s: &stmt, (e, v): (E, vt)) { match s.node { stmt_decl(d, _) => (v.visit_decl)(d, (e, v)), stmt_expr(ex, _) => (v.visit_expr)(ex, (e, v)), @@ -437,7 +437,7 @@ pub fn visit_stmt(s: @stmt, (e, v): (E, vt)) { } } -pub fn visit_decl(d: @decl, (e, v): (E, vt)) { +pub fn visit_decl(d: &decl, (e, v): (E, vt)) { match d.node { decl_local(ref loc) => (v.visit_local)(*loc, (e, v)), decl_item(it) => (v.visit_item)(it, (e, v))