mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Disallow writing to function arguments again

Browse source 
Remove implicit copying hack.

Closes #1118
This commit is contained in:
Marijn Haverbeke 2011-11-03 10:57:54 +01:00
parent 1deaf97002
commit 1a68a98824
28 changed files with 107 additions and 113 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/comp/driver/rustc.rs
View file

@ -504,7 +504,7 @@ fn early_error(msg: str) -> ! {
}
fn main(args: [str]) {
let binary = vec::shift(args);
let args = args, binary = vec::shift(args);
let match =
alt getopts::getopts(args, opts()) {
getopts::success(m) { m }

1
src/comp/metadata/creader.rs
View file

@ -118,6 +118,7 @@ fn find_library_crate(sess: session::session, ident: ast::ident,
-> option::t<{ident: str, data: @[u8]}> {
attr::require_unique_names(sess, metas);
let metas = metas;
// Metadata "name" will be used to find the crate. Use `ident'
// as "name" if the attribute is not explicitly specified

2
src/comp/middle/alias.rs
View file

@ -132,7 +132,7 @@ fn visit_expr(cx: @ctx, ex: @ast::expr, sc: scope, v: vt<scope>) {
}
fn visit_block(cx: @ctx, b: ast::blk, sc: scope, v: vt<scope>) {
let bs = sc.bs;
let bs = sc.bs, sc = sc;
for stmt in b.node.stmts {
alt stmt.node {
ast::stmt_decl(@{node: ast::decl_item(it), _}, _) {

6
src/comp/middle/mut.rs
View file

@ -15,7 +15,7 @@ type deref = @{mut: bool, kind: deref_t, outer_t: ty::t};
fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
{ex: @expr, ds: @[deref]} {
fn maybe_auto_unbox(tcx: ty::ctxt, t: ty::t) -> {t: ty::t, ds: [deref]} {
let ds = [];
let ds = [], t = t;
while true {
alt ty::struct(tcx, t) {
ty::ty_box(mt) {
@ -44,7 +44,7 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
}
ret {t: t, ds: ds};
}
let ds: [deref] = [];
let ds: [deref] = [], ex = ex;
while true {
alt copy ex.node {
expr_field(base, ident) {
@ -237,6 +237,8 @@ fn is_immutable_def(def: def) -> option::t<str> {
def_use(_) {
some("static item")
}
def_arg(_, by_ref.) | def_arg(_, by_val.) |
def_arg(_, mode_infer.) { some("argument") }
def_obj_field(_, imm.) { some("immutable object field") }
def_upvar(_, inner, mut) {
if !mut { some("upvar") } else { is_immutable_def(*inner) }

3
src/comp/middle/resolve.rs
View file

@ -502,6 +502,7 @@ fn ns_name(ns: namespace) -> str {
fn unresolved_err(e: env, sc: scopes, sp: span, name: ident, kind: str) {
fn find_fn_or_mod_scope(sc: scopes) -> option::t<scope> {
let sc = sc;
while true {
alt sc {
cons(cur, rest) {
@ -671,6 +672,7 @@ fn lookup_in_scope(e: env, sc: scopes, sp: span, name: ident, ns: namespace)
let closing = [];
// Used to determine whether obj fields are in scope
let left_fn_level2 = false;
let sc = sc;
while true {
alt copy sc {
nil. { ret none::<def>; }
@ -1191,6 +1193,7 @@ fn check_mod_name(e: env, name: ident, entries: list<mod_index_entry>) {
let saw_mod = false;
let saw_type = false;
let saw_value = false;
let entries = entries;
fn dup(e: env, sp: span, word: str, name: ident) {
e.sess.span_fatal(sp, "duplicate definition of " + word + name);
}

83
src/comp/middle/trans.rs
View file

@ -929,7 +929,7 @@ fn trans_stack_local_derived_tydesc(cx: @block_ctxt, llsz: ValueRef,
let llmyroottydesc = alloca(cx, bcx_ccx(cx).tydesc_type);
// By convention, desc 0 is the root descriptor.
llroottydesc = Load(cx, llroottydesc);
let llroottydesc = Load(cx, llroottydesc);
Store(cx, llroottydesc, llmyroottydesc);
// Store a pointer to the rest of the descriptors.
@ -1352,7 +1352,7 @@ fn make_free_glue(bcx: @block_ctxt, v: ValueRef, t: ty::t) {
// everything to a pointer to the type that the glue acts on).
let bcx = alt ty::struct(bcx_tcx(bcx), t) {
ty::ty_box(body_mt) {
v = PointerCast(bcx, v, type_of_1(bcx, t));
let v = PointerCast(bcx, v, type_of_1(bcx, t));
let body = GEPi(bcx, v, [0, abi::box_rc_field_body]);
let bcx = drop_ty(bcx, body, body_mt.ty);
if !bcx_ccx(bcx).sess.get_opts().do_gc {
@ -1361,7 +1361,7 @@ fn make_free_glue(bcx: @block_ctxt, v: ValueRef, t: ty::t) {
}
ty::ty_uniq(content_mt) {
check trans_uniq::type_is_unique_box(bcx, t);
v = PointerCast(bcx, v, type_of_1(bcx, t));
let v = PointerCast(bcx, v, type_of_1(bcx, t));
trans_uniq::make_free_glue(bcx, v, t)
}
ty::ty_vec(_) | ty::ty_str. {
@ -1388,7 +1388,7 @@ fn make_free_glue(bcx: @block_ctxt, v: ValueRef, t: ty::t) {
// Call through the closure's own fields-drop glue first.
// Then free the body.
let ccx = bcx_ccx(bcx);
v = PointerCast(bcx, v, T_opaque_closure_ptr(ccx));
let v = PointerCast(bcx, v, T_opaque_closure_ptr(ccx));
let body = GEPi(bcx, v, [0, abi::box_rc_field_body]);
let bindings =
GEPi(bcx, body, [0, abi::closure_elt_bindings]);
@ -1448,7 +1448,7 @@ fn trans_res_drop(cx: @block_ctxt, rs: ValueRef, did: ast::def_id,
// Silly check
check type_is_tup_like(cx, tup_ty);
let drop_flag = GEP_tup_like(cx, tup_ty, rs, [0, 0]);
cx = drop_flag.bcx;
let cx = drop_flag.bcx;
let null_test = IsNull(cx, Load(cx, drop_flag.val));
CondBr(cx, null_test, next_cx.llbb, drop_cx.llbb);
cx = drop_cx;
@ -1487,7 +1487,7 @@ fn decr_refcnt_maybe_free(cx: @block_ctxt, box_ptr: ValueRef, t: ty::t)
let free_cx = new_sub_block_ctxt(cx, "free");
let next_cx = new_sub_block_ctxt(cx, "next");
let llbox_ty = T_opaque_obj_ptr(ccx);
box_ptr = PointerCast(cx, box_ptr, llbox_ty);
let box_ptr = PointerCast(cx, box_ptr, llbox_ty);
let null_test = IsNull(cx, box_ptr);
CondBr(cx, null_test, next_cx.llbb, rc_adj_cx.llbb);
let rc_ptr =
@ -1640,6 +1640,7 @@ fn iter_structural_ty(cx: @block_ctxt, av: ValueRef, t: ty::t,
if std::vec::len::<ty::t>(variant.args) == 0u { ret cx; }
let fn_ty = variant.ctor_ty;
let ccx = bcx_ccx(cx);
let cx = cx;
alt ty::struct(ccx.tcx, fn_ty) {
ty::ty_fn(_, args, _, _, _) {
let j = 0u;
@ -1661,6 +1662,7 @@ fn iter_structural_ty(cx: @block_ctxt, av: ValueRef, t: ty::t,
/*
Typestate constraint that shows the unimpl case doesn't happen?
*/
let cx = cx;
alt ty::struct(bcx_tcx(cx), t) {
ty::ty_rec(fields) {
let i: int = 0;
@ -2054,7 +2056,7 @@ fn copy_val(cx: @block_ctxt, action: copy_action, dst: ValueRef,
fn copy_val_no_check(bcx: @block_ctxt, action: copy_action, dst: ValueRef,
src: ValueRef, t: ty::t) -> @block_ctxt {
let ccx = bcx_ccx(bcx);
let ccx = bcx_ccx(bcx), bcx = bcx;
if ty::type_is_scalar(ccx.tcx, t) || ty::type_is_native(ccx.tcx, t) {
Store(bcx, src, dst);
ret bcx;
@ -2084,7 +2086,7 @@ fn copy_val_no_check(bcx: @block_ctxt, action: copy_action, dst: ValueRef,
fn move_val(cx: @block_ctxt, action: copy_action, dst: ValueRef,
src: lval_result, t: ty::t) -> @block_ctxt {
let src_val = src.val;
let tcx = bcx_tcx(cx);
let tcx = bcx_tcx(cx), cx = cx;
if ty::type_is_scalar(tcx, t) || ty::type_is_native(tcx, t) {
if src.kind == owned { src_val = Load(cx, src_val); }
Store(cx, src_val, dst);
@ -2230,7 +2232,7 @@ fn trans_unary(bcx: @block_ctxt, op: ast::unop, e: @ast::expr,
fn trans_expr_fn(bcx: @block_ctxt, f: ast::_fn, sp: span,
id: ast::node_id, dest: dest) -> @block_ctxt {
if dest == ignore { ret bcx; }
let ccx = bcx_ccx(bcx);
let ccx = bcx_ccx(bcx), bcx = bcx;
let fty = node_id_type(ccx, id);
check returns_non_ty_var(ccx, fty);
let llfnty = type_of_fn_from_ty(ccx, sp, fty, 0u);
@ -2238,9 +2240,8 @@ fn trans_expr_fn(bcx: @block_ctxt, f: ast::_fn, sp: span,
let s = mangle_internal_name_by_path(ccx, sub_cx.path);
let llfn = decl_internal_cdecl_fn(ccx.llmod, s, llfnty);
let copying =
f.proto == ast::proto_shared(ast::sugar_normal)
|| f.proto == ast::proto_shared(ast::sugar_sexy);
let copying = f.proto == ast::proto_shared(ast::sugar_normal)
|| f.proto == ast::proto_shared(ast::sugar_sexy);
let env;
alt f.proto {
ast::proto_block. | ast::proto_shared(_) {
@ -2300,7 +2301,7 @@ fn trans_eager_binop(cx: @block_ctxt, op: ast::binop, lhs: ValueRef,
if op == ast::add && ty::type_is_sequence(bcx_tcx(cx), intype) {
ret tvec::trans_add(cx, intype, lhs, rhs, dest);
}
let val = alt op {
let cx = cx, val = alt op {
ast::add. {
if is_float { FAdd(cx, lhs, rhs) }
else { Add(cx, lhs, rhs) }
@ -2573,9 +2574,9 @@ fn trans_for(cx: @block_ctxt, local: @ast::local, seq: @ast::expr,
new_loop_scope_block_ctxt(bcx, option::some(next_cx),
outer_next_cx, "for loop scope");
Br(bcx, scope_cx.llbb);
curr = PointerCast(bcx, curr, T_ptr(type_of_or_i8(bcx, t)));
bcx = trans_alt::bind_irrefutable_pat(scope_cx, local.node.pat, curr,
false);
let curr = PointerCast(bcx, curr, T_ptr(type_of_or_i8(bcx, t)));
let bcx = trans_alt::bind_irrefutable_pat(scope_cx, local.node.pat,
curr, false);
bcx = trans_block_dps(bcx, body, ignore);
Br(bcx, next_cx.llbb);
ret next_cx;
@ -2649,7 +2650,7 @@ fn build_environment(bcx: @block_ctxt, lltydescs: [ValueRef],
// Finally, synthesize a type for that whole vector.
let closure_ty: ty::t = ty::mk_tup(tcx, closure_tys);
let temp_cleanups = [];
let temp_cleanups = [], bcx = bcx;
// Allocate a box that can hold something closure-sized.
let (closure, box) = if copying {
let r = trans_malloc_boxed(bcx, closure_ty);
@ -2903,7 +2904,7 @@ fn lval_static_fn(bcx: @block_ctxt, tpt: ty::ty_param_kinds_and_ty,
trans_external_path(bcx, fn_id, tpt)
};
let tys = ty::node_id_to_type_params(bcx_tcx(bcx), id);
let gen = none;
let gen = none, bcx = bcx;
if std::vec::len::<ty::t>(tys) != 0u {
let tydescs = [], tis = [];
for t in tys {
@ -3736,7 +3737,7 @@ fn trans_args(cx: @block_ctxt, outer_cx: @block_ctxt, llenv: ValueRef,
// This will be needed if this is a generic call, because the callee has
// to cast her view of the arguments to the caller's view.
let arg_tys = type_of_explicit_args(ccx, cx.sp, args);
let i = 0u;
let i = 0u, outer_cx = outer_cx;
for e: @ast::expr in es {
let is_referenced = alt ret_style {
ast::return_ref(_, arg_n) { i + 1u == arg_n }
@ -3838,7 +3839,7 @@ fn trans_c_stack_native_call(bcx: @block_ctxt, f: @ast::expr,
args: [@ast::expr], dest: dest) -> @block_ctxt {
let ccx = bcx_ccx(bcx);
let f_res = trans_callee(bcx, f);
let llfn = f_res.val; bcx = f_res.bcx;
let llfn = f_res.val, bcx = f_res.bcx;
// Translate the callee.
let { params: _, ty: fn_ty } = ty::expr_ty_params_and_ty(bcx_tcx(bcx), f);
@ -4033,6 +4034,7 @@ fn trans_landing_pad(bcx: @block_ctxt,
fn trans_tup(bcx: @block_ctxt, elts: [@ast::expr], id: ast::node_id,
dest: dest) -> @block_ctxt {
let t = node_id_type(bcx.fcx.lcx.ccx, id);
let bcx = bcx;
let addr = alt dest {
ignore. {
for ex in elts { bcx = trans_expr(bcx, ex, ignore); }
@ -4057,6 +4059,7 @@ fn trans_rec(bcx: @block_ctxt, fields: [ast::field],
base: option::t<@ast::expr>, id: ast::node_id,
dest: dest) -> @block_ctxt {
let t = node_id_type(bcx_ccx(bcx), id);
let bcx = bcx;
let addr = alt dest {
ignore. {
for fld in fields {
@ -4116,6 +4119,7 @@ fn trans_expr_save_in(bcx: @block_ctxt, e: @ast::expr, dest: ValueRef)
// trans_expr_save_in. For intermediates where you don't care about lval-ness,
// use trans_temp_expr.
fn trans_temp_lval(bcx: @block_ctxt, e: @ast::expr) -> lval_result {
let bcx = bcx;
if expr_is_lval(bcx_tcx(bcx), e) {
ret trans_lval(bcx, e);
} else {
@ -4429,6 +4433,7 @@ fn trans_check_expr(cx: @block_ctxt, e: @ast::expr, s: str) -> @block_ctxt {
fn trans_fail_expr(bcx: @block_ctxt, sp_opt: option::t<span>,
fail_expr: option::t<@ast::expr>) -> @block_ctxt {
let bcx = bcx;
alt fail_expr {
some(expr) {
let tcx = bcx_tcx(bcx);
@ -4483,7 +4488,7 @@ fn trans_fail_value(bcx: @block_ctxt, sp_opt: option::t<span>,
fn trans_break_cont(sp: span, bcx: @block_ctxt, to_end: bool)
-> @block_ctxt {
// Locate closest loop block, outputting cleanup as we go.
let cleanup_cx = bcx;
let cleanup_cx = bcx, bcx = bcx;
while true {
bcx = trans_block_cleanups(bcx, cleanup_cx);
alt copy cleanup_cx.kind {
@ -4524,7 +4529,7 @@ fn trans_cont(sp: span, cx: @block_ctxt) -> @block_ctxt {
}
fn trans_ret(bcx: @block_ctxt, e: option::t<@ast::expr>) -> @block_ctxt {
let cleanup_cx = bcx;
let cleanup_cx = bcx, bcx = bcx;
alt e {
some(x) {
if ast_util::ret_by_ref(bcx.fcx.ret_style) {
@ -4582,6 +4587,7 @@ fn init_local(bcx: @block_ctxt, local: @ast::local) -> @block_ctxt {
}
};
let bcx = bcx;
alt local.node.init {
some(init) {
if init.op == ast::init_assign ||
@ -4730,7 +4736,7 @@ fn trans_block_cleanups(bcx: @block_ctxt, cleanup_cx: @block_ctxt) ->
if cleanup_cx.kind == NON_SCOPE_BLOCK {
assert (std::vec::len::<cleanup>(cleanup_cx.cleanups) == 0u);
}
let i = std::vec::len::<cleanup>(cleanup_cx.cleanups);
let i = std::vec::len::<cleanup>(cleanup_cx.cleanups), bcx = bcx;
while i > 0u {
i -= 1u;
let c = cleanup_cx.cleanups[i];
@ -4863,6 +4869,7 @@ fn trans_block(bcx: @block_ctxt, b: ast::blk) -> @block_ctxt {
fn trans_block_dps(bcx: @block_ctxt, b: ast::blk, dest: dest)
-> @block_ctxt {
let bcx = bcx;
block_locals(b) {|local| bcx = alloc_local(bcx, local); };
for s: @ast::stmt in b.node.stmts {
bcx = trans_stmt(bcx, *s);
@ -4998,41 +5005,25 @@ fn create_llargs_for_fn_args(cx: @fn_ctxt, ty_self: option::t<ty::t>,
}
fn copy_args_to_allocas(fcx: @fn_ctxt, bcx: @block_ctxt, args: [ast::arg],
arg_tys: [ty::arg], ignore_mut: bool)
-> @block_ctxt {
let arg_n: uint = 0u;
arg_tys: [ty::arg]) -> @block_ctxt {
let arg_n: uint = 0u, bcx = bcx;
for arg in arg_tys {
let id = args[arg_n].id;
let mutated = !ignore_mut && fcx.lcx.ccx.mut_map.contains_key(id);
let argval = alt fcx.llargs.get(id) { local_mem(v) { v } };
alt arg.mode {
ast::by_mut_ref. { }
ast::by_move. { add_clean(bcx, argval, arg.ty); }
ast::by_val. {
if mutated || !ty::type_is_immediate(bcx_tcx(bcx), arg.ty) {
if !ty::type_is_immediate(bcx_tcx(bcx), arg.ty) {
let {bcx: cx, val: alloc} = alloc_ty(bcx, arg.ty);
bcx = cx;
Store(bcx, argval, alloc);
if mutated {
bcx = take_ty(bcx, alloc, arg.ty);
add_clean(bcx, alloc, arg.ty);
}
fcx.llargs.insert(id, local_mem(alloc));
} else {
fcx.llargs.insert(id, local_imm(argval));
}
}
ast::by_ref. {
// Overwrite the llargs entry for locally mutated params
// with a local alloca.
if mutated {
let {bcx: cx, val: alloc} = alloc_ty(bcx, arg.ty);
bcx = copy_val(cx, INIT, alloc,
load_if_immediate(cx, argval, arg.ty), arg.ty);
fcx.llargs.insert(id, local_mem(alloc));
add_clean(bcx, alloc, arg.ty);
}
}
ast::by_ref. {}
}
arg_n += 1u;
}
@ -5129,7 +5120,7 @@ fn trans_closure(cx: @local_ctxt, sp: span, f: ast::_fn, llfndecl: ValueRef,
let block_ty = node_id_type(cx.ccx, f.body.node.id);
let arg_tys = arg_tys_of_fn(fcx.lcx.ccx, id);
bcx = copy_args_to_allocas(fcx, bcx, f.decl.inputs, arg_tys, false);
bcx = copy_args_to_allocas(fcx, bcx, f.decl.inputs, arg_tys);
maybe_load_env(fcx);
@ -5254,7 +5245,7 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id,
let arg_tys = arg_tys_of_fn(ccx, variant.node.id);
let bcx = new_top_block_ctxt(fcx);
let lltop = bcx.llbb;
bcx = copy_args_to_allocas(fcx, bcx, fn_args, arg_tys, true);
bcx = copy_args_to_allocas(fcx, bcx, fn_args, arg_tys);
// Cast the tag to a type we can GEP into.
let llblobptr =
@ -5991,7 +5982,7 @@ fn decl_crate_map(sess: session::session, mapname: str,
let n_subcrates = 1;
let cstore = sess.get_cstore();
while cstore::have_crate_data(cstore, n_subcrates) { n_subcrates += 1; }
if !sess.get_opts().library { mapname = "toplevel"; }
let mapname = sess.get_opts().library ? mapname : "toplevel";
let sym_name = "_rust_crate_map_" + mapname;
let arrtype = T_array(int_type, n_subcrates as uint);
let maptype = T_struct([int_type, arrtype]);

16
src/comp/middle/trans_alt.rs
View file

@ -44,7 +44,7 @@ tag opt_result {
range_result(result, result);
}
fn trans_opt(bcx: @block_ctxt, o: opt) -> opt_result {
let ccx = bcx_ccx(bcx);
let ccx = bcx_ccx(bcx), bcx = bcx;
alt o {
lit(l) {
alt l.node {
@ -249,7 +249,7 @@ fn get_options(ccx: @crate_ctxt, m: match, col: uint) -> [opt] {
fn extract_variant_args(bcx: @block_ctxt, pat_id: ast::node_id,
vdefs: {tg: def_id, var: def_id}, val: ValueRef) ->
{vals: [ValueRef], bcx: @block_ctxt} {
let ccx = bcx.fcx.lcx.ccx;
let ccx = bcx.fcx.lcx.ccx, bcx = bcx;
let ty_param_substs = ty::node_id_to_type_params(ccx.tcx, pat_id);
let blobptr = val;
let variants = ty::tag_variants(ccx.tcx, vdefs.tg);
@ -348,6 +348,7 @@ fn pick_col(m: match) -> uint {
fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
&exits: [exit_node]) {
let bcx = bcx;
if vec::len(m) == 0u { Br(bcx, f()); ret; }
if vec::len(m[0].pats) == 0u {
let data = m[0].data;
@ -543,7 +544,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
let le = trans::trans_compare(ge.bcx, ast::le, test_val, t,
rend.val, t);
let in_range = rslt(le.bcx, And(le.bcx, ge.val, le.val));
/*let*/ bcx = in_range.bcx; //XXX uncomment for assertion
bcx = in_range.bcx;
let cleanup_cx =
trans::trans_block_cleanups(bcx, compare_cx);
bcx = new_sub_block_ctxt(bcx, "compare_next");
@ -580,7 +581,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
fn make_phi_bindings(bcx: @block_ctxt, map: [exit_node],
ids: ast_util::pat_id_map) -> bool {
let our_block = bcx.llbb as uint;
let success = true;
let success = true, bcx = bcx;
ids.items {|name, node_id|
let llbbs = [];
let vals = [];
@ -679,7 +680,7 @@ fn trans_alt(cx: @block_ctxt, expr: @ast::expr, arms: [ast::arm],
// Not alt-related, but similar to the pattern-munging code above
fn bind_irrefutable_pat(bcx: @block_ctxt, pat: @ast::pat, val: ValueRef,
make_copy: bool) -> @block_ctxt {
let ccx = bcx.fcx.lcx.ccx;
let ccx = bcx.fcx.lcx.ccx, bcx = bcx;
alt pat.node {
ast::pat_bind(_) {
if make_copy || ccx.copy_map.contains_key(pat.id) {
@ -690,9 +691,8 @@ fn bind_irrefutable_pat(bcx: @block_ctxt, pat: @ast::pat, val: ValueRef,
check non_ty_var(ccx, ty);
let llty = trans::type_of(ccx, pat.span, ty);
let alloc = trans::alloca(bcx, llty);
bcx =
trans::copy_val(bcx, trans::INIT, alloc,
trans::load_if_immediate(bcx, val, ty), ty);
bcx = trans::copy_val(bcx, trans::INIT, alloc,
trans::load_if_immediate(bcx, val, ty), ty);
bcx.fcx.lllocals.insert(pat.id, local_mem(alloc));
trans_common::add_clean(bcx, alloc, ty);
} else { bcx.fcx.lllocals.insert(pat.id, local_mem(val)); }

3
src/comp/middle/trans_objects.rs
View file

@ -54,7 +54,7 @@ fn trans_obj(cx: @local_ctxt, sp: span, ob: ast::_obj, ctor_id: ast::node_id,
// Both regular arguments and type parameters are handled here.
create_llargs_for_fn_args(fcx, none::<ty::t>, fn_args, ty_params);
let arg_tys: [ty::arg] = arg_tys_of_fn(ccx, ctor_id);
bcx = copy_args_to_allocas(fcx, bcx, fn_args, arg_tys, true);
bcx = copy_args_to_allocas(fcx, bcx, fn_args, arg_tys);
// Pick up the type of this object by looking at our own output type, that
// is, the output type of the object constructor we're building.
@ -216,6 +216,7 @@ fn trans_obj(cx: @local_ctxt, sp: span, ob: ast::_obj, ctor_id: ast::node_id,
// itself.
fn trans_anon_obj(bcx: @block_ctxt, sp: span, anon_obj: ast::anon_obj,
id: ast::node_id, dest: trans::dest) -> @block_ctxt {
let bcx = bcx;
if dest == trans::ignore {
alt anon_obj.inner_obj {
some(e) { ret trans::trans_expr(bcx, e, trans::ignore); }

13
src/comp/middle/trans_vec.rs
View file

@ -99,7 +99,7 @@ fn make_free_glue(bcx: @block_ctxt, vptr: ValueRef, vec_ty: ty::t) ->
fn trans_vec(bcx: @block_ctxt, args: [@ast::expr], id: ast::node_id,
dest: dest) -> @block_ctxt {
let ccx = bcx_ccx(bcx);
let ccx = bcx_ccx(bcx), bcx = bcx;
if dest == trans::ignore {
for arg in args {
bcx = trans::trans_expr(bcx, arg, trans::ignore);
@ -150,10 +150,9 @@ fn trans_append(cx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef,
let ccx = bcx_ccx(cx);
let unit_ty = ty::sequence_element_type(bcx_tcx(cx), vec_ty);
let dynamic = ty::type_has_dynamic_size(bcx_tcx(cx), unit_ty);
if dynamic {
lhsptr = PointerCast(cx, lhsptr, T_ptr(T_ptr(ccx.opaque_vec_type)));
rhs = PointerCast(cx, rhs, T_ptr(ccx.opaque_vec_type));
}
let (lhsptr, rhs) = !dynamic ? (lhsptr, rhs) :
(PointerCast(cx, lhsptr, T_ptr(T_ptr(ccx.opaque_vec_type))),
PointerCast(cx, rhs, T_ptr(ccx.opaque_vec_type)));
let strings = alt ty::struct(bcx_tcx(cx), vec_ty) {
ty::ty_str. { true }
ty::ty_vec(_) { false }
@ -271,7 +270,7 @@ fn iter_vec_raw(bcx: @block_ctxt, vptr: ValueRef, vec_ty: ty::t,
let unit_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty);
let llunitty = type_of_or_i8(bcx, unit_ty);
let {bcx: bcx, val: unit_sz} = size_of(bcx, unit_ty);
vptr = PointerCast(bcx, vptr, T_ptr(T_vec(ccx, llunitty)));
let vptr = PointerCast(bcx, vptr, T_ptr(T_vec(ccx, llunitty)));
let data_ptr = get_dataptr(bcx, vptr, llunitty);
// Calculate the last pointer address we want to handle.
@ -302,7 +301,7 @@ fn iter_vec_raw(bcx: @block_ctxt, vptr: ValueRef, vec_ty: ty::t,
fn iter_vec(bcx: @block_ctxt, vptr: ValueRef, vec_ty: ty::t,
f: iter_vec_block) -> @block_ctxt {
let ccx = bcx_ccx(bcx);
vptr = PointerCast(bcx, vptr, T_ptr(ccx.opaque_vec_type));
let vptr = PointerCast(bcx, vptr, T_ptr(ccx.opaque_vec_type));
ret iter_vec_raw(bcx, vptr, vec_ty, get_fill(bcx, vptr), f);
}

5
src/comp/middle/typeck.rs
View file

@ -1693,9 +1693,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
element_ty: ty::t, body: ast::blk,
node_id: ast::node_id) -> bool {
let locid = lookup_local(fcx, local.span, local.node.id);
element_ty =
demand::simple(fcx, local.span, element_ty,
ty::mk_var(fcx.ccx.tcx, locid));
let element_ty = demand::simple(fcx, local.span, element_ty,
ty::mk_var(fcx.ccx.tcx, locid));
let bot = check_decl_local(fcx, local);
check_block(fcx, body);
// Unify type of decl with element type of the seq

21
src/comp/syntax/parse/lexer.rs
View file

@ -158,17 +158,6 @@ fn consume_block_comment(rdr: reader) {
be consume_whitespace_and_comments(rdr);
}
fn string_to_int(s: str) -> int {
let negative = false;
if str::char_at(s, 0u) == '-' {
negative = true;
s = str::substr(s, 1u, str::byte_len(s) - 1u);
}
let accum_int: int = 0;
for c: u8 in s { accum_int *= 10; accum_int += dec_digit_val(c as char); }
ret if negative { -accum_int } else { accum_int };
}
fn scan_exponent(rdr: reader) -> option::t<str> {
let c = rdr.curr();
let rslt = "";
@ -210,7 +199,7 @@ fn scan_dec_digits(rdr: reader) -> str {
}
fn scan_number(c: char, rdr: reader) -> token::token {
let accum_int = 0;
let accum_int = 0, c = c;
let num_str: str = "";
let n = rdr.next();
if c == '0' && n == 'x' {
@ -233,7 +222,7 @@ fn scan_number(c: char, rdr: reader) -> token::token {
}
} else {
num_str = scan_dec_digits_with_prefix(rdr);
accum_int = string_to_int(num_str);
accum_int = std::int::from_str(num_str);
}
c = rdr.curr();
n = rdr.next();
@ -321,8 +310,8 @@ fn scan_number(c: char, rdr: reader) -> token::token {
}
fn scan_numeric_escape(rdr: reader, n_hex_digits: uint) -> char {
let accum_int = 0;
while n_hex_digits != 0u {
let accum_int = 0, i = n_hex_digits;
while i != 0u {
let n = rdr.curr();
rdr.bump();
if !is_hex_digit(n) {
@ -331,7 +320,7 @@ fn scan_numeric_escape(rdr: reader, n_hex_digits: uint) -> char {
}
accum_int *= 16;
accum_int += hex_digit_val(n);
n_hex_digits -= 1u;
i -= 1u;
}
ret accum_int as char;
}

1
src/comp/syntax/parse/parser.rs
View file

@ -1038,6 +1038,7 @@ fn parse_dot_or_call_expr(p: parser) -> @ast::expr {
fn parse_dot_or_call_expr_with(p: parser, e: @ast::expr) -> @ast::expr {
let lo = e.span.lo;
let hi = e.span.hi;
let e = e;
while true {
alt p.peek() {
token::LPAREN. {

2
src/lib/aio.rs
View file

@ -157,7 +157,7 @@ fn iotask(c: chan<ctx>) {
log "io task init";
// Spawn our request task
let reqtask = task::spawn_joinable(c, request_task);
let reqtask = task::spawn_joinable(copy c, request_task);
log "uv run task init";
// Enter IO loop. This never returns until aio_stop is called.

9
src/lib/float.rs
View file

@ -17,18 +17,19 @@ num - The float value
digits: The number of significant digits
*/
fn to_str(num: float, digits: uint) -> str {
let accum = if num < 0.0 { num = -num; "-" } else { "" };
let (num, accum) = num < 0.0 ? (-num, "-") : (num, "");
let trunc = num as uint;
let frac = num - (trunc as float);
accum += uint::str(trunc);
if frac == 0.0 || digits == 0u { ret accum; }
accum += ".";
while digits > 0u && frac > 0.0 {
let i = digits;
while i > 0u && frac > 0.0 {
frac *= 10.0;
let digit = frac as uint;
accum += uint::str(digit);
frac -= digit as float;
digits -= 1u;
i -= 1u;
}
ret accum;
}
@ -60,7 +61,7 @@ Returns:
Otherwise, the floating-point number represented [num].
*/
fn from_str(num: str) -> float {
num = str::trim(num);
let num = str::trim(num);
let pos = 0u; //Current byte position in the string.
//Used to walk the string in O(n).

3
src/lib/int.rs
View file

@ -80,7 +80,8 @@ Function: range
Iterate over the range [`lo`..`hi`)
*/
fn range(lo: int, hi: int, it: block(int)) {
while lo < hi { it(lo); lo += 1; }
let i = lo;
while i < hi { it(i); i += 1; }
}
/*

24
src/lib/io.rs
View file

@ -132,31 +132,31 @@ obj new_reader(rdr: buf_reader) {
fn read_le_uint(size: uint) -> uint {
let val = 0u;
let pos = 0u;
while size > 0u {
let i = size;
while i > 0u {
val += (rdr.read_byte() as uint) << pos;
pos += 8u;
size -= 1u;
i -= 1u;
}
ret val;
}
fn read_le_int(size: uint) -> int {
let val = 0u;
let pos = 0u;
while size > 0u {
let val = 0u, pos = 0u, i = size;
while i > 0u {
val += (rdr.read_byte() as uint) << pos;
pos += 8u;
size -= 1u;
i -= 1u;
}
ret val as int;
}
// FIXME deal with eof?
fn read_be_uint(sz: uint) -> uint {
let val = 0u;
let val = 0u, i = sz;
while sz > 0u {
sz -= 1u;
val += (rdr.read_byte() as uint) << sz * 8u;
while i > 0u {
i -= 1u;
val += (rdr.read_byte() as uint) << i * 8u;
}
ret val;
}
@ -324,8 +324,8 @@ type writer =
};
fn uint_to_le_bytes(n: uint, size: uint) -> [u8] {
let bytes: [u8] = [];
while size > 0u { bytes += [n & 255u as u8]; n >>= 8u; size -= 1u; }
let bytes: [u8] = [], i = size, n = n;
while i > 0u { bytes += [n & 255u as u8]; n >>= 8u; i -= 1u; }
ret bytes;
}

2
src/lib/str.rs
View file

@ -277,7 +277,7 @@ fn char_range_at(s: str, i: uint) -> {ch: char, next: uint} {
if w == 1u { ret {ch: b0 as char, next: i + 1u}; }
let val = 0u;
let end = i + w;
i += 1u;
let i = i + 1u;
while i < end {
let byte = s[i];
assert (byte & 192u8 == tag_cont_u8);

1
src/lib/term.rs
View file

@ -76,6 +76,7 @@ fn color_supported() -> bool {
fn set_color(writer: io::buf_writer, first_char: u8, color: u8) {
assert (color < 16u8);
esc(writer);
let color = color;
if color >= 8u8 { writer.write(['1' as u8, ';' as u8]); color -= 8u8; }
writer.write([first_char, ('0' as u8) + color, 'm' as u8]);
}

2
src/lib/test.rs
View file

@ -334,7 +334,7 @@ fn default_test_to_task(&&f: default_test_fn) -> joinable {
configure_test_task();
f();
}
ret task::spawn_joinable(f, run_task);
ret task::spawn_joinable(copy f, run_task);
}
// Call from within a test task to make sure it's set up correctly

1
src/lib/u64.rs
View file

@ -52,6 +52,7 @@ fn to_str(n: u64, radix: uint) -> str {
let s = "";
let n = n;
while n > 0u64 { s = digit(n % r64) + s; n /= r64; }
ret s;
}

3
src/lib/u8.rs
View file

@ -55,7 +55,8 @@ Function: range
Iterate over the range [`lo`..`hi`)
*/
fn range(lo: u8, hi: u8, it: block(u8)) {
while lo < hi { it(lo); lo += 1u8; }
let i = lo;
while i < hi { it(i); i += 1u8; }
}
// Local Variables:

3
src/lib/uint.rs
View file

@ -61,7 +61,8 @@ Function: range
Iterate over the range [`lo`..`hi`)
*/
fn range(lo: uint, hi: uint, it: block(uint)) {
while lo < hi { it(lo); lo += 1u; }
let i = lo;
while i < hi { it(i); i += 1u; }
}
/*

2
src/test/run-pass/issue-507.rs
View file

@ -18,7 +18,7 @@ import std::comm::recv;
fn grandchild(c: chan<int>) { send(c, 42); }
fn child(c: chan<int>) {
let _grandchild = task::spawn_joinable(c, grandchild);
let _grandchild = task::spawn_joinable(copy c, grandchild);
join(_grandchild);
}

1
src/test/run-pass/move-4-unique.rs
View file

@ -2,6 +2,7 @@ use std;
import std::uint;
fn test(foo: ~{a: int, b: int, c: int}) -> ~{a: int, b: int, c: int} {
let foo = foo;
let bar <- foo;
let baz <- bar;
let quux <- baz;

1
src/test/run-pass/move-4.rs
View file

@ -3,6 +3,7 @@ use std;
import std::uint;
fn test(foo: @{a: int, b: int, c: int}) -> @{a: int, b: int, c: int} {
let foo = foo;
let bar <- foo;
let baz <- bar;
let quux <- baz;

2
src/test/run-pass/obj-docs.rs
View file

@ -41,7 +41,7 @@ fn main() {
}
obj sender(c: chan<int>) {
fn take(z: int) { send(c, z); }
fn take(z: int) { send(c, copy z); }
}
fn give_ints(t: taker) { t.take(1); t.take(2); t.take(3); }

4
src/test/run-pass/obj-self-2.rs
View file

@ -2,8 +2,8 @@
fn main() {
obj foo() {
fn m1(i: int) { i += 1; log "hi!"; }
fn m2(i: int) { i += 1; self.m1(i); }
fn m1(i: int) { let i = i + 1; log "hi!"; }
fn m2(i: int) { let i = i + 1; self.m1(i); }
}
let a = foo();
let i: int = 0;

4
src/test/run-pass/obj-self-3.rs
View file

@ -2,9 +2,9 @@
fn main() {
obj foo() {
fn m1(i: int) -> int { i += 1; ret i; }
fn m1(i: int) -> int { let i = i + 1; ret i; }
fn m2(i: int) -> int { ret self.m1(i); }
fn m3(i: int) -> int { i += 1; ret self.m1(i); }
fn m3(i: int) -> int { let i = i + 1; ret self.m1(i); }
}
let a = foo();
let i: int = 0;