bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Remove many shared pointers

Browse source 
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.
This commit is contained in:
Philipp Brüschweiler 2013-06-27 15:04:22 +02:00
parent 0bad3e62b4
commit 7295a6da92
50 changed files with 388 additions and 427 deletions
Download patch file Download diff file Expand all files Collapse all files

24
src/librustc/driver/driver.rs
View file

@ -181,12 +181,12 @@ pub fn compile_rest(sess: Session,
let time_passes = sess.time_passes(); 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 { if phases.from == cu_parse || phases.from == cu_everything {
*sess.building_library = session::building_library( *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 // strip before expansion to allow macros to depend on
// configuration variables e.g/ in // configuration variables e.g/ in
@ -195,27 +195,25 @@ pub fn compile_rest(sess: Session,
// mod bar { macro_rules! baz!(() => {{}}) } // mod bar { macro_rules! baz!(() => {{}}) }
// //
// baz! should not use this definition unless foo is enabled. // baz! should not use this definition unless foo is enabled.
crate_opt = Some(time(time_passes, ~"configuration 1", || crate = time(time_passes, ~"configuration 1", ||
front::config::strip_unconfigured_items(crate_opt.unwrap()))); 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, syntax::ext::expand::expand_crate(sess.parse_sess, copy cfg,
crate_opt.unwrap()))); crate));
// strip again, in case expansion added anything with a #[cfg]. // strip again, in case expansion added anything with a #[cfg].
crate_opt = Some(time(time_passes, ~"configuration 2", || crate = time(time_passes, ~"configuration 2", ||
front::config::strip_unconfigured_items(crate_opt.unwrap()))); front::config::strip_unconfigured_items(crate));
crate_opt = Some(time(time_passes, ~"maybe building test harness", || crate = time(time_passes, ~"maybe building test harness", ||
front::test::modify_for_testing(sess, crate_opt.unwrap()))); 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); assert!(phases.from != cu_no_trans);
let mut crate = crate_opt.unwrap();
let (llcx, llmod, link_meta) = { let (llcx, llmod, link_meta) = {
crate = time(time_passes, ~"extra injection", || crate = time(time_passes, ~"extra injection", ||
front::std_inject::maybe_inject_libstd_ref(sess, crate)); front::std_inject::maybe_inject_libstd_ref(sess, crate));

2
src/librustc/driver/session.rs
View file

@ -349,7 +349,7 @@ pub fn expect<T:Copy>(sess: Session,
} }
pub fn building_library(req_crate_type: crate_type, pub fn building_library(req_crate_type: crate_type,
crate: @ast::crate, crate: &ast::crate,
testing: bool) -> bool { testing: bool) -> bool {
match req_crate_type { match req_crate_type {
bin_crate => false, bin_crate => false,

13
src/librustc/front/config.rs
View file

@ -24,11 +24,11 @@ struct Context {
// any items that do not belong in the current configuration // any items that do not belong in the current configuration
pub fn strip_unconfigured_items(crate: @ast::crate) -> @ast::crate { pub fn strip_unconfigured_items(crate: @ast::crate) -> @ast::crate {
do strip_items(crate) |attrs| { 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 { -> @ast::crate {
let ctxt = @Context { in_cfg: in_cfg }; 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()}; .. *fold::default_ast_fold()};
let fold = fold::make_fold(precursor); let fold = fold::make_fold(precursor);
let res = @fold.fold_crate(&*crate); @fold.fold_crate(crate)
return res;
} }
fn filter_item(cx: @Context, item: @ast::item) -> 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 // Determine if an item should be translated in the current crate
// configuration based on the item's attributes // 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)) metas_in_cfg(cfg, attr::attr_metas(attrs))
} }
pub fn metas_in_cfg(cfg: ast::crate_cfg, pub fn metas_in_cfg(cfg: &[@ast::meta_item],
metas: ~[@ast::meta_item]) -> bool { metas: &[@ast::meta_item]) -> bool {
// The "cfg" attributes on the item // The "cfg" attributes on the item
let cfg_metas = attr::find_meta_items_by_name(metas, "cfg"); let cfg_metas = attr::find_meta_items_by_name(metas, "cfg");

4
src/librustc/front/std_inject.rs
View file

@ -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") !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<T:Copy>(x: T) -> codemap::spanned<T> { fn spanned<T:Copy>(x: T) -> codemap::spanned<T> {
codemap::spanned { node: x, span: dummy_sp() } codemap::spanned { node: x, span: dummy_sp() }
} }

2
src/librustc/front/test.rs
View file

@ -92,7 +92,7 @@ fn generate_test_harness(sess: session::Session,
return res; 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 // When not compiling with --test we should not compile the
// #[test] functions // #[test] functions
do config::strip_items(crate) |attrs| { do config::strip_items(crate) |attrs| {

30
src/librustc/metadata/creader.rs
View file

@ -18,7 +18,6 @@ use metadata::filesearch::FileSearch;
use metadata::loader; use metadata::loader;
use core::hashmap::HashMap; use core::hashmap::HashMap;
use core::vec;
use syntax::attr; use syntax::attr;
use syntax::codemap::{span, dummy_sp}; use syntax::codemap::{span, dummy_sp};
use syntax::diagnostic::span_handler; 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 // Traverses an AST, reading all the information about use'd crates and extern
// libraries necessary for later resolving, typechecking, linking, etc. // libraries necessary for later resolving, typechecking, linking, etc.
pub fn read_crates(diag: @span_handler, pub fn read_crates(diag: @span_handler,
crate: @ast::crate, crate: &ast::crate,
cstore: @mut cstore::CStore, cstore: @mut cstore::CStore,
filesearch: @FileSearch, filesearch: @FileSearch,
os: loader::os, os: loader::os,
@ -53,8 +52,8 @@ pub fn read_crates(diag: @span_handler,
.. *visit::default_simple_visitor()}); .. *visit::default_simple_visitor()});
visit_crate(e, crate); visit_crate(e, crate);
visit::visit_crate(crate, ((), v)); visit::visit_crate(crate, ((), v));
dump_crates(e.crate_cache); dump_crates(*e.crate_cache);
warn_if_multiple_versions(e, diag, e.crate_cache); warn_if_multiple_versions(e, diag, *e.crate_cache);
} }
struct cache_entry { struct cache_entry {
@ -64,7 +63,7 @@ struct cache_entry {
metas: @~[@ast::meta_item] metas: @~[@ast::meta_item]
} }
fn dump_crates(crate_cache: @mut ~[cache_entry]) { fn dump_crates(crate_cache: &[cache_entry]) {
debug!("resolved crates:"); debug!("resolved crates:");
for crate_cache.iter().advance |entry| { for crate_cache.iter().advance |entry| {
debug!("cnum: %?", entry.cnum); debug!("cnum: %?", entry.cnum);
@ -75,11 +74,9 @@ fn dump_crates(crate_cache: @mut ~[cache_entry]) {
fn warn_if_multiple_versions(e: @mut Env, fn warn_if_multiple_versions(e: @mut Env,
diag: @span_handler, diag: @span_handler,
crate_cache: @mut ~[cache_entry]) { crate_cache: &[cache_entry]) {
use core::either::*; use core::either::*;
let crate_cache = &mut *crate_cache;
if crate_cache.len() != 0u { if crate_cache.len() != 0u {
let name = loader::crate_name_from_metas( let name = loader::crate_name_from_metas(
*crate_cache[crate_cache.len() - 1].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 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 cstore = e.cstore;
let link_args = attr::find_attrs_by_name(c.node.attrs, "link_args"); 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 { match i.node {
ast::item_foreign_mod(ref fm) => { ast::item_foreign_mod(ref fm) => {
if fm.abis.is_rust() || fm.abis.is_intrinsic() { 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] { -> ~[@ast::meta_item] {
let name_items = attr::find_meta_items_by_name(metas, key); let name_items = attr::find_meta_items_by_name(metas, key);
if name_items.is_empty() { if name_items.is_empty() {
vec::append_one(metas, attr::mk_name_value_item_str(key, ident)) metas.push(attr::mk_name_value_item_str(key, ident));
} else {
metas
} }
metas
} }
fn metas_with_ident(ident: @str, metas: ~[@ast::meta_item]) 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) 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<int> { -> Option<int> {
for e.crate_cache.iter().advance |c| { for e.crate_cache.iter().advance |c| {
if loader::metadata_matches(*c.metas, metas) 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); return Some(c.cnum);
} }
} }

6
src/librustc/middle/borrowck/mod.rs
View file

@ -58,7 +58,7 @@ pub fn check_crate(
moves_map: moves::MovesMap, moves_map: moves::MovesMap,
moved_variables_set: moves::MovedVariablesSet, moved_variables_set: moves::MovedVariablesSet,
capture_map: moves::CaptureMap, capture_map: moves::CaptureMap,
crate: @ast::crate) -> (root_map, write_guard_map) crate: &ast::crate) -> (root_map, write_guard_map)
{ {
let bccx = @BorrowckCtxt { let bccx = @BorrowckCtxt {
tcx: tcx, tcx: tcx,
@ -507,7 +507,7 @@ impl BorrowckCtxt {
pub fn report_use_of_moved_value(&self, pub fn report_use_of_moved_value(&self,
use_span: span, use_span: span,
use_kind: MovedValueUseKind, use_kind: MovedValueUseKind,
lp: @LoanPath, lp: &LoanPath,
move: &move_data::Move, move: &move_data::Move,
moved_lp: @LoanPath) { moved_lp: @LoanPath) {
let verb = match use_kind { let verb = match use_kind {
@ -570,7 +570,7 @@ impl BorrowckCtxt {
pub fn report_reassigned_immutable_variable(&self, pub fn report_reassigned_immutable_variable(&self,
span: span, span: span,
lp: @LoanPath, lp: &LoanPath,
assign: assign:
&move_data::Assignment) { &move_data::Assignment) {
self.tcx.sess.span_err( self.tcx.sess.span_err(

2
src/librustc/middle/check_const.rs
View file

@ -21,7 +21,7 @@ use syntax::codemap;
use syntax::{visit, ast_util, ast_map}; use syntax::{visit, ast_util, ast_map};
pub fn check_crate(sess: Session, pub fn check_crate(sess: Session,
crate: @crate, crate: &crate,
ast_map: ast_map::map, ast_map: ast_map::map,
def_map: resolve::DefMap, def_map: resolve::DefMap,
method_map: typeck::method_map, method_map: typeck::method_map,

2
src/librustc/middle/check_loop.rs
View file

@ -19,7 +19,7 @@ pub struct Context {
can_ret: bool 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, visit::visit_crate(crate,
(Context { in_loop: false, can_ret: true }, (Context { in_loop: false, can_ret: true },
visit::mk_vt(@visit::Visitor { visit::mk_vt(@visit::Visitor {

32
src/librustc/middle/check_match.rs
View file

@ -36,7 +36,7 @@ pub struct MatchCheckCtxt {
pub fn check_crate(tcx: ty::ctxt, pub fn check_crate(tcx: ty::ctxt,
method_map: method_map, method_map: method_map,
moves_map: moves::MovesMap, moves_map: moves::MovesMap,
crate: @crate) { crate: &crate) {
let cx = @MatchCheckCtxt {tcx: tcx, let cx = @MatchCheckCtxt {tcx: tcx,
method_map: method_map, method_map: method_map,
moves_map: moves_map}; moves_map: moves_map};
@ -50,7 +50,7 @@ pub fn check_crate(tcx: ty::ctxt,
tcx.sess.abort_if_errors(); 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) { if !ty::expr_is_lval(cx.tcx, cx.method_map, expr) {
return false; return false;
} }
@ -108,7 +108,7 @@ pub fn check_expr(cx: @MatchCheckCtxt, ex: @expr, (s, v): ((), visit::vt<()>)) {
} }
// Check for unreachable patterns // Check for unreachable patterns
pub fn check_arms(cx: @MatchCheckCtxt, arms: &[arm]) { pub fn check_arms(cx: &MatchCheckCtxt, arms: &[arm]) {
let mut seen = ~[]; let mut seen = ~[];
for arms.iter().advance |arm| { for arms.iter().advance |arm| {
for arm.pats.iter().advance |pat| { 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())); assert!((!pats.is_empty()));
let ext = match is_useful(cx, &pats.map(|p| ~[*p]), [wild()]) { let ext = match is_useful(cx, &pats.map(|p| ~[*p]), [wild()]) {
not_useful => { not_useful => {
@ -205,7 +205,7 @@ pub enum ctor {
// Note: is_useful doesn't work on empty types, as the paper notes. // Note: is_useful doesn't work on empty types, as the paper notes.
// So it assumes that v is non-empty. // 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.len() == 0u { return useful_; }
if m[0].len() == 0u { return not_useful; } if m[0].len() == 0u { return not_useful; }
let real_pat = match m.iter().find_(|r| r[0].id != 0) { 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, m: &matrix,
v: &[@pat], v: &[@pat],
ctor: ctor, ctor: ctor,
@ -297,7 +297,7 @@ pub fn is_useful_specialized(cx: @MatchCheckCtxt,
} }
} }
pub fn pat_ctor_id(cx: @MatchCheckCtxt, p: @pat) -> Option<ctor> { pub fn pat_ctor_id(cx: &MatchCheckCtxt, p: @pat) -> Option<ctor> {
let pat = raw_pat(p); let pat = raw_pat(p);
match pat.node { match pat.node {
pat_wild => { None } pat_wild => { None }
@ -333,7 +333,7 @@ pub fn pat_ctor_id(cx: @MatchCheckCtxt, p: @pat) -> Option<ctor> {
} }
} }
pub fn is_wild(cx: @MatchCheckCtxt, p: @pat) -> bool { pub fn is_wild(cx: &MatchCheckCtxt, p: @pat) -> bool {
let pat = raw_pat(p); let pat = raw_pat(p);
match pat.node { match pat.node {
pat_wild => { true } 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, m: &matrix,
left_ty: ty::t) left_ty: ty::t)
-> Option<ctor> { -> Option<ctor> {
@ -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 { match ty::get(ty).sty {
ty::ty_tup(ref fs) => fs.len(), ty::ty_tup(ref fs) => fs.len(),
ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_rptr(*) => 1u, 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()} @pat {id: 0, node: pat_wild, span: dummy_sp()}
} }
pub fn specialize(cx: @MatchCheckCtxt, pub fn specialize(cx: &MatchCheckCtxt,
r: &[@pat], r: &[@pat],
ctor_id: &ctor, ctor_id: &ctor,
arity: uint, 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())) } if is_wild(cx, r[0]) { Some(vec::to_owned(r.tail())) }
else { None } else { None }
} }
pub fn check_local(cx: @MatchCheckCtxt, pub fn check_local(cx: &MatchCheckCtxt,
loc: @local, loc: @local,
(s, v): ((), (s, v): ((),
visit::vt<()>)) { visit::vt<()>)) {
@ -766,7 +766,7 @@ pub fn check_local(cx: @MatchCheckCtxt,
check_legality_of_move_bindings(cx, is_lvalue, false, [ loc.node.pat ]); 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, kind: &visit::fn_kind,
decl: &fn_decl, decl: &fn_decl,
body: &blk, 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) { match cx.tcx.def_map.find(&pat.id) {
Some(&def_variant(enum_id, _)) => { Some(&def_variant(enum_id, _)) => {
if ty::enum_variants(cx.tcx, enum_id).len() != 1u { 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 // 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, is_lvalue: bool,
has_guard: bool, has_guard: bool,
pats: &[@pat]) { pats: &[@pat]) {

20
src/librustc/middle/const_eval.rs
View file

@ -75,7 +75,7 @@ pub fn join_all(cs: &[constness]) -> constness {
cs.iter().fold(integral_const, |a, b| join(a, *b)) cs.iter().fold(integral_const, |a, b| join(a, *b))
} }
pub fn classify(e: @expr, pub fn classify(e: &expr,
tcx: ty::ctxt) tcx: ty::ctxt)
-> constness { -> constness {
let did = ast_util::local_def(e.id); 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) { match tcx.def_map.find(&e.id) {
Some(&ast::def_static(def_id, false)) => lookup_const_by_id(tcx, def_id), Some(&ast::def_static(def_id, false)) => lookup_const_by_id(tcx, def_id),
_ => None _ => 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) { match lookup_const(tcx, e) {
Some(rhs) => { Some(rhs) => {
let ty = ty::expr_ty(tcx, 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) { tcx: ty::ctxt) {
let v = visit::mk_simple_visitor(@visit::SimpleVisitor { let v = visit::mk_simple_visitor(@visit::SimpleVisitor {
visit_expr_post: |e| { classify(e, tcx); }, visit_expr_post: |e| { classify(e, tcx); },
@ -239,14 +239,14 @@ pub enum const_val {
const_bool(bool) 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) { match eval_const_expr_partial(tcx, e) {
Ok(r) => r, Ok(r) => r,
Err(s) => tcx.sess.span_fatal(e.span, s) 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<const_val, ~str> { -> Result<const_val, ~str> {
use middle::ty; use middle::ty;
fn fromb(b: bool) -> Result<const_val, ~str> { Ok(const_int(b as i64)) } fn fromb(b: bool) -> Result<const_val, ~str> { 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 { match lit.node {
lit_str(s) => const_str(s), lit_str(s) => const_str(s),
lit_int(n, _) => const_int(n), lit_int(n, _) => const_int(n),
@ -434,14 +434,14 @@ pub fn compare_const_vals(a: &const_val, b: &const_val) -> Option<int> {
} }
} }
pub fn compare_lit_exprs(tcx: middle::ty::ctxt, a: @expr, b: @expr) -> Option<int> { pub fn compare_lit_exprs(tcx: middle::ty::ctxt, a: &expr, b: &expr) -> Option<int> {
compare_const_vals(&eval_const_expr(tcx, a), &eval_const_expr(tcx, b)) 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<bool> { pub fn lit_expr_eq(tcx: middle::ty::ctxt, a: &expr, b: &expr) -> Option<bool> {
compare_lit_exprs(tcx, a, b).map(|&val| val == 0) compare_lit_exprs(tcx, a, b).map(|&val| val == 0)
} }
pub fn lit_eq(a: @lit, b: @lit) -> Option<bool> { pub fn lit_eq(a: &lit, b: &lit) -> Option<bool> {
compare_const_vals(&lit_to_const(a), &lit_to_const(b)).map(|&val| val == 0) compare_const_vals(&lit_to_const(a), &lit_to_const(b)).map(|&val| val == 0)
} }

2
src/librustc/middle/effect.rs
View file

@ -47,7 +47,7 @@ fn type_is_unsafe_function(ty: ty::t) -> bool {
pub fn check_crate(tcx: ty::ctxt, pub fn check_crate(tcx: ty::ctxt,
method_map: method_map, method_map: method_map,
crate: @ast::crate) { crate: &ast::crate) {
let context = @mut Context { let context = @mut Context {
method_map: method_map, method_map: method_map,
unsafe_context: SafeContext, unsafe_context: SafeContext,

2
src/librustc/middle/entry.rs
View file

@ -41,7 +41,7 @@ struct EntryContext {
type EntryVisitor = vt<@mut 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 // FIXME #4404 android JNI hacks
if *session.building_library && if *session.building_library &&

2
src/librustc/middle/freevars.rs
View file

@ -88,7 +88,7 @@ fn collect_freevars(def_map: resolve::DefMap, blk: &ast::blk)
// efficient as it fully recomputes the free variables at every // efficient as it fully recomputes the free variables at every
// node of interest rather than building up the free variables in // node of interest rather than building up the free variables in
// one pass. This could be improved upon if it turns out to matter. // 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 { freevar_map {
let freevars = @mut HashMap::new(); let freevars = @mut HashMap::new();

13
src/librustc/middle/kind.rs
View file

@ -17,7 +17,6 @@ use middle::typeck;
use util::ppaux::{Repr, ty_to_str}; use util::ppaux::{Repr, ty_to_str};
use util::ppaux::UserString; use util::ppaux::UserString;
use core::vec;
use syntax::ast::*; use syntax::ast::*;
use syntax::attr::attrs_contains_name; use syntax::attr::attrs_contains_name;
use syntax::codemap::span; use syntax::codemap::span;
@ -63,7 +62,7 @@ pub struct Context {
pub fn check_crate(tcx: ty::ctxt, pub fn check_crate(tcx: ty::ctxt,
method_map: typeck::method_map, method_map: typeck::method_map,
crate: @crate) { crate: &crate) {
let ctx = Context { let ctx = Context {
tcx: tcx, tcx: tcx,
method_map: method_map, method_map: method_map,
@ -163,7 +162,7 @@ fn check_item(item: @item, (cx, visitor): (Context, visit::vt<Context>)) {
// closure. // closure.
fn with_appropriate_checker(cx: Context, id: node_id, fn with_appropriate_checker(cx: Context, id: node_id,
b: &fn(checker: &fn(Context, @freevar_entry))) { 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 // all captured data must be owned, regardless of whether it is
// moved in or copied in. // moved in or copied in.
let id = ast_util::def_id_of_def(fv.def).node; 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); 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 // all captured data must be owned
let id = ast_util::def_id_of_def(fv.def).node; let id = ast_util::def_id_of_def(fv.def).node;
let var_t = ty::node_id_to_type(cx.tcx, id); 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); 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 id = ast_util::def_id_of_def(fv.def).node;
let var_t = ty::node_id_to_type(cx.tcx, id); let var_t = ty::node_id_to_type(cx.tcx, id);
check_freevar_bounds(cx, fv.span, var_t, bounds); 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. /// FIXME(#5723)---This code should probably move into regionck.
pub fn check_cast_for_escaping_regions( pub fn check_cast_for_escaping_regions(
cx: Context, cx: Context,
source: @expr, source: &expr,
target: @expr) target: &expr)
{ {
// Determine what type we are casting to; if it is not an trait, then no // Determine what type we are casting to; if it is not an trait, then no
// worries. // worries.

33
src/librustc/middle/lang_items.rs
View file

@ -281,9 +281,18 @@ impl LanguageItems {
} }
} }
fn LanguageItemCollector(crate: @crate, struct LanguageItemCollector<'self> {
session: Session) items: LanguageItems,
-> LanguageItemCollector {
crate: &'self crate,
session: Session,
item_refs: HashMap<@str, uint>,
}
impl<'self> LanguageItemCollector<'self> {
pub fn new<'a>(crate: &'a crate, session: Session) -> LanguageItemCollector<'a> {
let mut item_refs = HashMap::new(); let mut item_refs = HashMap::new();
item_refs.insert(@"const", ConstTraitLangItem as uint); item_refs.insert(@"const", ConstTraitLangItem as uint);
@ -342,19 +351,9 @@ fn LanguageItemCollector(crate: @crate,
} }
} }
struct LanguageItemCollector {
items: LanguageItems,
crate: @crate,
session: Session,
item_refs: HashMap<@str, uint>,
}
impl LanguageItemCollector {
pub fn match_and_collect_meta_item(&mut self, pub fn match_and_collect_meta_item(&mut self,
item_def_id: def_id, item_def_id: def_id,
meta_item: @meta_item) { meta_item: &meta_item) {
match meta_item.node { match meta_item.node {
meta_name_value(key, literal) => { meta_name_value(key, literal) => {
match literal.node { match literal.node {
@ -386,7 +385,7 @@ impl LanguageItemCollector {
pub fn match_and_collect_item(&mut self, pub fn match_and_collect_item(&mut self,
item_def_id: def_id, item_def_id: def_id,
key: @str, key: &str,
value: @str) { value: @str) {
if "lang" != key { if "lang" != key {
return; // Didn't match. 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) session: Session)
-> LanguageItems { -> LanguageItems {
let mut collector = LanguageItemCollector(crate, session); let mut collector = LanguageItemCollector::new(crate, session);
collector.collect(); collector.collect();
let LanguageItemCollector { items, _ } = collector; let LanguageItemCollector { items, _ } = collector;
session.abort_if_errors(); session.abort_if_errors();

12
src/librustc/middle/lint.rs
View file

@ -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 { match item.node {
ast::item_trait(_, _, ref methods) => { ast::item_trait(_, _, ref methods) => {
for methods.iter().advance |method| { 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_item_ctypes(cx: &Context, it: &ast::item) {
fn check_ty(cx: &Context, ty: @ast::Ty) { fn check_ty(cx: &Context, ty: &ast::Ty) {
match ty.node { match ty.node {
ast::ty_path(_, _, id) => { ast::ty_path(_, _, id) => {
match cx.tcx.def_map.get_copy(&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 { match it.node {
ast::item_fn(*) | ast::item_fn(*) |
ast::item_ty(*) | 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 { fn is_camel_case(cx: ty::ctxt, ident: ast::ident) -> bool {
let ident = cx.sess.str_of(ident); let ident = cx.sess.str_of(ident);
assert!(!ident.is_empty()); assert!(!ident.is_empty());
@ -973,7 +973,7 @@ fn lint_session() -> visit::vt<@mut Context> {
fn lint_unnecessary_allocations() -> visit::vt<@mut Context> { fn lint_unnecessary_allocations() -> visit::vt<@mut Context> {
// Warn if string and vector literals with sigils are immediately borrowed. // Warn if string and vector literals with sigils are immediately borrowed.
// Those can have the sigil removed. // Those can have the sigil removed.
fn check(cx: &Context, e: @ast::expr) { fn check(cx: &Context, e: &ast::expr) {
match e.node { match e.node {
ast::expr_vstore(e2, ast::expr_vstore_uniq) | ast::expr_vstore(e2, ast::expr_vstore_uniq) |
ast::expr_vstore(e2, ast::expr_vstore_box) => { ast::expr_vstore(e2, ast::expr_vstore_box) => {

18
src/librustc/middle/liveness.rs
View file

@ -150,7 +150,7 @@ fn live_node_kind_to_str(lnk: LiveNodeKind, cx: ty::ctxt) -> ~str {
pub fn check_crate(tcx: ty::ctxt, pub fn check_crate(tcx: ty::ctxt,
method_map: typeck::method_map, method_map: typeck::method_map,
capture_map: moves::CaptureMap, capture_map: moves::CaptureMap,
crate: @crate) { crate: &crate) {
let visitor = visit::mk_vt(@visit::Visitor { let visitor = visit::mk_vt(@visit::Visitor {
visit_fn: visit_fn, visit_fn: visit_fn,
visit_local: visit_local, visit_local: visit_local,
@ -322,7 +322,7 @@ impl IrMaps {
self.capture_info_map.insert(node_id, @cs); 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) { match self.capture_info_map.find(&expr.id) {
Some(&caps) => caps, Some(&caps) => caps,
None => { None => {
@ -596,7 +596,7 @@ impl Liveness {
} }
} }
pub fn variable_from_path(&self, expr: @expr) -> Option<Variable> { pub fn variable_from_path(&self, expr: &expr) -> Option<Variable> {
match expr.node { match expr.node {
expr_path(_) => { expr_path(_) => {
let def = self.tcx.def_map.get_copy(&expr.id); 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 { -> LiveNode {
match stmt.node { match stmt.node {
stmt_decl(decl, _) => { 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 { -> LiveNode {
match decl.node { match decl.node {
decl_local(ref local) => { 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 { -> LiveNode {
// Note: we mark the variable as defined regardless of whether // Note: we mark the variable as defined regardless of whether
// there is an initializer. Initially I had thought to only mark // there is an initializer. Initially I had thought to only mark
@ -1293,7 +1293,7 @@ impl Liveness {
} }
// see comment on propagate_through_lvalue() // 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 { -> LiveNode {
match expr.node { match expr.node {
expr_path(_) => self.access_path(expr, succ, acc), 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 { -> LiveNode {
let def = self.tcx.def_map.get_copy(&expr.id); let def = self.tcx.def_map.get_copy(&expr.id);
match moves::moved_variable_node_id_from_def(def) { match moves::moved_variable_node_id_from_def(def) {
@ -1324,7 +1324,7 @@ impl Liveness {
} }
pub fn propagate_through_loop(&self, pub fn propagate_through_loop(&self,
expr: @expr, expr: &expr,
cond: Option<@expr>, cond: Option<@expr>,
body: &blk, body: &blk,
succ: LiveNode) succ: LiveNode)

4
src/librustc/middle/moves.rs
View file

@ -190,7 +190,7 @@ enum UseMode {
pub fn compute_moves(tcx: ty::ctxt, pub fn compute_moves(tcx: ty::ctxt,
method_map: method_map, method_map: method_map,
crate: @crate) -> MoveMaps crate: &crate) -> MoveMaps
{ {
let visitor = visit::mk_vt(@visit::Visitor { let visitor = visit::mk_vt(@visit::Visitor {
visit_expr: compute_modes_for_expr, visit_expr: compute_modes_for_expr,
@ -521,7 +521,7 @@ impl VisitContext {
} }
pub fn use_overloaded_operator(&self, pub fn use_overloaded_operator(&self,
expr: @expr, expr: &expr,
receiver_expr: @expr, receiver_expr: @expr,
arg_exprs: &[@expr], arg_exprs: &[@expr],
visitor: vt<VisitContext>) visitor: vt<VisitContext>)

2
src/librustc/middle/pat_util.rs
View file

@ -29,7 +29,7 @@ pub fn pat_id_map(dm: resolve::DefMap, pat: @pat) -> PatIdMap {
map 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 { match pat.node {
pat_enum(_, _) | pat_ident(_, _, None) | pat_struct(*) => { pat_enum(_, _) | pat_ident(_, _, None) | pat_struct(*) => {
match dm.find(&pat.id) { match dm.find(&pat.id) {

2
src/librustc/middle/privacy.rs
View file

@ -40,7 +40,7 @@ use syntax::visit;
pub fn check_crate<'mm>(tcx: ty::ctxt, pub fn check_crate<'mm>(tcx: ty::ctxt,
method_map: &'mm method_map, method_map: &'mm method_map,
crate: @ast::crate) { crate: &ast::crate) {
let privileged_items = @mut ~[]; let privileged_items = @mut ~[];
// Adds an item to its scope. // Adds an item to its scope.

64
src/librustc/middle/region.rs
View file

@ -34,8 +34,6 @@ use syntax::parse::token;
use syntax::parse::token::special_idents; use syntax::parse::token::special_idents;
use syntax::{ast, visit}; use syntax::{ast, visit};
pub type parent = Option<ast::node_id>;
/** /**
The region maps encode information about region relationships. The region maps encode information about region relationships.
@ -68,10 +66,10 @@ pub struct Context {
region_maps: @mut RegionMaps, region_maps: @mut RegionMaps,
// Scope where variables should be parented to // Scope where variables should be parented to
var_parent: parent, var_parent: Option<ast::node_id>,
// Innermost enclosing expression // Innermost enclosing expression
parent: parent, parent: Option<ast::node_id>,
} }
impl RegionMaps { 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`. /// 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=%?)", debug!("region::parent_to_expr(span=%?)",
cx.sess.codemap.span_to_str(sp)); cx.sess.codemap.span_to_str(sp));
for cx.parent.iter().advance |parent_id| { 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<Context>)) { fn resolve_block(blk: &ast::blk, (cx, visitor): (Context, visit::vt<Context>)) {
// Record the parent of this block. // Record the parent of this block.
parent_to_expr(cx, blk.node.id, blk.span); 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<Context>
visit::visit_block(blk, (new_cx, visitor)); visit::visit_block(blk, (new_cx, visitor));
} }
pub fn resolve_arm(arm: &ast::arm, (cx, visitor): (Context, visit::vt<Context>)) { fn resolve_arm(arm: &ast::arm, (cx, visitor): (Context, visit::vt<Context>)) {
visit::visit_arm(arm, (cx, visitor)); visit::visit_arm(arm, (cx, visitor));
} }
pub fn resolve_pat(pat: @ast::pat, (cx, visitor): (Context, visit::vt<Context>)) { fn resolve_pat(pat: @ast::pat, (cx, visitor): (Context, visit::vt<Context>)) {
assert_eq!(cx.var_parent, cx.parent); assert_eq!(cx.var_parent, cx.parent);
parent_to_expr(cx, pat.id, pat.span); parent_to_expr(cx, pat.id, pat.span);
visit::visit_pat(pat, (cx, visitor)); visit::visit_pat(pat, (cx, visitor));
} }
pub fn resolve_stmt(stmt: @ast::stmt, (cx, visitor): (Context, visit::vt<Context>)) { fn resolve_stmt(stmt: @ast::stmt, (cx, visitor): (Context, visit::vt<Context>)) {
match stmt.node { match stmt.node {
ast::stmt_decl(*) => { ast::stmt_decl(*) => {
visit::visit_stmt(stmt, (cx, visitor)); visit::visit_stmt(stmt, (cx, visitor));
@ -370,7 +356,7 @@ pub fn resolve_stmt(stmt: @ast::stmt, (cx, visitor): (Context, visit::vt<Context
} }
} }
pub fn resolve_expr(expr: @ast::expr, (cx, visitor): (Context, visit::vt<Context>)) { fn resolve_expr(expr: @ast::expr, (cx, visitor): (Context, visit::vt<Context>)) {
parent_to_expr(cx, expr.id, expr.span); parent_to_expr(cx, expr.id, expr.span);
let mut new_cx = cx; let mut new_cx = cx;
@ -409,7 +395,7 @@ pub fn resolve_expr(expr: @ast::expr, (cx, visitor): (Context, visit::vt<Context
visit::visit_expr(expr, (new_cx, visitor)); visit::visit_expr(expr, (new_cx, visitor));
} }
pub fn resolve_local(local: @ast::local, fn resolve_local(local: @ast::local,
(cx, visitor) : (Context, (cx, visitor) : (Context,
visit::vt<Context>)) { visit::vt<Context>)) {
assert_eq!(cx.var_parent, cx.parent); assert_eq!(cx.var_parent, cx.parent);
@ -417,13 +403,13 @@ pub fn resolve_local(local: @ast::local,
visit::visit_local(local, (cx, visitor)); visit::visit_local(local, (cx, visitor));
} }
pub fn resolve_item(item: @ast::item, (cx, visitor): (Context, visit::vt<Context>)) { fn resolve_item(item: @ast::item, (cx, visitor): (Context, visit::vt<Context>)) {
// Items create a new outer block scope as far as we're concerned. // Items create a new outer block scope as far as we're concerned.
let new_cx = Context {var_parent: None, parent: None, ..cx}; let new_cx = Context {var_parent: None, parent: None, ..cx};
visit::visit_item(item, (new_cx, visitor)); visit::visit_item(item, (new_cx, visitor));
} }
pub fn resolve_fn(fk: &visit::fn_kind, fn resolve_fn(fk: &visit::fn_kind,
decl: &ast::fn_decl, decl: &ast::fn_decl,
body: &ast::blk, body: &ast::blk,
sp: span, sp: span,
@ -468,7 +454,7 @@ pub fn resolve_fn(fk: &visit::fn_kind,
pub fn resolve_crate(sess: Session, pub fn resolve_crate(sess: Session,
def_map: resolve::DefMap, def_map: resolve::DefMap,
crate: @ast::crate) -> @mut RegionMaps crate: &ast::crate) -> @mut RegionMaps
{ {
let region_maps = @mut RegionMaps { let region_maps = @mut RegionMaps {
scope_map: HashMap::new(), scope_map: HashMap::new(),
@ -522,14 +508,12 @@ pub struct region_dep {
id: ast::node_id id: ast::node_id
} }
pub type dep_map = @mut HashMap<ast::node_id, @mut ~[region_dep]>;
pub struct DetermineRpCtxt { pub struct DetermineRpCtxt {
sess: Session, sess: Session,
ast_map: ast_map::map, ast_map: ast_map::map,
def_map: resolve::DefMap, def_map: resolve::DefMap,
region_paramd_items: region_paramd_items, region_paramd_items: region_paramd_items,
dep_map: dep_map, dep_map: @mut HashMap<ast::node_id, @mut ~[region_dep]>,
worklist: ~[ast::node_id], worklist: ~[ast::node_id],
// the innermost enclosing item id // the innermost enclosing item id
@ -619,14 +603,8 @@ impl DetermineRpCtxt {
ast_map::node_id_to_str(self.ast_map, self.item_id, ast_map::node_id_to_str(self.ast_map, self.item_id,
token::get_ident_interner()), token::get_ident_interner()),
copy self.ambient_variance); copy self.ambient_variance);
let vec = match self.dep_map.find(&from) { let vec = do self.dep_map.find_or_insert_with(from) |_| {
Some(&vec) => vec, @mut ~[]
None => {
let vec = @mut ~[];
let dep_map = self.dep_map;
dep_map.insert(from, vec);
vec
}
}; };
let dep = region_dep { let dep = region_dep {
ambient_variance: self.ambient_variance, ambient_variance: self.ambient_variance,
@ -715,7 +693,7 @@ impl DetermineRpCtxt {
} }
} }
pub fn determine_rp_in_item(item: @ast::item, fn determine_rp_in_item(item: @ast::item,
(cx, visitor): (@mut DetermineRpCtxt, (cx, visitor): (@mut DetermineRpCtxt,
visit::vt<@mut DetermineRpCtxt>)) { visit::vt<@mut DetermineRpCtxt>)) {
do cx.with(item.id, true) { do cx.with(item.id, true) {
@ -723,7 +701,7 @@ pub fn determine_rp_in_item(item: @ast::item,
} }
} }
pub fn determine_rp_in_fn(fk: &visit::fn_kind, fn determine_rp_in_fn(fk: &visit::fn_kind,
decl: &ast::fn_decl, decl: &ast::fn_decl,
body: &ast::blk, body: &ast::blk,
_: span, _: span,
@ -743,7 +721,7 @@ pub fn determine_rp_in_fn(fk: &visit::fn_kind,
} }
} }
pub fn determine_rp_in_ty_method(ty_m: &ast::ty_method, fn determine_rp_in_ty_method(ty_m: &ast::ty_method,
(cx, visitor): (@mut DetermineRpCtxt, (cx, visitor): (@mut DetermineRpCtxt,
visit::vt<@mut DetermineRpCtxt>)) { visit::vt<@mut DetermineRpCtxt>)) {
do cx.with(cx.item_id, false) { do cx.with(cx.item_id, false) {
@ -751,7 +729,7 @@ pub fn determine_rp_in_ty_method(ty_m: &ast::ty_method,
} }
} }
pub fn determine_rp_in_ty(ty: @ast::Ty, fn determine_rp_in_ty(ty: @ast::Ty,
(cx, visitor): (@mut DetermineRpCtxt, (cx, visitor): (@mut DetermineRpCtxt,
visit::vt<@mut DetermineRpCtxt>)) { visit::vt<@mut DetermineRpCtxt>)) {
// we are only interested in types that will require an item to // we are only interested in types that will require an item to
@ -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, cm: @ast::struct_field,
(cx, visitor): (@mut DetermineRpCtxt, (cx, visitor): (@mut DetermineRpCtxt,
visit::vt<@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, pub fn determine_rp_in_crate(sess: Session,
ast_map: ast_map::map, ast_map: ast_map::map,
def_map: resolve::DefMap, def_map: resolve::DefMap,
crate: @ast::crate) crate: &ast::crate)
-> region_paramd_items { -> region_paramd_items {
let cx = @mut DetermineRpCtxt { let cx = @mut DetermineRpCtxt {
sess: sess, sess: sess,

8
src/librustc/middle/trans/_match.rs
View file

@ -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) { pub fn assert_is_binding_or_wild(bcx: block, p: @ast::pat) {
if !pat_is_binding_or_wild(bcx.tcx().def_map, p) { if !pat_is_binding_or_wild(bcx.tcx().def_map, p) {
bcx.sess().span_bug( 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, pub fn enter_match<'r>(bcx: block,
dm: DefMap, dm: DefMap,
m: &[@Match<'r>], 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 type mk_fail = @fn() -> BasicBlockRef;
pub fn pick_col(m: &[@Match]) -> uint { pub fn pick_col(m: &[@Match]) -> uint {
fn score(p: @ast::pat) -> uint { fn score(p: &ast::pat) -> uint {
match p.node { match p.node {
ast::pat_lit(_) | ast::pat_enum(_, _) | ast::pat_range(_, _) => 1u, ast::pat_lit(_) | ast::pat_enum(_, _) | ast::pat_range(_, _) => 1u,
ast::pat_ident(_, _, Some(p)) => score(p), ast::pat_ident(_, _, Some(p)) => score(p),
@ -1609,7 +1609,7 @@ pub fn compile_submatch(bcx: block,
} }
pub fn trans_match(bcx: block, pub fn trans_match(bcx: block,
match_expr: @ast::expr, match_expr: &ast::expr,
discr_expr: @ast::expr, discr_expr: @ast::expr,
arms: ~[ast::arm], arms: ~[ast::arm],
dest: Dest) -> block { dest: Dest) -> block {

17
src/librustc/middle/trans/base.rs
View file

@ -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 // Only use this if you are going to actually define the function. It's
// not valid to simply declare a function as internal. // 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); let llfn = decl_cdecl_fn(llmod, name, ty);
lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage); lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage);
return llfn; 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<'self> = &'self fn(block, ValueRef, ty::t) -> block;
pub type val_and_ty_fn = @fn(block, ValueRef, ty::t) -> block;
pub fn load_inbounds(cx: block, p: ValueRef, idxs: &[uint]) -> ValueRef { pub fn load_inbounds(cx: block, p: ValueRef, idxs: &[uint]) -> ValueRef {
return Load(cx, GEPi(cx, p, idxs)); return Load(cx, GEPi(cx, p, idxs));
@ -1032,13 +1031,13 @@ pub fn build_return(bcx: block) {
Br(bcx, bcx.fcx.llreturn); 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 { match local.node.pat.node {
ast::pat_wild => true, _ => false 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=%?)", debug!("init_local(bcx=%s, local.id=%?)",
bcx.to_str(), local.node.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 _icx = push_ctxt("alloc_local");
let t = node_id_type(cx, local.node.id); let t = node_id_type(cx, local.node.id);
let simple_name = match local.node.pat.node { 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); 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) { let base = match ccx.tcx.items.get_copy(&i.id) {
ast_map::node_item(_, p) => p, ast_map::node_item(_, p) => p,
// separate map for paths? // separate map for paths?
@ -2544,7 +2543,7 @@ pub fn register_method(ccx: @mut CrateContext,
} }
// The constant translation pass. // 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"); let _icx = push_ctxt("trans_constant");
match it.node { match it.node {
ast::item_enum(ref enum_definition, _) => { 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, pub fn trans_crate(sess: session::Session,
crate: @ast::crate, crate: &ast::crate,
tcx: ty::ctxt, tcx: ty::ctxt,
output: &Path, output: &Path,
emap2: resolve::ExportMap2, emap2: resolve::ExportMap2,

0
src/librustc/middle/trans/block.rs
View file

2
src/librustc/middle/trans/closure.rs
View file

@ -468,7 +468,7 @@ pub fn make_closure_glue(
cx: block, cx: block,
v: ValueRef, v: ValueRef,
t: ty::t, 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 _icx = push_ctxt("closure::make_closure_glue");
let bcx = cx; let bcx = cx;
let tcx = cx.tcx(); let tcx = cx.tcx();

13
src/librustc/middle/trans/common.rs
View file

@ -411,7 +411,6 @@ pub fn add_clean_free(cx: block, ptr: ValueRef, heap: heap) {
// drop glue checks whether it is zero. // drop glue checks whether it is zero.
pub fn revoke_clean(cx: block, val: ValueRef) { pub fn revoke_clean(cx: block, val: ValueRef) {
do in_scope_cx(cx) |scope_info| { 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_( let cleanup_pos = scope_info.cleanups.iter().position_(
|cu| match *cu { |cu| match *cu {
clean_temp(v, _, _) if v == val => true, clean_temp(v, _, _) if v == val => true,
@ -473,7 +472,7 @@ pub trait get_node_info {
fn info(&self) -> Option<NodeInfo>; fn info(&self) -> Option<NodeInfo>;
} }
impl get_node_info for @ast::expr { impl get_node_info for ast::expr {
fn info(&self) -> Option<NodeInfo> { fn info(&self) -> Option<NodeInfo> {
Some(NodeInfo {id: self.id, Some(NodeInfo {id: self.id,
callee_id: self.get_callee_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; let mut cur = cx;
loop { loop {
match cur.kind { match cur.kind {
@ -612,11 +611,11 @@ impl block_ {
e.repr(self.tcx()) 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) 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) 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) 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) 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 tcx = bcx.tcx();
let t = ty::expr_ty_adjusted(tcx, ex); let t = ty::expr_ty_adjusted(tcx, ex);
monomorphize_type(bcx, t) monomorphize_type(bcx, t)

17
src/librustc/middle/trans/consts.rs
View file

@ -35,7 +35,7 @@ use core::libc::c_uint;
use core::str; use core::str;
use syntax::{ast, ast_util, ast_map}; 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 { -> ValueRef {
let _icx = push_ctxt("trans_lit"); let _icx = push_ctxt("trans_lit");
match lit.node { 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) { -> (ValueRef, ValueRef, Type) {
unsafe { unsafe {
let vec_ty = ty::expr_ty(cx.tcx, e); 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 { unsafe {
let gv = do "const".as_c_str |name| { let gv = do "const".as_c_str |name| {
llvm::LLVMAddGlobal(cx.llmod, val_ty(cv).to_ref(), 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)) { let v = match cx.const_globals.find(&(v as int)) {
Some(&v) => v, Some(&v) => v,
None => 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 { -> ValueRef {
let repr = adt::represent_type(cx, t); let repr = adt::represent_type(cx, t);
adt::const_get_field(cx, repr, v, 0, 0) 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) { -> (ValueRef, ty::t) {
match ty::deref(cx.tcx, t, explicit) { match ty::deref(cx.tcx, t, explicit) {
Some(ref mt) => { Some(ref mt) => {
@ -247,7 +247,7 @@ pub fn const_expr(cx: @mut CrateContext, e: @ast::expr) -> ValueRef {
llconst llconst
} }
fn const_expr_unadjusted(cx: @mut CrateContext, e: @ast::expr) -> ValueRef { fn const_expr_unadjusted(cx: @mut CrateContext, e: &ast::expr) -> ValueRef {
unsafe { unsafe {
let _icx = push_ctxt("const_expr"); let _icx = push_ctxt("const_expr");
return match e.node { 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 llunitty = type_of::type_of(cx, unit_ty);
let unit_sz = machine::llsize_of(cx, llunitty); 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]), llvm::LLVMConstUDiv(const_get_elt(cx, bv, [1]),
unit_sz)) unit_sz))
}, },

2
src/librustc/middle/trans/controlflow.rs
View file

@ -178,7 +178,7 @@ pub fn trans_loop(bcx:block,
return next_bcx; return next_bcx;
} }
pub fn trans_log(log_ex: @ast::expr, pub fn trans_log(log_ex: &ast::expr,
lvl: @ast::expr, lvl: @ast::expr,
bcx: block, bcx: block,
e: @ast::expr) -> block { e: @ast::expr) -> block {

2
src/librustc/middle/trans/datum.rs
View file

@ -723,7 +723,7 @@ impl Datum {
} }
/// expr: The deref expression. /// 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 { -> DatumBlock {
match self.try_deref(bcx, expr.span, expr.id, derefs, false) { match self.try_deref(bcx, expr.span, expr.id, derefs, false) {
(Some(lvres), bcx) => DatumBlock { bcx: bcx, datum: lvres }, (Some(lvres), bcx) => DatumBlock { bcx: bcx, datum: lvres },

28
src/librustc/middle/trans/expr.rs
View file

@ -254,7 +254,7 @@ pub fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock {
fn auto_slice(bcx: block, fn auto_slice(bcx: block,
autoderefs: uint, autoderefs: uint,
expr: @ast::expr, expr: &ast::expr,
datum: Datum) -> DatumBlock { datum: Datum) -> DatumBlock {
// This is not the most efficient thing possible; since slices // This is not the most efficient thing possible; since slices
// are two words it'd be better if this were compiled in // 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} 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 // This is not the most efficient thing possible; since closures
// are two words it'd be better if this were compiled in // 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 // '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, fn auto_slice_and_ref(bcx: block,
autoderefs: uint, autoderefs: uint,
expr: @ast::expr, expr: &ast::expr,
datum: Datum) -> DatumBlock { datum: Datum) -> DatumBlock {
let DatumBlock { bcx, datum } = auto_slice(bcx, autoderefs, expr, datum); let DatumBlock { bcx, datum } = auto_slice(bcx, autoderefs, expr, datum);
auto_ref(bcx, 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 { def: ast::def, dest: Dest) -> block {
let _icx = push_ctxt("trans_def_dps_unadjusted"); let _icx = push_ctxt("trans_def_dps_unadjusted");
let ccx = bcx.ccx(); 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, fn trans_def_datum_unadjusted(bcx: block,
ref_expr: @ast::expr, ref_expr: &ast::expr,
def: ast::def) -> DatumBlock def: ast::def) -> DatumBlock
{ {
let _icx = push_ctxt("trans_def_datum_unadjusted"); 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, fn fn_data_to_datum(bcx: block,
ref_expr: @ast::expr, ref_expr: &ast::expr,
def_id: ast::def_id, def_id: ast::def_id,
fn_data: callee::FnData) -> DatumBlock { fn_data: callee::FnData) -> DatumBlock {
/*! /*!
@ -873,7 +873,7 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
} }
fn trans_index(bcx: block, fn trans_index(bcx: block,
index_expr: @ast::expr, index_expr: &ast::expr,
base: @ast::expr, base: @ast::expr,
idx: @ast::expr) -> DatumBlock { idx: @ast::expr) -> DatumBlock {
//! Translates `base[idx]`. //! Translates `base[idx]`.
@ -936,7 +936,7 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
} }
fn trans_def_lvalue(bcx: block, fn trans_def_lvalue(bcx: block,
ref_expr: @ast::expr, ref_expr: &ast::expr,
def: ast::def) def: ast::def)
-> DatumBlock -> DatumBlock
{ {
@ -1263,7 +1263,7 @@ fn trans_immediate_lit(bcx: block, expr: @ast::expr,
} }
fn trans_unary_datum(bcx: block, fn trans_unary_datum(bcx: block,
un_expr: @ast::expr, un_expr: &ast::expr,
op: ast::unop, op: ast::unop,
sub_expr: @ast::expr) -> DatumBlock { sub_expr: @ast::expr) -> DatumBlock {
let _icx = push_ctxt("trans_unary_datum"); 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 { subexpr: @ast::expr) -> DatumBlock {
let _icx = push_ctxt("trans_addr_of"); let _icx = push_ctxt("trans_addr_of");
let mut bcx = bcx; 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 _|_ // Important to get types for both lhs and rhs, because one might be _|_
// and the other not. // and the other not.
fn trans_eager_binop(bcx: block, fn trans_eager_binop(bcx: block,
binop_expr: @ast::expr, binop_expr: &ast::expr,
binop_ty: ty::t, binop_ty: ty::t,
op: ast::binop, op: ast::binop,
lhs_datum: &Datum, lhs_datum: &Datum,
@ -1447,7 +1447,7 @@ fn trans_eager_binop(bcx: block,
enum lazy_binop_ty { lazy_and, lazy_or } enum lazy_binop_ty { lazy_and, lazy_or }
fn trans_lazy_binop(bcx: block, fn trans_lazy_binop(bcx: block,
binop_expr: @ast::expr, binop_expr: &ast::expr,
op: lazy_binop_ty, op: lazy_binop_ty,
a: @ast::expr, a: @ast::expr,
b: @ast::expr) -> DatumBlock { b: @ast::expr) -> DatumBlock {
@ -1492,7 +1492,7 @@ fn trans_lazy_binop(bcx: block,
} }
fn trans_binary(bcx: block, fn trans_binary(bcx: block,
binop_expr: @ast::expr, binop_expr: &ast::expr,
op: ast::binop, op: ast::binop,
lhs: @ast::expr, lhs: @ast::expr,
rhs: @ast::expr) -> DatumBlock rhs: @ast::expr) -> DatumBlock
@ -1518,7 +1518,7 @@ fn trans_binary(bcx: block,
} }
fn trans_overloaded_op(bcx: block, fn trans_overloaded_op(bcx: block,
expr: @ast::expr, expr: &ast::expr,
callee_id: ast::node_id, callee_id: ast::node_id,
rcvr: @ast::expr, rcvr: @ast::expr,
args: ~[@ast::expr], args: ~[@ast::expr],

14
src/librustc/middle/trans/foreign.rs
View file

@ -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") { match attr::first_attr_value_str_by_name(i.attrs, "link_name") {
None => ccx.sess.str_of(i.ident), None => ccx.sess.str_of(i.ident),
Some(ln) => ln, Some(ln) => ln,
@ -89,7 +89,7 @@ struct LlvmSignature {
sret: bool, sret: bool,
} }
fn foreign_signature(ccx: @mut CrateContext, fn_sig: &ty::FnSig) fn foreign_signature(ccx: &mut CrateContext, fn_sig: &ty::FnSig)
-> LlvmSignature { -> LlvmSignature {
/*! /*!
* The ForeignSignature is the LLVM types of the arguments/return type * The ForeignSignature is the LLVM types of the arguments/return type
@ -138,7 +138,7 @@ type shim_ret_builder<'self> =
llretval: ValueRef); llretval: ValueRef);
fn build_shim_fn_(ccx: @mut CrateContext, fn build_shim_fn_(ccx: @mut CrateContext,
shim_name: ~str, shim_name: &str,
llbasefn: ValueRef, llbasefn: ValueRef,
tys: &ShimTypes, tys: &ShimTypes,
cc: lib::llvm::CallConv, cc: lib::llvm::CallConv,
@ -357,7 +357,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
} }
fn build_shim_fn(ccx: @mut CrateContext, fn build_shim_fn(ccx: @mut CrateContext,
foreign_item: @ast::foreign_item, foreign_item: &ast::foreign_item,
tys: &ShimTypes, tys: &ShimTypes,
cc: lib::llvm::CallConv) cc: lib::llvm::CallConv)
-> ValueRef { -> ValueRef {
@ -419,7 +419,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
// over the place // over the place
fn build_direct_fn(ccx: @mut CrateContext, fn build_direct_fn(ccx: @mut CrateContext,
decl: ValueRef, decl: ValueRef,
item: @ast::foreign_item, item: &ast::foreign_item,
tys: &ShimTypes, tys: &ShimTypes,
cc: lib::llvm::CallConv) { cc: lib::llvm::CallConv) {
debug!("build_direct_fn(%s)", link_name(ccx, item)); debug!("build_direct_fn(%s)", link_name(ccx, item));
@ -446,7 +446,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
// over the place // over the place
fn build_fast_ffi_fn(ccx: @mut CrateContext, fn build_fast_ffi_fn(ccx: @mut CrateContext,
decl: ValueRef, decl: ValueRef,
item: @ast::foreign_item, item: &ast::foreign_item,
tys: &ShimTypes, tys: &ShimTypes,
cc: lib::llvm::CallConv) { cc: lib::llvm::CallConv) {
debug!("build_fast_ffi_fn(%s)", link_name(ccx, item)); 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, pub fn trans_intrinsic(ccx: @mut CrateContext,
decl: ValueRef, decl: ValueRef,
item: @ast::foreign_item, item: &ast::foreign_item,
path: ast_map::path, path: ast_map::path,
substs: @param_substs, substs: @param_substs,
attributes: &[ast::attribute], attributes: &[ast::attribute],

21
src/librustc/middle/trans/glue.rs
View file

@ -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, pub fn lazily_emit_simplified_tydesc_glue(ccx: @mut CrateContext,
field: uint, field: uint,
ti: @mut tydesc_info) -> bool { ti: &mut tydesc_info) -> bool {
let _icx = push_ctxt("lazily_emit_simplified_tydesc_glue"); let _icx = push_ctxt("lazily_emit_simplified_tydesc_glue");
let simpl = simplified_glue_type(ccx.tcx, field, ti.ty); let simpl = simplified_glue_type(ccx.tcx, field, ti.ty);
if simpl != ti.ty { if simpl != ti.ty {
@ -244,7 +244,7 @@ pub fn lazily_emit_tydesc_glue(ccx: @mut CrateContext,
None => { None => {
debug!("+++ lazily_emit_tydesc_glue TAKE %s", debug!("+++ lazily_emit_tydesc_glue TAKE %s",
ppaux::ty_to_str(ccx.tcx, ti.ty)); 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); ti.take_glue = Some(glue_fn);
make_generic_glue(ccx, ti.ty, glue_fn, make_take_glue, "take"); make_generic_glue(ccx, ti.ty, glue_fn, make_take_glue, "take");
debug!("--- lazily_emit_tydesc_glue TAKE %s", debug!("--- lazily_emit_tydesc_glue TAKE %s",
@ -257,7 +257,7 @@ pub fn lazily_emit_tydesc_glue(ccx: @mut CrateContext,
None => { None => {
debug!("+++ lazily_emit_tydesc_glue DROP %s", debug!("+++ lazily_emit_tydesc_glue DROP %s",
ppaux::ty_to_str(ccx.tcx, ti.ty)); 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); ti.drop_glue = Some(glue_fn);
make_generic_glue(ccx, ti.ty, glue_fn, make_drop_glue, "drop"); make_generic_glue(ccx, ti.ty, glue_fn, make_drop_glue, "drop");
debug!("--- lazily_emit_tydesc_glue DROP %s", debug!("--- lazily_emit_tydesc_glue DROP %s",
@ -270,7 +270,7 @@ pub fn lazily_emit_tydesc_glue(ccx: @mut CrateContext,
None => { None => {
debug!("+++ lazily_emit_tydesc_glue FREE %s", debug!("+++ lazily_emit_tydesc_glue FREE %s",
ppaux::ty_to_str(ccx.tcx, ti.ty)); 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); ti.free_glue = Some(glue_fn);
make_generic_glue(ccx, ti.ty, glue_fn, make_free_glue, "free"); make_generic_glue(ccx, ti.ty, glue_fn, make_free_glue, "free");
debug!("--- lazily_emit_tydesc_glue FREE %s", debug!("--- lazily_emit_tydesc_glue FREE %s",
@ -283,7 +283,7 @@ pub fn lazily_emit_tydesc_glue(ccx: @mut CrateContext,
None => { None => {
debug!("+++ lazily_emit_tydesc_glue VISIT %s", debug!("+++ lazily_emit_tydesc_glue VISIT %s",
ppaux::ty_to_str(ccx.tcx, ti.ty)); 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); ti.visit_glue = Some(glue_fn);
make_generic_glue(ccx, ti.ty, glue_fn, make_visit_glue, "visit"); make_generic_glue(ccx, ti.ty, glue_fn, make_visit_glue, "visit");
debug!("--- lazily_emit_tydesc_glue VISIT %s", 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) => { ty::ty_opaque_closure_ptr(ck) => {
closure::make_opaque_cbox_take_glue(bcx, ck, v) closure::make_opaque_cbox_take_glue(bcx, ck, v)
} }
ty::ty_struct(did, ref substs) => { ty::ty_struct(did, _) => {
let tcx = bcx.tcx(); let tcx = bcx.tcx();
let bcx = iter_structural_ty(bcx, v, t, take_ty); let bcx = iter_structural_ty(bcx, v, t, take_ty);
match ty::ty_dtor(tcx, did) { match ty::ty_dtor(tcx, did) {
ty::TraitDtor(dtor, false) => { ty::TraitDtor(_, false) => {
// Zero out the struct // Zero out the struct
unsafe { unsafe {
let ty = Type::from_ref(llvm::LLVMTypeOf(v)); 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; 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, pub fn declare_generic_glue(ccx: &mut CrateContext, t: ty::t, llfnty: Type,
name: ~str) -> ValueRef { name: &str) -> ValueRef {
let _icx = push_ctxt("declare_generic_glue"); 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(); 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)); debug!("%s is for type %s", fn_nm, ppaux::ty_to_str(ccx.tcx, t));
note_unique_llvm_symbol(ccx, fn_nm); note_unique_llvm_symbol(ccx, fn_nm);

8
src/librustc/middle/trans/meth.rs
View file

@ -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)) 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, impl_id: ast::def_id,
name: ast::ident) -> ast::def_id { name: ast::ident) -> ast::def_id {
let imp = ccx.impl_method_cache.find_copy(&(impl_id, name)); 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. /// Helper function to declare and initialize the vtable.
pub fn make_vtable(ccx: @mut CrateContext, pub fn make_vtable(ccx: &mut CrateContext,
tydesc: @mut tydesc_info, tydesc: &tydesc_info,
ptrs: &[ValueRef]) ptrs: &[ValueRef])
-> ValueRef { -> ValueRef {
unsafe { unsafe {
@ -770,7 +770,7 @@ pub fn make_vtable(ccx: @mut CrateContext,
pub fn make_impl_vtable(bcx: block, pub fn make_impl_vtable(bcx: block,
impl_id: ast::def_id, impl_id: ast::def_id,
self_ty: ty::t, self_ty: ty::t,
substs: ~[ty::t], substs: &[ty::t],
vtables: typeck::vtable_res) vtables: typeck::vtable_res)
-> ValueRef { -> ValueRef {
let ccx = bcx.ccx(); let ccx = bcx.ccx();

92
src/librustc/middle/trans/reflect.rs
View file

@ -86,7 +86,7 @@ impl Reflector {
self.c_tydesc(mt.ty)] 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 tcx = self.bcx.tcx();
let mth_idx = ty::method_idx( let mth_idx = ty::method_idx(
tcx.sess.ident_of(~"visit_" + ty_name), tcx.sess.ident_of(~"visit_" + ty_name),
@ -122,7 +122,7 @@ impl Reflector {
} }
pub fn bracketed(&mut self, pub fn bracketed(&mut self,
bracket_name: ~str, bracket_name: &str,
extra: &[ValueRef], extra: &[ValueRef],
inner: &fn(&mut Reflector)) { inner: &fn(&mut Reflector)) {
self.visit(~"enter_" + bracket_name, extra); 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, []); self.visit(name, []);
} }
@ -156,27 +156,27 @@ impl Reflector {
debug!("reflect::visit_ty %s", ty_to_str(bcx.ccx().tcx, t)); debug!("reflect::visit_ty %s", ty_to_str(bcx.ccx().tcx, t));
match ty::get(t).sty { match ty::get(t).sty {
ty::ty_bot => self.leaf(~"bot"), ty::ty_bot => self.leaf("bot"),
ty::ty_nil => self.leaf(~"nil"), ty::ty_nil => self.leaf("nil"),
ty::ty_bool => self.leaf(~"bool"), ty::ty_bool => self.leaf("bool"),
ty::ty_int(ast::ty_i) => self.leaf(~"int"), ty::ty_int(ast::ty_i) => self.leaf("int"),
ty::ty_int(ast::ty_char) => self.leaf(~"char"), ty::ty_int(ast::ty_char) => self.leaf("char"),
ty::ty_int(ast::ty_i8) => self.leaf(~"i8"), ty::ty_int(ast::ty_i8) => self.leaf("i8"),
ty::ty_int(ast::ty_i16) => self.leaf(~"i16"), ty::ty_int(ast::ty_i16) => self.leaf("i16"),
ty::ty_int(ast::ty_i32) => self.leaf(~"i32"), ty::ty_int(ast::ty_i32) => self.leaf("i32"),
ty::ty_int(ast::ty_i64) => self.leaf(~"i64"), ty::ty_int(ast::ty_i64) => self.leaf("i64"),
ty::ty_uint(ast::ty_u) => self.leaf(~"uint"), ty::ty_uint(ast::ty_u) => self.leaf("uint"),
ty::ty_uint(ast::ty_u8) => self.leaf(~"u8"), ty::ty_uint(ast::ty_u8) => self.leaf("u8"),
ty::ty_uint(ast::ty_u16) => self.leaf(~"u16"), ty::ty_uint(ast::ty_u16) => self.leaf("u16"),
ty::ty_uint(ast::ty_u32) => self.leaf(~"u32"), ty::ty_uint(ast::ty_u32) => self.leaf("u32"),
ty::ty_uint(ast::ty_u64) => self.leaf(~"u64"), ty::ty_uint(ast::ty_u64) => self.leaf("u64"),
ty::ty_float(ast::ty_f) => self.leaf(~"float"), ty::ty_float(ast::ty_f) => self.leaf("float"),
ty::ty_float(ast::ty_f32) => self.leaf(~"f32"), ty::ty_float(ast::ty_f32) => self.leaf("f32"),
ty::ty_float(ast::ty_f64) => self.leaf(~"f64"), ty::ty_float(ast::ty_f64) => self.leaf("f64"),
ty::ty_unboxed_vec(ref mt) => { ty::ty_unboxed_vec(ref mt) => {
let values = self.c_mt(mt); let values = self.c_mt(mt);
self.visit(~"vec", values) self.visit("vec", values)
} }
ty::ty_estr(vst) => { ty::ty_estr(vst) => {
@ -190,28 +190,28 @@ impl Reflector {
} }
ty::ty_box(ref mt) => { ty::ty_box(ref mt) => {
let extra = self.c_mt(mt); let extra = self.c_mt(mt);
self.visit(~"box", extra) self.visit("box", extra)
} }
ty::ty_uniq(ref mt) => { ty::ty_uniq(ref mt) => {
let extra = self.c_mt(mt); let extra = self.c_mt(mt);
self.visit(~"uniq", extra) self.visit("uniq", extra)
} }
ty::ty_ptr(ref mt) => { ty::ty_ptr(ref mt) => {
let extra = self.c_mt(mt); let extra = self.c_mt(mt);
self.visit(~"ptr", extra) self.visit("ptr", extra)
} }
ty::ty_rptr(_, ref mt) => { ty::ty_rptr(_, ref mt) => {
let extra = self.c_mt(mt); let extra = self.c_mt(mt);
self.visit(~"rptr", extra) self.visit("rptr", extra)
} }
ty::ty_tup(ref tys) => { ty::ty_tup(ref tys) => {
let extra = ~[self.c_uint(tys.len())] let extra = ~[self.c_uint(tys.len())]
+ self.c_size_and_align(t); + 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)| { for tys.iter().enumerate().advance |(i, t)| {
let extra = ~[this.c_uint(i), this.c_tydesc(*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(sigilval),
self.c_uint(fty.sig.inputs.len()), self.c_uint(fty.sig.inputs.len()),
self.c_uint(retval)]; self.c_uint(retval)];
self.visit(~"enter_fn", extra); self.visit("enter_fn", extra);
self.visit_sig(retval, &fty.sig); 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 // FIXME (#2594): fetch constants out of intrinsic:: for the
@ -241,9 +241,9 @@ impl Reflector {
self.c_uint(sigilval), self.c_uint(sigilval),
self.c_uint(fty.sig.inputs.len()), self.c_uint(fty.sig.inputs.len()),
self.c_uint(retval)]; self.c_uint(retval)];
self.visit(~"enter_fn", extra); self.visit("enter_fn", extra);
self.visit_sig(retval, &fty.sig); self.visit_sig(retval, &fty.sig);
self.visit(~"leave_fn", extra); self.visit("leave_fn", extra);
} }
ty::ty_struct(did, ref substs) => { ty::ty_struct(did, ref substs) => {
@ -253,13 +253,13 @@ impl Reflector {
let extra = ~[self.c_uint(fields.len())] let extra = ~[self.c_uint(fields.len())]
+ self.c_size_and_align(t); + 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)| { for fields.iter().enumerate().advance |(i, field)| {
let extra = ~[this.c_uint(i), let extra = ~[this.c_uint(i),
this.c_slice( this.c_slice(
bcx.ccx().sess.str_of(field.ident))] bcx.ccx().sess.str_of(field.ident))]
+ this.c_mt(&field.mt); + 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()] let enum_args = ~[self.c_uint(variants.len()), make_get_disr()]
+ self.c_size_and_align(t); + 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)| { for variants.iter().enumerate().advance |(i, v)| {
let name = ccx.sess.str_of(v.name); let name = ccx.sess.str_of(v.name);
let variant_args = ~[this.c_uint(i), let variant_args = ~[this.c_uint(i),
this.c_int(v.disr_val), this.c_int(v.disr_val),
this.c_uint(v.args.len()), this.c_uint(v.args.len()),
this.c_slice(name)]; 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)| { for v.args.iter().enumerate().advance |(j, a)| {
let bcx = this.bcx; let bcx = this.bcx;
let null = C_null(llptrty); let null = C_null(llptrty);
@ -325,7 +325,7 @@ impl Reflector {
let field_args = ~[this.c_uint(j), let field_args = ~[this.c_uint(j),
offset, offset,
this.c_tydesc(*a)]; 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 // Miscallaneous extra types
ty::ty_trait(_, _, _, _, _) => self.leaf(~"trait"), ty::ty_trait(_, _, _, _, _) => self.leaf("trait"),
ty::ty_infer(_) => self.leaf(~"infer"), ty::ty_infer(_) => self.leaf("infer"),
ty::ty_err => self.leaf(~"err"), ty::ty_err => self.leaf("err"),
ty::ty_param(ref p) => { ty::ty_param(ref p) => {
let extra = ~[self.c_uint(p.idx)]; let extra = ~[self.c_uint(p.idx)];
self.visit(~"param", extra) self.visit("param", extra)
} }
ty::ty_self(*) => self.leaf(~"self"), ty::ty_self(*) => self.leaf("self"),
ty::ty_type => self.leaf(~"type"), ty::ty_type => self.leaf("type"),
ty::ty_opaque_box => self.leaf(~"opaque_box"), ty::ty_opaque_box => self.leaf("opaque_box"),
ty::ty_opaque_closure_ptr(ck) => { ty::ty_opaque_closure_ptr(ck) => {
let ckval = ast_sigil_constant(ck); let ckval = ast_sigil_constant(ck);
let extra = ~[self.c_uint(ckval)]; 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), let extra = ~[self.c_uint(i),
self.c_uint(modeval), self.c_uint(modeval),
self.c_tydesc(*arg)]; self.c_tydesc(*arg)];
self.visit(~"fn_input", extra); self.visit("fn_input", extra);
} }
let extra = ~[self.c_uint(retval), let extra = ~[self.c_uint(retval),
self.c_tydesc(sig.output)]; self.c_tydesc(sig.output)];
self.visit(~"fn_output", extra); self.visit("fn_output", extra);
} }
} }

12
src/librustc/middle/trans/tvec.rs
View file

@ -164,7 +164,7 @@ impl VecTypes {
pub fn trans_fixed_vstore(bcx: block, pub fn trans_fixed_vstore(bcx: block,
vstore_expr: @ast::expr, vstore_expr: @ast::expr,
content_expr: @ast::expr, content_expr: &ast::expr,
dest: expr::Dest) dest: expr::Dest)
-> block { -> 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, 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 // @[...] 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, pub fn write_content(bcx: block,
vt: &VecTypes, vt: &VecTypes,
vstore_expr: @ast::expr, vstore_expr: @ast::expr,
content_expr: @ast::expr, content_expr: &ast::expr,
dest: Dest) dest: Dest)
-> block { -> block {
let _icx = push_ctxt("tvec::write_content"); 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); let vec_ty = node_id_type(bcx, vec_expr.id);
vec_types(bcx, vec_ty) vec_types(bcx, vec_ty)
} }
@ -488,7 +488,7 @@ pub fn vec_types(bcx: block, vec_ty: ty::t) -> VecTypes {
llunit_size: llunit_size} 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 //! Figure out the number of elements we need to store this content
match content_expr.node { 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 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, pub fn iter_vec_raw(bcx: block, data_ptr: ValueRef, vec_ty: ty::t,

16
src/librustc/middle/trans/type_use.rs
View file

@ -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_bare_fn(ty::BareFnTy {sig: ref sig, _}) |
ty::ty_closure(ty::ClosureTy {sig: ref sig, _}) => { ty::ty_closure(ty::ClosureTy {sig: ref sig, _}) => {
for sig.inputs.iter().advance |arg| { 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_item(@ast::item { node: item_fn(_, _, _, _, ref body),
_ }, _) | _ }, _) |
ast_map::node_method(@ast::method {body: ref body, _}, _, _) => { ast_map::node_method(@ast::method {body: ref body, _}, _, _) => {
handle_body(cx, body); handle_body(&cx, body);
} }
ast_map::node_trait_method(*) => { ast_map::node_trait_method(*) => {
// This will be a static trait method. For now, we just assume // 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 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 // Optimization -- don't descend type if all params already have this use
let len = { let len = {
let uses = &*cx.uses; 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, use_: uint,
ty: ty::t, ty: ty::t,
enums_seen: @List<def_id>) { enums_seen: @List<def_id>) {
@ -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)); 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 mut opt_static_did = None;
{ {
let r = cx.ccx.maps.method_map.find(&e_id); 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 { match e.node {
expr_vstore(_, _) | expr_vec(_, _) | expr_struct(*) | expr_tup(_) | expr_vstore(_, _) | expr_vec(_, _) | expr_struct(*) | expr_tup(_) |
expr_unary(_, box(_), _) | expr_unary(_, uniq(_), _) | 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 { let v = visit::mk_vt(@visit::Visitor {
visit_expr: |e, (cx, v)| { visit_expr: |e, (cx, v)| {
visit::visit_expr(e, (cx, v)); visit::visit_expr(e, (cx, v));

20
src/librustc/middle/ty.rs
View file

@ -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 // Returns the type of a pattern as a monotype. Like @expr_ty, this function
// doesn't provide type parameter substitutions. // 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); 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" // 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 // instead of "fn(t) -> T with T = int". If this isn't what you want, see
// expr_ty_params_and_ty() below. // 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); 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` * Returns the type of `expr`, considering any `AutoAdjustment`
@ -3191,7 +3191,7 @@ pub struct ParamsTy {
} }
pub fn expr_ty_params_and_ty(cx: ctxt, pub fn expr_ty_params_and_ty(cx: ctxt,
expr: @ast::expr) expr: &ast::expr)
-> ParamsTy { -> ParamsTy {
ParamsTy { ParamsTy {
params: node_id_to_type_params(cx, expr.id), 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); 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) { match tcx.def_map.find(&expr.id) {
Some(&def) => def, Some(&def) => def,
None => { None => {
@ -3247,7 +3247,7 @@ pub fn resolve_expr(tcx: ctxt, expr: @ast::expr) -> ast::def {
pub fn expr_is_lval(tcx: ctxt, pub fn expr_is_lval(tcx: ctxt,
method_map: typeck::method_map, method_map: typeck::method_map,
e: @ast::expr) -> bool { e: &ast::expr) -> bool {
match expr_kind(tcx, method_map, e) { match expr_kind(tcx, method_map, e) {
LvalueExpr => true, LvalueExpr => true,
RvalueDpsExpr | RvalueDatumExpr | RvalueStmtExpr => false RvalueDpsExpr | RvalueDatumExpr | RvalueStmtExpr => false
@ -3268,7 +3268,7 @@ pub enum ExprKind {
pub fn expr_kind(tcx: ctxt, pub fn expr_kind(tcx: ctxt,
method_map: typeck::method_map, method_map: typeck::method_map,
expr: @ast::expr) -> ExprKind { expr: &ast::expr) -> ExprKind {
if method_map.contains_key(&expr.id) { if method_map.contains_key(&expr.id) {
// Overloaded operations are generally calls, and hence they are // Overloaded operations are generally calls, and hence they are
// generated via DPS. However, assign_op (e.g., `x += y`) is an // 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 { match s.node {
ast::stmt_decl(_, id) | stmt_expr(_, id) | stmt_semi(_, id) => { ast::stmt_decl(_, id) | stmt_expr(_, id) | stmt_semi(_, id) => {
return 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. // 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) { match const_eval::eval_const_expr_partial(tcx, count_expr) {
Ok(ref const_val) => match *const_val { Ok(ref const_val) => match *const_val {
const_eval::const_int(count) => if count < 0 { const_eval::const_int(count) => if count < 0 {

2
src/librustc/middle/typeck/astconv.rs
View file

@ -248,7 +248,7 @@ pub static NO_TPS: uint = 2;
// internal notion of a type. `getter` is a function that returns the type // internal notion of a type. `getter` is a function that returns the type
// corresponding to a definition ID: // corresponding to a definition ID:
pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + 'static>( pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + 'static>(
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<AC:AstConv, RS:region_scope + Copy + 'static>( fn ast_mt_to_mt<AC:AstConv, RS:region_scope + Copy + 'static>(
this: &AC, rscope: &RS, mt: &ast::mt) -> ty::mt { this: &AC, rscope: &RS, mt: &ast::mt) -> ty::mt {

4
src/librustc/middle/typeck/check/method.rs
View file

@ -329,11 +329,9 @@ impl<'self> LookupContext<'self> {
let opt_applicable_traits = trait_map.find(&self.expr.id); let opt_applicable_traits = trait_map.find(&self.expr.id);
for opt_applicable_traits.iter().advance |applicable_traits| { for opt_applicable_traits.iter().advance |applicable_traits| {
for applicable_traits.iter().advance |trait_did| { for applicable_traits.iter().advance |trait_did| {
let coherence_info = self.fcx.ccx.coherence_info;
// Look for explicit implementations. // Look for explicit implementations.
let opt_impl_infos = 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 opt_impl_infos.iter().advance |impl_infos| {
for impl_infos.iter().advance |impl_info| { for impl_infos.iter().advance |impl_info| {
self.push_candidates_from_impl( self.push_candidates_from_impl(

2
src/librustc/middle/typeck/check/mod.rs
View file

@ -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 { let visit = visit::mk_simple_visitor(@visit::SimpleVisitor {
visit_item: |a| check_item(ccx, a), visit_item: |a| check_item(ccx, a),
.. *visit::default_simple_visitor() .. *visit::default_simple_visitor()

14
src/librustc/middle/typeck/coherence.rs
View file

@ -197,7 +197,7 @@ pub struct CoherenceChecker {
} }
impl 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 // Check implementations and traits. This populates the tables
// containing the inherent methods and extension methods. It also // containing the inherent methods and extension methods. It also
// builds up the trait inheritance table. // builds up the trait inheritance table.
@ -455,7 +455,7 @@ impl CoherenceChecker {
} }
pub fn check_implementation_coherence(&self) { 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| { for coherence_info.extension_methods.each_key |&trait_id| {
self.check_implementation_coherence_of(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)) { 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; let extension_methods = &*coherence_info.extension_methods;
match extension_methods.find(&trait_def_id) { match extension_methods.find(&trait_def_id) {
@ -631,7 +631,7 @@ impl CoherenceChecker {
} }
// Privileged scope checking // 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_crate(crate, ((), mk_vt(@Visitor {
visit_item: |item, (_context, visitor)| { visit_item: |item, (_context, visitor)| {
match item.node { match item.node {
@ -978,7 +978,7 @@ impl CoherenceChecker {
// //
pub fn populate_destructor_table(&self) { 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 tcx = self.crate_context.tcx;
let drop_trait = tcx.lang_items.drop_trait(); let drop_trait = tcx.lang_items.drop_trait();
let impls_opt = coherence_info.extension_methods.find(&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) { pub fn check_coherence(crate_context: @mut CrateCtxt, crate: &crate) {
let coherence_checker = @CoherenceChecker(crate_context); let coherence_checker = CoherenceChecker(crate_context);
coherence_checker.check_coherence(crate); coherence_checker.check_coherence(crate);
} }

26
src/librustc/middle/typeck/collect.rs
View file

@ -61,8 +61,8 @@ use syntax::visit;
use syntax::opt_vec::OptVec; use syntax::opt_vec::OptVec;
use syntax::opt_vec; use syntax::opt_vec;
pub fn collect_item_types(ccx: @mut CrateCtxt, crate: @ast::crate) { pub fn collect_item_types(ccx: @mut CrateCtxt, crate: &ast::crate) {
fn collect_intrinsic_type(ccx: @mut CrateCtxt, fn collect_intrinsic_type(ccx: &CrateCtxt,
lang_item: ast::def_id) { lang_item: ast::def_id) {
let ty::ty_param_bounds_and_ty { ty: ty, _ } = let ty::ty_param_bounds_and_ty { ty: ty, _ } =
ccx.get_item_ty(lang_item); ccx.get_item_ty(lang_item);
@ -83,7 +83,7 @@ pub fn collect_item_types(ccx: @mut CrateCtxt, crate: @ast::crate) {
impl CrateCtxt { impl CrateCtxt {
fn to_ty<RS:region_scope + Copy + 'static>( fn to_ty<RS:region_scope + Copy + 'static>(
&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) ast_ty_to_ty(self, rs, ast_ty)
} }
@ -632,7 +632,7 @@ pub fn check_methods_against_trait(ccx: &CrateCtxt,
generics: &ast::Generics, generics: &ast::Generics,
rp: Option<ty::region_variance>, rp: Option<ty::region_variance>,
selfty: ty::t, selfty: ty::t,
a_trait_ty: @ast::trait_ref, a_trait_ty: &ast::trait_ref,
impl_ms: &[ConvertedMethod]) impl_ms: &[ConvertedMethod])
{ {
let tcx = ccx.tcx; let tcx = ccx.tcx;
@ -670,7 +670,7 @@ pub fn check_methods_against_trait(ccx: &CrateCtxt,
pub fn convert_field(ccx: &CrateCtxt, pub fn convert_field(ccx: &CrateCtxt,
rp: Option<ty::region_variance>, rp: Option<ty::region_variance>,
type_param_defs: @~[ty::TypeParameterDef], type_param_defs: @~[ty::TypeParameterDef],
v: @ast::struct_field, v: &ast::struct_field,
generics: &ast::Generics) { generics: &ast::Generics) {
let region_parameterization = let region_parameterization =
RegionParameterization::from_variance_and_generics(rp, generics); RegionParameterization::from_variance_and_generics(rp, generics);
@ -736,7 +736,7 @@ pub fn convert_methods(ccx: &CrateCtxt,
}); });
fn ty_of_method(ccx: &CrateCtxt, fn ty_of_method(ccx: &CrateCtxt,
m: @ast::method, m: &ast::method,
rp: Option<ty::region_variance>, rp: Option<ty::region_variance>,
untransformed_rcvr_ty: ty::t, untransformed_rcvr_ty: ty::t,
rcvr_generics: &ast::Generics, 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 tcx = ccx.tcx;
let rp = tcx.region_paramd_items.find(&it.id).map_consume(|x| *x); let rp = tcx.region_paramd_items.find(&it.id).map_consume(|x| *x);
debug!("convert: item %s with id %d rp %?", 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, pub fn convert_struct(ccx: &CrateCtxt,
rp: Option<ty::region_variance>, rp: Option<ty::region_variance>,
struct_def: @ast::struct_def, struct_def: &ast::struct_def,
generics: &ast::Generics, generics: &ast::Generics,
tpt: ty::ty_param_bounds_and_ty, tpt: ty::ty_param_bounds_and_ty,
id: ast::node_id) { 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 // As above, this call populates the type table with the converted
// type of the foreign item. We simply write it into the node type // type of the foreign item. We simply write it into the node type
// table. // table.
@ -937,7 +937,7 @@ pub fn convert_foreign(ccx: &CrateCtxt, i: @ast::foreign_item) {
} }
pub fn instantiate_trait_ref(ccx: &CrateCtxt, pub fn instantiate_trait_ref(ccx: &CrateCtxt,
ast_trait_ref: @ast::trait_ref, ast_trait_ref: &ast::trait_ref,
rp: Option<ty::region_variance>, rp: Option<ty::region_variance>,
generics: &ast::Generics, generics: &ast::Generics,
self_ty: ty::t) -> @ty::TraitRef 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 def_id = local_def(it.id);
let tcx = ccx.tcx; let tcx = ccx.tcx;
match tcx.trait_defs.find(&def_id) { 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 { -> ty::ty_param_bounds_and_ty {
let def_id = local_def(it.id); let def_id = local_def(it.id);
let tcx = ccx.tcx; 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, pub fn ty_of_foreign_item(ccx: &CrateCtxt,
it: @ast::foreign_item, it: &ast::foreign_item,
abis: AbiSet) -> ty::ty_param_bounds_and_ty abis: AbiSet) -> ty::ty_param_bounds_and_ty
{ {
match it.node { match it.node {

18
src/librustc/middle/typeck/mod.rs
View file

@ -182,7 +182,7 @@ pub struct CrateCtxt {
trait_map: resolve::TraitMap, trait_map: resolve::TraitMap,
method_map: method_map, method_map: method_map,
vtable_map: vtable_map, vtable_map: vtable_map,
coherence_info: @coherence::CoherenceInfo, coherence_info: coherence::CoherenceInfo,
tcx: ty::ctxt 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 { -> ast::def {
lookup_def_tcx(ccx.tcx, sp, id) lookup_def_tcx(ccx.tcx, sp, id)
} }
@ -276,11 +276,11 @@ trait get_and_find_region {
} }
impl get_and_find_region for isr_alist { 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() self.find(br).get()
} }
fn find(&self, br: ty::bound_region) -> Option<ty::Region> { pub fn find(&self, br: ty::bound_region) -> Option<ty::Region> {
for list::each(*self) |isr| { for list::each(*self) |isr| {
let (isr_br, isr_r) = *isr; let (isr_br, isr_r) = *isr;
if isr_br == br { return Some(isr_r); } 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_id: ast::node_id,
main_span: span) { main_span: span) {
let tcx = ccx.tcx; 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_id: ast::node_id,
start_span: span) { start_span: span) {
let tcx = ccx.tcx; 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; let tcx = ccx.tcx;
if !*tcx.sess.building_library { if !*tcx.sess.building_library {
match *tcx.sess.entry_fn { match *tcx.sess.entry_fn {
@ -395,14 +395,14 @@ fn check_for_entry_fn(ccx: @mut CrateCtxt) {
pub fn check_crate(tcx: ty::ctxt, pub fn check_crate(tcx: ty::ctxt,
trait_map: resolve::TraitMap, trait_map: resolve::TraitMap,
crate: @ast::crate) crate: &ast::crate)
-> (method_map, vtable_map) { -> (method_map, vtable_map) {
let time_passes = tcx.sess.time_passes(); let time_passes = tcx.sess.time_passes();
let ccx = @mut CrateCtxt { let ccx = @mut CrateCtxt {
trait_map: trait_map, trait_map: trait_map,
method_map: @mut HashMap::new(), method_map: @mut HashMap::new(),
vtable_map: @mut HashMap::new(), vtable_map: @mut HashMap::new(),
coherence_info: @coherence::CoherenceInfo(), coherence_info: coherence::CoherenceInfo(),
tcx: tcx tcx: tcx
}; };

2
src/librustpkg/util.rs
View file

@ -331,7 +331,7 @@ pub fn find_and_install_dependencies(ctxt: &Ctx,
debug!("In find_and_install_dependencies..."); debug!("In find_and_install_dependencies...");
let my_workspace = copy *workspace; let my_workspace = copy *workspace;
let my_ctxt = copy *ctxt; 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!"); debug!("A view item!");
match vi.node { match vi.node {
// ignore metadata, I guess // ignore metadata, I guess

2
src/libsyntax/ast_map.rs
View file

@ -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 { let cx = @mut Ctx {
map: @mut HashMap::new(), map: @mut HashMap::new(),
path: ~[], path: ~[],

6
src/libsyntax/ast_util.rs
View file

@ -565,11 +565,11 @@ pub fn walk_pat(pat: @pat, it: &fn(@pat) -> bool) -> bool {
} }
pub trait EachViewItem { 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 { 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 broke = @mut false;
let vtor: visit::vt<()> = visit::mk_simple_visitor(@visit::SimpleVisitor { let vtor: visit::vt<()> = visit::mk_simple_visitor(@visit::SimpleVisitor {
visit_view_item: |vi| { *broke = f(vi); }, ..*visit::default_simple_visitor() 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 { match p.node {
view_path_simple(_, _, id) | view_path_simple(_, _, id) |
view_path_glob(_, id) | view_path_glob(_, id) |

2
src/libsyntax/ext/deriving/cmp/totaleq.rs
View file

@ -8,8 +8,6 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use std::prelude::*;
use ast::{meta_item, item, expr}; use ast::{meta_item, item, expr};
use codemap::span; use codemap::span;
use ext::base::ExtCtxt; use ext::base::ExtCtxt;

4
src/libsyntax/ext/expand.rs
View file

@ -644,7 +644,7 @@ pub fn core_macros() -> @str {
} }
pub fn expand_crate(parse_sess: @mut parse::ParseSess, 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 // adding *another* layer of indirection here so that the block
// visitor can swap out one exts table for another for the duration // visitor can swap out one exts table for another for the duration
// of the block. The cleaner alternative would be to thread the // 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. // as it registers all the core macros as expanders.
f.fold_item(cm); f.fold_item(cm);
@f.fold_crate(&*c) @f.fold_crate(c)
} }
// given a function from idents to idents, produce // given a function from idents to idents, produce

28
src/libsyntax/visit.rs
View file

@ -39,7 +39,7 @@ pub enum fn_kind<'self> {
// fn foo(&self) // fn foo(&self)
fk_method(ident, &'self Generics, &'self method), fk_method(ident, &'self Generics, &'self method),
// fn@(x, y) { ... } // @fn(x, y) { ... }
fk_anon(ast::Sigil), fk_anon(ast::Sigil),
// |x, y| ... // |x, y| ...
@ -129,9 +129,9 @@ pub fn visit_mod<E: Copy>(m: &_mod, _sp: span, _id: node_id, (e, v): (E, vt<E>))
for m.items.iter().advance |i| { (v.visit_item)(*i, (copy e, v)); } for m.items.iter().advance |i| { (v.visit_item)(*i, (copy e, v)); }
} }
pub fn visit_view_item<E>(_vi: @view_item, (_e, _v): (E, vt<E>)) { } pub fn visit_view_item<E>(_vi: &view_item, (_e, _v): (E, vt<E>)) { }
pub fn visit_local<E: Copy>(loc: @local, (e, v): (E, vt<E>)) { pub fn visit_local<E: Copy>(loc: &local, (e, v): (E, vt<E>)) {
(v.visit_pat)(loc.node.pat, (copy e, v)); (v.visit_pat)(loc.node.pat, (copy e, v));
(v.visit_ty)(loc.node.ty, (copy e, v)); (v.visit_ty)(loc.node.ty, (copy e, v));
match loc.node.init { match loc.node.init {
@ -140,11 +140,11 @@ pub fn visit_local<E: Copy>(loc: @local, (e, v): (E, vt<E>)) {
} }
} }
fn visit_trait_ref<E: Copy>(tref: @ast::trait_ref, (e, v): (E, vt<E>)) { fn visit_trait_ref<E: Copy>(tref: &ast::trait_ref, (e, v): (E, vt<E>)) {
visit_path(tref.path, (e, v)); visit_path(tref.path, (e, v));
} }
pub fn visit_item<E: Copy>(i: @item, (e, v): (E, vt<E>)) { pub fn visit_item<E: Copy>(i: &item, (e, v): (E, vt<E>)) {
match i.node { match i.node {
item_static(t, _, ex) => { item_static(t, _, ex) => {
(v.visit_ty)(t, (copy e, v)); (v.visit_ty)(t, (copy e, v));
@ -230,9 +230,9 @@ pub fn visit_enum_def<E: Copy>(enum_definition: &ast::enum_def,
} }
} }
pub fn skip_ty<E>(_t: @Ty, (_e,_v): (E, vt<E>)) {} pub fn skip_ty<E>(_t: &Ty, (_e,_v): (E, vt<E>)) {}
pub fn visit_ty<E: Copy>(t: @Ty, (e, v): (E, vt<E>)) { pub fn visit_ty<E: Copy>(t: &Ty, (e, v): (E, vt<E>)) {
match t.node { match t.node {
ty_box(mt) | ty_uniq(mt) | ty_box(mt) | ty_uniq(mt) |
ty_vec(mt) | ty_ptr(mt) | ty_rptr(_, mt) => { ty_vec(mt) | ty_ptr(mt) | ty_rptr(_, mt) => {
@ -268,11 +268,11 @@ pub fn visit_ty<E: Copy>(t: @Ty, (e, v): (E, vt<E>)) {
} }
} }
pub fn visit_path<E: Copy>(p: @Path, (e, v): (E, vt<E>)) { pub fn visit_path<E: Copy>(p: &Path, (e, v): (E, vt<E>)) {
for p.types.iter().advance |tp| { (v.visit_ty)(*tp, (copy e, v)); } for p.types.iter().advance |tp| { (v.visit_ty)(*tp, (copy e, v)); }
} }
pub fn visit_pat<E: Copy>(p: @pat, (e, v): (E, vt<E>)) { pub fn visit_pat<E: Copy>(p: &pat, (e, v): (E, vt<E>)) {
match p.node { match p.node {
pat_enum(path, ref children) => { pat_enum(path, ref children) => {
visit_path(path, (copy e, v)); visit_path(path, (copy e, v));
@ -322,7 +322,7 @@ pub fn visit_pat<E: Copy>(p: @pat, (e, v): (E, vt<E>)) {
} }
} }
pub fn visit_foreign_item<E: Copy>(ni: @foreign_item, (e, v): (E, vt<E>)) { pub fn visit_foreign_item<E: Copy>(ni: &foreign_item, (e, v): (E, vt<E>)) {
match ni.node { match ni.node {
foreign_item_fn(ref fd, _, ref generics) => { foreign_item_fn(ref fd, _, ref generics) => {
visit_fn_decl(fd, (copy e, v)); visit_fn_decl(fd, (copy e, v));
@ -410,11 +410,11 @@ pub fn visit_struct_def<E: Copy>(
} }
} }
pub fn visit_struct_field<E: Copy>(sf: @struct_field, (e, v): (E, vt<E>)) { pub fn visit_struct_field<E: Copy>(sf: &struct_field, (e, v): (E, vt<E>)) {
(v.visit_ty)(sf.node.ty, (e, v)); (v.visit_ty)(sf.node.ty, (e, v));
} }
pub fn visit_struct_method<E: Copy>(m: @method, (e, v): (E, vt<E>)) { pub fn visit_struct_method<E: Copy>(m: &method, (e, v): (E, vt<E>)) {
visit_method_helper(m, (e, v)); visit_method_helper(m, (e, v));
} }
@ -428,7 +428,7 @@ pub fn visit_block<E: Copy>(b: &blk, (e, v): (E, vt<E>)) {
visit_expr_opt(b.node.expr, (e, v)); visit_expr_opt(b.node.expr, (e, v));
} }
pub fn visit_stmt<E>(s: @stmt, (e, v): (E, vt<E>)) { pub fn visit_stmt<E>(s: &stmt, (e, v): (E, vt<E>)) {
match s.node { match s.node {
stmt_decl(d, _) => (v.visit_decl)(d, (e, v)), stmt_decl(d, _) => (v.visit_decl)(d, (e, v)),
stmt_expr(ex, _) => (v.visit_expr)(ex, (e, v)), stmt_expr(ex, _) => (v.visit_expr)(ex, (e, v)),
@ -437,7 +437,7 @@ pub fn visit_stmt<E>(s: @stmt, (e, v): (E, vt<E>)) {
} }
} }
pub fn visit_decl<E: Copy>(d: @decl, (e, v): (E, vt<E>)) { pub fn visit_decl<E: Copy>(d: &decl, (e, v): (E, vt<E>)) {
match d.node { match d.node {
decl_local(ref loc) => (v.visit_local)(*loc, (e, v)), decl_local(ref loc) => (v.visit_local)(*loc, (e, v)),
decl_item(it) => (v.visit_item)(it, (e, v)) decl_item(it) => (v.visit_item)(it, (e, v))