bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Add non_ty_var precondition for type_of_fn, plus minor cleanup

Browse source
This commit is contained in:
Tim Chevalier 2011-09-16 10:49:05 -07:00
parent 469853d5ff
commit 172df2e3a2
2 changed files with 17 additions and 10 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -74,11 +74,11 @@ fn type_of_explicit_args(cx: @crate_ctxt, sp: span, inputs: [ty::arg]) ->
// - trans_args // - trans_args
fn type_of_fn(cx: @crate_ctxt, sp: span, proto: ast::proto, fn type_of_fn(cx: @crate_ctxt, sp: span, proto: ast::proto,
is_method: bool, ret_ref: bool, inputs: [ty::arg], is_method: bool, ret_ref: bool, inputs: [ty::arg],
output: ty::t, ty_param_count: uint) -> TypeRef { output: ty::t, ty_param_count: uint)
: non_ty_var(cx, output) -> TypeRef {
let atys: [TypeRef] = []; let atys: [TypeRef] = [];
// Arg 0: Output pointer. // Arg 0: Output pointer.
check non_ty_var(cx, output);
let out_ty = T_ptr(type_of_inner(cx, sp, output)); let out_ty = T_ptr(type_of_inner(cx, sp, output));
atys += [ret_ref ? T_ptr(out_ty) : out_ty]; atys += [ret_ref ? T_ptr(out_ty) : out_ty];
@ -2073,6 +2073,7 @@ fn move_val(cx: @block_ctxt, action: copy_action, dst: ValueRef,
// If we're here, it must be a temporary. // If we're here, it must be a temporary.
ret revoke_clean(cx, src_val, t); ret revoke_clean(cx, src_val, t);
} }
/* FIXME: suggests a type constraint */
bcx_ccx(cx).sess.bug("unexpected type in trans::move_val: " + bcx_ccx(cx).sess.bug("unexpected type in trans::move_val: " +
ty_to_str(tcx, t)); ty_to_str(tcx, t));
} }
@ -2999,12 +3000,18 @@ fn trans_field(cx: @block_ctxt, sp: span, v: ValueRef, t0: ty::t,
let v = GEP(r.bcx, vtbl, [C_int(0), C_int(ix as int)]); let v = GEP(r.bcx, vtbl, [C_int(0), C_int(ix as int)]);
let tcx = bcx_tcx(cx); let tcx = bcx_tcx(cx);
let ccx = bcx_ccx(cx);
let fn_ty: ty::t = ty::method_ty_to_fn_ty(tcx, methods[ix]); let fn_ty: ty::t = ty::method_ty_to_fn_ty(tcx, methods[ix]);
let ret_ty = ty::ty_fn_ret(tcx, fn_ty);
let ret_ref = ast_util::ret_by_ref(ty::ty_fn_ret_style(tcx, fn_ty)); let ret_ref = ast_util::ret_by_ref(ty::ty_fn_ret_style(tcx, fn_ty));
// FIXME: constrain ty_obj?
check non_ty_var(ccx, ret_ty);
let ll_fn_ty = let ll_fn_ty =
type_of_fn(bcx_ccx(cx), sp, ty::ty_fn_proto(tcx, fn_ty), type_of_fn(ccx, sp, ty::ty_fn_proto(tcx, fn_ty),
true, ret_ref, ty::ty_fn_args(tcx, fn_ty), true, ret_ref, ty::ty_fn_args(tcx, fn_ty),
ty::ty_fn_ret(tcx, fn_ty), 0u); ret_ty, 0u);
v = PointerCast(r.bcx, v, T_ptr(T_ptr(ll_fn_ty))); v = PointerCast(r.bcx, v, T_ptr(T_ptr(ll_fn_ty)));
let lvo = lval_mem(r.bcx, v); let lvo = lval_mem(r.bcx, v);
ret {llobj: some::<ValueRef>(r.val) with lvo}; ret {llobj: some::<ValueRef>(r.val) with lvo};
@ -4581,7 +4588,7 @@ fn trans_stmt(cx: @block_ctxt, s: ast::stmt) -> result {
} }
_ { bcx_ccx(cx).sess.unimpl("stmt variant"); } _ { bcx_ccx(cx).sess.unimpl("stmt variant"); }
} }
ret rslt(bcx, C_nil()); rslt(bcx, C_nil())
} }
// You probably don't want to use this one. See the // You probably don't want to use this one. See the
@ -5438,7 +5445,7 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef,
let vecarg_ty: ty::arg = let vecarg_ty: ty::arg =
{mode: ast::by_ref, {mode: ast::by_ref,
ty: ty::mk_vec(ccx.tcx, {ty: unit_ty, mut: ast::imm})}; ty: ty::mk_vec(ccx.tcx, {ty: unit_ty, mut: ast::imm})};
// FIXME: mk_nil should have a post condition // FIXME: mk_nil should have a postcondition
let nt = ty::mk_nil(ccx.tcx); let nt = ty::mk_nil(ccx.tcx);
check non_ty_var(ccx, nt); check non_ty_var(ccx, nt);

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

@ -885,9 +885,9 @@ fn process_normal_mthd(cx: @local_ctxt, m: @ast::method, self_ty: ty::t,
ty_params: [ast::ty_param]) -> ValueRef { ty_params: [ast::ty_param]) -> ValueRef {
let llfnty = T_nil(); let llfnty = T_nil();
let ccx = cx.ccx;
alt ty::struct(cx.ccx.tcx, node_id_type(cx.ccx, m.node.id)) { alt ty::struct(cx.ccx.tcx, node_id_type(cx.ccx, m.node.id)) {
ty::ty_fn(proto, inputs, output, rs, _) { ty::ty_fn(proto, inputs, output, rs, _) {
let ccx = cx.ccx;
check non_ty_var(ccx, output); check non_ty_var(ccx, output);
llfnty = type_of_fn(ccx, m.span, proto, true, llfnty = type_of_fn(ccx, m.span, proto, true,
ast_util::ret_by_ref(rs), inputs, output, ast_util::ret_by_ref(rs), inputs, output,
@ -897,13 +897,13 @@ fn process_normal_mthd(cx: @local_ctxt, m: @ast::method, self_ty: ty::t,
let mcx: @local_ctxt = let mcx: @local_ctxt =
@{path: cx.path + ["method", m.node.ident] with *cx}; @{path: cx.path + ["method", m.node.ident] with *cx};
let s: str = mangle_internal_name_by_path(mcx.ccx, mcx.path); let s: str = mangle_internal_name_by_path(mcx.ccx, mcx.path);
let llfn: ValueRef = decl_internal_fastcall_fn(cx.ccx.llmod, s, llfnty); let llfn: ValueRef = decl_internal_fastcall_fn(ccx.llmod, s, llfnty);
// Every method on an object gets its node_id inserted into the crate-wide // Every method on an object gets its node_id inserted into the crate-wide
// item_ids map, together with the ValueRef that points to where that // item_ids map, together with the ValueRef that points to where that
// method's definition will be in the executable. // method's definition will be in the executable.
cx.ccx.item_ids.insert(m.node.id, llfn); ccx.item_ids.insert(m.node.id, llfn);
cx.ccx.item_symbols.insert(m.node.id, s); ccx.item_symbols.insert(m.node.id, s);
trans_fn(mcx, m.span, m.node.meth, llfn, some(self_ty), ty_params, trans_fn(mcx, m.span, m.node.meth, llfn, some(self_ty), ty_params,
m.node.id); m.node.id);