mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rustc: Use interior vectors for record types

Browse Source
This commit is contained in:
Patrick Walton 2011-06-30 12:02:26 -07:00
parent fd0d1cb7d8
commit add9031dd5
5 changed files with 24 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -198,14 +198,14 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
}
case ('R') {
assert (next(st) as char == '[');
let vec[ty::field] fields = [];
let ty::field[] fields = ~[];
while (peek(st) as char != ']') {
auto name = "";
while (peek(st) as char != '=') {
name += str::unsafe_from_byte(next(st));
}
st.pos = st.pos + 1u;
fields += [rec(ident=name, mt=parse_mt(st, sd))];
fields += ~[rec(ident=name, mt=parse_mt(st, sd))];
}
st.pos = st.pos + 1u;
ret ty::mk_rec(st.tcx, fields);

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

@ -5901,7 +5901,7 @@ fn trans_rec(&@block_ctxt cx, &vec[ast::field] fields,
base_val = base_res.val;
}
}
let vec[ty::field] ty_fields = [];
let ty::field[] ty_fields = ~[];
alt (ty::struct(cx.fcx.lcx.ccx.tcx, t)) {
case (ty::ty_rec(?flds)) { ty_fields = flds; }
}

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

@ -265,7 +265,7 @@ tag sty {
ty_chan(t);
ty_task;
ty_tup(mt[]);
ty_rec(vec[field]);
ty_rec(field[]);
ty_fn(ast::proto, vec[arg], t, controlflow, vec[@constr_def]);
ty_native_fn(ast::native_abi, vec[arg], t);
ty_obj(vec[method]);
@ -595,7 +595,7 @@ fn mk_imm_tup(&ctxt cx, &t[] tys) -> t {
ret mk_tup(cx, mts);
}
fn mk_rec(&ctxt cx, &vec[field] fs) -> t { ret gen_ty(cx, ty_rec(fs)); }
fn mk_rec(&ctxt cx, &field[] fs) -> t { ret gen_ty(cx, ty_rec(fs)); }
fn mk_fn(&ctxt cx, &ast::proto proto, &vec[arg] args, &t ty, &controlflow cf,
&vec[@constr_def] constrs) -> t {
@ -784,11 +784,11 @@ fn fold_ty(&ctxt cx, fold_mode fld, t ty_0) -> t {
ty = copy_cname(cx, mk_tup(cx, new_mts), ty);
}
case (ty_rec(?fields)) {
let vec[field] new_fields = [];
let field[] new_fields = ~[];
for (field fl in fields) {
auto new_ty = fold_ty(cx, fld, fl.mt.ty);
auto new_mt = rec(ty=new_ty, mut=fl.mt.mut);
new_fields += [rec(ident=fl.ident, mt=new_mt)];
new_fields += ~[rec(ident=fl.ident, mt=new_mt)];
}
ty = copy_cname(cx, mk_rec(cx, new_fields), ty);
}
@ -1124,7 +1124,7 @@ fn type_has_dynamic_size(&ctxt cx, &t ty) -> bool {
}
case (ty_rec(?fields)) {
auto i = 0u;
while (i < vec::len[field](fields)) {
while (i < ivec::len[field](fields)) {
if (type_has_dynamic_size(cx, fields.(i).mt.ty)) { ret true; }
i += 1u;
}
@ -1576,8 +1576,8 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
case (ty_rec(?flds_a)) {
alt (b) {
case (ty_rec(?flds_b)) {
auto len = vec::len[field](flds_a);
if (len != vec::len[field](flds_b)) { ret false; }
auto len = ivec::len[field](flds_a);
if (len != ivec::len[field](flds_b)) { ret false; }
auto i = 0u;
while (i < len) {
auto fld_a = flds_a.(i);
@ -1917,7 +1917,7 @@ fn field_num(&session::session sess, &span sp, &ast::ident id) -> uint {
}
fn field_idx(&session::session sess, &span sp, &ast::ident id,
&vec[field] fields) -> uint {
&field[] fields) -> uint {
let uint i = 0u;
for (field f in fields) { if (str::eq(f.ident, id)) { ret i; } i += 1u; }
sess.span_fatal(sp, "unknown field '" + id + "' of record");
@ -2531,8 +2531,8 @@ mod unify {
case (ty::ty_rec(?expected_fields)) {
alt (struct(cx.tcx, actual)) {
case (ty::ty_rec(?actual_fields)) {
auto expected_len = vec::len[field](expected_fields);
auto actual_len = vec::len[field](actual_fields);
auto expected_len = ivec::len[field](expected_fields);
auto actual_len = ivec::len[field](actual_fields);
if (expected_len != actual_len) {
auto err =
terr_record_size(expected_len, actual_len);
@ -2541,7 +2541,7 @@ mod unify {
// TODO: implement an iterator that can iterate over
// two arrays simultaneously.
let vec[field] result_fields = [];
let field[] result_fields = ~[];
auto i = 0u;
while (i < expected_len) {
auto expected_field = expected_fields.(i);
@ -2567,10 +2567,8 @@ mod unify {
alt (result) {
case (ures_ok(?rty)) {
auto mt = rec(ty=rty, mut=mut);
vec::push[field](result_fields,
rec(mt=mt
with
expected_field));
result_fields +=
~[rec(mt=mt with expected_field)];
}
case (_) { ret result; }
}

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

@ -302,10 +302,10 @@ fn ast_ty_to_ty(&ty::ctxt tcx, &ty_getter getter, &@ast::ty ast_ty) -> ty::t {
typ = ty::mk_tup(tcx, flds);
}
case (ast::ty_rec(?fields)) {
let vec[field] flds = [];
let field[] flds = ~[];
for (ast::ty_field f in fields) {
auto tm = ast_mt_to_mt(tcx, getter, f.node.mt);
vec::push[field](flds, rec(ident=f.node.ident, mt=tm));
flds += ~[rec(ident=f.node.ident, mt=tm)];
}
typ = ty::mk_rec(tcx, flds);
}
@ -1954,13 +1954,12 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
case (none) {/* no-op */ }
case (some(?b_0)) { check_expr(fcx, b_0); }
}
let vec[field] fields_t = [];
let field[] fields_t = ~[];
for (ast::field f in fields) {
check_expr(fcx, f.node.expr);
auto expr_t = expr_ty(fcx.ccx.tcx, f.node.expr);
auto expr_mt = rec(ty=expr_t, mut=f.node.mut);
vec::push[field](fields_t,
rec(ident=f.node.ident, mt=expr_mt));
fields_t += ~[rec(ident=f.node.ident, mt=expr_mt)];
}
alt (base) {
case (none) {
@ -1970,7 +1969,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
case (some(?bexpr)) {
check_expr(fcx, bexpr);
auto bexpr_t = expr_ty(fcx.ccx.tcx, bexpr);
let vec[field] base_fields = [];
let field[] base_fields = ~[];
alt (structure_of(fcx, expr.span, bexpr_t)) {
case (ty::ty_rec(?flds)) { base_fields = flds; }
case (_) {
@ -2017,7 +2016,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
let uint ix =
ty::field_idx(fcx.ccx.tcx.sess, expr.span, field,
fields);
if (ix >= vec::len[ty::field](fields)) {
if (ix >= ivec::len[ty::field](fields)) {
fcx.ccx.tcx.sess.span_fatal(expr.span,
"bad index on record");
}

4
src/comp/pretty/ppaux.rs
View File

@ -112,8 +112,8 @@ fn ty_to_str(&ctxt cx, &t typ) -> str {
s += "tup(" + str::connect(strs, ",") + ")";
}
case (ty_rec(?elems)) {
auto f = bind field_to_str(cx, _);
auto strs = vec::map[field, str](f, elems);
let vec[str] strs = [];
for (field fld in elems) { strs += [field_to_str(cx, fld)]; }
s += "rec(" + str::connect(strs, ",") + ")";
}
case (ty_tag(?id, ?tps)) {