nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-12-01 19:23:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

rustc: Pass a type store around, which does nothing yet

Browse Source
This commit is contained in:
Patrick Walton 2011-04-20 18:52:04 -07:00
parent 3dbfc9310a
commit 5dbf554bb3
7 changed files with 601 additions and 441 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/comp/driver/rustc.rs
View File

@ -68,16 +68,19 @@ fn compile_input(session.session sess,
auto p = parser.new_parser(sess, env, def, input, 0u); auto p = parser.new_parser(sess, env, def, input, 0u);
auto crate = parse_input(sess, p, input); auto crate = parse_input(sess, p, input);
if (ot == trans.output_type_none) {ret;} if (ot == trans.output_type_none) {ret;}
crate = creader.read_crates(sess, crate, library_search_paths); crate = creader.read_crates(sess, crate, library_search_paths);
crate = resolve.resolve_crate(sess, crate); crate = resolve.resolve_crate(sess, crate);
capture.check_for_captures(sess, crate); capture.check_for_captures(sess, crate);
auto typeck_result = typeck.check_crate(sess, crate);
auto tystore = ty.mk_type_store();
auto typeck_result = typeck.check_crate(sess, tystore, crate);
crate = typeck_result._0; crate = typeck_result._0;
auto type_cache = typeck_result._1; auto type_cache = typeck_result._1;
// FIXME: uncomment once typestate_check works // FIXME: uncomment once typestate_check works
// crate = typestate_check.check_crate(crate); // crate = typestate_check.check_crate(crate);
trans.trans_crate(sess, crate, type_cache, output, shared, optimize, trans.trans_crate(sess, crate, tystore, type_cache, output, shared,
verify, ot); optimize, verify, ot);
} }
fn pretty_print_input(session.session sess, fn pretty_print_input(session.session sess,

88
src/comp/front/creader.rs
View File

@ -49,22 +49,23 @@ tag resolve_result {
// Callback to translate defs to strs or back. // Callback to translate defs to strs or back.
type str_def = fn(str) -> ast.def_id; type str_def = fn(str) -> ast.def_id;
type pstate = rec(str rep, mutable uint pos, uint len); type pstate = rec(str rep, mutable uint pos, uint len,
@ty.type_store tystore);
fn peek(@pstate st) -> u8 { fn peek(@pstate st) -> u8 {
if (st.pos < st.len) {ret st.rep.(st.pos) as u8;} if (st.pos < st.len) {ret st.rep.(st.pos) as u8;}
else {ret ' ' as u8;} else {ret ' ' as u8;}
} }
fn next(@pstate st) -> u8 { // ?? somehow not recognized as impure fn next(@pstate st) -> u8 {
if (st.pos >= st.len) {fail;} if (st.pos >= st.len) {fail;}
auto ch = st.rep.(st.pos); auto ch = st.rep.(st.pos);
st.pos = st.pos + 1u; st.pos = st.pos + 1u;
ret ch as u8; ret ch as u8;
} }
fn parse_ty_str(str rep, str_def sd) -> @ty.t { fn parse_ty_str(str rep, str_def sd, @ty.type_store tystore) -> @ty.t {
auto len = _str.byte_len(rep); auto len = _str.byte_len(rep);
auto st = @rec(rep=rep, mutable pos=0u, len=len); auto st = @rec(rep=rep, mutable pos=0u, len=len, tystore=tystore);
auto result = parse_ty(st, sd); auto result = parse_ty(st, sd);
if (st.pos != len) { if (st.pos != len) {
log_err "parse_ty_str: incomplete parse, stopped at byte " log_err "parse_ty_str: incomplete parse, stopped at byte "
@ -76,27 +77,27 @@ fn parse_ty_str(str rep, str_def sd) -> @ty.t {
fn parse_ty(@pstate st, str_def sd) -> @ty.t { fn parse_ty(@pstate st, str_def sd) -> @ty.t {
alt (next(st) as char) { alt (next(st) as char) {
case ('n') { ret ty.mk_nil(); } case ('n') { ret ty.mk_nil(st.tystore); }
case ('b') { ret ty.mk_bool(); } case ('b') { ret ty.mk_bool(st.tystore); }
case ('i') { ret ty.mk_int(); } case ('i') { ret ty.mk_int(st.tystore); }
case ('u') { ret ty.mk_uint(); } case ('u') { ret ty.mk_uint(st.tystore); }
case ('l') { ret ty.mk_float(); } case ('l') { ret ty.mk_float(st.tystore); }
case ('M') { case ('M') {
alt (next(st) as char) { alt (next(st) as char) {
case ('b') { ret ty.mk_mach(common.ty_u8); } case ('b') { ret ty.mk_mach(st.tystore, common.ty_u8); }
case ('w') { ret ty.mk_mach(common.ty_u16); } case ('w') { ret ty.mk_mach(st.tystore, common.ty_u16); }
case ('l') { ret ty.mk_mach(common.ty_u32); } case ('l') { ret ty.mk_mach(st.tystore, common.ty_u32); }
case ('d') { ret ty.mk_mach(common.ty_u64); } case ('d') { ret ty.mk_mach(st.tystore, common.ty_u64); }
case ('B') { ret ty.mk_mach(common.ty_i8); } case ('B') { ret ty.mk_mach(st.tystore, common.ty_i8); }
case ('W') { ret ty.mk_mach(common.ty_i16); } case ('W') { ret ty.mk_mach(st.tystore, common.ty_i16); }
case ('L') { ret ty.mk_mach(common.ty_i32); } case ('L') { ret ty.mk_mach(st.tystore, common.ty_i32); }
case ('D') { ret ty.mk_mach(common.ty_i64); } case ('D') { ret ty.mk_mach(st.tystore, common.ty_i64); }
case ('f') { ret ty.mk_mach(common.ty_f32); } case ('f') { ret ty.mk_mach(st.tystore, common.ty_f32); }
case ('F') { ret ty.mk_mach(common.ty_f64); } case ('F') { ret ty.mk_mach(st.tystore, common.ty_f64); }
} }
} }
case ('c') { ret ty.mk_char(); } case ('c') { ret ty.mk_char(st.tystore); }
case ('s') { ret ty.mk_str(); } case ('s') { ret ty.mk_str(st.tystore); }
case ('t') { case ('t') {
check(next(st) as char == '['); check(next(st) as char == '[');
auto def = parse_def(st, sd); auto def = parse_def(st, sd);
@ -105,13 +106,13 @@ fn parse_ty(@pstate st, str_def sd) -> @ty.t {
params += vec(parse_ty(st, sd)); params += vec(parse_ty(st, sd));
} }
st.pos = st.pos + 1u; st.pos = st.pos + 1u;
ret ty.mk_tag(def, params); ret ty.mk_tag(st.tystore, def, params);
} }
case ('p') { ret ty.mk_param(parse_int(st) as uint); } case ('p') { ret ty.mk_param(st.tystore, parse_int(st) as uint); }
case ('@') { ret ty.mk_box(parse_mt(st, sd)); } case ('@') { ret ty.mk_box(st.tystore, parse_mt(st, sd)); }
case ('V') { ret ty.mk_vec(parse_mt(st, sd)); } case ('V') { ret ty.mk_vec(st.tystore, parse_mt(st, sd)); }
case ('P') { ret ty.mk_port(parse_ty(st, sd)); } case ('P') { ret ty.mk_port(st.tystore, parse_ty(st, sd)); }
case ('C') { ret ty.mk_chan(parse_ty(st, sd)); } case ('C') { ret ty.mk_chan(st.tystore, parse_ty(st, sd)); }
case ('T') { case ('T') {
check(next(st) as char == '['); check(next(st) as char == '[');
let vec[ty.mt] params = vec(); let vec[ty.mt] params = vec();
@ -119,7 +120,7 @@ fn parse_ty(@pstate st, str_def sd) -> @ty.t {
params += vec(parse_mt(st, sd)); params += vec(parse_mt(st, sd));
} }
st.pos = st.pos + 1u; st.pos = st.pos + 1u;
ret ty.mk_tup(params); ret ty.mk_tup(st.tystore, params);
} }
case ('R') { case ('R') {
check(next(st) as char == '['); check(next(st) as char == '[');
@ -133,15 +134,15 @@ fn parse_ty(@pstate st, str_def sd) -> @ty.t {
fields += vec(rec(ident=name, mt=parse_mt(st, sd))); fields += vec(rec(ident=name, mt=parse_mt(st, sd)));
} }
st.pos = st.pos + 1u; st.pos = st.pos + 1u;
ret ty.mk_rec(fields); ret ty.mk_rec(st.tystore, fields);
} }
case ('F') { case ('F') {
auto func = parse_ty_fn(st, sd); auto func = parse_ty_fn(st, sd);
ret ty.mk_fn(ast.proto_fn, func._0, func._1); ret ty.mk_fn(st.tystore, ast.proto_fn, func._0, func._1);
} }
case ('W') { case ('W') {
auto func = parse_ty_fn(st, sd); auto func = parse_ty_fn(st, sd);
ret ty.mk_fn(ast.proto_iter, func._0, func._1); ret ty.mk_fn(st.tystore, ast.proto_iter, func._0, func._1);
} }
case ('N') { case ('N') {
auto abi; auto abi;
@ -151,7 +152,7 @@ fn parse_ty(@pstate st, str_def sd) -> @ty.t {
case ('l') {abi = ast.native_abi_llvm;} case ('l') {abi = ast.native_abi_llvm;}
} }
auto func = parse_ty_fn(st, sd); auto func = parse_ty_fn(st, sd);
ret ty.mk_native_fn(abi,func._0,func._1); ret ty.mk_native_fn(st.tystore,abi,func._0,func._1);
} }
case ('O') { case ('O') {
check(next(st) as char == '['); check(next(st) as char == '[');
@ -173,11 +174,11 @@ fn parse_ty(@pstate st, str_def sd) -> @ty.t {
output=func._1)); output=func._1));
} }
st.pos += 1u; st.pos += 1u;
ret ty.mk_obj(methods); ret ty.mk_obj(st.tystore, methods);
} }
case ('X') { ret ty.mk_var(parse_int(st)); } case ('X') { ret ty.mk_var(st.tystore, parse_int(st)); }
case ('E') { ret ty.mk_native(); } case ('E') { ret ty.mk_native(st.tystore); }
case ('Y') { ret ty.mk_type(); } case ('Y') { ret ty.mk_type(st.tystore); }
} }
} }
@ -330,7 +331,7 @@ fn variant_tag_id(&ebml.doc d) -> ast.def_id {
ret parse_def_id(ebml.doc_data(tagdoc)); ret parse_def_id(ebml.doc_data(tagdoc));
} }
fn item_type(&ebml.doc item, int this_cnum) -> @ty.t { fn item_type(&ebml.doc item, int this_cnum, @ty.type_store tystore) -> @ty.t {
fn parse_external_def_id(int this_cnum, str s) -> ast.def_id { fn parse_external_def_id(int this_cnum, str s) -> ast.def_id {
// FIXME: This is completely wrong when linking against a crate // FIXME: This is completely wrong when linking against a crate
// that, in turn, links against another crate. We need a mapping // that, in turn, links against another crate. We need a mapping
@ -343,7 +344,7 @@ fn item_type(&ebml.doc item, int this_cnum) -> @ty.t {
auto tp = ebml.get_doc(item, metadata.tag_items_data_item_type); auto tp = ebml.get_doc(item, metadata.tag_items_data_item_type);
auto s = _str.unsafe_from_bytes(ebml.doc_data(tp)); auto s = _str.unsafe_from_bytes(ebml.doc_data(tp));
ret parse_ty_str(s, bind parse_external_def_id(this_cnum, _)); ret parse_ty_str(s, bind parse_external_def_id(this_cnum, _), tystore);
} }
fn item_ty_param_count(&ebml.doc item, int this_cnum) -> uint { fn item_ty_param_count(&ebml.doc item, int this_cnum) -> uint {
@ -505,12 +506,12 @@ fn lookup_def(session.session sess, int cnum, vec[ast.ident] path)
ret some[ast.def](def); ret some[ast.def](def);
} }
fn get_type(session.session sess, ast.def_id def) fn get_type(session.session sess, @ty.type_store tystore, ast.def_id def)
-> ty.ty_param_count_and_ty { -> ty.ty_param_count_and_ty {
auto external_crate_id = def._0; auto external_crate_id = def._0;
auto data = sess.get_external_crate(external_crate_id).data; auto data = sess.get_external_crate(external_crate_id).data;
auto item = lookup_item(def._1, data); auto item = lookup_item(def._1, data);
auto t = item_type(item, external_crate_id); auto t = item_type(item, external_crate_id, tystore);
auto tp_count; auto tp_count;
auto kind_ch = item_kind(item); auto kind_ch = item_kind(item);
@ -531,8 +532,9 @@ fn get_symbol(session.session sess, ast.def_id def) -> str {
ret item_symbol(item); ret item_symbol(item);
} }
fn get_tag_variants(session.session sess, ast.def_id def) fn get_tag_variants(session.session sess,
-> vec[trans.variant_info] { @ty.type_store tystore,
ast.def_id def) -> vec[trans.variant_info] {
auto external_crate_id = def._0; auto external_crate_id = def._0;
auto data = sess.get_external_crate(external_crate_id).data; auto data = sess.get_external_crate(external_crate_id).data;
auto items = ebml.get_doc(ebml.new_doc(data), metadata.tag_items); auto items = ebml.get_doc(ebml.new_doc(data), metadata.tag_items);
@ -542,7 +544,7 @@ fn get_tag_variants(session.session sess, ast.def_id def)
auto variant_ids = tag_variant_ids(item, external_crate_id); auto variant_ids = tag_variant_ids(item, external_crate_id);
for (ast.def_id did in variant_ids) { for (ast.def_id did in variant_ids) {
auto item = find_item(did._1, items); auto item = find_item(did._1, items);
auto ctor_ty = item_type(item, external_crate_id); auto ctor_ty = item_type(item, external_crate_id, tystore);
let vec[@ty.t] arg_tys = vec(); let vec[@ty.t] arg_tys = vec();
alt (ctor_ty.struct) { alt (ctor_ty.struct) {
case (ty.ty_fn(_, ?args, _)) { case (ty.ty_fn(_, ?args, _)) {

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

@ -461,7 +461,7 @@ fn encode_info_for_native_item(@trans.crate_ctxt cx, &ebml.writer ebml_w,
case (ast.native_item_ty(_, ?did)) { case (ast.native_item_ty(_, ?did)) {
encode_def_id(ebml_w, did); encode_def_id(ebml_w, did);
encode_kind(ebml_w, 'T' as u8); encode_kind(ebml_w, 'T' as u8);
encode_type(ebml_w, ty.mk_native()); encode_type(ebml_w, ty.mk_native(cx.tystore));
} }
case (ast.native_item_fn(_, _, _, ?tps, ?did, ?ann)) { case (ast.native_item_fn(_, _, _, ?tps, ?did, ?ann)) {
encode_def_id(ebml_w, did); encode_def_id(ebml_w, did);

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

@ -112,7 +112,8 @@ state type crate_ctxt = rec(session.session sess,
hashmap[@ty.t, TypeRef] lltypes, hashmap[@ty.t, TypeRef] lltypes,
@glue_fns glues, @glue_fns glues,
namegen names, namegen names,
std.sha1.sha1 sha); std.sha1.sha1 sha,
@ty.type_store tystore);
type local_ctxt = rec(vec[str] path, type local_ctxt = rec(vec[str] path,
vec[str] module_path, vec[str] module_path,
@ -638,7 +639,7 @@ fn type_of_fn_full(@crate_ctxt cx,
vec(T_fn_pair(cx.tn, vec(T_fn_pair(cx.tn,
type_of_fn_full(cx, ast.proto_fn, none[TypeRef], type_of_fn_full(cx, ast.proto_fn, none[TypeRef],
vec(rec(mode=ast.val, ty=output)), vec(rec(mode=ast.val, ty=output)),
ty.mk_nil(), 0u))); ty.mk_nil(cx.tystore), 0u)));
} }
// ... then explicit args. // ... then explicit args.
@ -1145,17 +1146,17 @@ fn array_alloca(@block_ctxt cx, TypeRef t, ValueRef n) -> ValueRef {
// to have (a) the same size as the type that was passed in; (b) to be non- // 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 // recursive. This is done by replacing all boxes in a type with boxed unit
// types. // types.
fn simplify_type(@ty.t typ) -> @ty.t { fn simplify_type(@crate_ctxt ccx, @ty.t typ) -> @ty.t {
fn simplifier(@ty.t typ) -> @ty.t { fn simplifier(@crate_ctxt ccx, @ty.t typ) -> @ty.t {
alt (typ.struct) { alt (typ.struct) {
case (ty.ty_box(_)) { case (ty.ty_box(_)) {
ret ty.mk_imm_box(ty.mk_nil()); ret ty.mk_imm_box(ccx.tystore, ty.mk_nil(ccx.tystore));
} }
case (_) { ret typ; } case (_) { ret typ; }
} }
} }
auto f = simplifier; auto f = bind simplifier(ccx, _);
ret ty.fold_ty(f, typ); ret ty.fold_ty(ccx.tystore, f, typ);
} }
// Computes the size of the data part of a non-dynamically-sized tag. // Computes the size of the data part of a non-dynamically-sized tag.
@ -1186,11 +1187,12 @@ fn static_size_of_tag(@crate_ctxt cx, @ty.t t) -> uint {
auto max_size = 0u; auto max_size = 0u;
auto variants = tag_variants(cx, tid); auto variants = tag_variants(cx, tid);
for (variant_info variant in variants) { for (variant_info variant in variants) {
auto tup_ty = simplify_type(ty.mk_imm_tup(variant.args)); auto tup_ty = simplify_type(cx,
ty.mk_imm_tup(cx.tystore, variant.args));
// Perform any type parameter substitutions. // Perform any type parameter substitutions.
tup_ty = ty.bind_params_in_type(tup_ty); tup_ty = ty.bind_params_in_type(cx.tystore, tup_ty);
tup_ty = ty.substitute_type_params(subtys, tup_ty); tup_ty = ty.substitute_type_params(cx.tystore, subtys, tup_ty);
// Here we possibly do a recursive call. // Here we possibly do a recursive call.
auto this_size = llsize_of_real(cx, type_of(cx, tup_ty)); auto this_size = llsize_of_real(cx, type_of(cx, tup_ty));
@ -1262,8 +1264,10 @@ fn dynamic_size_of(@block_ctxt cx, @ty.t t) -> result {
let vec[@ty.t] raw_tys = variant.args; let vec[@ty.t] raw_tys = variant.args;
let vec[@ty.t] tys = vec(); let vec[@ty.t] tys = vec();
for (@ty.t raw_ty in raw_tys) { for (@ty.t raw_ty in raw_tys) {
auto t = ty.bind_params_in_type(raw_ty); auto t = ty.bind_params_in_type(cx.fcx.lcx.ccx.tystore,
t = ty.substitute_type_params(tps, t); raw_ty);
t = ty.substitute_type_params(cx.fcx.lcx.ccx.tystore, tps,
t);
tys += vec(t); tys += vec(t);
} }
@ -1402,7 +1406,7 @@ fn GEP_tup_like(@block_ctxt cx, @ty.t t,
// flattened the incoming structure. // flattened the incoming structure.
auto s = split_type(t, ixs, 0u); auto s = split_type(t, ixs, 0u);
auto prefix_ty = ty.mk_imm_tup(s.prefix); auto prefix_ty = ty.mk_imm_tup(cx.fcx.lcx.ccx.tystore, s.prefix);
auto bcx = cx; auto bcx = cx;
auto sz = size_of(bcx, prefix_ty); auto sz = size_of(bcx, prefix_ty);
bcx = sz.bcx; bcx = sz.bcx;
@ -1433,12 +1437,13 @@ fn GEP_tag(@block_ctxt cx,
// Synthesize a tuple type so that GEP_tup_like() can work its magic. // Synthesize a tuple type so that GEP_tup_like() can work its magic.
// Separately, store the type of the element we're interested in. // Separately, store the type of the element we're interested in.
auto arg_tys = variant.args; auto arg_tys = variant.args;
auto elem_ty = ty.mk_nil(); // typestate infelicity auto elem_ty = ty.mk_nil(cx.fcx.lcx.ccx.tystore); // typestate infelicity
auto i = 0; auto i = 0;
let vec[@ty.t] true_arg_tys = vec(); let vec[@ty.t] true_arg_tys = vec();
for (@ty.t aty in arg_tys) { for (@ty.t aty in arg_tys) {
auto arg_ty = ty.bind_params_in_type(aty); auto arg_ty = ty.bind_params_in_type(cx.fcx.lcx.ccx.tystore, aty);
arg_ty = ty.substitute_type_params(ty_substs, arg_ty); arg_ty = ty.substitute_type_params(cx.fcx.lcx.ccx.tystore, ty_substs,
arg_ty);
true_arg_tys += vec(arg_ty); true_arg_tys += vec(arg_ty);
if (i == ix) { if (i == ix) {
elem_ty = arg_ty; elem_ty = arg_ty;
@ -1447,7 +1452,7 @@ fn GEP_tag(@block_ctxt cx,
i += 1; i += 1;
} }
auto tup_ty = ty.mk_imm_tup(true_arg_tys); auto tup_ty = ty.mk_imm_tup(cx.fcx.lcx.ccx.tystore, true_arg_tys);
// Cast the blob pointer to the appropriate type, if we need to (i.e. if // Cast the blob pointer to the appropriate type, if we need to (i.e. if
// the blob pointer isn't dynamically sized). // the blob pointer isn't dynamically sized).
@ -1487,8 +1492,10 @@ fn trans_raw_malloc(@block_ctxt cx, TypeRef llptr_ty, ValueRef llsize)
fn trans_malloc_boxed(@block_ctxt cx, @ty.t t) -> result { fn trans_malloc_boxed(@block_ctxt cx, @ty.t t) -> result {
// Synthesize a fake box type structurally so we have something // Synthesize a fake box type structurally so we have something
// to measure the size of. // to measure the size of.
auto boxed_body = ty.mk_imm_tup(vec(ty.mk_int(), t)); auto boxed_body = ty.mk_imm_tup(cx.fcx.lcx.ccx.tystore,
auto box_ptr = ty.mk_imm_box(t); vec(ty.mk_int(cx.fcx.lcx.ccx.tystore),
t));
auto box_ptr = ty.mk_imm_box(cx.fcx.lcx.ccx.tystore, t);
auto sz = size_of(cx, boxed_body); auto sz = size_of(cx, boxed_body);
auto llty = type_of(cx.fcx.lcx.ccx, box_ptr); auto llty = type_of(cx.fcx.lcx.ccx, box_ptr);
ret trans_raw_malloc(sz.bcx, llty, sz.val); ret trans_raw_malloc(sz.bcx, llty, sz.val);
@ -2116,7 +2123,7 @@ fn make_cmp_glue(@block_ctxt cx,
auto min_len = umin(r.bcx, vec_fill(r.bcx, lhs), auto min_len = umin(r.bcx, vec_fill(r.bcx, lhs),
vec_fill(r.bcx, rhs)); vec_fill(r.bcx, rhs));
auto rhs_lim = r.bcx.build.GEP(rhs_p0, vec(min_len)); auto rhs_lim = r.bcx.build.GEP(rhs_p0, vec(min_len));
auto elt_ty = ty.sequence_element_type(t); auto elt_ty = ty.sequence_element_type(cx.fcx.lcx.ccx.tystore, t);
r = size_of(r.bcx, elt_ty); r = size_of(r.bcx, elt_ty);
r = iter_sequence_raw(r.bcx, lhs_p0, rhs_p0, rhs_lim, r.val, r = iter_sequence_raw(r.bcx, lhs_p0, rhs_p0, rhs_lim, r.val,
bind inner(next, true, flag, llop, bind inner(next, true, flag, llop,
@ -2250,7 +2257,7 @@ type variant_info = rec(vec[@ty.t] args, @ty.t ctor_ty, ast.def_id id);
// Returns information about the variants in a tag. // Returns information about the variants in a tag.
fn tag_variants(@crate_ctxt cx, ast.def_id id) -> vec[variant_info] { fn tag_variants(@crate_ctxt cx, ast.def_id id) -> vec[variant_info] {
if (cx.sess.get_targ_crate_num() != id._0) { if (cx.sess.get_targ_crate_num() != id._0) {
ret creader.get_tag_variants(cx.sess, id); ret creader.get_tag_variants(cx.sess, cx.tystore, id);
} }
check (cx.items.contains_key(id)); check (cx.items.contains_key(id));
@ -2333,8 +2340,8 @@ fn iter_structural_ty_full(@block_ctxt cx,
val_pair_and_ty_fn f) -> result { val_pair_and_ty_fn f) -> result {
auto box_a_ptr = cx.build.Load(box_a_cell); auto box_a_ptr = cx.build.Load(box_a_cell);
auto box_b_ptr = cx.build.Load(box_b_cell); auto box_b_ptr = cx.build.Load(box_b_cell);
auto tnil = ty.mk_nil(); auto tnil = ty.mk_nil(cx.fcx.lcx.ccx.tystore);
auto tbox = ty.mk_imm_box(tnil); auto tbox = ty.mk_imm_box(cx.fcx.lcx.ccx.tystore, tnil);
auto inner_cx = new_sub_block_ctxt(cx, "iter box"); auto inner_cx = new_sub_block_ctxt(cx, "iter box");
auto next_cx = new_sub_block_ctxt(cx, "next"); auto next_cx = new_sub_block_ctxt(cx, "next");
@ -2399,7 +2406,8 @@ fn iter_structural_ty_full(@block_ctxt cx,
// NB: we must hit the discriminant first so that structural // NB: we must hit the discriminant first so that structural
// comparison know not to proceed when the discriminants differ. // comparison know not to proceed when the discriminants differ.
auto bcx = cx; auto bcx = cx;
bcx = f(bcx, lldiscrim_a, lldiscrim_b, ty.mk_int()).bcx; bcx = f(bcx, lldiscrim_a, lldiscrim_b,
ty.mk_int(cx.fcx.lcx.ccx.tystore)).bcx;
auto unr_cx = new_sub_block_ctxt(bcx, "tag-iter-unr"); auto unr_cx = new_sub_block_ctxt(bcx, "tag-iter-unr");
unr_cx.build.Unreachable(); unr_cx.build.Unreachable();
@ -2435,9 +2443,10 @@ fn iter_structural_ty_full(@block_ctxt cx,
auto llfldp_b = rslt.val; auto llfldp_b = rslt.val;
variant_cx = rslt.bcx; variant_cx = rslt.bcx;
auto ty_subst = ty.bind_params_in_type(a.ty); auto ty_subst = ty.bind_params_in_type(
ty_subst = cx.fcx.lcx.ccx.tystore, a.ty);
ty.substitute_type_params(tps, ty_subst); ty_subst = ty.substitute_type_params(
cx.fcx.lcx.ccx.tystore, tps, ty_subst);
auto llfld_a = auto llfld_a =
load_if_immediate(variant_cx, load_if_immediate(variant_cx,
@ -2619,7 +2628,7 @@ fn iter_sequence(@block_ctxt cx,
ret iter_sequence_body(cx, v, elt.ty, f, false); ret iter_sequence_body(cx, v, elt.ty, f, false);
} }
case (ty.ty_str) { case (ty.ty_str) {
auto et = ty.mk_mach(common.ty_u8); auto et = ty.mk_mach(cx.fcx.lcx.ccx.tystore, common.ty_u8);
ret iter_sequence_body(cx, v, et, f, true); ret iter_sequence_body(cx, v, et, f, true);
} }
case (_) { fail; } case (_) { fail; }
@ -2843,11 +2852,13 @@ fn trans_lit(@crate_ctxt cx, &ast.lit lit, &ast.ann ann) -> ValueRef {
fn target_type(@crate_ctxt cx, @ty.t t) -> @ty.t { fn target_type(@crate_ctxt cx, @ty.t t) -> @ty.t {
alt (t.struct) { alt (t.struct) {
case (ty.ty_int) { case (ty.ty_int) {
auto struct_ty = ty.mk_mach(cx.sess.get_targ_cfg().int_type); auto struct_ty = ty.mk_mach(cx.tystore,
cx.sess.get_targ_cfg().int_type);
ret ty.copy_cname(struct_ty, t); ret ty.copy_cname(struct_ty, t);
} }
case (ty.ty_uint) { case (ty.ty_uint) {
auto struct_ty = ty.mk_mach(cx.sess.get_targ_cfg().uint_type); auto struct_ty = ty.mk_mach(cx.tystore,
cx.sess.get_targ_cfg().uint_type);
ret ty.copy_cname(struct_ty, t); ret ty.copy_cname(struct_ty, t);
} }
case (_) { /* fall through */ } case (_) { /* fall through */ }
@ -2858,7 +2869,7 @@ fn target_type(@crate_ctxt cx, @ty.t t) -> @ty.t {
// Converts an annotation to a type // Converts an annotation to a type
fn node_ann_type(@crate_ctxt cx, &ast.ann a) -> @ty.t { fn node_ann_type(@crate_ctxt cx, &ast.ann a) -> @ty.t {
ret target_type(cx, ty.ann_to_monotype(a)); ret target_type(cx, ty.ann_to_monotype(cx.tystore, a));
} }
fn node_ann_ty_params(&ast.ann a) -> vec[@ty.t] { fn node_ann_ty_params(&ast.ann a) -> vec[@ty.t] {
@ -2887,19 +2898,22 @@ fn trans_unary(@block_ctxt cx, ast.unop op,
@ast.expr e, &ast.ann a) -> result { @ast.expr e, &ast.ann a) -> result {
auto sub = trans_expr(cx, e); auto sub = trans_expr(cx, e);
auto e_ty = ty.expr_ty(e); auto e_ty = ty.expr_ty(cx.fcx.lcx.ccx.tystore, e);
alt (op) { alt (op) {
case (ast.bitnot) { case (ast.bitnot) {
sub = autoderef(sub.bcx, sub.val, ty.expr_ty(e)); sub = autoderef(sub.bcx, sub.val,
ty.expr_ty(cx.fcx.lcx.ccx.tystore, e));
ret res(sub.bcx, sub.bcx.build.Not(sub.val)); ret res(sub.bcx, sub.bcx.build.Not(sub.val));
} }
case (ast.not) { case (ast.not) {
sub = autoderef(sub.bcx, sub.val, ty.expr_ty(e)); sub = autoderef(sub.bcx, sub.val,
ty.expr_ty(cx.fcx.lcx.ccx.tystore, e));
ret res(sub.bcx, sub.bcx.build.Not(sub.val)); ret res(sub.bcx, sub.bcx.build.Not(sub.val));
} }
case (ast.neg) { case (ast.neg) {
sub = autoderef(sub.bcx, sub.val, ty.expr_ty(e)); sub = autoderef(sub.bcx, sub.val,
ty.expr_ty(cx.fcx.lcx.ccx.tystore, e));
if(e_ty.struct == ty.ty_float) { if(e_ty.struct == ty.ty_float) {
ret res(sub.bcx, sub.bcx.build.FNeg(sub.val)); ret res(sub.bcx, sub.bcx.build.FNeg(sub.val));
} }
@ -2908,7 +2922,7 @@ fn trans_unary(@block_ctxt cx, ast.unop op,
} }
} }
case (ast.box(_)) { case (ast.box(_)) {
auto e_ty = ty.expr_ty(e); auto e_ty = ty.expr_ty(cx.fcx.lcx.ccx.tystore, e);
auto e_val = sub.val; auto e_val = sub.val;
auto box_ty = node_ann_type(sub.bcx.fcx.lcx.ccx, a); auto box_ty = node_ann_type(sub.bcx.fcx.lcx.ccx, a);
sub = trans_malloc_boxed(sub.bcx, e_ty); sub = trans_malloc_boxed(sub.bcx, e_ty);
@ -2988,7 +3002,7 @@ fn trans_compare(@block_ctxt cx0, ast.binop op, @ty.t t0,
fn trans_vec_append(@block_ctxt cx, @ty.t t, fn trans_vec_append(@block_ctxt cx, @ty.t t,
ValueRef lhs, ValueRef rhs) -> result { ValueRef lhs, ValueRef rhs) -> result {
auto elt_ty = ty.sequence_element_type(t); auto elt_ty = ty.sequence_element_type(cx.fcx.lcx.ccx.tystore, t);
auto skip_null = C_bool(false); auto skip_null = C_bool(false);
alt (t.struct) { alt (t.struct) {
@ -3160,11 +3174,13 @@ fn trans_binary(@block_ctxt cx, ast.binop op,
case (ast.and) { case (ast.and) {
// Lazy-eval and // Lazy-eval and
auto lhs_res = trans_expr(cx, a); auto lhs_res = trans_expr(cx, a);
lhs_res = autoderef(lhs_res.bcx, lhs_res.val, ty.expr_ty(a)); lhs_res = autoderef(lhs_res.bcx, lhs_res.val,
ty.expr_ty(cx.fcx.lcx.ccx.tystore, a));
auto rhs_cx = new_scope_block_ctxt(cx, "rhs"); auto rhs_cx = new_scope_block_ctxt(cx, "rhs");
auto rhs_res = trans_expr(rhs_cx, b); auto rhs_res = trans_expr(rhs_cx, b);
rhs_res = autoderef(rhs_res.bcx, rhs_res.val, ty.expr_ty(b)); rhs_res = autoderef(rhs_res.bcx, rhs_res.val,
ty.expr_ty(cx.fcx.lcx.ccx.tystore, b));
auto lhs_false_cx = new_scope_block_ctxt(cx, "lhs false"); auto lhs_false_cx = new_scope_block_ctxt(cx, "lhs false");
auto lhs_false_res = res(lhs_false_cx, C_bool(false)); auto lhs_false_res = res(lhs_false_cx, C_bool(false));
@ -3180,11 +3196,13 @@ fn trans_binary(@block_ctxt cx, ast.binop op,
case (ast.or) { case (ast.or) {
// Lazy-eval or // Lazy-eval or
auto lhs_res = trans_expr(cx, a); auto lhs_res = trans_expr(cx, a);
lhs_res = autoderef(lhs_res.bcx, lhs_res.val, ty.expr_ty(a)); lhs_res = autoderef(lhs_res.bcx, lhs_res.val,
ty.expr_ty(cx.fcx.lcx.ccx.tystore, a));
auto rhs_cx = new_scope_block_ctxt(cx, "rhs"); auto rhs_cx = new_scope_block_ctxt(cx, "rhs");
auto rhs_res = trans_expr(rhs_cx, b); auto rhs_res = trans_expr(rhs_cx, b);
rhs_res = autoderef(rhs_res.bcx, rhs_res.val, ty.expr_ty(b)); rhs_res = autoderef(rhs_res.bcx, rhs_res.val,
ty.expr_ty(cx.fcx.lcx.ccx.tystore, b));
auto lhs_true_cx = new_scope_block_ctxt(cx, "lhs true"); auto lhs_true_cx = new_scope_block_ctxt(cx, "lhs true");
auto lhs_true_res = res(lhs_true_cx, C_bool(true)); auto lhs_true_res = res(lhs_true_cx, C_bool(true));
@ -3200,10 +3218,10 @@ fn trans_binary(@block_ctxt cx, ast.binop op,
case (_) { case (_) {
// Remaining cases are eager: // Remaining cases are eager:
auto lhs = trans_expr(cx, a); auto lhs = trans_expr(cx, a);
auto lhty = ty.expr_ty(a); auto lhty = ty.expr_ty(cx.fcx.lcx.ccx.tystore, a);
lhs = autoderef(lhs.bcx, lhs.val, lhty); lhs = autoderef(lhs.bcx, lhs.val, lhty);
auto rhs = trans_expr(lhs.bcx, b); auto rhs = trans_expr(lhs.bcx, b);
auto rhty = ty.expr_ty(b); auto rhty = ty.expr_ty(cx.fcx.lcx.ccx.tystore, b);
rhs = autoderef(rhs.bcx, rhs.val, rhty); rhs = autoderef(rhs.bcx, rhs.val, rhty);
ret trans_eager_binop(rhs.bcx, op, ret trans_eager_binop(rhs.bcx, op,
autoderefed_ty(lhty), autoderefed_ty(lhty),
@ -3281,7 +3299,7 @@ fn trans_if(@block_ctxt cx, @ast.expr cond,
// If we have an else expression, then the entire // If we have an else expression, then the entire
// if expression can have a non-nil type. // if expression can have a non-nil type.
// FIXME: This isn't quite right, particularly re: dynamic types // FIXME: This isn't quite right, particularly re: dynamic types
auto expr_ty = ty.expr_ty(elexpr); auto expr_ty = ty.expr_ty(cx.fcx.lcx.ccx.tystore, elexpr);
if (ty.type_has_dynamic_size(expr_ty)) { if (ty.type_has_dynamic_size(expr_ty)) {
expr_llty = T_typaram_ptr(cx.fcx.lcx.ccx.tn); expr_llty = T_typaram_ptr(cx.fcx.lcx.ccx.tn);
} else { } else {
@ -3338,7 +3356,7 @@ fn trans_for(@block_ctxt cx,
} }
auto next_cx = new_sub_block_ctxt(cx, "next"); auto next_cx = new_sub_block_ctxt(cx, "next");
auto seq_ty = ty.expr_ty(seq); auto seq_ty = ty.expr_ty(cx.fcx.lcx.ccx.tystore, seq);
auto seq_res = trans_expr(cx, seq); auto seq_res = trans_expr(cx, seq);
auto it = iter_sequence(seq_res.bcx, seq_res.val, seq_ty, auto it = iter_sequence(seq_res.bcx, seq_res.val, seq_ty,
bind inner(_, local, _, _, body, next_cx)); bind inner(_, local, _, _, body, next_cx));
@ -3440,7 +3458,7 @@ fn trans_for_each(@block_ctxt cx,
auto lcx = cx.fcx.lcx; auto lcx = cx.fcx.lcx;
// FIXME: possibly support alias-mode here? // FIXME: possibly support alias-mode here?
auto decl_ty = ty.mk_nil(); auto decl_ty = ty.mk_nil(lcx.ccx.tystore);
auto decl_id; auto decl_id;
alt (decl.node) { alt (decl.node) {
case (ast.decl_local(?local)) { case (ast.decl_local(?local)) {
@ -3527,7 +3545,7 @@ fn trans_for_each(@block_ctxt cx,
auto iter_body_llty = type_of_fn_full(lcx.ccx, ast.proto_fn, auto iter_body_llty = type_of_fn_full(lcx.ccx, ast.proto_fn,
none[TypeRef], none[TypeRef],
vec(rec(mode=ast.val, ty=decl_ty)), vec(rec(mode=ast.val, ty=decl_ty)),
ty.mk_nil(), 0u); ty.mk_nil(lcx.ccx.tystore), 0u);
let ValueRef lliterbody = decl_internal_fastcall_fn(lcx.ccx.llmod, let ValueRef lliterbody = decl_internal_fastcall_fn(lcx.ccx.llmod,
s, iter_body_llty); s, iter_body_llty);
@ -3715,8 +3733,7 @@ fn trans_pat_match(@block_ctxt cx, @ast.pat pat, ValueRef llval,
matched_cx = rslt.bcx; matched_cx = rslt.bcx;
auto llsubval = load_if_immediate(matched_cx, auto llsubval = load_if_immediate(matched_cx,
llsubvalptr, llsubvalptr, pat_ty(cx.fcx.lcx.ccx.tystore, subpat));
pat_ty(subpat));
auto subpat_res = trans_pat_match(matched_cx, subpat, auto subpat_res = trans_pat_match(matched_cx, subpat,
llsubval, next_cx); llsubval, next_cx);
matched_cx = subpat_res.bcx; matched_cx = subpat_res.bcx;
@ -3770,7 +3787,7 @@ fn trans_pat_binding(@block_ctxt cx, @ast.pat pat, ValueRef llval)
auto llsubvalptr = rslt.val; auto llsubvalptr = rslt.val;
auto llsubval = load_if_immediate(this_cx, llsubvalptr, auto llsubval = load_if_immediate(this_cx, llsubvalptr,
pat_ty(subpat)); pat_ty(cx.fcx.lcx.ccx.tystore, subpat));
auto subpat_res = trans_pat_binding(this_cx, subpat, auto subpat_res = trans_pat_binding(this_cx, subpat,
llsubval); llsubval);
this_cx = subpat_res.bcx; this_cx = subpat_res.bcx;
@ -3959,16 +3976,19 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt,
} }
case (ast.def_fn(?did)) { case (ast.def_fn(?did)) {
auto tyt = ty.lookup_item_type(cx.fcx.lcx.ccx.sess, auto tyt = ty.lookup_item_type(cx.fcx.lcx.ccx.sess,
cx.fcx.lcx.ccx.tystore,
cx.fcx.lcx.ccx.type_cache, did); cx.fcx.lcx.ccx.type_cache, did);
ret lval_generic_fn(cx, tyt, did, ann); ret lval_generic_fn(cx, tyt, did, ann);
} }
case (ast.def_obj(?did)) { case (ast.def_obj(?did)) {
auto tyt = ty.lookup_item_type(cx.fcx.lcx.ccx.sess, auto tyt = ty.lookup_item_type(cx.fcx.lcx.ccx.sess,
cx.fcx.lcx.ccx.tystore,
cx.fcx.lcx.ccx.type_cache, did); cx.fcx.lcx.ccx.type_cache, did);
ret lval_generic_fn(cx, tyt, did, ann); ret lval_generic_fn(cx, tyt, did, ann);
} }
case (ast.def_variant(?tid, ?vid)) { case (ast.def_variant(?tid, ?vid)) {
auto v_tyt = ty.lookup_item_type(cx.fcx.lcx.ccx.sess, auto v_tyt = ty.lookup_item_type(cx.fcx.lcx.ccx.sess,
cx.fcx.lcx.ccx.tystore,
cx.fcx.lcx.ccx.type_cache, vid); cx.fcx.lcx.ccx.type_cache, vid);
alt (v_tyt._1.struct) { alt (v_tyt._1.struct) {
case (ty.ty_fn(_, _, _)) { case (ty.ty_fn(_, _, _)) {
@ -4010,6 +4030,7 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt,
} }
case (ast.def_native_fn(?did)) { case (ast.def_native_fn(?did)) {
auto tyt = ty.lookup_item_type(cx.fcx.lcx.ccx.sess, auto tyt = ty.lookup_item_type(cx.fcx.lcx.ccx.sess,
cx.fcx.lcx.ccx.tystore,
cx.fcx.lcx.ccx.type_cache, did); cx.fcx.lcx.ccx.type_cache, did);
ret lval_generic_fn(cx, tyt, did, ann); ret lval_generic_fn(cx, tyt, did, ann);
} }
@ -4054,7 +4075,8 @@ fn trans_field(@block_ctxt cx, &ast.span sp, ValueRef v, @ty.t t0,
C_int(ix as int))); C_int(ix as int)));
auto lvo = lval_mem(r.bcx, v); auto lvo = lval_mem(r.bcx, v);
let @ty.t fn_ty = ty.method_ty_to_fn_ty(methods.(ix)); let @ty.t fn_ty = ty.method_ty_to_fn_ty(cx.fcx.lcx.ccx.tystore,
methods.(ix));
ret rec(llobj = some[ValueRef](r.val), ret rec(llobj = some[ValueRef](r.val),
method_ty = some[@ty.t](fn_ty) method_ty = some[@ty.t](fn_ty)
with lvo); with lvo);
@ -4068,7 +4090,7 @@ fn trans_index(@block_ctxt cx, &ast.span sp, @ast.expr base,
@ast.expr idx, &ast.ann ann) -> lval_result { @ast.expr idx, &ast.ann ann) -> lval_result {
auto lv = trans_expr(cx, base); auto lv = trans_expr(cx, base);
lv = autoderef(lv.bcx, lv.val, ty.expr_ty(base)); lv = autoderef(lv.bcx, lv.val, ty.expr_ty(cx.fcx.lcx.ccx.tystore, base));
auto ix = trans_expr(lv.bcx, idx); auto ix = trans_expr(lv.bcx, idx);
auto v = lv.val; auto v = lv.val;
auto bcx = ix.bcx; auto bcx = ix.bcx;
@ -4134,7 +4156,7 @@ fn trans_lval(@block_ctxt cx, @ast.expr e) -> lval_result {
} }
case (ast.expr_field(?base, ?ident, ?ann)) { case (ast.expr_field(?base, ?ident, ?ann)) {
auto r = trans_expr(cx, base); auto r = trans_expr(cx, base);
auto t = ty.expr_ty(base); auto t = ty.expr_ty(cx.fcx.lcx.ccx.tystore, base);
ret trans_field(r.bcx, e.span, r.val, t, ident, ann); ret trans_field(r.bcx, e.span, r.val, t, ident, ann);
} }
case (ast.expr_index(?base, ?idx, ?ann)) { case (ast.expr_index(?base, ?idx, ?ann)) {
@ -4178,7 +4200,7 @@ fn trans_cast(@block_ctxt cx, @ast.expr e, &ast.ann ann) -> result {
auto lldsttype = type_of(cx.fcx.lcx.ccx, t); auto lldsttype = type_of(cx.fcx.lcx.ccx, t);
if (!ty.type_is_fp(t)) { if (!ty.type_is_fp(t)) {
// TODO: native-to-native casts // TODO: native-to-native casts
if (ty.type_is_native(ty.expr_ty(e))) { if (ty.type_is_native(ty.expr_ty(cx.fcx.lcx.ccx.tystore, e))) {
e_res.val = e_res.bcx.build.PtrToInt(e_res.val, lldsttype); e_res.val = e_res.bcx.build.PtrToInt(e_res.val, lldsttype);
} else if (ty.type_is_native(t)) { } else if (ty.type_is_native(t)) {
e_res.val = e_res.bcx.build.IntToPtr(e_res.val, lldsttype); e_res.val = e_res.bcx.build.IntToPtr(e_res.val, lldsttype);
@ -4226,7 +4248,8 @@ fn trans_bind_thunk(@local_ctxt cx,
auto bcx = new_top_block_ctxt(fcx); auto bcx = new_top_block_ctxt(fcx);
auto lltop = bcx.llbb; auto lltop = bcx.llbb;
auto llclosure_ptr_ty = type_of(cx.ccx, ty.mk_imm_box(closure_ty)); auto llclosure_ptr_ty =
type_of(cx.ccx, ty.mk_imm_box(cx.ccx.tystore, closure_ty));
auto llclosure = bcx.build.PointerCast(fcx.llenv, llclosure_ptr_ty); auto llclosure = bcx.build.PointerCast(fcx.llenv, llclosure_ptr_ty);
auto lltarget = GEP_tup_like(bcx, closure_ty, llclosure, auto lltarget = GEP_tup_like(bcx, closure_ty, llclosure,
@ -4368,7 +4391,7 @@ fn trans_bind(@block_ctxt cx, @ast.expr f,
let vec[ValueRef] lltydescs; let vec[ValueRef] lltydescs;
alt (f_res.generic) { alt (f_res.generic) {
case (none[generic_info]) { case (none[generic_info]) {
outgoing_fty = ty.expr_ty(f); outgoing_fty = ty.expr_ty(cx.fcx.lcx.ccx.tystore, f);
lltydescs = vec(); lltydescs = vec();
} }
case (some[generic_info](?ginfo)) { case (some[generic_info](?ginfo)) {
@ -4395,18 +4418,20 @@ fn trans_bind(@block_ctxt cx, @ast.expr f,
bcx = arg.bcx; bcx = arg.bcx;
_vec.push[ValueRef](bound_vals, arg.val); _vec.push[ValueRef](bound_vals, arg.val);
_vec.push[@ty.t](bound_tys, ty.expr_ty(e)); _vec.push[@ty.t](bound_tys,
ty.expr_ty(cx.fcx.lcx.ccx.tystore, e));
i += 1u; i += 1u;
} }
// Synthesize a closure type. // Synthesize a closure type.
let @ty.t bindings_ty = ty.mk_imm_tup(bound_tys); let @ty.t bindings_ty = ty.mk_imm_tup(cx.fcx.lcx.ccx.tystore,
bound_tys);
// NB: keep this in sync with T_closure_ptr; we're making // NB: keep this in sync with T_closure_ptr; we're making
// a ty.t structure that has the same "shape" as the LLVM type // a ty.t structure that has the same "shape" as the LLVM type
// it constructs. // it constructs.
let @ty.t tydesc_ty = ty.mk_type(); let @ty.t tydesc_ty = ty.mk_type(cx.fcx.lcx.ccx.tystore);
let vec[@ty.t] captured_tys = let vec[@ty.t] captured_tys =
_vec.init_elt[@ty.t](tydesc_ty, ty_param_count); _vec.init_elt[@ty.t](tydesc_ty, ty_param_count);
@ -4415,9 +4440,10 @@ fn trans_bind(@block_ctxt cx, @ast.expr f,
vec(tydesc_ty, vec(tydesc_ty,
outgoing_fty, outgoing_fty,
bindings_ty, bindings_ty,
ty.mk_imm_tup(captured_tys)); ty.mk_imm_tup(cx.fcx.lcx.ccx.tystore, captured_tys));
let @ty.t closure_ty = ty.mk_imm_tup(closure_tys); let @ty.t closure_ty = ty.mk_imm_tup(cx.fcx.lcx.ccx.tystore,
closure_tys);
auto r = trans_malloc_boxed(bcx, closure_ty); auto r = trans_malloc_boxed(bcx, closure_ty);
auto box = r.val; auto box = r.val;
@ -4622,7 +4648,7 @@ fn trans_args(@block_ctxt cx,
auto mode = args.(i).mode; auto mode = args.(i).mode;
auto val; auto val;
if (ty.type_is_structural(ty.expr_ty(e))) { if (ty.type_is_structural(ty.expr_ty(cx.fcx.lcx.ccx.tystore, e))) {
auto re = trans_expr(bcx, e); auto re = trans_expr(bcx, e);
val = re.val; val = re.val;
bcx = re.bcx; bcx = re.bcx;
@ -4632,7 +4658,8 @@ fn trans_args(@block_ctxt cx,
lv = trans_lval(bcx, e); lv = trans_lval(bcx, e);
} else { } else {
auto r = trans_expr(bcx, e); auto r = trans_expr(bcx, e);
if (type_is_immediate(ty.expr_ty(e))) { if (type_is_immediate(ty.expr_ty(cx.fcx.lcx.ccx.tystore,
e))) {
lv = lval_val(r.bcx, r.val); lv = lval_val(r.bcx, r.val);
} else { } else {
lv = lval_mem(r.bcx, r.val); lv = lval_mem(r.bcx, r.val);
@ -4658,7 +4685,8 @@ fn trans_args(@block_ctxt cx,
auto lldestty = arg_tys.(i); auto lldestty = arg_tys.(i);
if (mode == ast.val) { if (mode == ast.val) {
// FIXME: we'd prefer to use &&, but rustboot doesn't like it // FIXME: we'd prefer to use &&, but rustboot doesn't like it
if (ty.type_is_structural(ty.expr_ty(e))) { if (ty.type_is_structural(ty.expr_ty(cx.fcx.lcx.ccx.tystore,
e))) {
lldestty = T_ptr(lldestty); lldestty = T_ptr(lldestty);
} }
} }
@ -4668,7 +4696,8 @@ fn trans_args(@block_ctxt cx,
if (mode == ast.val) { if (mode == ast.val) {
// FIXME: we'd prefer to use &&, but rustboot doesn't like it // FIXME: we'd prefer to use &&, but rustboot doesn't like it
if (ty.type_is_structural(ty.expr_ty(e))) { if (ty.type_is_structural(ty.expr_ty(cx.fcx.lcx.ccx.tystore,
e))) {
// Until here we've been treating structures by pointer; // Until here we've been treating structures by pointer;
// we are now passing it as an arg, so need to load it. // we are now passing it as an arg, so need to load it.
val = bcx.build.Load(val); val = bcx.build.Load(val);
@ -4723,7 +4752,7 @@ fn trans_call(@block_ctxt cx, @ast.expr f,
} }
case (_) { case (_) {
fn_ty = ty.expr_ty(f); fn_ty = ty.expr_ty(cx.fcx.lcx.ccx.tystore, f);
} }
@ -4776,7 +4805,7 @@ fn trans_tup(@block_ctxt cx, vec[ast.elt] elts,
let int i = 0; let int i = 0;
for (ast.elt e in elts) { for (ast.elt e in elts) {
auto e_ty = ty.expr_ty(e.expr); auto e_ty = ty.expr_ty(cx.fcx.lcx.ccx.tystore, e.expr);
auto src_res = trans_expr(bcx, e.expr); auto src_res = trans_expr(bcx, e.expr);
bcx = src_res.bcx; bcx = src_res.bcx;
auto dst_res = GEP_tup_like(bcx, t, tup_val, vec(0, i)); auto dst_res = GEP_tup_like(bcx, t, tup_val, vec(0, i));
@ -4819,7 +4848,8 @@ fn trans_vec(@block_ctxt cx, vec[@ast.expr] args,
C_int(abi.vec_elt_data))); C_int(abi.vec_elt_data)));
auto pseudo_tup_ty = auto pseudo_tup_ty =
ty.mk_imm_tup(_vec.init_elt[@ty.t](unit_ty, ty.mk_imm_tup(cx.fcx.lcx.ccx.tystore,
_vec.init_elt[@ty.t](unit_ty,
_vec.len[@ast.expr](args))); _vec.len[@ast.expr](args)));
let int i = 0; let int i = 0;
@ -5076,7 +5106,7 @@ fn trans_expr(@block_ctxt cx, @ast.expr e) -> result {
// lval cases fall through to trans_lval and then // lval cases fall through to trans_lval and then
// possibly load the result (if it's non-structural). // possibly load the result (if it's non-structural).
auto t = ty.expr_ty(e); auto t = ty.expr_ty(cx.fcx.lcx.ccx.tystore, e);
auto sub = trans_lval(cx, e); auto sub = trans_lval(cx, e);
ret res(sub.res.bcx, load_if_immediate(sub.res.bcx, sub.res.val, t)); ret res(sub.res.bcx, load_if_immediate(sub.res.bcx, sub.res.val, t));
} }
@ -5135,7 +5165,7 @@ fn trans_log(int lvl, @block_ctxt cx, @ast.expr e) -> result {
cx.build.CondBr(test, log_cx.llbb, after_cx.llbb); cx.build.CondBr(test, log_cx.llbb, after_cx.llbb);
auto sub = trans_expr(log_cx, e); auto sub = trans_expr(log_cx, e);
auto e_ty = ty.expr_ty(e); auto e_ty = ty.expr_ty(cx.fcx.lcx.ccx.tystore, e);
if (ty.type_is_fp(e_ty)) { if (ty.type_is_fp(e_ty)) {
let TypeRef tr; let TypeRef tr;
@ -5251,7 +5281,8 @@ fn trans_put(@block_ctxt cx, &option.t[@ast.expr] e) -> result {
auto llarg = r.val; auto llarg = r.val;
bcx = r.bcx; bcx = r.bcx;
if (ty.type_is_structural(ty.expr_ty(x))) { if (ty.type_is_structural(ty.expr_ty(cx.fcx.lcx.ccx.tystore,
x))) {
// Until here we've been treating structures by pointer; we // Until here we've been treating structures by pointer; we
// are now passing it as an arg, so need to load it. // are now passing it as an arg, so need to load it.
llarg = bcx.build.Load(llarg); llarg = bcx.build.Load(llarg);
@ -5311,7 +5342,7 @@ fn trans_ret(@block_ctxt cx, &option.t[@ast.expr] e) -> result {
alt (e) { alt (e) {
case (some[@ast.expr](?x)) { case (some[@ast.expr](?x)) {
auto t = ty.expr_ty(x); auto t = ty.expr_ty(cx.fcx.lcx.ccx.tystore, x);
auto r = trans_expr(cx, x); auto r = trans_expr(cx, x);
bcx = r.bcx; bcx = r.bcx;
val = r.val; val = r.val;
@ -5686,7 +5717,7 @@ fn trans_block(@block_ctxt cx, &ast.block b) -> result {
if (is_terminated(bcx)) { if (is_terminated(bcx)) {
ret r; ret r;
} else { } else {
auto r_ty = ty.expr_ty(e); auto r_ty = ty.expr_ty(cx.fcx.lcx.ccx.tystore, e);
if (!ty.type_is_nil(r_ty)) { if (!ty.type_is_nil(r_ty)) {
// The value resulting from the block gets copied into an // The value resulting from the block gets copied into an
// alloca created in an outer scope and its refcount // alloca created in an outer scope and its refcount
@ -5917,7 +5948,7 @@ fn populate_fn_ctxt_from_llself(@fn_ctxt fcx, self_vt llself) {
// Synthesize a tuple type for the fields so that GEP_tup_like() can work // Synthesize a tuple type for the fields so that GEP_tup_like() can work
// its magic. // its magic.
auto fields_tup_ty = ty.mk_imm_tup(field_tys); auto fields_tup_ty = ty.mk_imm_tup(fcx.lcx.ccx.tystore, field_tys);
auto n_typarams = _vec.len[ast.ty_param](bcx.fcx.lcx.obj_typarams); auto n_typarams = _vec.len[ast.ty_param](bcx.fcx.lcx.obj_typarams);
let TypeRef llobj_box_ty = T_obj_ptr(bcx.fcx.lcx.ccx.tn, n_typarams); let TypeRef llobj_box_ty = T_obj_ptr(bcx.fcx.lcx.ccx.tn, n_typarams);
@ -6142,18 +6173,19 @@ fn trans_obj(@local_ctxt cx, &ast._obj ob, ast.def_id oid,
} }
// Synthesize an obj body type. // Synthesize an obj body type.
auto tydesc_ty = ty.mk_type(); auto tydesc_ty = ty.mk_type(cx.ccx.tystore);
let vec[@ty.t] tps = vec(); let vec[@ty.t] tps = vec();
for (ast.ty_param tp in ty_params) { for (ast.ty_param tp in ty_params) {
_vec.push[@ty.t](tps, tydesc_ty); _vec.push[@ty.t](tps, tydesc_ty);
} }
let @ty.t typarams_ty = ty.mk_imm_tup(tps); let @ty.t typarams_ty = ty.mk_imm_tup(cx.ccx.tystore, tps);
let @ty.t fields_ty = ty.mk_imm_tup(obj_fields); let @ty.t fields_ty = ty.mk_imm_tup(cx.ccx.tystore, obj_fields);
let @ty.t body_ty = ty.mk_imm_tup(vec(tydesc_ty, let @ty.t body_ty = ty.mk_imm_tup(cx.ccx.tystore,
vec(tydesc_ty,
typarams_ty, typarams_ty,
fields_ty)); fields_ty));
let @ty.t boxed_body_ty = ty.mk_imm_box(body_ty); let @ty.t boxed_body_ty = ty.mk_imm_box(cx.ccx.tystore, body_ty);
// Malloc a box for the body. // Malloc a box for the body.
auto box = trans_malloc_boxed(bcx, body_ty); auto box = trans_malloc_boxed(bcx, body_ty);
@ -6255,7 +6287,7 @@ fn trans_tag_variant(@local_ctxt cx, ast.def_id tag_id,
let vec[@ty.t] ty_param_substs = vec(); let vec[@ty.t] ty_param_substs = vec();
i = 0u; i = 0u;
for (ast.ty_param tp in ty_params) { for (ast.ty_param tp in ty_params) {
ty_param_substs += vec(ty.mk_param(i)); ty_param_substs += vec(ty.mk_param(cx.ccx.tystore, i));
i += 1u; i += 1u;
} }
@ -7450,7 +7482,7 @@ fn create_crate_map(@crate_ctxt ccx) -> ValueRef {
ret map; ret map;
} }
fn trans_crate(session.session sess, @ast.crate crate, fn trans_crate(session.session sess, @ast.crate crate, @ty.type_store tystore,
&ty.type_cache type_cache, str output, bool shared, &ty.type_cache type_cache, str output, bool shared,
bool optimize, bool verify, output_type ot) { bool optimize, bool verify, output_type ot) {
auto llmod = auto llmod =
@ -7496,7 +7528,8 @@ fn trans_crate(session.session sess, @ast.crate crate,
lltypes = lltypes, lltypes = lltypes,
glues = glues, glues = glues,
names = namegen(0), names = namegen(0),
sha = std.sha1.mk_sha1()); sha = std.sha1.mk_sha1(),
tystore = tystore);
auto cx = new_local_ctxt(ccx); auto cx = new_local_ctxt(ccx);
create_typedefs(ccx); create_typedefs(ccx);

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

@ -31,8 +31,8 @@ type mt = rec(@t ty, ast.mutability mut);
// Convert from method type to function type. Pretty easy; we just drop // Convert from method type to function type. Pretty easy; we just drop
// 'ident'. // 'ident'.
fn method_ty_to_fn_ty(method m) -> @ty.t { fn method_ty_to_fn_ty(@type_store tystore, method m) -> @ty.t {
ret mk_fn(m.proto, m.inputs, m.output); ret mk_fn(tystore, m.proto, m.inputs, m.output);
} }
// Do not construct these manually. Soon we want to intern these, at which // Do not construct these manually. Soon we want to intern these, at which
@ -100,62 +100,99 @@ type ty_param_count_and_ty = tup(uint, @t);
type type_cache = hashmap[ast.def_id,ty_param_count_and_ty]; type type_cache = hashmap[ast.def_id,ty_param_count_and_ty];
type type_store = hashmap[@t,()];
fn mk_type_store() -> @hashmap[@t,()] {
auto hasher = hash_ty;
auto eqer = eq_ty;
ret @map.mk_hashmap[@t,()](hasher, eqer);
}
// Type constructors // Type constructors
// This is a private constructor to this module. External users should always // This is a private constructor to this module. External users should always
// use the mk_foo() functions below. // use the mk_foo() functions below.
fn gen_ty(&sty st) -> @t { fn gen_ty(@type_store tystore, &sty st) -> @t {
// TODO: Intern the type.
ret @rec(struct=st, cname=none[str], hash=hash_type_structure(st)); ret @rec(struct=st, cname=none[str], hash=hash_type_structure(st));
} }
fn mk_nil() -> @t { ret gen_ty(ty_nil); } fn mk_nil(@type_store ts) -> @t { ret gen_ty(ts, ty_nil); }
fn mk_bool() -> @t { ret gen_ty(ty_bool); } fn mk_bool(@type_store ts) -> @t { ret gen_ty(ts, ty_bool); }
fn mk_int() -> @t { ret gen_ty(ty_int); } fn mk_int(@type_store ts) -> @t { ret gen_ty(ts, ty_int); }
fn mk_float() -> @t { ret gen_ty(ty_float); } fn mk_float(@type_store ts) -> @t { ret gen_ty(ts, ty_float); }
fn mk_uint() -> @t { ret gen_ty(ty_uint); } fn mk_uint(@type_store ts) -> @t { ret gen_ty(ts, ty_uint); }
fn mk_mach(util.common.ty_mach tm) -> @t { ret gen_ty(ty_machine(tm)); }
fn mk_char() -> @t { ret gen_ty(ty_char); }
fn mk_str() -> @t { ret gen_ty(ty_str); }
fn mk_tag(ast.def_id did, vec[@t] tys) -> @t { fn mk_mach(@type_store ts, util.common.ty_mach tm) -> @t {
ret gen_ty(ty_tag(did, tys)); ret gen_ty(ts, ty_machine(tm));
} }
fn mk_box(mt tm) -> @t { ret gen_ty(ty_box(tm)); } fn mk_char(@type_store ts) -> @t { ret gen_ty(ts, ty_char); }
fn mk_imm_box(@t ty) -> @t { ret mk_box(rec(ty=ty, mut=ast.imm)); } fn mk_str(@type_store ts) -> @t { ret gen_ty(ts, ty_str); }
fn mk_vec(mt tm) -> @t { ret gen_ty(ty_vec(tm)); } fn mk_tag(@type_store ts, ast.def_id did, vec[@t] tys) -> @t {
fn mk_port(@t ty) -> @t { ret gen_ty(ty_port(ty)); } ret gen_ty(ts, ty_tag(did, tys));
fn mk_chan(@t ty) -> @t { ret gen_ty(ty_chan(ty)); } }
fn mk_task() -> @t { ret gen_ty(ty_task); }
fn mk_tup(vec[mt] tms) -> @t { ret gen_ty(ty_tup(tms)); } fn mk_box(@type_store ts, mt tm) -> @t {
fn mk_imm_tup(vec[@t] tys) -> @t { ret gen_ty(ts, ty_box(tm));
}
fn mk_imm_box(@type_store ts, @t ty) -> @t {
ret mk_box(ts, rec(ty=ty, mut=ast.imm));
}
fn mk_vec(@type_store ts, mt tm) -> @t { ret gen_ty(ts, ty_vec(tm)); }
fn mk_port(@type_store ts, @t ty) -> @t { ret gen_ty(ts, ty_port(ty)); }
fn mk_chan(@type_store ts, @t ty) -> @t { ret gen_ty(ts, ty_chan(ty)); }
fn mk_task(@type_store ts) -> @t { ret gen_ty(ts, ty_task); }
fn mk_tup(@type_store ts, vec[mt] tms) -> @t {
ret gen_ty(ts, ty_tup(tms));
}
fn mk_imm_tup(@type_store ts, vec[@t] tys) -> @t {
// TODO: map // TODO: map
let vec[ty.mt] mts = vec(); let vec[ty.mt] mts = vec();
for (@ty.t typ in tys) { for (@ty.t typ in tys) {
mts += vec(rec(ty=typ, mut=ast.imm)); mts += vec(rec(ty=typ, mut=ast.imm));
} }
ret mk_tup(mts); ret mk_tup(ts, mts);
} }
fn mk_rec(vec[field] fs) -> @t { ret gen_ty(ty_rec(fs)); } fn mk_rec(@type_store ts, vec[field] fs) -> @t {
ret gen_ty(ts, ty_rec(fs));
fn mk_fn(ast.proto proto, vec[arg] args, @t ty) -> @t {
ret gen_ty(ty_fn(proto, args, ty));
} }
fn mk_native_fn(ast.native_abi abi, vec[arg] args, @t ty) -> @t { fn mk_fn(@type_store ts, ast.proto proto, vec[arg] args, @t ty) -> @t {
ret gen_ty(ty_native_fn(abi, args, ty)); ret gen_ty(ts, ty_fn(proto, args, ty));
} }
fn mk_obj(vec[method] meths) -> @t { ret gen_ty(ty_obj(meths)); } fn mk_native_fn(@type_store ts, ast.native_abi abi, vec[arg] args, @t ty)
fn mk_var(int v) -> @t { ret gen_ty(ty_var(v)); } -> @t {
fn mk_local(ast.def_id did) -> @t { ret gen_ty(ty_local(did)); } ret gen_ty(ts, ty_native_fn(abi, args, ty));
fn mk_param(uint n) -> @t { ret gen_ty(ty_param(n)); } }
fn mk_bound_param(uint n) -> @t { ret gen_ty(ty_bound_param(n)); }
fn mk_type() -> @t { ret gen_ty(ty_type); } fn mk_obj(@type_store ts, vec[method] meths) -> @t {
fn mk_native() -> @t { ret gen_ty(ty_native); } ret gen_ty(ts, ty_obj(meths));
}
fn mk_var(@type_store ts, int v) -> @t { ret gen_ty(ts, ty_var(v)); }
fn mk_local(@type_store ts, ast.def_id did) -> @t {
ret gen_ty(ts, ty_local(did));
}
fn mk_param(@type_store ts, uint n) -> @t {
ret gen_ty(ts, ty_param(n));
}
fn mk_bound_param(@type_store ts, uint n) -> @t {
ret gen_ty(ts, ty_bound_param(n));
}
fn mk_type(@type_store ts) -> @t { ret gen_ty(ts, ty_type); }
fn mk_native(@type_store ts) -> @t { ret gen_ty(ts, ty_native); }
// Stringification // Stringification
@ -386,7 +423,7 @@ fn walk_ty(ty_walk walker, @t ty) {
type ty_fold = fn(@t) -> @t; type ty_fold = fn(@t) -> @t;
fn fold_ty(ty_fold fld, @t ty_0) -> @t { fn fold_ty(@type_store tystore, ty_fold fld, @t ty_0) -> @t {
auto ty = ty_0; auto ty = ty_0;
alt (ty.struct) { alt (ty.struct) {
case (ty_nil) { /* no-op */ } case (ty_nil) { /* no-op */ }
@ -400,58 +437,65 @@ fn fold_ty(ty_fold fld, @t ty_0) -> @t {
case (ty_type) { /* no-op */ } case (ty_type) { /* no-op */ }
case (ty_native) { /* no-op */ } case (ty_native) { /* no-op */ }
case (ty_box(?tm)) { case (ty_box(?tm)) {
ty = copy_cname(mk_box(rec(ty=fold_ty(fld, tm.ty), mut=tm.mut)), ty = copy_cname(mk_box(tystore,
ty); rec(ty=fold_ty(tystore, fld, tm.ty),
mut=tm.mut)), ty);
} }
case (ty_vec(?tm)) { case (ty_vec(?tm)) {
ty = copy_cname(mk_vec(rec(ty=fold_ty(fld, tm.ty), mut=tm.mut)), ty = copy_cname(mk_vec(tystore,
ty); rec(ty=fold_ty(tystore, fld, tm.ty),
mut=tm.mut)), ty);
} }
case (ty_port(?subty)) { case (ty_port(?subty)) {
ty = copy_cname(mk_port(fold_ty(fld, subty)), ty); ty = copy_cname(mk_port(tystore, fold_ty(tystore, fld, subty)),
ty);
} }
case (ty_chan(?subty)) { case (ty_chan(?subty)) {
ty = copy_cname(mk_chan(fold_ty(fld, subty)), ty); ty = copy_cname(mk_chan(tystore, fold_ty(tystore, fld, subty)),
ty);
} }
case (ty_tag(?tid, ?subtys)) { case (ty_tag(?tid, ?subtys)) {
let vec[@t] new_subtys = vec(); let vec[@t] new_subtys = vec();
for (@t subty in subtys) { for (@t subty in subtys) {
new_subtys += vec(fold_ty(fld, subty)); new_subtys += vec(fold_ty(tystore, fld, subty));
} }
ty = copy_cname(mk_tag(tid, new_subtys), ty); ty = copy_cname(mk_tag(tystore, tid, new_subtys), ty);
} }
case (ty_tup(?mts)) { case (ty_tup(?mts)) {
let vec[mt] new_mts = vec(); let vec[mt] new_mts = vec();
for (mt tm in mts) { for (mt tm in mts) {
auto new_subty = fold_ty(fld, tm.ty); auto new_subty = fold_ty(tystore, fld, tm.ty);
new_mts += vec(rec(ty=new_subty, mut=tm.mut)); new_mts += vec(rec(ty=new_subty, mut=tm.mut));
} }
ty = copy_cname(mk_tup(new_mts), ty); ty = copy_cname(mk_tup(tystore, new_mts), ty);
} }
case (ty_rec(?fields)) { case (ty_rec(?fields)) {
let vec[field] new_fields = vec(); let vec[field] new_fields = vec();
for (field fl in fields) { for (field fl in fields) {
auto new_ty = fold_ty(fld, fl.mt.ty); auto new_ty = fold_ty(tystore, fld, fl.mt.ty);
auto new_mt = rec(ty=new_ty, mut=fl.mt.mut); auto new_mt = rec(ty=new_ty, mut=fl.mt.mut);
new_fields += vec(rec(ident=fl.ident, mt=new_mt)); new_fields += vec(rec(ident=fl.ident, mt=new_mt));
} }
ty = copy_cname(mk_rec(new_fields), ty); ty = copy_cname(mk_rec(tystore, new_fields), ty);
} }
case (ty_fn(?proto, ?args, ?ret_ty)) { case (ty_fn(?proto, ?args, ?ret_ty)) {
let vec[arg] new_args = vec(); let vec[arg] new_args = vec();
for (arg a in args) { for (arg a in args) {
auto new_ty = fold_ty(fld, a.ty); auto new_ty = fold_ty(tystore, fld, a.ty);
new_args += vec(rec(mode=a.mode, ty=new_ty)); new_args += vec(rec(mode=a.mode, ty=new_ty));
} }
ty = copy_cname(mk_fn(proto, new_args, fold_ty(fld, ret_ty)), ty); ty = copy_cname(mk_fn(tystore, proto, new_args,
fold_ty(tystore, fld, ret_ty)),
ty);
} }
case (ty_native_fn(?abi, ?args, ?ret_ty)) { case (ty_native_fn(?abi, ?args, ?ret_ty)) {
let vec[arg] new_args = vec(); let vec[arg] new_args = vec();
for (arg a in args) { for (arg a in args) {
auto new_ty = fold_ty(fld, a.ty); auto new_ty = fold_ty(tystore, fld, a.ty);
new_args += vec(rec(mode=a.mode, ty=new_ty)); new_args += vec(rec(mode=a.mode, ty=new_ty));
} }
ty = copy_cname(mk_native_fn(abi, new_args, fold_ty(fld, ret_ty)), ty = copy_cname(mk_native_fn(tystore, abi, new_args,
fold_ty(tystore, fld, ret_ty)),
ty); ty);
} }
case (ty_obj(?methods)) { case (ty_obj(?methods)) {
@ -459,13 +503,15 @@ fn fold_ty(ty_fold fld, @t ty_0) -> @t {
for (method m in methods) { for (method m in methods) {
let vec[arg] new_args = vec(); let vec[arg] new_args = vec();
for (arg a in m.inputs) { for (arg a in m.inputs) {
new_args += vec(rec(mode=a.mode, ty=fold_ty(fld, a.ty))); new_args += vec(rec(mode=a.mode,
ty=fold_ty(tystore, fld, a.ty)));
} }
new_methods += vec(rec(proto=m.proto, ident=m.ident, new_methods += vec(rec(proto=m.proto, ident=m.ident,
inputs=new_args, inputs=new_args,
output=fold_ty(fld, m.output))); output=fold_ty(tystore, fld,
m.output)));
} }
ty = copy_cname(mk_obj(new_methods), ty); ty = copy_cname(mk_obj(tystore, new_methods), ty);
} }
case (ty_var(_)) { /* no-op */ } case (ty_var(_)) { /* no-op */ }
case (ty_local(_)) { /* no-op */ } case (ty_local(_)) { /* no-op */ }
@ -536,9 +582,9 @@ fn type_is_sequence(@t ty) -> bool {
fail; fail;
} }
fn sequence_element_type(@t ty) -> @t { fn sequence_element_type(@type_store tystore, @t ty) -> @t {
alt (ty.struct) { alt (ty.struct) {
case (ty_str) { ret mk_mach(common.ty_u8); } case (ty_str) { ret mk_mach(tystore, common.ty_u8); }
case (ty_vec(?mt)) { ret mt.ty; } case (ty_vec(?mt)) { ret mt.ty; }
} }
fail; fail;
@ -1158,7 +1204,7 @@ fn ann_to_type_params(&ast.ann ann) -> vec[@t] {
// Returns the type of an annotation, with type parameter substitutions // Returns the type of an annotation, with type parameter substitutions
// performed if applicable. // performed if applicable.
fn ann_to_monotype(ast.ann a) -> @ty.t { fn ann_to_monotype(@type_store tystore, ast.ann a) -> @ty.t {
// TODO: Refactor to use recursive pattern matching when we're more // TODO: Refactor to use recursive pattern matching when we're more
// confident that it works. // confident that it works.
alt (a) { alt (a) {
@ -1170,7 +1216,7 @@ fn ann_to_monotype(ast.ann a) -> @ty.t {
alt (tps_opt) { alt (tps_opt) {
case (none[vec[@ty.t]]) { ret typ; } case (none[vec[@ty.t]]) { ret typ; }
case (some[vec[@ty.t]](?tps)) { case (some[vec[@ty.t]](?tps)) {
ret substitute_type_params(tps, typ); ret substitute_type_params(tystore, tps, typ);
} }
} }
} }
@ -1312,32 +1358,32 @@ fn item_ty(@ast.item it) -> ty_param_count_and_ty {
ret tup(ty_param_count, result_ty); ret tup(ty_param_count, result_ty);
} }
fn stmt_ty(@ast.stmt s) -> @t { fn stmt_ty(@type_store tystore, @ast.stmt s) -> @t {
alt (s.node) { alt (s.node) {
case (ast.stmt_expr(?e,_)) { case (ast.stmt_expr(?e,_)) {
ret expr_ty(e); ret expr_ty(tystore, e);
} }
case (_) { case (_) {
ret mk_nil(); ret mk_nil(tystore);
} }
} }
} }
fn block_ty(&ast.block b) -> @t { fn block_ty(@type_store tystore, &ast.block b) -> @t {
alt (b.node.expr) { alt (b.node.expr) {
case (some[@ast.expr](?e)) { ret expr_ty(e); } case (some[@ast.expr](?e)) { ret expr_ty(tystore, e); }
case (none[@ast.expr]) { ret mk_nil(); } case (none[@ast.expr]) { ret mk_nil(tystore); }
} }
} }
// 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.
fn pat_ty(@ast.pat pat) -> @t { fn pat_ty(@type_store ts, @ast.pat pat) -> @t {
alt (pat.node) { alt (pat.node) {
case (ast.pat_wild(?ann)) { ret ann_to_monotype(ann); } case (ast.pat_wild(?ann)) { ret ann_to_monotype(ts, ann); }
case (ast.pat_lit(_, ?ann)) { ret ann_to_monotype(ann); } case (ast.pat_lit(_, ?ann)) { ret ann_to_monotype(ts, ann); }
case (ast.pat_bind(_, _, ?ann)) { ret ann_to_monotype(ann); } case (ast.pat_bind(_, _, ?ann)) { ret ann_to_monotype(ts, ann); }
case (ast.pat_tag(_, _, _, ?ann)) { ret ann_to_monotype(ann); } case (ast.pat_tag(_, _, _, ?ann)) { ret ann_to_monotype(ts, ann); }
} }
fail; // not reached fail; // not reached
} }
@ -1394,18 +1440,19 @@ fn expr_ann(@ast.expr expr) -> option.t[ast.ann] {
// 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.
fn expr_ty(@ast.expr expr) -> @t { fn expr_ty(@type_store tystore, @ast.expr expr) -> @t {
alt (expr_ann(expr)) { alt (expr_ann(expr)) {
case (none[ast.ann]) { ret mk_nil(); } case (none[ast.ann]) { ret mk_nil(tystore); }
case (some[ast.ann](?a)) { ret ann_to_monotype(a); } case (some[ast.ann](?a)) { ret ann_to_monotype(tystore, a); }
} }
} }
fn expr_ty_params_and_ty(@ast.expr expr) -> tup(vec[@t], @t) { fn expr_ty_params_and_ty(@type_store tystore, @ast.expr expr)
-> tup(vec[@t], @t) {
alt (expr_ann(expr)) { alt (expr_ann(expr)) {
case (none[ast.ann]) { case (none[ast.ann]) {
let vec[@t] tps = vec(); let vec[@t] tps = vec();
ret tup(tps, mk_nil()); ret tup(tps, mk_nil(tystore));
} }
case (some[ast.ann](?a)) { case (some[ast.ann](?a)) {
ret tup(ann_to_type_params(a), ann_to_type(a)); ret tup(ann_to_type_params(a), ann_to_type(a));
@ -1555,7 +1602,8 @@ mod Unify {
type ctxt = rec(UFind.ufind sets, type ctxt = rec(UFind.ufind sets,
hashmap[int,uint] var_ids, hashmap[int,uint] var_ids,
mutable vec[mutable vec[@t]] types, mutable vec[mutable vec[@t]] types,
unify_handler handler); unify_handler handler,
@type_store tystore);
// Wraps the given type in an appropriate cname. // Wraps the given type in an appropriate cname.
// //
@ -1670,7 +1718,7 @@ mod Unify {
ret r; ret r;
} }
case (fn_common_res_ok(?result_ins, ?result_out)) { case (fn_common_res_ok(?result_ins, ?result_out)) {
auto t2 = mk_fn(e_proto, result_ins, result_out); auto t2 = mk_fn(cx.tystore, e_proto, result_ins, result_out);
ret ures_ok(t2); ret ures_ok(t2);
} }
} }
@ -1696,7 +1744,8 @@ mod Unify {
ret r; ret r;
} }
case (fn_common_res_ok(?result_ins, ?result_out)) { case (fn_common_res_ok(?result_ins, ?result_out)) {
auto t2 = mk_native_fn(e_abi, result_ins, result_out); auto t2 = mk_native_fn(cx.tystore, e_abi, result_ins,
result_out);
ret ures_ok(t2); ret ures_ok(t2);
} }
} }
@ -1744,7 +1793,7 @@ mod Unify {
} }
i += 1u; i += 1u;
} }
auto t = mk_obj(result_meths); auto t = mk_obj(cx.tystore, result_meths);
ret ures_ok(t); ret ures_ok(t);
} }
@ -1868,7 +1917,8 @@ mod Unify {
i += 1u; i += 1u;
} }
ret ures_ok(mk_tag(expected_id, result_tps)); ret ures_ok(mk_tag(cx.tystore, expected_id,
result_tps));
} }
case (_) { /* fall through */ } case (_) { /* fall through */ }
} }
@ -1894,7 +1944,7 @@ mod Unify {
alt (result) { alt (result) {
case (ures_ok(?result_sub)) { case (ures_ok(?result_sub)) {
auto mt = rec(ty=result_sub, mut=mut); auto mt = rec(ty=result_sub, mut=mut);
ret ures_ok(mk_box(mt)); ret ures_ok(mk_box(cx.tystore, mt));
} }
case (_) { case (_) {
ret result; ret result;
@ -1926,7 +1976,7 @@ mod Unify {
alt (result) { alt (result) {
case (ures_ok(?result_sub)) { case (ures_ok(?result_sub)) {
auto mt = rec(ty=result_sub, mut=mut); auto mt = rec(ty=result_sub, mut=mut);
ret ures_ok(mk_vec(mt)); ret ures_ok(mk_vec(cx.tystore, mt));
} }
case (_) { case (_) {
ret result; ret result;
@ -1948,7 +1998,7 @@ mod Unify {
actual_sub); actual_sub);
alt (result) { alt (result) {
case (ures_ok(?result_sub)) { case (ures_ok(?result_sub)) {
ret ures_ok(mk_port(result_sub)); ret ures_ok(mk_port(cx.tystore, result_sub));
} }
case (_) { case (_) {
ret result; ret result;
@ -1970,7 +2020,7 @@ mod Unify {
actual_sub); actual_sub);
alt (result) { alt (result) {
case (ures_ok(?result_sub)) { case (ures_ok(?result_sub)) {
ret ures_ok(mk_chan(result_sub)); ret ures_ok(mk_chan(cx.tystore, result_sub));
} }
case (_) { case (_) {
ret result; ret result;
@ -2029,7 +2079,7 @@ mod Unify {
i += 1u; i += 1u;
} }
ret ures_ok(mk_tup(result_elems)); ret ures_ok(mk_tup(cx.tystore, result_elems));
} }
case (_) { case (_) {
@ -2093,7 +2143,7 @@ mod Unify {
i += 1u; i += 1u;
} }
ret ures_ok(mk_rec(result_fields)); ret ures_ok(mk_rec(cx.tystore, result_fields));
} }
case (_) { case (_) {
@ -2202,7 +2252,7 @@ mod Unify {
} }
auto f = bind substituter(cx, set_types, _); auto f = bind substituter(cx, set_types, _);
ret fold_ty(f, typ); ret fold_ty(cx.tystore, f, typ);
} }
fn unify_sets(@ctxt cx) -> vec[@t] { fn unify_sets(@ctxt cx) -> vec[@t] {
@ -2235,8 +2285,10 @@ mod Unify {
ret result; ret result;
} }
fn unify(@ty.t expected, @ty.t actual, &unify_handler handler) fn unify(@ty.t expected,
-> result { @ty.t actual,
&unify_handler handler,
@type_store tystore) -> result {
let vec[@t] throwaway = vec(); let vec[@t] throwaway = vec();
let vec[mutable vec[@t]] types = vec(mutable throwaway); let vec[mutable vec[@t]] types = vec(mutable throwaway);
_vec.pop[mutable vec[@t]](types); // FIXME: botch _vec.pop[mutable vec[@t]](types); // FIXME: botch
@ -2244,7 +2296,8 @@ mod Unify {
auto cx = @rec(sets=UFind.make(), auto cx = @rec(sets=UFind.make(),
var_ids=common.new_int_hash[uint](), var_ids=common.new_int_hash[uint](),
mutable types=types, mutable types=types,
handler=handler); handler=handler,
tystore=tystore);
auto ures = unify_step(cx, expected, actual); auto ures = unify_step(cx, expected, actual);
alt (ures) { alt (ures) {
@ -2307,7 +2360,9 @@ fn type_err_to_str(&ty.type_err err) -> str {
// Performs bound type parameter replacement using the supplied mapping from // Performs bound type parameter replacement using the supplied mapping from
// parameter IDs to types. // parameter IDs to types.
fn substitute_type_params(vec[@t] bindings, @t typ) -> @t { fn substitute_type_params(@type_store tystore,
vec[@t] bindings,
@t typ) -> @t {
fn replacer(vec[@t] bindings, @t typ) -> @t { fn replacer(vec[@t] bindings, @t typ) -> @t {
alt (typ.struct) { alt (typ.struct) {
case (ty_bound_param(?param_index)) { case (ty_bound_param(?param_index)) {
@ -2318,25 +2373,25 @@ fn substitute_type_params(vec[@t] bindings, @t typ) -> @t {
} }
auto f = bind replacer(bindings, _); auto f = bind replacer(bindings, _);
ret fold_ty(f, typ); ret fold_ty(tystore, f, typ);
} }
// Converts type parameters in a type to bound type parameters. // Converts type parameters in a type to bound type parameters.
fn bind_params_in_type(@t typ) -> @t { fn bind_params_in_type(@type_store tystore, @t typ) -> @t {
fn binder(@t typ) -> @t { fn binder(@type_store tystore, @t typ) -> @t {
alt (typ.struct) { alt (typ.struct) {
case (ty_bound_param(?index)) { case (ty_bound_param(?index)) {
log_err "bind_params_in_type() called on type that already " + log_err "bind_params_in_type() called on type that already " +
"has bound params in it"; "has bound params in it";
fail; fail;
} }
case (ty_param(?index)) { ret mk_bound_param(index); } case (ty_param(?index)) { ret mk_bound_param(tystore, index); }
case (_) { ret typ; } case (_) { ret typ; }
} }
} }
auto f = binder; auto f = bind binder(tystore, _);
ret fold_ty(f, typ); ret fold_ty(tystore, f, typ);
} }
@ -2361,7 +2416,9 @@ fn def_has_ty_params(&ast.def def) -> bool {
// If the given item is in an external crate, looks up its type and adds it to // If the given item is in an external crate, looks up its type and adds it to
// the type cache. Returns the type parameters and type. // the type cache. Returns the type parameters and type.
fn lookup_item_type(session.session sess, &type_cache cache, fn lookup_item_type(session.session sess,
@type_store tystore,
&type_cache cache,
ast.def_id did) -> ty_param_count_and_ty { ast.def_id did) -> ty_param_count_and_ty {
if (did._0 == sess.get_targ_crate_num()) { if (did._0 == sess.get_targ_crate_num()) {
// The item is in this crate. The caller should have added it to the // The item is in this crate. The caller should have added it to the
@ -2374,7 +2431,7 @@ fn lookup_item_type(session.session sess, &type_cache cache,
ret cache.get(did); ret cache.get(did);
} }
auto tyt = creader.get_type(sess, did); auto tyt = creader.get_type(sess, tystore, did);
cache.insert(did, tyt); cache.insert(did, tyt);
ret tyt; ret tyt;
} }

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

File diff suppressed because it is too large Load Diff

4
src/comp/util/common.rs
View File

@ -110,8 +110,8 @@ fn field_exprs(vec[ast.field] fields) -> vec [@ast.expr] {
ret _vec.map[ast.field, @ast.expr](f, fields); ret _vec.map[ast.field, @ast.expr](f, fields);
} }
fn plain_ann() -> ast.ann { fn plain_ann(@middle.ty.type_store tystore) -> ast.ann {
ret ast.ann_type(middle.ty.mk_nil(), ret ast.ann_type(middle.ty.mk_nil(tystore),
none[vec[@middle.ty.t]], none[@ts_ann]); none[vec[@middle.ty.t]], none[@ts_ann]);
} }