OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Replace &ty::t with ty::t throughout the compiler

Browse Source 
Type handles are uints, passing them by reference only causes
unnecessary spilling.
This commit is contained in:
Marijn Haverbeke 2011-08-22 12:45:18 +02:00
parent 081caf5bb8
commit 10269dfaeb
7 changed files with 151 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/comp/back/link.rs
View File

@ -392,7 +392,7 @@ fn truncated_sha1_result(sha: sha1) -> str {
// This calculates STH for a symbol, as defined above
fn symbol_hash(tcx: ty::ctxt, sha: sha1, t: &ty::t, link_meta: &link_meta) ->
fn symbol_hash(tcx: ty::ctxt, sha: sha1, t: ty::t, link_meta: &link_meta) ->
str {
// NB: do *not* use abbrevs here as we want the symbol names
// to be independent of one another in the crate.
@ -410,7 +410,7 @@ fn symbol_hash(tcx: ty::ctxt, sha: sha1, t: &ty::t, link_meta: &link_meta) ->
ret "_" + hash;
}
fn get_symbol_hash(ccx: &@crate_ctxt, t: &ty::t) -> str {
fn get_symbol_hash(ccx: &@crate_ctxt, t: ty::t) -> str {
let hash = "";
alt ccx.type_sha1s.find(t) {
some(h) { hash = h; }
@ -440,12 +440,12 @@ fn exported_name(path: &[str], hash: &str, _vers: &str) -> str {
}
fn mangle_exported_name(ccx: &@crate_ctxt, path: &[str], t: &ty::t) -> str {
fn mangle_exported_name(ccx: &@crate_ctxt, path: &[str], t: ty::t) -> str {
let hash = get_symbol_hash(ccx, t);
ret exported_name(path, hash, ccx.link_meta.vers);
}
fn mangle_internal_name_by_type_only(ccx: &@crate_ctxt, t: &ty::t, name: &str)
fn mangle_internal_name_by_type_only(ccx: &@crate_ctxt, t: ty::t, name: &str)
-> str {
let s = util::ppaux::ty_to_short_str(ccx.tcx, t);
let hash = get_symbol_hash(ccx, t);

4
src/comp/metadata/encoder.rs
View File

@ -193,7 +193,7 @@ fn encode_variant_id(ebml_w: &ebml::writer, vid: &def_id) {
ebml::end_tag(ebml_w);
}
fn encode_type(ecx: &@encode_ctxt, ebml_w: &ebml::writer, typ: &ty::t) {
fn encode_type(ecx: &@encode_ctxt, ebml_w: &ebml::writer, typ: ty::t) {
ebml::start_tag(ebml_w, tag_items_data_item_type);
let f = def_to_str;
let ty_str_ctxt =
@ -618,7 +618,7 @@ fn encode_metadata(cx: &@crate_ctxt, crate: &@crate) -> str {
}
// Get the encoded string for a type
fn encoded_ty(tcx: &ty::ctxt, t: &ty::t) -> str {
fn encoded_ty(tcx: &ty::ctxt, t: ty::t) -> str {
let cx = @{ds: def_to_str, tcx: tcx, abbrevs: tyencode::ac_no_abbrevs};
let sw = io::string_writer();
tyencode::enc_ty(sw.get_writer(), cx, t);

4
src/comp/metadata/tyencode.rs
View File

@ -36,7 +36,7 @@ fn cx_uses_abbrevs(cx: &@ctxt) -> bool {
}
}
fn enc_ty(w: &io::writer, cx: &@ctxt, t: &ty::t) {
fn enc_ty(w: &io::writer, cx: &@ctxt, t: ty::t) {
alt cx.abbrevs {
ac_no_abbrevs. {
let result_str;
@ -202,7 +202,7 @@ fn enc_proto(w: &io::writer, proto: proto) {
}
}
fn enc_ty_fn(w: &io::writer, cx: &@ctxt, args: &[ty::arg], out: &ty::t,
fn enc_ty_fn(w: &io::writer, cx: &@ctxt, args: &[ty::arg], out: ty::t,
cf: &controlflow, constrs: &[@ty::constr]) {
w.write_char('[');
for arg: ty::arg in args {

2
src/comp/middle/gc.rs
View File

@ -94,7 +94,7 @@ fn add_gc_root(cx: &@block_ctxt, llval: ValueRef, ty: ty::t) -> @block_ctxt {
ret bcx;
}
fn type_is_gc_relevant(cx: &ty::ctxt, ty: &ty::t) -> bool {
fn type_is_gc_relevant(cx: &ty::ctxt, ty: ty::t) -> bool {
alt ty::struct(cx, ty) {
ty::ty_nil. | ty::ty_bot. | ty::ty_bool. | ty::ty_int. | ty::ty_float. |
ty::ty_uint. | ty::ty_machine(_) | ty::ty_char. | ty::ty_istr. |

124
src/comp/middle/trans.rs
View File

@ -78,7 +78,7 @@ import trans_objects::trans_obj;
// return value was always meaningless in that case anyhow). Beware!
//
// TODO: Enforce via a predicate.
fn type_of(cx: &@crate_ctxt, sp: &span, t: &ty::t) -> TypeRef {
fn type_of(cx: &@crate_ctxt, sp: &span, t: ty::t) -> TypeRef {
if ty::type_has_dynamic_size(cx.tcx, t) {
cx.sess.span_fatal(sp,
"type_of() called on a type with dynamic size: " +
@ -113,7 +113,7 @@ fn type_of_explicit_args(cx: &@crate_ctxt, sp: &span, inputs: &[ty::arg]) ->
// - new_fn_ctxt
// - trans_args
fn type_of_fn_full(cx: &@crate_ctxt, sp: &span, proto: ast::proto,
is_method: bool, inputs: &[ty::arg], output: &ty::t,
is_method: bool, inputs: &[ty::arg], output: ty::t,
ty_param_count: uint) -> TypeRef {
let atys: [TypeRef] = [];
@ -145,13 +145,13 @@ fn type_of_fn_full(cx: &@crate_ctxt, sp: &span, proto: ast::proto,
}
fn type_of_fn(cx: &@crate_ctxt, sp: &span, proto: ast::proto,
inputs: &[ty::arg], output: &ty::t, ty_param_count: uint) ->
inputs: &[ty::arg], output: ty::t, ty_param_count: uint) ->
TypeRef {
ret type_of_fn_full(cx, sp, proto, false, inputs, output, ty_param_count);
}
// Given a function type and a count of ty params, construct an llvm type
fn type_of_fn_from_ty(cx: &@crate_ctxt, sp: &span, fty: &ty::t,
fn type_of_fn_from_ty(cx: &@crate_ctxt, sp: &span, fty: ty::t,
ty_param_count: uint) -> TypeRef {
ret type_of_fn(cx, sp, ty::ty_fn_proto(cx.tcx, fty),
ty::ty_fn_args(cx.tcx, fty), ty::ty_fn_ret(cx.tcx, fty),
@ -159,7 +159,7 @@ fn type_of_fn_from_ty(cx: &@crate_ctxt, sp: &span, fty: &ty::t,
}
fn type_of_native_fn(cx: &@crate_ctxt, sp: &span, abi: ast::native_abi,
inputs: &[ty::arg], output: &ty::t, ty_param_count: uint)
inputs: &[ty::arg], output: ty::t, ty_param_count: uint)
-> TypeRef {
let atys: [TypeRef] = [];
if abi == ast::native_abi_rust {
@ -171,7 +171,7 @@ fn type_of_native_fn(cx: &@crate_ctxt, sp: &span, abi: ast::native_abi,
ret T_fn(atys, type_of_inner(cx, sp, output));
}
fn type_of_inner(cx: &@crate_ctxt, sp: &span, t: &ty::t) -> TypeRef {
fn type_of_inner(cx: &@crate_ctxt, sp: &span, t: ty::t) -> TypeRef {
// Check the cache.
if cx.lltypes.contains_key(t) { ret cx.lltypes.get(t); }
@ -248,7 +248,7 @@ fn type_of_inner(cx: &@crate_ctxt, sp: &span, t: &ty::t) -> TypeRef {
ret llty;
}
fn type_of_tag(cx: &@crate_ctxt, sp: &span, did: &ast::def_id, t: &ty::t) ->
fn type_of_tag(cx: &@crate_ctxt, sp: &span, did: &ast::def_id, t: ty::t) ->
TypeRef {
let degen = std::vec::len(ty::tag_variants(cx.tcx, did)) == 1u;
if ty::type_has_dynamic_size(cx.tcx, t) {
@ -437,14 +437,14 @@ fn llalign_of(t: TypeRef) -> ValueRef {
False);
}
fn size_of(cx: &@block_ctxt, t: &ty::t) -> result {
fn size_of(cx: &@block_ctxt, t: ty::t) -> result {
if !ty::type_has_dynamic_size(bcx_tcx(cx), t) {
ret rslt(cx, llsize_of(type_of(bcx_ccx(cx), cx.sp, t)));
}
ret dynamic_size_of(cx, t);
}
fn align_of(cx: &@block_ctxt, t: &ty::t) -> result {
fn align_of(cx: &@block_ctxt, t: ty::t) -> result {
if !ty::type_has_dynamic_size(bcx_tcx(cx), t) {
ret rslt(cx, llalign_of(type_of(bcx_ccx(cx), cx.sp, t)));
}
@ -485,7 +485,7 @@ fn mk_obstack_token(ccx: &@crate_ctxt, lldynamicallocas: BasicBlockRef,
// to have (a) the same size as the type that was passed in; (b) to be non-
// recursive. This is done by replacing all boxes in a type with boxed unit
// types.
fn simplify_type(ccx: &@crate_ctxt, typ: &ty::t) -> ty::t {
fn simplify_type(ccx: &@crate_ctxt, typ: ty::t) -> ty::t {
fn simplifier(ccx: @crate_ctxt, typ: ty::t) -> ty::t {
alt ty::struct(ccx.tcx, typ) {
ty::ty_box(_) { ret ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx)); }
@ -513,7 +513,7 @@ fn simplify_type(ccx: &@crate_ctxt, typ: &ty::t) -> ty::t {
// Computes the size of the data part of a non-dynamically-sized tag.
fn static_size_of_tag(cx: &@crate_ctxt, sp: &span, t: &ty::t) -> uint {
fn static_size_of_tag(cx: &@crate_ctxt, sp: &span, t: ty::t) -> uint {
if ty::type_has_dynamic_size(cx.tcx, t) {
cx.tcx.sess.span_fatal(sp,
"dynamically sized type passed to \
@ -628,7 +628,7 @@ fn dynamic_size_of(cx: &@block_ctxt, t: ty::t) -> result {
}
}
fn dynamic_align_of(cx: &@block_ctxt, t: &ty::t) -> result {
fn dynamic_align_of(cx: &@block_ctxt, t: ty::t) -> result {
alt ty::struct(bcx_tcx(cx), t) {
ty::ty_param(p, _) {
let aptr = field_of_tydesc(cx, t, false, abi::tydesc_field_align);
@ -677,7 +677,7 @@ fn GEPi(cx: &@block_ctxt, base: ValueRef, ixs: &[int]) -> ValueRef {
// Increment a pointer by a given amount and then cast it to be a pointer
// to a given type.
fn bump_ptr(bcx: &@block_ctxt, t: &ty::t, base: ValueRef, sz: ValueRef) ->
fn bump_ptr(bcx: &@block_ctxt, t: ty::t, base: ValueRef, sz: ValueRef) ->
ValueRef {
let raw = bcx.build.PointerCast(base, T_ptr(T_i8()));
let bumped = bcx.build.GEP(raw, [sz]);
@ -691,7 +691,7 @@ fn bump_ptr(bcx: &@block_ctxt, t: &ty::t, base: ValueRef, sz: ValueRef) ->
// ty::struct and knows what to do when it runs into a ty_param stuck in the
// middle of the thing it's GEP'ing into. Much like size_of and align_of,
// above.
fn GEP_tup_like(cx: &@block_ctxt, t: &ty::t, base: ValueRef, ixs: &[int]) ->
fn GEP_tup_like(cx: &@block_ctxt, t: ty::t, base: ValueRef, ixs: &[int]) ->
result {
assert (ty::type_is_tup_like(bcx_tcx(cx), t));
// It might be a static-known type. Handle this.
@ -714,7 +714,7 @@ fn GEP_tup_like(cx: &@block_ctxt, t: &ty::t, base: ValueRef, ixs: &[int]) ->
// elements of the type and splitting the Xth off. Return the prefix as
// well as the innermost Xth type.
fn split_type(ccx: &@crate_ctxt, t: &ty::t, ixs: &[int], n: uint) ->
fn split_type(ccx: &@crate_ctxt, t: ty::t, ixs: &[int], n: uint) ->
{prefix: [ty::t], target: ty::t} {
let len: uint = std::vec::len::<int>(ixs);
// We don't support 0-index or 1-index GEPs: The former is nonsense
@ -879,7 +879,7 @@ fn trans_malloc_boxed(cx: &@block_ctxt, t: ty::t) ->
// Given a type and a field index into its corresponding type descriptor,
// returns an LLVM ValueRef of that field from the tydesc, generating the
// tydesc if necessary.
fn field_of_tydesc(cx: &@block_ctxt, t: &ty::t, escapes: bool, field: int) ->
fn field_of_tydesc(cx: &@block_ctxt, t: ty::t, escapes: bool, field: int) ->
result {
let ti = none::<@tydesc_info>;
let tydesc = get_tydesc(cx, t, escapes, ti).result;
@ -892,7 +892,7 @@ fn field_of_tydesc(cx: &@block_ctxt, t: &ty::t, escapes: bool, field: int) ->
// each of the ty params it uses (from the current frame) and a vector of the
// indices of the ty params present in the type. This is used solely for
// constructing derived tydescs.
fn linearize_ty_params(cx: &@block_ctxt, t: &ty::t) ->
fn linearize_ty_params(cx: &@block_ctxt, t: ty::t) ->
{params: [uint], descs: [ValueRef]} {
let param_vals: [ValueRef] = [];
let param_defs: [uint] = [];
@ -938,7 +938,7 @@ fn trans_stack_local_derived_tydesc(cx: &@block_ctxt, llsz: ValueRef,
ret llmyroottydesc;
}
fn get_derived_tydesc(cx: &@block_ctxt, t: &ty::t, escapes: bool,
fn get_derived_tydesc(cx: &@block_ctxt, t: ty::t, escapes: bool,
static_ti: &mutable option::t<@tydesc_info>) -> result {
alt cx.fcx.derived_tydescs.find(t) {
some(info) {
@ -1008,7 +1008,7 @@ fn get_derived_tydesc(cx: &@block_ctxt, t: &ty::t, escapes: bool,
type get_tydesc_result = {kind: tydesc_kind, result: result};
fn get_tydesc(cx: &@block_ctxt, orig_t: &ty::t, escapes: bool,
fn get_tydesc(cx: &@block_ctxt, orig_t: ty::t, escapes: bool,
static_ti: &mutable option::t<@tydesc_info>) ->
get_tydesc_result {
@ -1043,7 +1043,7 @@ fn get_tydesc(cx: &@block_ctxt, orig_t: &ty::t, escapes: bool,
ret {kind: tk_static, result: rslt(cx, info.tydesc)};
}
fn get_static_tydesc(cx: &@block_ctxt, orig_t: &ty::t, ty_params: &[uint]) ->
fn get_static_tydesc(cx: &@block_ctxt, orig_t: ty::t, ty_params: &[uint]) ->
@tydesc_info {
let t = ty::strip_cname(bcx_tcx(cx), orig_t);
@ -1079,7 +1079,7 @@ fn set_always_inline(f: ValueRef) {
lib::llvm::llvm::Attribute);
}
fn set_glue_inlining(cx: &@local_ctxt, f: ValueRef, t: &ty::t) {
fn set_glue_inlining(cx: &@local_ctxt, f: ValueRef, t: ty::t) {
if ty::type_is_structural(cx.ccx.tcx, t) {
set_no_inline(f);
} else { set_always_inline(f); }
@ -1087,7 +1087,7 @@ fn set_glue_inlining(cx: &@local_ctxt, f: ValueRef, t: &ty::t) {
// Generates the declaration for (but doesn't emit) a type descriptor.
fn declare_tydesc(cx: &@local_ctxt, sp: &span, t: &ty::t, ty_params: &[uint])
fn declare_tydesc(cx: &@local_ctxt, sp: &span, t: ty::t, ty_params: &[uint])
-> @tydesc_info {
log "+++ declare_tydesc " + ty_to_str(cx.ccx.tcx, t);
let ccx = cx.ccx;
@ -1127,11 +1127,11 @@ fn declare_tydesc(cx: &@local_ctxt, sp: &span, t: &ty::t, ty_params: &[uint])
}
tag glue_helper {
default_helper(fn(&@block_ctxt, ValueRef, &ty::t));
copy_helper(fn(&@block_ctxt, ValueRef, ValueRef, &ty::t));
default_helper(fn(&@block_ctxt, ValueRef, ty::t));
copy_helper(fn(&@block_ctxt, ValueRef, ValueRef, ty::t));
}
fn declare_generic_glue(cx: &@local_ctxt, t: &ty::t, llfnty: TypeRef,
fn declare_generic_glue(cx: &@local_ctxt, t: ty::t, llfnty: TypeRef,
name: &str) -> ValueRef {
let fn_nm;
if cx.ccx.sess.get_opts().debuginfo {
@ -1143,7 +1143,7 @@ fn declare_generic_glue(cx: &@local_ctxt, t: &ty::t, llfnty: TypeRef,
ret llfn;
}
fn make_generic_glue_inner(cx: &@local_ctxt, sp: &span, t: &ty::t,
fn make_generic_glue_inner(cx: &@local_ctxt, sp: &span, t: ty::t,
llfn: ValueRef,
helper: &glue_helper,
ty_params: &[uint]) -> ValueRef {
@ -1195,7 +1195,7 @@ fn make_generic_glue_inner(cx: &@local_ctxt, sp: &span, t: &ty::t,
ret llfn;
}
fn make_generic_glue(cx: &@local_ctxt, sp: &span, t: &ty::t, llfn: ValueRef,
fn make_generic_glue(cx: &@local_ctxt, sp: &span, t: ty::t, llfn: ValueRef,
helper: &glue_helper, ty_params: &[uint],
name: &str) -> ValueRef {
if !cx.ccx.sess.get_opts().stats {
@ -1272,12 +1272,12 @@ fn emit_tydescs(ccx: &@crate_ctxt) {
}
}
fn make_copy_glue(cx: &@block_ctxt, dst: ValueRef, src: ValueRef, t: &ty::t) {
fn make_copy_glue(cx: &@block_ctxt, dst: ValueRef, src: ValueRef, t: ty::t) {
let bcx = memmove_ty(cx, dst, src, t).bcx;
build_return(bcx);
}
fn make_take_glue(cx: &@block_ctxt, v: ValueRef, t: &ty::t) {
fn make_take_glue(cx: &@block_ctxt, v: ValueRef, t: ty::t) {
// NB: v is an *alias* of type t here, not a direct value.
let bcx;
@ -1308,7 +1308,7 @@ fn incr_refcnt_of_boxed(cx: &@block_ctxt, box_ptr: ValueRef) -> result {
ret rslt(next_cx, C_nil());
}
fn make_free_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) {
fn make_free_glue(cx: &@block_ctxt, v0: ValueRef, t: ty::t) {
// NB: v is an *alias* of type t here, not a direct value.
let rs =
alt ty::struct(bcx_tcx(cx), t) {
@ -1407,7 +1407,7 @@ fn maybe_free_ivec_heap_part(cx: &@block_ctxt, v0: ValueRef, unit_ty: ty::t)
ret rslt(next_cx, C_nil());
}
fn make_drop_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) {
fn make_drop_glue(cx: &@block_ctxt, v0: ValueRef, t: ty::t) {
// NB: v0 is an *alias* of type t here, not a direct value.
let ccx = bcx_ccx(cx);
let rs =
@ -1495,7 +1495,7 @@ fn trans_res_drop(cx: @block_ctxt, rs: ValueRef, did: &ast::def_id,
}
fn decr_refcnt_maybe_free(cx: &@block_ctxt, box_ptr_alias: ValueRef,
full_alias: ValueRef, t: &ty::t) -> result {
full_alias: ValueRef, t: ty::t) -> result {
let ccx = bcx_ccx(cx);
let load_rc_cx = new_sub_block_ctxt(cx, "load rc");
let rc_adj_cx = new_sub_block_ctxt(cx, "rc--");
@ -1544,7 +1544,7 @@ tag scalar_type { nil_type; signed_int; unsigned_int; floating_point; }
fn compare_scalar_types(cx: @block_ctxt, lhs: ValueRef, rhs: ValueRef,
t: &ty::t, llop: ValueRef) -> result {
t: ty::t, llop: ValueRef) -> result {
let f = bind compare_scalar_values(cx, lhs, rhs, _, llop);
alt ty::struct(bcx_tcx(cx), t) {
@ -1662,7 +1662,7 @@ type val_and_ty_fn = fn(&@block_ctxt, ValueRef, ty::t) -> result;
// Iterates through the elements of a structural type.
fn iter_structural_ty(cx: &@block_ctxt, v: ValueRef, t: &ty::t,
fn iter_structural_ty(cx: &@block_ctxt, v: ValueRef, t: ty::t,
f: val_and_ty_fn) -> result {
fn adaptor_fn(f: val_and_ty_fn, cx: &@block_ctxt, av: ValueRef, t: ty::t)
-> result {
@ -1687,7 +1687,7 @@ fn incr_ptr(cx: &@block_ctxt, p: ValueRef, incr: ValueRef, pp: ValueRef) {
cx.build.Store(cx.build.InBoundsGEP(p, [incr]), pp);
}
fn iter_structural_ty_full(cx: &@block_ctxt, av: ValueRef, t: &ty::t,
fn iter_structural_ty_full(cx: &@block_ctxt, av: ValueRef, t: ty::t,
f: &val_and_ty_fn) -> result {
fn iter_boxpp(cx: @block_ctxt, box_cell: ValueRef, f: &val_and_ty_fn) ->
result {
@ -1936,9 +1936,9 @@ fn iter_sequence_inner(cx: &@block_ctxt, src: ValueRef,
// Iterates through the elements of a vec or str.
fn iter_sequence(cx: @block_ctxt, v: ValueRef, t: &ty::t, f: &val_and_ty_fn)
fn iter_sequence(cx: @block_ctxt, v: ValueRef, t: ty::t, f: &val_and_ty_fn)
-> result {
fn iter_sequence_body(cx: @block_ctxt, v: ValueRef, elt_ty: &ty::t,
fn iter_sequence_body(cx: @block_ctxt, v: ValueRef, elt_ty: ty::t,
f: &val_and_ty_fn, trailing_null: bool,
interior: bool) -> result {
let p0;
@ -2131,7 +2131,7 @@ fn call_tydesc_glue_full(cx: &@block_ctxt, v: ValueRef, tydesc: ValueRef,
C_null(T_ptr(T_nil())), lltydescs, llrawptr]);
}
fn call_tydesc_glue(cx: &@block_ctxt, v: ValueRef, t: &ty::t, field: int) ->
fn call_tydesc_glue(cx: &@block_ctxt, v: ValueRef, t: ty::t, field: int) ->
result {
let ti: option::t<@tydesc_info> = none::<@tydesc_info>;
let td = get_tydesc(cx, t, false, ti).result;
@ -2140,7 +2140,7 @@ fn call_tydesc_glue(cx: &@block_ctxt, v: ValueRef, t: &ty::t, field: int) ->
ret rslt(td.bcx, C_nil());
}
fn call_cmp_glue(cx: &@block_ctxt, lhs: ValueRef, rhs: ValueRef, t: &ty::t,
fn call_cmp_glue(cx: &@block_ctxt, lhs: ValueRef, rhs: ValueRef, t: ty::t,
llop: ValueRef) -> result {
// We can't use call_tydesc_glue_full() and friends here because compare
// glue has a special signature.
@ -2177,7 +2177,7 @@ fn call_cmp_glue(cx: &@block_ctxt, lhs: ValueRef, rhs: ValueRef, t: &ty::t,
ret rslt(r.bcx, r.bcx.build.Load(llcmpresultptr));
}
fn call_copy_glue(cx: &@block_ctxt, dst: ValueRef, src: ValueRef, t: &ty::t,
fn call_copy_glue(cx: &@block_ctxt, dst: ValueRef, src: ValueRef, t: ty::t,
take: bool) -> @block_ctxt {
// You can't call this on immediate types. Those are simply copied with
// Load/Store.
@ -2218,7 +2218,7 @@ fn call_copy_glue(cx: &@block_ctxt, dst: ValueRef, src: ValueRef, t: &ty::t,
// Compares two values. Performs the simple scalar comparison if the types are
// scalar and calls to comparison glue otherwise.
fn compare(cx: &@block_ctxt, lhs: ValueRef, rhs: ValueRef, t: &ty::t,
fn compare(cx: &@block_ctxt, lhs: ValueRef, rhs: ValueRef, t: ty::t,
llop: ValueRef) -> result {
if ty::type_is_scalar(bcx_tcx(cx), t) {
ret compare_scalar_types(cx, lhs, rhs, t, llop);
@ -2234,7 +2234,7 @@ fn take_ty(cx: &@block_ctxt, v: ValueRef, t: ty::t) -> result {
ret rslt(cx, C_nil());
}
fn drop_slot(cx: &@block_ctxt, slot: ValueRef, t: &ty::t) -> result {
fn drop_slot(cx: &@block_ctxt, slot: ValueRef, t: ty::t) -> result {
let llptr = load_if_immediate(cx, slot, t);
ret drop_ty(cx, llptr, t);
}
@ -2292,7 +2292,7 @@ fn call_bzero(cx: &@block_ctxt, dst: ValueRef, n_bytes: ValueRef,
[dst_ptr, C_u8(0u), size, align, volatile]));
}
fn memmove_ty(cx: &@block_ctxt, dst: ValueRef, src: ValueRef, t: &ty::t) ->
fn memmove_ty(cx: &@block_ctxt, dst: ValueRef, src: ValueRef, t: ty::t) ->
result {
if ty::type_has_dynamic_size(bcx_tcx(cx), t) {
let llsz = size_of(cx, t);
@ -2328,7 +2328,7 @@ fn type_is_structural_or_param(tcx: &ty::ctxt, t: ty::t) -> bool {
}
fn copy_val(cx: &@block_ctxt, action: copy_action, dst: ValueRef,
src: ValueRef, t: &ty::t) -> @block_ctxt {
src: ValueRef, t: ty::t) -> @block_ctxt {
if type_is_structural_or_param(bcx_ccx(cx).tcx, t) &&
action == DROP_EXISTING {
let do_copy_cx = new_sub_block_ctxt(cx, "do_copy");
@ -2345,7 +2345,7 @@ fn copy_val(cx: &@block_ctxt, action: copy_action, dst: ValueRef,
}
fn copy_val_no_check(cx: &@block_ctxt, action: copy_action, dst: ValueRef,
src: ValueRef, t: &ty::t) -> @block_ctxt {
src: ValueRef, t: ty::t) -> @block_ctxt {
let ccx = bcx_ccx(cx);
// FIXME this is just a clunky stopgap. we should do proper checking in an
// earlier pass.
@ -2384,7 +2384,7 @@ fn copy_val_no_check(cx: &@block_ctxt, action: copy_action, dst: ValueRef,
// case where a variable is always deinitialized by block exit and thus
// doesn't need to be dropped.
fn move_val(cx: @block_ctxt, action: copy_action, dst: ValueRef,
src: &lval_result, t: &ty::t) -> @block_ctxt {
src: &lval_result, t: ty::t) -> @block_ctxt {
let src_val = src.res.val;
if ty::type_is_scalar(bcx_tcx(cx), t) ||
ty::type_is_native(bcx_tcx(cx), t) {
@ -2422,7 +2422,7 @@ fn move_val(cx: @block_ctxt, action: copy_action, dst: ValueRef,
}
fn move_val_if_temp(cx: @block_ctxt, action: copy_action, dst: ValueRef,
src: &lval_result, t: &ty::t) -> @block_ctxt {
src: &lval_result, t: ty::t) -> @block_ctxt {
// Lvals in memory are not temporaries. Copy them.
if src.is_mem {
@ -2606,7 +2606,7 @@ fn trans_compare(cx: &@block_ctxt, op: ast::binop, lhs: ValueRef,
}
}
fn trans_evec_append(cx: &@block_ctxt, t: &ty::t, lhs: ValueRef,
fn trans_evec_append(cx: &@block_ctxt, t: ty::t, lhs: ValueRef,
rhs: ValueRef) -> result {
let elt_ty = ty::sequence_element_type(bcx_tcx(cx), t);
let skip_null = C_bool(false);
@ -2847,7 +2847,7 @@ mod ivec {
stack_no_spill_cx.llbb, stack_spill_cx.llbb]);
ret rslt(next_cx, data_ptr);
}
fn trans_append(cx: &@block_ctxt, t: &ty::t, orig_lhs: ValueRef,
fn trans_append(cx: &@block_ctxt, t: ty::t, orig_lhs: ValueRef,
orig_rhs: ValueRef) -> result {
// Cast to opaque interior vector types if necessary.
let lhs;
@ -3231,7 +3231,7 @@ mod ivec {
}
}
fn trans_evec_add(cx: &@block_ctxt, t: &ty::t, lhs: ValueRef, rhs: ValueRef)
fn trans_evec_add(cx: &@block_ctxt, t: ty::t, lhs: ValueRef, rhs: ValueRef)
-> result {
let r = alloc_ty(cx, t);
let tmp = r.val;
@ -3306,7 +3306,7 @@ fn trans_eager_binop(cx: &@block_ctxt, op: ast::binop, lhs: ValueRef,
}
}
fn autoderef(cx: &@block_ctxt, v: ValueRef, t: &ty::t) -> result_t {
fn autoderef(cx: &@block_ctxt, v: ValueRef, t: ty::t) -> result_t {
let v1: ValueRef = v;
let t1: ty::t = t;
let ccx = bcx_ccx(cx);
@ -3644,7 +3644,7 @@ fn build_closure(cx: &@block_ctxt, upvars: &@[ast::node_id], copying: bool) ->
// be dynamically sized, we can't skip past them to get to the tydescs until
// we have loaded the tydescs. Thus we use the stored size of the bindings
// in the tydesc for the closure to skip over them. Ugh.
fn find_environment_tydescs(bcx: &@block_ctxt, envty: &ty::t,
fn find_environment_tydescs(bcx: &@block_ctxt, envty: ty::t,
closure: ValueRef) -> ValueRef {
ret if !ty::type_has_dynamic_size(bcx_tcx(bcx), envty) {
@ -3675,7 +3675,7 @@ fn find_environment_tydescs(bcx: &@block_ctxt, envty: &ty::t,
// Given an enclosing block context, a new function context, a closure type,
// and a list of upvars, generate code to load and populate the environment
// with the upvars and type descriptors.
fn load_environment(enclosing_cx: &@block_ctxt, fcx: &@fn_ctxt, envty: &ty::t,
fn load_environment(enclosing_cx: &@block_ctxt, fcx: &@fn_ctxt, envty: ty::t,
upvars: &@[ast::node_id], copying: bool) {
let bcx = new_raw_block_ctxt(fcx, fcx.llcopyargs);
@ -4003,7 +4003,7 @@ fn trans_path(cx: &@block_ctxt, p: &ast::path, id: ast::node_id) ->
ret trans_var(cx, p.span, id);
}
fn trans_field(cx: &@block_ctxt, sp: &span, v: ValueRef, t0: &ty::t,
fn trans_field(cx: &@block_ctxt, sp: &span, v: ValueRef, t0: ty::t,
field: &ast::ident) -> lval_result {
let r = autoderef(cx, v, t0);
let t = r.ty;
@ -4270,9 +4270,9 @@ fn trans_cast(cx: &@block_ctxt, e: &@ast::expr, id: ast::node_id) -> result {
ret rslt(e_res.bcx, newval);
}
fn trans_bind_thunk(cx: &@local_ctxt, sp: &span, incoming_fty: &ty::t,
outgoing_fty: &ty::t, args: &[option::t<@ast::expr>],
env_ty: &ty::t, ty_param_count: uint,
fn trans_bind_thunk(cx: &@local_ctxt, sp: &span, incoming_fty: ty::t,
outgoing_fty: ty::t, args: &[option::t<@ast::expr>],
env_ty: ty::t, ty_param_count: uint,
target_fn: &option::t<ValueRef>) ->
{val: ValueRef, ty: TypeRef} {
@ -4594,7 +4594,7 @@ fn trans_arg_expr(cx: &@block_ctxt, arg: &ty::arg, lldestty0: TypeRef,
// - trans_args
fn trans_args(cx: &@block_ctxt, llenv: ValueRef,
gen: &option::t<generic_info>, lliterbody: &option::t<ValueRef>,
es: &[@ast::expr], fn_ty: &ty::t) ->
es: &[@ast::expr], fn_ty: ty::t) ->
{bcx: @block_ctxt,
args: [ValueRef],
retslot: ValueRef,
@ -5176,7 +5176,7 @@ fn with_out_method(work: fn(&out_method) -> result, cx: @block_ctxt,
// latter group "immediates" and, in some circumstances when we know we have a
// pointer (or need one), perform load/store operations based on the
// immediate-ness of the type.
fn type_is_immediate(ccx: &@crate_ctxt, t: &ty::t) -> bool {
fn type_is_immediate(ccx: &@crate_ctxt, t: ty::t) -> bool {
ret ty::type_is_scalar(ccx.tcx, t) || ty::type_is_boxed(ccx.tcx, t) ||
ty::type_is_native(ccx.tcx, t);
}
@ -5188,12 +5188,12 @@ fn do_spill(cx: &@block_ctxt, v: ValueRef) -> ValueRef {
ret llptr;
}
fn spill_if_immediate(cx: &@block_ctxt, v: ValueRef, t: &ty::t) -> ValueRef {
fn spill_if_immediate(cx: &@block_ctxt, v: ValueRef, t: ty::t) -> ValueRef {
if type_is_immediate(bcx_ccx(cx), t) { ret do_spill(cx, v); }
ret v;
}
fn load_if_immediate(cx: &@block_ctxt, v: ValueRef, t: &ty::t) -> ValueRef {
fn load_if_immediate(cx: &@block_ctxt, v: ValueRef, t: ty::t) -> ValueRef {
if type_is_immediate(bcx_ccx(cx), t) { ret cx.build.Load(v); }
ret v;
}
@ -5665,7 +5665,7 @@ fn llderivedtydescs_block_ctxt(fcx: &@fn_ctxt) -> @block_ctxt {
}
fn alloc_ty(cx: &@block_ctxt, t: &ty::t) -> result {
fn alloc_ty(cx: &@block_ctxt, t: ty::t) -> result {
let bcx = cx;
let val = C_int(0);
if ty::type_has_dynamic_size(bcx_tcx(bcx), t) {

128
src/comp/middle/ty.rs
View File

@ -428,7 +428,7 @@ fn mk_raw_ty(cx: &ctxt, st: &sty, _in_cname: &option::t<str>) -> @raw_t {
let has_params: bool = false;
let has_vars: bool = false;
fn derive_flags_t(cx: &ctxt, has_params: &mutable bool,
has_vars: &mutable bool, tt: &t) {
has_vars: &mutable bool, tt: t) {
let rt = interner::get::<@raw_t>(*cx.ts, tt);
has_params = has_params || rt.has_params;
has_vars = has_vars || rt.has_vars;
@ -442,7 +442,7 @@ fn mk_raw_ty(cx: &ctxt, st: &sty, _in_cname: &option::t<str>) -> @raw_t {
derive_flags_t(cx, has_params, has_vars, a.ty);
}
fn derive_flags_sig(cx: &ctxt, has_params: &mutable bool,
has_vars: &mutable bool, args: &[arg], tt: &t) {
has_vars: &mutable bool, args: &[arg], tt: t) {
for a: arg in args { derive_flags_arg(cx, has_params, has_vars, a); }
derive_flags_t(cx, has_params, has_vars, tt);
}
@ -553,15 +553,15 @@ fn mk_tag(cx: &ctxt, did: &ast::def_id, tys: &[t]) -> t {
fn mk_box(cx: &ctxt, tm: &mt) -> t { ret gen_ty(cx, ty_box(tm)); }
fn mk_uniq(cx: &ctxt, typ: &t) -> t { ret gen_ty(cx, ty_uniq(typ)); }
fn mk_uniq(cx: &ctxt, typ: t) -> t { ret gen_ty(cx, ty_uniq(typ)); }
fn mk_ptr(cx: &ctxt, tm: &mt) -> t { ret gen_ty(cx, ty_ptr(tm)); }
fn mk_imm_box(cx: &ctxt, ty: &t) -> t {
fn mk_imm_box(cx: &ctxt, ty: t) -> t {
ret mk_box(cx, {ty: ty, mut: ast::imm});
}
fn mk_mut_ptr(cx: &ctxt, ty: &t) -> t {
fn mk_mut_ptr(cx: &ctxt, ty: t) -> t {
ret mk_ptr(cx, {ty: ty, mut: ast::mut});
}
@ -569,24 +569,24 @@ fn mk_vec(cx: &ctxt, tm: &mt) -> t { ret gen_ty(cx, ty_vec(tm)); }
fn mk_rec(cx: &ctxt, fs: &[field]) -> t { ret gen_ty(cx, ty_rec(fs)); }
fn mk_constr(cx: &ctxt, t: &t, cs: &[@type_constr]) -> t {
fn mk_constr(cx: &ctxt, t: t, cs: &[@type_constr]) -> t {
ret gen_ty(cx, ty_constr(t, cs));
}
fn mk_tup(cx: &ctxt, ts: &[t]) -> t { ret gen_ty(cx, ty_tup(ts)); }
fn mk_fn(cx: &ctxt, proto: &ast::proto, args: &[arg], ty: &t,
fn mk_fn(cx: &ctxt, proto: &ast::proto, args: &[arg], ty: t,
cf: &controlflow, constrs: &[@constr]) -> t {
ret gen_ty(cx, ty_fn(proto, args, ty, cf, constrs));
}
fn mk_native_fn(cx: &ctxt, abi: &ast::native_abi, args: &[arg], ty: &t) -> t {
fn mk_native_fn(cx: &ctxt, abi: &ast::native_abi, args: &[arg], ty: t) -> t {
ret gen_ty(cx, ty_native_fn(abi, args, ty));
}
fn mk_obj(cx: &ctxt, meths: &[method]) -> t { ret gen_ty(cx, ty_obj(meths)); }
fn mk_res(cx: &ctxt, did: &ast::def_id, inner: &t, tps: &[t]) -> t {
fn mk_res(cx: &ctxt, did: &ast::def_id, inner: t, tps: &[t]) -> t {
ret gen_ty(cx, ty_res(did, inner, tps));
}
@ -600,19 +600,19 @@ fn mk_type(_cx: &ctxt) -> t { ret idx_type; }
fn mk_native(cx: &ctxt, did: &def_id) -> t { ret gen_ty(cx, ty_native(did)); }
fn mk_iter_body_fn(cx: &ctxt, output: &t) -> t {
fn mk_iter_body_fn(cx: &ctxt, output: t) -> t {
ret mk_fn(cx, ast::proto_block, [{mode: ty::mo_alias(false), ty: output}],
ty::mk_nil(cx), ast::return, []);
}
// Returns the one-level-deep type structure of the given type.
fn struct(cx: &ctxt, typ: &t) -> sty {
fn struct(cx: &ctxt, typ: t) -> sty {
ret interner::get(*cx.ts, typ).struct;
}
// Returns the canonical name of the given type.
fn cname(cx: &ctxt, typ: &t) -> option::t<str> {
fn cname(cx: &ctxt, typ: t) -> option::t<str> {
ret interner::get(*cx.ts, typ).cname;
}
@ -803,19 +803,19 @@ fn copy_cname(cx: &ctxt, struct_ty: t, cname_ty: t) -> t {
ret gen_ty_full(cx, struct(cx, struct_ty), cname(cx, cname_ty));
}
fn type_is_nil(cx: &ctxt, ty: &t) -> bool {
fn type_is_nil(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) { ty_nil. { ret true; } _ { ret false; } }
}
fn type_is_bot(cx: &ctxt, ty: &t) -> bool {
fn type_is_bot(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) { ty_bot. { ret true; } _ { ret false; } }
}
fn type_is_bool(cx: &ctxt, ty: &t) -> bool {
fn type_is_bool(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) { ty_bool. { ret true; } _ { ret false; } }
}
fn type_is_structural(cx: &ctxt, ty: &t) -> bool {
fn type_is_structural(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) {
ty_rec(_) { ret true; }
ty_tup(_) { ret true; }
@ -829,7 +829,7 @@ fn type_is_structural(cx: &ctxt, ty: &t) -> bool {
}
}
fn type_is_copyable(cx: &ctxt, ty: &t) -> bool {
fn type_is_copyable(cx: &ctxt, ty: t) -> bool {
ret alt struct(cx, ty) {
ty_res(_, _, _) { false }
ty_fn(proto_block., _, _, _, _) { false }
@ -837,7 +837,7 @@ fn type_is_copyable(cx: &ctxt, ty: &t) -> bool {
};
}
fn type_is_sequence(cx: &ctxt, ty: &t) -> bool {
fn type_is_sequence(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) {
ty_str. { ret true; }
ty_istr. { ret true; }
@ -846,7 +846,7 @@ fn type_is_sequence(cx: &ctxt, ty: &t) -> bool {
}
}
fn type_is_str(cx: &ctxt, ty: &t) -> bool {
fn type_is_str(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) {
ty_str. { ret true; }
ty_istr. { ret true; }
@ -854,7 +854,7 @@ fn type_is_str(cx: &ctxt, ty: &t) -> bool {
}
}
fn sequence_is_interior(cx: &ctxt, ty: &t) -> bool {
fn sequence_is_interior(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) {
@ -867,7 +867,7 @@ fn sequence_is_interior(cx: &ctxt, ty: &t) -> bool {
}
}
fn sequence_element_type(cx: &ctxt, ty: &t) -> t {
fn sequence_element_type(cx: &ctxt, ty: t) -> t {
alt struct(cx, ty) {
ty_str. { ret mk_mach(cx, ast::ty_u8); }
ty_istr. { ret mk_mach(cx, ast::ty_u8); }
@ -876,7 +876,7 @@ fn sequence_element_type(cx: &ctxt, ty: &t) -> t {
}
}
fn type_is_tup_like(cx: &ctxt, ty: &t) -> bool {
fn type_is_tup_like(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) {
ty_box(_) { ret true; }
ty_rec(_) { ret true; }
@ -886,7 +886,7 @@ fn type_is_tup_like(cx: &ctxt, ty: &t) -> bool {
}
}
fn get_element_type(cx: &ctxt, ty: &t, i: uint) -> t {
fn get_element_type(cx: &ctxt, ty: t, i: uint) -> t {
alt struct(cx, ty) {
ty_rec(flds) { ret flds[i].mt.ty; }
ty_tup(ts) { ret ts[i]; }
@ -900,11 +900,11 @@ fn get_element_type(cx: &ctxt, ty: &t, i: uint) -> t {
// tag.
}
fn type_is_box(cx: &ctxt, ty: &t) -> bool {
fn type_is_box(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) { ty_box(_) { ret true; } _ { ret false; } }
}
fn type_is_boxed(cx: &ctxt, ty: &t) -> bool {
fn type_is_boxed(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) {
ty_str. { ret true; }
ty_box(_) { ret true; }
@ -912,11 +912,11 @@ fn type_is_boxed(cx: &ctxt, ty: &t) -> bool {
}
}
fn type_is_unique(cx: &ctxt, ty: &t) -> bool {
fn type_is_unique(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) { ty_uniq(_) { ret true; } _ { ret false; } }
}
fn type_is_scalar(cx: &ctxt, ty: &t) -> bool {
fn type_is_scalar(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) {
ty_nil. { ret true; }
ty_bool. { ret true; }
@ -932,7 +932,7 @@ fn type_is_scalar(cx: &ctxt, ty: &t) -> bool {
}
}
fn type_has_pointers(cx: &ctxt, ty: &t) -> bool {
fn type_has_pointers(cx: &ctxt, ty: t) -> bool {
alt cx.has_pointer_cache.find(ty) {
some(result) { ret result; }
none. {/* fall through */ }
@ -986,14 +986,14 @@ fn type_has_pointers(cx: &ctxt, ty: &t) -> bool {
ret result;
}
fn type_needs_drop(cx: &ctxt, ty: &t) -> bool {
fn type_needs_drop(cx: &ctxt, ty: t) -> bool {
ret alt struct(cx, ty) {
ty_res(_, _, _) { true }
_ { type_has_pointers(cx, ty) }
};
}
fn type_kind(cx: &ctxt, ty: &t) -> ast::kind {
fn type_kind(cx: &ctxt, ty: t) -> ast::kind {
alt cx.kind_cache.find(ty) {
some(result) { ret result; }
none. {/* fall through */ }
@ -1127,11 +1127,11 @@ fn type_kind(cx: &ctxt, ty: &t) -> ast::kind {
// FIXME: should we just return true for native types in
// type_is_scalar?
fn type_is_native(cx: &ctxt, ty: &t) -> bool {
fn type_is_native(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) { ty_native(_) { ret true; } _ { ret false; } }
}
fn type_has_dynamic_size(cx: &ctxt, ty: &t) -> bool {
fn type_has_dynamic_size(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) {
ty_nil. { ret false; }
ty_bot. { ret false; }
@ -1181,7 +1181,7 @@ fn type_has_dynamic_size(cx: &ctxt, ty: &t) -> bool {
}
}
fn type_is_integral(cx: &ctxt, ty: &t) -> bool {
fn type_is_integral(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) {
ty_int. { ret true; }
ty_uint. { ret true; }
@ -1204,7 +1204,7 @@ fn type_is_integral(cx: &ctxt, ty: &t) -> bool {
}
}
fn type_is_fp(cx: &ctxt, ty: &t) -> bool {
fn type_is_fp(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) {
ty_machine(tm) {
alt tm {
@ -1218,7 +1218,7 @@ fn type_is_fp(cx: &ctxt, ty: &t) -> bool {
}
}
fn type_is_signed(cx: &ctxt, ty: &t) -> bool {
fn type_is_signed(cx: &ctxt, ty: t) -> bool {
alt struct(cx, ty) {
ty_int. { ret true; }
ty_machine(tm) {
@ -1234,7 +1234,7 @@ fn type_is_signed(cx: &ctxt, ty: &t) -> bool {
}
}
fn type_owns_heap_mem(cx: &ctxt, ty: &t) -> bool {
fn type_owns_heap_mem(cx: &ctxt, ty: t) -> bool {
alt cx.owns_heap_mem_cache.find(ty) {
some(result) { ret result; }
none. {/* fall through */ }
@ -1311,7 +1311,7 @@ fn type_owns_heap_mem(cx: &ctxt, ty: &t) -> bool {
}
// Whether a type is Plain Old Data (i.e. can be safely memmoved).
fn type_is_pod(cx: &ctxt, ty: &t) -> bool {
fn type_is_pod(cx: &ctxt, ty: t) -> bool {
let result = true;
alt struct(cx, ty) {
@ -1363,7 +1363,7 @@ fn type_is_pod(cx: &ctxt, ty: &t) -> bool {
ret result;
}
fn type_param(cx: &ctxt, ty: &t) -> option::t<uint> {
fn type_param(cx: &ctxt, ty: t) -> option::t<uint> {
alt struct(cx, ty) {
ty_param(id, _) { ret some(id); }
_ {/* fall through */ }
@ -1373,7 +1373,7 @@ fn type_param(cx: &ctxt, ty: &t) -> option::t<uint> {
// Returns a vec of all the type variables
// occurring in t. It may contain duplicates.
fn vars_in_type(cx: &ctxt, ty: &t) -> [int] {
fn vars_in_type(cx: &ctxt, ty: t) -> [int] {
fn collect_var(cx: &ctxt, vars: &@mutable [int], ty: t) {
alt struct(cx, ty) { ty_var(v) { *vars += [v]; } _ { } }
}
@ -1384,7 +1384,7 @@ fn vars_in_type(cx: &ctxt, ty: &t) -> [int] {
ret *rslt;
}
fn type_autoderef(cx: &ctxt, t: &ty::t) -> ty::t {
fn type_autoderef(cx: &ctxt, t: ty::t) -> ty::t {
let t1: ty::t = t;
while true {
alt struct(cx, t1) {
@ -1419,7 +1419,7 @@ fn hash_type_structure(st: &sty) -> uint {
h += h << 5u + (did.node as uint);
ret h;
}
fn hash_subty(id: uint, subty: &t) -> uint {
fn hash_subty(id: uint, subty: t) -> uint {
let h = id;
h += h << 5u + hash_ty(subty);
ret h;
@ -1448,7 +1448,7 @@ fn hash_type_structure(st: &sty) -> uint {
}
fn hash_fn(id: uint, args: &[arg], rty: &t) -> uint {
fn hash_fn(id: uint, args: &[arg], rty: t) -> uint {
let h = id;
for a: arg in args { h += h << 5u + hash_ty(a.ty); }
h += h << 5u + hash_ty(rty);
@ -1681,17 +1681,17 @@ fn count_ty_params(cx: &ctxt, ty: t) -> uint {
ret vec::len::<uint>(*param_indices);
}
fn type_contains_vars(cx: &ctxt, typ: &t) -> bool {
fn type_contains_vars(cx: &ctxt, typ: t) -> bool {
ret interner::get(*cx.ts, typ).has_vars;
}
fn type_contains_params(cx: &ctxt, typ: &t) -> bool {
fn type_contains_params(cx: &ctxt, typ: t) -> bool {
ret interner::get(*cx.ts, typ).has_params;
}
// Type accessors for substructures of types
fn ty_fn_args(cx: &ctxt, fty: &t) -> [arg] {
fn ty_fn_args(cx: &ctxt, fty: t) -> [arg] {
alt struct(cx, fty) {
ty::ty_fn(_, a, _, _, _) { ret a; }
ty::ty_native_fn(_, a, _) { ret a; }
@ -1699,21 +1699,21 @@ fn ty_fn_args(cx: &ctxt, fty: &t) -> [arg] {
}
}
fn ty_fn_proto(cx: &ctxt, fty: &t) -> ast::proto {
fn ty_fn_proto(cx: &ctxt, fty: t) -> ast::proto {
alt struct(cx, fty) {
ty::ty_fn(p, _, _, _, _) { ret p; }
_ { cx.sess.bug("ty_fn_proto() called on non-fn type"); }
}
}
fn ty_fn_abi(cx: &ctxt, fty: &t) -> ast::native_abi {
fn ty_fn_abi(cx: &ctxt, fty: t) -> ast::native_abi {
alt struct(cx, fty) {
ty::ty_native_fn(a, _, _) { ret a; }
_ { cx.sess.bug("ty_fn_abi() called on non-native-fn type"); }
}
}
fn ty_fn_ret(cx: &ctxt, fty: &t) -> t {
fn ty_fn_ret(cx: &ctxt, fty: t) -> t {
alt struct(cx, fty) {
ty::ty_fn(_, _, r, _, _) { ret r; }
ty::ty_native_fn(_, _, r) { ret r; }
@ -1721,7 +1721,7 @@ fn ty_fn_ret(cx: &ctxt, fty: &t) -> t {
}
}
fn is_fn_ty(cx: &ctxt, fty: &t) -> bool {
fn is_fn_ty(cx: &ctxt, fty: t) -> bool {
alt struct(cx, fty) {
ty::ty_fn(_, _, _, _, _) { ret true; }
ty::ty_native_fn(_, _, _) { ret true; }
@ -1754,7 +1754,7 @@ fn pat_ty(cx: &ctxt, pat: &@ast::pat) -> t {
//
// NB: This type doesn't provide type parameter substitutions; e.g. if you
// 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.
fn expr_ty(cx: &ctxt, expr: &@ast::expr) -> t {
ret node_id_to_monotype(cx, expr.id);
@ -1812,7 +1812,7 @@ fn is_lval(expr: &@ast::expr) -> bool {
}
}
fn occurs_check_fails(tcx: &ctxt, sp: &option::t<span>, vid: int, rt: &t) ->
fn occurs_check_fails(tcx: &ctxt, sp: &option::t<span>, vid: int, rt: t) ->
bool {
if !type_contains_vars(tcx, rt) {
// Fast path
@ -1947,7 +1947,7 @@ mod unify {
// Right now this just checks that the lists of constraints are
// pairwise equal.
fn unify_constrs(base_t: &t, expected: [@type_constr],
fn unify_constrs(base_t: t, expected: [@type_constr],
actual: &[@type_constr]) -> result {
let expected_len = vec::len(expected);
let actual_len = vec::len(actual);
@ -1964,7 +1964,7 @@ mod unify {
}
ret ures_ok(base_t);
}
fn unify_constr(base_t: &t, expected: @type_constr,
fn unify_constr(base_t: t, expected: @type_constr,
actual_constr: &@type_constr) -> result {
let ok_res = ures_ok(base_t);
let err_res = ures_err(terr_constr_mismatch(expected, actual_constr));
@ -2010,9 +2010,9 @@ mod unify {
fn_common_res_err(result);
fn_common_res_ok([arg], t);
}
fn unify_fn_common(cx: &@ctxt, _expected: &t, _actual: &t,
expected_inputs: &[arg], expected_output: &t,
actual_inputs: &[arg], actual_output: &t) ->
fn unify_fn_common(cx: &@ctxt, _expected: t, _actual: t,
expected_inputs: &[arg], expected_output: t,
actual_inputs: &[arg], actual_output: t) ->
fn_common_res {
let expected_len = vec::len::<arg>(expected_inputs);
let actual_len = vec::len::<arg>(actual_inputs);
@ -2050,8 +2050,8 @@ mod unify {
}
}
fn unify_fn(cx: &@ctxt, e_proto: &ast::proto, a_proto: &ast::proto,
expected: &t, actual: &t, expected_inputs: &[arg],
expected_output: &t, actual_inputs: &[arg], actual_output: &t,
expected: t, actual: t, expected_inputs: &[arg],
expected_output: t, actual_inputs: &[arg], actual_output: t,
expected_cf: &controlflow, actual_cf: &controlflow,
_expected_constrs: &[@constr], actual_constrs: &[@constr]) ->
result {
@ -2092,9 +2092,9 @@ mod unify {
}
}
fn unify_native_fn(cx: &@ctxt, e_abi: &ast::native_abi,
a_abi: &ast::native_abi, expected: &t, actual: &t,
expected_inputs: &[arg], expected_output: &t,
actual_inputs: &[arg], actual_output: &t) -> result {
a_abi: &ast::native_abi, expected: t, actual: t,
expected_inputs: &[arg], expected_output: t,
actual_inputs: &[arg], actual_output: t) -> result {
if e_abi != a_abi { ret ures_err(terr_mismatch); }
let t =
unify_fn_common(cx, expected, actual, expected_inputs,
@ -2107,7 +2107,7 @@ mod unify {
}
}
}
fn unify_obj(cx: &@ctxt, expected: &t, actual: &t,
fn unify_obj(cx: &@ctxt, expected: t, actual: t,
expected_meths: &[method], actual_meths: &[method]) ->
result {
let result_meths: [method] = [];
@ -2159,7 +2159,7 @@ mod unify {
_ { ret fix_ok(typ); }
}
}
fn unify_step(cx: &@ctxt, expected: &t, actual: &t) -> result {
fn unify_step(cx: &@ctxt, expected: t, actual: t) -> result {
// TODO: rewrite this using tuple pattern matching when available, to
// avoid all this rightward drift and spikiness.
@ -2506,7 +2506,7 @@ mod unify {
}
}
}
fn unify(expected: &t, actual: &t, vb: &@var_bindings, tcx: &ty_ctxt) ->
fn unify(expected: t, actual: t, vb: &@var_bindings, tcx: &ty_ctxt) ->
result {
let cx = @{vb: vb, tcx: tcx};
ret unify_step(cx, expected, actual);

32
src/comp/middle/typeck.rs
View File

@ -883,7 +883,7 @@ mod collect {
// Type unification
mod unify {
fn unify(fcx: &@fn_ctxt, expected: &ty::t, actual: &ty::t) ->
fn unify(fcx: &@fn_ctxt, expected: ty::t, actual: ty::t) ->
ty::unify::result {
ret ty::unify::unify(expected, actual, fcx.var_bindings, fcx.ccx.tcx);
}
@ -892,7 +892,7 @@ mod unify {
// FIXME This is almost a duplicate of ty::type_autoderef, with structure_of
// instead of ty::struct.
fn do_autoderef(fcx: &@fn_ctxt, sp: &span, t: &ty::t) -> ty::t {
fn do_autoderef(fcx: &@fn_ctxt, sp: &span, t: ty::t) -> ty::t {
let t1 = t;
while true {
alt structure_of(fcx, sp, t1) {
@ -926,8 +926,8 @@ fn do_autoderef(fcx: &@fn_ctxt, sp: &span, t: &ty::t) -> ty::t {
fail;
}
fn do_fn_block_coerce(fcx: &@fn_ctxt, sp: &span, actual: &ty::t,
expected: &ty::t) -> ty::t {
fn do_fn_block_coerce(fcx: &@fn_ctxt, sp: &span, actual: ty::t,
expected: ty::t) -> ty::t {
// fns can be silently coerced to blocks when being used as
// function call or bind arguments, but not the reverse.
@ -963,17 +963,17 @@ fn resolve_type_vars_if_possible(fcx: &@fn_ctxt, typ: ty::t) -> ty::t {
type ty_param_substs_and_ty = {substs: [ty::t], ty: ty::t};
mod demand {
fn simple(fcx: &@fn_ctxt, sp: &span, expected: &ty::t, actual: &ty::t) ->
fn simple(fcx: &@fn_ctxt, sp: &span, expected: ty::t, actual: ty::t) ->
ty::t {
full(fcx, sp, expected, actual, [], false).ty
}
fn block_coerce(fcx: &@fn_ctxt, sp: &span, expected: &ty::t,
actual: &ty::t) -> ty::t {
fn block_coerce(fcx: &@fn_ctxt, sp: &span, expected: ty::t,
actual: ty::t) -> ty::t {
full(fcx, sp, expected, actual, [], true).ty
}
fn with_substs(fcx: &@fn_ctxt, sp: &span, expected: &ty::t,
actual: &ty::t, ty_param_substs_0: &[ty::t]) ->
fn with_substs(fcx: &@fn_ctxt, sp: &span, expected: ty::t,
actual: ty::t, ty_param_substs_0: &[ty::t]) ->
ty_param_substs_and_ty {
full(fcx, sp, expected, actual, ty_param_substs_0, false)
}
@ -998,7 +998,7 @@ mod demand {
simple(fcx, sp, ty_param_subst, t_0);
}
fn mk_result(fcx: &@fn_ctxt, result_ty: &ty::t,
fn mk_result(fcx: &@fn_ctxt, result_ty: ty::t,
ty_param_subst_var_ids: &[int]) ->
ty_param_substs_and_ty {
let result_ty_param_substs: [ty::t] = [];
@ -1029,7 +1029,7 @@ mod demand {
// Returns true if the two types unify and false if they don't.
fn are_compatible(fcx: &@fn_ctxt, expected: &ty::t, actual: &ty::t) -> bool {
fn are_compatible(fcx: &@fn_ctxt, expected: ty::t, actual: ty::t) -> bool {
alt unify::unify(fcx, expected, actual) {
ures_ok(_) { ret true; }
ures_err(_) { ret false; }
@ -1519,22 +1519,22 @@ fn require_pure_call(ccx: @crate_ctxt, caller_purity: &ast::purity,
}
}
type unifier = fn(&@fn_ctxt, &span, &ty::t, &ty::t) -> ty::t;
type unifier = fn(&@fn_ctxt, &span, ty::t, ty::t) -> ty::t;
fn check_expr(fcx: &@fn_ctxt, expr: &@ast::expr) -> bool {
fn dummy_unify(_fcx: &@fn_ctxt, _sp: &span, _expected: &ty::t,
actual: &ty::t) -> ty::t {
fn dummy_unify(_fcx: &@fn_ctxt, _sp: &span, _expected: ty::t,
actual: ty::t) -> ty::t {
actual
}
ret check_expr_with_unifier(fcx, expr, dummy_unify, 0u);
}
fn check_expr_with(fcx: &@fn_ctxt, expr: &@ast::expr, expected: &ty::t) ->
fn check_expr_with(fcx: &@fn_ctxt, expr: &@ast::expr, expected: ty::t) ->
bool {
ret check_expr_with_unifier(fcx, expr, demand::simple, expected);
}
fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
expected: &ty::t) -> bool {
expected: ty::t) -> bool {
//log_err "typechecking expr " + syntax::print::pprust::expr_to_str(expr);
// A generic function to factor out common logic from call and bind