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

rustc: Change function argument types to interior vectors

This commit is contained in:
Patrick Walton 2011-06-30 16:10:33 -07:00
parent 50b1953f9b
commit 108cc4e0ed
7 changed files with 97 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -334,9 +334,9 @@ fn parse_hex(@pstate st) -> uint {
}
fn parse_ty_fn(@pstate st, str_def sd) ->
tup(vec[ty::arg], ty::t, ast::controlflow, vec[@ty::constr_def]) {
tup(ty::arg[], ty::t, ast::controlflow, vec[@ty::constr_def]) {
assert (next(st) as char == '[');
let vec[ty::arg] inputs = [];
let ty::arg[] inputs = ~[];
while (peek(st) as char != ']') {
auto mode = ty::mo_val;
if (peek(st) as char == '&') {
@ -347,7 +347,7 @@ fn parse_ty_fn(@pstate st, str_def sd) ->
st.pos += 1u;
}
}
inputs += [rec(mode=mode, ty=parse_ty(st, sd))];
inputs += ~[rec(mode=mode, ty=parse_ty(st, sd))];
}
st.pos += 1u; // eat the ']'
auto cs = parse_constrs(st, sd);

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

@ -199,7 +199,7 @@ fn enc_proto(&io::writer w, proto proto) {
case (proto_fn) { w.write_char('F'); }
}
}
fn enc_ty_fn(&io::writer w, &@ctxt cx, &vec[ty::arg] args, &ty::t out,
fn enc_ty_fn(&io::writer w, &@ctxt cx, &ty::arg[] args, &ty::t out,
&controlflow cf, &vec[@ty::constr_def] constrs) {
w.write_char('[');
for (ty::arg arg in args) {

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

@ -662,7 +662,7 @@ fn def_is_local(&ast::def d, bool objfields_count) -> bool {
};
}
fn fty_args(&ctx cx, ty::t fty) -> vec[ty::arg] {
fn fty_args(&ctx cx, ty::t fty) -> ty::arg[] {
ret alt (ty::struct(*cx.tcx, fty)) {
case (ty::ty_fn(_, ?args, _, _, _)) { args }
case (ty::ty_native_fn(_, ?args, _)) { args }

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

@ -472,7 +472,7 @@ fn T_glue_fn(&type_names tn) -> TypeRef {
fn T_dtor(&@crate_ctxt ccx, &span sp, TypeRef llself_ty) -> TypeRef {
ret type_of_fn_full(ccx, sp, ast::proto_fn, some[TypeRef](llself_ty),
vec::empty[ty::arg](), ty::mk_nil(ccx.tcx), 0u);
~[], ty::mk_nil(ccx.tcx), 0u);
}
fn T_cmp_glue_fn(&type_names tn) -> TypeRef {
@ -681,7 +681,7 @@ fn type_of(&@crate_ctxt cx, &span sp, &ty::t t) -> TypeRef {
ret type_of_inner(cx, sp, t);
}
fn type_of_explicit_args(&@crate_ctxt cx, &span sp, &vec[ty::arg] inputs) ->
fn type_of_explicit_args(&@crate_ctxt cx, &span sp, &ty::arg[] inputs) ->
vec[TypeRef] {
let vec[TypeRef] atys = [];
for (ty::arg arg in inputs) {
@ -710,7 +710,7 @@ fn type_of_explicit_args(&@crate_ctxt cx, &span sp, &vec[ty::arg] inputs) ->
// - new_fn_ctxt
// - trans_args
fn type_of_fn_full(&@crate_ctxt cx, &span sp, ast::proto proto,
&option::t[TypeRef] obj_self, &vec[ty::arg] inputs,
&option::t[TypeRef] obj_self, &ty::arg[] inputs,
&ty::t output, uint ty_param_count) -> TypeRef {
let vec[TypeRef] atys = [];
@ -743,7 +743,7 @@ fn type_of_fn_full(&@crate_ctxt cx, &span sp, ast::proto proto,
atys +=
[T_fn_pair(cx.tn,
type_of_fn_full(cx, sp, ast::proto_fn, none[TypeRef],
[rec(mode=ty::mo_alias(false),
~[rec(mode=ty::mo_alias(false),
ty=output)], ty::mk_nil(cx.tcx),
0u))];
}
@ -754,14 +754,14 @@ fn type_of_fn_full(&@crate_ctxt cx, &span sp, ast::proto proto,
}
fn type_of_fn(&@crate_ctxt cx, &span sp, ast::proto proto,
&vec[ty::arg] inputs, &ty::t output, uint ty_param_count) ->
&ty::arg[] inputs, &ty::t output, uint ty_param_count) ->
TypeRef {
ret type_of_fn_full(cx, sp, proto, none[TypeRef], inputs, output,
ty_param_count);
}
fn type_of_native_fn(&@crate_ctxt cx, &span sp, ast::native_abi abi,
&vec[ty::arg] inputs, &ty::t output, uint ty_param_count)
&ty::arg[] inputs, &ty::t output, uint ty_param_count)
-> TypeRef {
let vec[TypeRef] atys = [];
if (abi == ast::native_abi_rust) {
@ -2137,7 +2137,7 @@ fn trans_res_drop(@block_ctxt cx, ValueRef rs, &ast::def_id did,
} else {
auto params = decoder::get_type_param_count(ccx.tcx, did);
auto f_t = type_of_fn(ccx, cx.sp, ast::proto_fn,
[rec(mode=ty::mo_alias(false), ty=inner_t)],
~[rec(mode=ty::mo_alias(false), ty=inner_t)],
ty::mk_nil(ccx.tcx), params);
get_extern_const(ccx.externs, ccx.llmod,
decoder::get_symbol(ccx.sess, did),
@ -4526,7 +4526,7 @@ fn trans_for_each(&@block_ctxt cx, &@ast::local local, &@ast::expr seq,
// and pass it in as a first class fn-arg to the iterator.
auto iter_body_llty =
type_of_fn_full(lcx.ccx, cx.sp, ast::proto_fn, none[TypeRef],
[rec(mode=ty::mo_alias(false), ty=decl_ty)],
~[rec(mode=ty::mo_alias(false), ty=decl_ty)],
ty::mk_nil(lcx.ccx.tcx), 0u);
let ValueRef lliterbody =
decl_internal_fastcall_fn(lcx.ccx.llmod, s, iter_body_llty);
@ -5551,7 +5551,7 @@ fn trans_args(&@block_ctxt cx, ValueRef llenv, &option::t[ValueRef] llobj,
&option::t[generic_info] gen, &option::t[ValueRef] lliterbody,
&vec[@ast::expr] es, &ty::t fn_ty) ->
tup(@block_ctxt, vec[ValueRef], ValueRef) {
let vec[ty::arg] args = ty::ty_fn_args(cx.fcx.lcx.ccx.tcx, fn_ty);
let ty::arg[] args = ty::ty_fn_args(cx.fcx.lcx.ccx.tcx, fn_ty);
let vec[ValueRef] llargs = [];
let vec[ValueRef] lltydescs = [];
let @block_ctxt bcx = cx;
@ -6342,7 +6342,7 @@ fn trans_put(&@block_ctxt cx, &option::t[@ast::expr] e) -> result {
auto e_ty = ty::expr_ty(cx.fcx.lcx.ccx.tcx, x);
auto arg = rec(mode=ty::mo_alias(false), ty=e_ty);
auto arg_tys =
type_of_explicit_args(cx.fcx.lcx.ccx, x.span, [arg]);
type_of_explicit_args(cx.fcx.lcx.ccx, x.span, ~[arg]);
auto r = trans_arg_expr(bcx, arg, arg_tys.(0), x);
bcx = r.bcx;
llargs += [r.val];
@ -6578,7 +6578,7 @@ fn mk_spawn_wrapper(&@block_ctxt cx, &@ast::expr func, &ty::t args_ty) ->
auto llmod = cx.fcx.lcx.ccx.llmod;
let TypeRef wrapper_fn_type =
type_of_fn(cx.fcx.lcx.ccx, cx.sp, ast::proto_fn,
[rec(mode=ty::mo_alias(false), ty=args_ty)], ty::idx_nil,
~[rec(mode=ty::mo_alias(false), ty=args_ty)], ty::idx_nil,
0u);
// TODO: construct a name based on tname
@ -7450,7 +7450,7 @@ fn copy_any_self_to_alloca(@fn_ctxt fcx, option::t[ty_self_pair] ty_self) {
}
fn copy_args_to_allocas(@fn_ctxt fcx, vec[ast::arg] args,
vec[ty::arg] arg_tys) {
&ty::arg[] arg_tys) {
auto bcx = new_raw_block_ctxt(fcx, fcx.llcopyargs);
let uint arg_n = 0u;
for (ast::arg aarg in args) {
@ -7468,7 +7468,7 @@ fn copy_args_to_allocas(@fn_ctxt fcx, vec[ast::arg] args,
}
fn add_cleanups_for_args(&@block_ctxt bcx, vec[ast::arg] args,
vec[ty::arg] arg_tys) {
&ty::arg[] arg_tys) {
let uint arg_n = 0u;
for (ast::arg aarg in args) {
if (aarg.mode == ast::val) {
@ -7485,7 +7485,7 @@ fn is_terminated(&@block_ctxt cx) -> bool {
ret llvm::LLVMIsATerminatorInst(inst) as int != 0;
}
fn arg_tys_of_fn(&@crate_ctxt ccx,ast::node_id id) -> vec[ty::arg] {
fn arg_tys_of_fn(&@crate_ctxt ccx,ast::node_id id) -> ty::arg[] {
alt (ty::struct(ccx.tcx, ty::node_id_to_type(ccx.tcx, id))) {
case (ty::ty_fn(_, ?arg_tys, _, _, _)) { ret arg_tys; }
}
@ -7699,7 +7699,7 @@ fn trans_obj(@local_ctxt cx, &span sp, &ast::_obj ob, ast::node_id ctor_id,
create_llargs_for_fn_args(fcx, ast::proto_fn, none[ty_self_pair],
ty::ret_ty_of_fn(ccx.tcx, ctor_id),
fn_args, ty_params);
let vec[ty::arg] arg_tys = arg_tys_of_fn(ccx, ctor_id);
let ty::arg[] arg_tys = arg_tys_of_fn(ccx, ctor_id);
copy_args_to_allocas(fcx, fn_args, arg_tys);
// Create the first block context in the function and keep a handle on it
@ -7747,7 +7747,7 @@ fn trans_obj(@local_ctxt cx, &span sp, &ast::_obj ob, ast::node_id ctor_id,
// a dtor, since otherwise they are never dropped, and the dtor never
// runs.
if (vec::len[ast::ty_param](ty_params) == 0u &&
vec::len[ty::arg](arg_tys) == 0u) {
std::ivec::len[ty::arg](arg_tys) == 0u) {
// If the object we're translating has no fields or type parameters,
// there's not much to do.

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

@ -192,7 +192,7 @@ type field = rec(ast::ident ident, mt mt);
type method =
rec(ast::proto proto,
ast::ident ident,
vec[arg] inputs,
arg[] inputs,
t output,
controlflow cf,
vec[@constr_def] constrs);
@ -266,8 +266,8 @@ tag sty {
ty_task;
ty_tup(mt[]);
ty_rec(field[]);
ty_fn(ast::proto, vec[arg], t, controlflow, vec[@constr_def]);
ty_native_fn(ast::native_abi, vec[arg], t);
ty_fn(ast::proto, arg[], t, controlflow, vec[@constr_def]);
ty_native_fn(ast::native_abi, arg[], t);
ty_obj(vec[method]);
ty_res(def_id, t, vec[t]);
ty_var(int); // type variable
@ -445,7 +445,7 @@ fn mk_raw_ty(&ctxt cx, &sty st, &option::t[str] cname) -> raw_t {
derive_flags_t(cx, has_params, has_vars, a.ty);
}
fn derive_flags_sig(&ctxt cx, &mutable bool has_params,
&mutable bool has_vars, &vec[arg] args, &t tt) {
&mutable bool has_vars, &arg[] args, &t tt) {
for (arg a in args) { derive_flags_arg(cx, has_params, has_vars, a); }
derive_flags_t(cx, has_params, has_vars, tt);
}
@ -597,12 +597,12 @@ fn mk_imm_tup(&ctxt cx, &t[] tys) -> t {
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,
fn mk_fn(&ctxt cx, &ast::proto proto, &arg[] args, &t ty, &controlflow cf,
&vec[@constr_def] constrs) -> t {
ret gen_ty(cx, ty_fn(proto, args, ty, cf, constrs));
}
fn mk_native_fn(&ctxt cx, &ast::native_abi abi, &vec[arg] args, &t ty) -> t {
fn mk_native_fn(&ctxt cx, &ast::native_abi abi, &arg[] args, &t ty) -> t {
ret gen_ty(cx, ty_native_fn(abi, args, ty));
}
@ -792,10 +792,10 @@ fn fold_ty(&ctxt cx, fold_mode fld, t ty_0) -> t {
ty = copy_cname(cx, mk_rec(cx, new_fields), ty);
}
case (ty_fn(?proto, ?args, ?ret_ty, ?cf, ?constrs)) {
let vec[arg] new_args = [];
let arg[] new_args = ~[];
for (arg a in args) {
auto new_ty = fold_ty(cx, fld, a.ty);
new_args += [rec(mode=a.mode, ty=new_ty)];
new_args += ~[rec(mode=a.mode, ty=new_ty)];
}
ty =
copy_cname(cx,
@ -803,10 +803,10 @@ fn fold_ty(&ctxt cx, fold_mode fld, t ty_0) -> t {
fold_ty(cx, fld, ret_ty), cf, constrs), ty);
}
case (ty_native_fn(?abi, ?args, ?ret_ty)) {
let vec[arg] new_args = [];
let arg[] new_args = ~[];
for (arg a in args) {
auto new_ty = fold_ty(cx, fld, a.ty);
new_args += [rec(mode=a.mode, ty=new_ty)];
new_args += ~[rec(mode=a.mode, ty=new_ty)];
}
ty =
copy_cname(cx,
@ -816,9 +816,10 @@ fn fold_ty(&ctxt cx, fold_mode fld, t ty_0) -> t {
case (ty_obj(?methods)) {
let vec[method] new_methods = [];
for (method m in methods) {
let vec[arg] new_args = [];
let arg[] new_args = ~[];
for (arg a in m.inputs) {
new_args += [rec(mode=a.mode, ty=fold_ty(cx, fld, a.ty))];
new_args += ~[rec(mode=a.mode,
ty=fold_ty(cx, fld, a.ty))];
}
new_methods +=
[rec(proto=m.proto,
@ -1302,7 +1303,7 @@ fn hash_type_structure(&sty st) -> uint {
h += h << 5u + hash_ty(subty);
ret h;
}
fn hash_fn(uint id, &vec[arg] args, &t rty) -> uint {
fn hash_fn(uint id, &arg[] args, &t rty) -> uint {
auto h = id;
for (arg a in args) { h += h << 5u + hash_ty(a.ty); }
h += h << 5u + hash_ty(rty);
@ -1448,11 +1449,11 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
fn equal_mt(&mt a, &mt b) -> bool {
ret a.mut == b.mut && eq_ty(a.ty, b.ty);
}
fn equal_fn(&vec[arg] args_a, &t rty_a, &vec[arg] args_b, &t rty_b) ->
fn equal_fn(&arg[] args_a, &t rty_a, &arg[] args_b, &t rty_b) ->
bool {
if (!eq_ty(rty_a, rty_b)) { ret false; }
auto len = vec::len[arg](args_a);
if (len != vec::len[arg](args_b)) { ret false; }
auto len = ivec::len[arg](args_a);
if (len != ivec::len[arg](args_b)) { ret false; }
auto i = 0u;
while (i < len) {
auto arg_a = args_a.(i);
@ -1788,7 +1789,7 @@ fn type_contains_params(&ctxt cx, &t typ) -> bool {
// Type accessors for substructures of types
fn ty_fn_args(&ctxt cx, &t fty) -> vec[arg] {
fn ty_fn_args(&ctxt cx, &t fty) -> arg[] {
alt (struct(cx, fty)) {
case (ty::ty_fn(_, ?a, _, _, _)) { ret a; }
case (ty::ty_native_fn(_, ?a, _)) { ret a; }
@ -2073,20 +2074,20 @@ mod unify {
}
tag fn_common_res {
fn_common_res_err(result);
fn_common_res_ok(vec[arg], t);
fn_common_res_ok(arg[], t);
}
fn unify_fn_common(&@ctxt cx, &t expected, &t actual,
&vec[arg] expected_inputs, &t expected_output,
&vec[arg] actual_inputs, &t actual_output) ->
&arg[] expected_inputs, &t expected_output,
&arg[] actual_inputs, &t actual_output) ->
fn_common_res {
auto expected_len = vec::len[arg](expected_inputs);
auto actual_len = vec::len[arg](actual_inputs);
auto expected_len = ivec::len[arg](expected_inputs);
auto actual_len = ivec::len[arg](actual_inputs);
if (expected_len != actual_len) {
ret fn_common_res_err(ures_err(terr_arg_count));
}
// TODO: as above, we should have an iter2 iterator.
let vec[arg] result_ins = [];
let arg[] result_ins = ~[];
auto i = 0u;
while (i < expected_len) {
auto expected_input = expected_inputs.(i);
@ -2101,7 +2102,7 @@ mod unify {
auto result = unify_step(cx, expected_input.ty, actual_input.ty);
alt (result) {
case (ures_ok(?rty)) {
result_ins += [rec(mode=result_mode, ty=rty)];
result_ins += ~[rec(mode=result_mode, ty=rty)];
}
case (_) { ret fn_common_res_err(result); }
}
@ -2116,8 +2117,8 @@ mod unify {
}
}
fn unify_fn(&@ctxt cx, &ast::proto e_proto, &ast::proto a_proto,
&t expected, &t actual, &vec[arg] expected_inputs,
&t expected_output, &vec[arg] actual_inputs, &t actual_output,
&t expected, &t actual, &arg[] expected_inputs,
&t expected_output, &arg[] actual_inputs, &t actual_output,
&controlflow expected_cf, &controlflow actual_cf,
&vec[@constr_def] expected_constrs,
&vec[@constr_def] actual_constrs) -> result {
@ -2158,8 +2159,8 @@ mod unify {
}
fn unify_native_fn(&@ctxt cx, &ast::native_abi e_abi,
&ast::native_abi a_abi, &t expected, &t actual,
&vec[arg] expected_inputs, &t expected_output,
&vec[arg] actual_inputs, &t actual_output) -> result {
&arg[] expected_inputs, &t expected_output,
&arg[] actual_inputs, &t actual_output) -> result {
if (e_abi != a_abi) { ret ures_err(terr_mismatch); }
auto t =
unify_fn_common(cx, expected, actual, expected_inputs,

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

@ -308,9 +308,12 @@ fn ast_ty_to_ty(&ty::ctxt tcx, &ty_getter getter, &@ast::ty ast_ty) -> ty::t {
typ = ty::mk_rec(tcx, flds);
}
case (ast::ty_fn(?proto, ?inputs, ?output, ?cf, ?constrs)) {
auto f = bind ast_arg_to_arg(tcx, getter, _);
auto i = vec::map[ast::ty_arg, arg](f, inputs);
auto i = ~[];
for (ast::ty_arg ta in inputs) {
i += ~[ast_arg_to_arg(tcx, getter, ta)];
}
auto out_ty = ast_ty_to_ty(tcx, getter, output);
let fn(&@ast::constr) -> @ty::constr_def g =
bind ast_constr_to_constr(tcx, _);
let vec[@ty::constr_def] out_constrs = vec::map(g, constrs);
@ -336,8 +339,12 @@ fn ast_ty_to_ty(&ty::ctxt tcx, &ty_getter getter, &@ast::ty ast_ty) -> ty::t {
let vec[ty::method] tmeths = [];
auto f = bind ast_arg_to_arg(tcx, getter, _);
for (ast::ty_method m in meths) {
auto ins = vec::map[ast::ty_arg, arg](f, m.node.inputs);
auto ins = ~[];
for (ast::ty_arg ta in m.node.inputs) {
ins += ~[ast_arg_to_arg(tcx, getter, ta)];
}
auto out = ast_ty_to_ty(tcx, getter, m.node.output);
let fn(&@ast::constr) -> @ty::constr_def g =
bind ast_constr_to_constr(tcx, _);
let vec[@ty::constr_def] out_constrs =
@ -453,8 +460,10 @@ mod collect {
ast::proto proto, &vec[ast::ty_param] ty_params,
&option::t[ast::def_id] def_id) ->
ty::ty_param_count_and_ty {
auto input_tys = vec::map[ast::arg, arg](ty_of_arg, decl.inputs);
auto input_tys = ~[];
for (ast::arg a in decl.inputs) { input_tys += ~[ty_of_arg(a)]; }
auto output_ty = convert(decl.output);
let fn(&@ast::constr) -> @ty::constr_def g =
bind ast_constr_to_constr(cx.tcx, _);
let vec[@ty::constr_def] out_constrs = vec::map(g, decl.constraints);
@ -475,8 +484,10 @@ mod collect {
&vec[ast::ty_param] ty_params,
&ast::def_id def_id) ->
ty::ty_param_count_and_ty {
auto input_tys = vec::map[ast::arg, arg](ty_of_arg, decl.inputs);
auto input_tys = ~[];
for (ast::arg a in decl.inputs) { input_tys += ~[ty_of_arg(a)]; }
auto output_ty = convert(decl.output);
auto t_fn = ty::mk_native_fn(cx.tcx, abi, input_tys, output_ty);
auto ty_param_count = vec::len[ast::ty_param](ty_params);
auto tpt = tup(ty_param_count, t_fn);
@ -519,8 +530,13 @@ mod collect {
fn ty_of_method(@ctxt cx, &@ast::method m) -> ty::method {
auto get = bind getter(cx, _);
auto convert = bind ast_ty_to_ty(cx.tcx, get, _);
auto inputs = ~[];
for (ast::arg a in m.node.meth.decl.inputs) {
inputs += ~[ty_of_arg(cx, a)];
}
auto f = bind ty_of_arg(cx, _);
auto inputs = vec::map[ast::arg, arg](f, m.node.meth.decl.inputs);
auto output = convert(m.node.meth.decl.output);
let fn(&@ast::constr) -> @ty::constr_def g =
bind ast_constr_to_constr(cx.tcx, _);
@ -541,12 +557,14 @@ mod collect {
ast::node_id ctor_id, &vec[ast::ty_param] ty_params) ->
ty::ty_param_count_and_ty {
auto t_obj = ty_of_obj(cx, id, obj_info, ty_params);
let vec[arg] t_inputs = [];
let arg[] t_inputs = ~[];
for (ast::obj_field f in obj_info.fields) {
auto g = bind getter(cx, _);
auto t_field = ast_ty_to_ty(cx.tcx, g, f.ty);
vec::push(t_inputs, rec(mode=ty::mo_alias(false), ty=t_field));
t_inputs += ~[rec(mode=ty::mo_alias(false), ty=t_field)];
}
auto t_fn = ty::mk_fn(cx.tcx, ast::proto_fn, t_inputs, t_obj._1,
ast::return, []);
auto tpt = tup(t_obj._0, t_fn);
@ -650,10 +668,10 @@ mod collect {
// should be called to resolve named types.
auto f = bind getter(cx, _);
let vec[arg] args = [];
let arg[] args = ~[];
for (ast::variant_arg va in variant.node.args) {
auto arg_ty = ast_ty_to_ty(cx.tcx, f, va.ty);
args += [rec(mode=ty::mo_alias(false), ty=arg_ty)];
args += ~[rec(mode=ty::mo_alias(false), ty=arg_ty)];
}
auto tag_t = ty::mk_tag(cx.tcx, tag_id, ty_param_tys);
// FIXME: this will be different for constrained types
@ -718,7 +736,7 @@ mod collect {
auto args = ty::ty_fn_args(cx.tcx, tpt._1);
i = 0u;
while (i < vec::len[ty::arg](args)) {
while (i < ivec::len[ty::arg](args)) {
auto fld = object.fields.(i);
write::ty_only(cx.tcx, fld.id, args.(i).ty);
i += 1u;
@ -728,7 +746,7 @@ mod collect {
alt (object.dtor) {
case (none) {/* nothing to do */ }
case (some(?m)) {
auto t = ty::mk_fn(cx.tcx, ast::proto_fn, [],
auto t = ty::mk_fn(cx.tcx, ast::proto_fn, ~[],
ty::mk_nil(cx.tcx), ast::return, []);
write::ty_only(cx.tcx, m.node.id, t);
}
@ -738,9 +756,9 @@ mod collect {
auto t_arg = ty_of_arg(cx, f.decl.inputs.(0));
auto t_res = ty::mk_res(cx.tcx, local_def(it.id), t_arg.ty,
mk_ty_params(cx, vec::len(tps)));
auto t_ctor = ty::mk_fn(cx.tcx, ast::proto_fn, [t_arg],
auto t_ctor = ty::mk_fn(cx.tcx, ast::proto_fn, ~[t_arg],
t_res, ast::return, []);
auto t_dtor = ty::mk_fn(cx.tcx, ast::proto_fn, [t_arg],
auto t_dtor = ty::mk_fn(cx.tcx, ast::proto_fn, ~[t_arg],
ty::mk_nil(cx.tcx), ast::return, []);
write::ty_only(cx.tcx, it.id, t_res);
write::ty_only(cx.tcx, ctor_id, t_ctor);
@ -1343,7 +1361,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
}
// Check that the correct number of arguments were supplied.
auto expected_arg_count = vec::len[ty::arg](arg_tys);
auto expected_arg_count = ivec::len[ty::arg](arg_tys);
auto supplied_arg_count = vec::len[option::t[@ast::expr]](args);
if (expected_arg_count != supplied_arg_count) {
fcx.ccx.tcx.sess.span_fatal(sp,
@ -1794,7 +1812,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
// Pull the argument and return types out.
auto proto_1;
let vec[ty::arg] arg_tys_1 = [];
let ty::arg[] arg_tys_1 = ~[];
auto rt_1;
auto fty = expr_ty(fcx.ccx.tcx, f);
auto t_1;
@ -1813,7 +1831,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
while (i < vec::len[option::t[@ast::expr]](args)) {
alt (args.(i)) {
case (some(_)) {/* no-op */ }
case (none) { arg_tys_1 += [arg_tys.(i)]; }
case (none) { arg_tys_1 += ~[arg_tys.(i)]; }
}
i += 1u;
}
@ -2149,9 +2167,12 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
}
fn ty_of_method(@crate_ctxt ccx, &@ast::method m) -> ty::method {
auto convert = bind ast_ty_to_ty_crate(ccx, _);
auto f = bind ty_of_arg(ccx, _);
auto inputs =
vec::map[ast::arg, arg](f, m.node.meth.decl.inputs);
auto inputs = ~[];
for (ast::arg aa in m.node.meth.decl.inputs) {
inputs += ~[ty_of_arg(ccx, aa)];
}
auto output = convert(m.node.meth.decl.output);
let fn(&@ast::constr) -> @ty::constr_def g =
bind ast_constr_to_constr(ccx.tcx, _);

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

@ -48,9 +48,8 @@ fn ty_to_str(&ctxt cx, &t typ) -> str {
ret s + ty_to_str(cx, input.ty);
}
fn fn_to_str(&ctxt cx, ast::proto proto, option::t[ast::ident] ident,
vec[arg] inputs, t output, ast::controlflow cf,
&arg[] inputs, t output, ast::controlflow cf,
&vec[@constr_def] constrs) -> str {
auto f = bind fn_input_to_str(cx, _);
auto s;
alt (proto) {
case (ast::proto_iter) { s = "iter"; }
@ -58,7 +57,9 @@ fn ty_to_str(&ctxt cx, &t typ) -> str {
}
alt (ident) { case (some(?i)) { s += " "; s += i; } case (_) { } }
s += "(";
s += str::connect(vec::map[arg, str](f, inputs), ", ");
auto strs = [];
for (arg a in inputs) { strs += [fn_input_to_str(cx, a)]; }
s += str::connect(strs, ", ");
s += ")";
if (struct(cx, output) != ty_nil) {
alt (cf) {
@ -130,9 +131,8 @@ fn ty_to_str(&ctxt cx, &t typ) -> str {
s += fn_to_str(cx, proto, none, inputs, output, cf, constrs);
}
case (ty_native_fn(_, ?inputs, ?output)) {
s +=
fn_to_str(cx, ast::proto_fn, none, inputs, output,
ast::return, []);
s += fn_to_str(cx, ast::proto_fn, none, inputs, output,
ast::return, []);
}
case (ty_obj(?meths)) {
auto f = bind method_to_str(cx, _);