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

rustc: Add a slot for explicit type parameter instantations to the typechecker's AST annotation

Browse Source
This commit is contained in:
Patrick Walton 2011-03-08 12:42:56 -08:00
parent e2f6f19fc8
commit 4654faa67c
4 changed files with 122 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/comp/front/ast.rs
View File

@ -21,7 +21,7 @@ type ty_param = rec(ident ident, def_id id);
// Annotations added during successive passes.
tag ann {
ann_none;
ann_type(@middle.ty.t);
ann_type(@middle.ty.t, option.t[vec[@middle.ty.t]] /* ty param substs */);
}
tag def {

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

@ -2238,7 +2238,7 @@ fn node_ann_type(@crate_ctxt cx, &ast.ann a) -> @ty.t {
case (ast.ann_none) {
cx.sess.bug("missing type annotation");
}
case (ast.ann_type(?t)) {
case (ast.ann_type(?t, _)) {
ret target_type(cx, t);
}
}

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

@ -599,7 +599,7 @@ fn ann_to_type(&ast.ann ann) -> @t {
// shouldn't happen, but can until the typechecker is complete
ret plain_ty(ty_var(-1)); // FIXME: broken, broken, broken
}
case (ast.ann_type(?ty)) {
case (ast.ann_type(?ty, _)) {
ret ty;
}
}

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

@ -540,7 +540,10 @@ fn collect_item_types(session.session sess, @ast.crate crate)
item_to_ty.insert(variant.id, result_ty);
auto variant_t = rec(ann=ast.ann_type(result_ty) with variant);
auto variant_t = rec(
ann=ast.ann_type(result_ty, none[vec[@ty.t]])
with variant
);
result += vec(variant_t);
}
@ -641,9 +644,9 @@ fn collect_item_types(session.session sess, @ast.crate crate)
@ast.ty t, @ast.expr ex,
ast.def_id id, ast.ann a) -> @ast.item {
check (e.item_to_ty.contains_key(id));
auto ty = e.item_to_ty.get(id);
auto typ = e.item_to_ty.get(id);
auto item = ast.item_const(i, t, ex, id,
ast.ann_type(ty));
ast.ann_type(typ, none[vec[@ty.t]]));
ret @fold.respan[ast.item_](sp, item);
}
@ -653,9 +656,9 @@ fn collect_item_types(session.session sess, @ast.crate crate)
collect_ty_params(e, id, ty_params);
check (e.item_to_ty.contains_key(id));
auto ty = e.item_to_ty.get(id);
auto typ = e.item_to_ty.get(id);
auto item = ast.item_fn(i, f, ty_params, id,
ast.ann_type(ty));
ast.ann_type(typ, none[vec[@ty.t]]));
ret @fold.respan[ast.item_](sp, item);
}
@ -665,9 +668,9 @@ fn collect_item_types(session.session sess, @ast.crate crate)
collect_ty_params(e, id, ty_params);
check (e.item_to_ty.contains_key(id));
auto ty = e.item_to_ty.get(id);
auto typ = e.item_to_ty.get(id);
auto item = ast.native_item_fn(i, d, ty_params, id,
ast.ann_type(ty));
ast.ann_type(typ, none[vec[@ty.t]]));
ret @fold.respan[ast.native_item_](sp, item);
}
@ -713,14 +716,20 @@ fn collect_item_types(session.session sess, @ast.crate crate)
auto meth_tfn = plain_ty(ty.ty_fn(meth_ty.proto,
meth_ty.inputs,
meth_ty.output));
m_ = rec(ann=ast.ann_type(meth_tfn) with meth.node);
m_ = rec(
ann=ast.ann_type(meth_tfn, none[vec[@ty.t]])
with meth.node
);
m = @rec(node=m_ with *meth);
append[@ast.method](methods, m);
}
auto g = bind getter(e.id_to_ty_item, e.item_to_ty, _);
for (ast.obj_field fld in ob.fields) {
let @ty.t fty = ast_ty_to_ty(g, fld.ty);
let ast.obj_field f = rec(ann=ast.ann_type(fty) with fld);
let ast.obj_field f = rec(
ann=ast.ann_type(fty, none[vec[@ty.t]])
with fld
);
append[ast.obj_field](fields, f);
}
@ -728,7 +737,7 @@ fn collect_item_types(session.session sess, @ast.crate crate)
fields = fields
with ob);
auto item = ast.item_obj(i, ob_, ty_params, id,
ast.ann_type(t));
ast.ann_type(t, none[vec[@ty.t]]));
ret @fold.respan[ast.item_](sp, item);
}
@ -738,9 +747,9 @@ fn collect_item_types(session.session sess, @ast.crate crate)
collect_ty_params(e, id, ty_params);
check (e.item_to_ty.contains_key(id));
auto ty = e.item_to_ty.get(id);
auto typ = e.item_to_ty.get(id);
auto item = ast.item_ty(i, t, ty_params, id,
ast.ann_type(ty));
ast.ann_type(typ, none[vec[@ty.t]]));
ret @fold.respan[ast.item_](sp, item);
}
@ -908,16 +917,16 @@ fn demand_pat(&@fn_ctxt fcx, @ty.t expected, @ast.pat pat) -> @ast.pat {
alt (pat.node) {
case (ast.pat_wild(?ann)) {
auto t = demand(fcx, pat.span, expected, ann_to_type(ann));
p_1 = ast.pat_wild(ast.ann_type(t));
p_1 = ast.pat_wild(ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.pat_lit(?lit, ?ann)) {
auto t = demand(fcx, pat.span, expected, ann_to_type(ann));
p_1 = ast.pat_lit(lit, ast.ann_type(t));
p_1 = ast.pat_lit(lit, ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.pat_bind(?id, ?did, ?ann)) {
auto t = demand(fcx, pat.span, expected, ann_to_type(ann));
fcx.locals.insert(did, t);
p_1 = ast.pat_bind(id, did, ast.ann_type(t));
p_1 = ast.pat_bind(id, did, ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.pat_tag(?id, ?subpats, ?vdef_opt, ?ann)) {
auto t = demand(fcx, pat.span, expected, ann_to_type(ann));
@ -939,10 +948,14 @@ fn demand_pat(&@fn_ctxt fcx, @ty.t expected, @ast.pat pat) -> @ast.pat {
alt (variant_ty.struct) {
case (ty.ty_tag(_, _)) {
// Nullary tag variant.
// TODO: ty param substs
check (subpats_len == 0u);
p_1 = ast.pat_tag(id, subpats, vdef_opt, ast.ann_type(t));
p_1 = ast.pat_tag(id, subpats, vdef_opt,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ty.ty_fn(_, ?args, ?tag_ty)) {
// N-ary tag variant.
// TODO: ty param substs
let vec[@ast.pat] new_subpats = vec();
auto i = 0u;
for (arg a in args) {
@ -951,7 +964,7 @@ fn demand_pat(&@fn_ctxt fcx, @ty.t expected, @ast.pat pat) -> @ast.pat {
i += 1u;
}
p_1 = ast.pat_tag(id, new_subpats, vdef_opt,
ast.ann_type(tag_ty));
ast.ann_type(tag_ty, none[vec[@ty.t]]));
}
}
}
@ -990,7 +1003,7 @@ fn demand_expr_full(&@fn_ctxt fcx, @ty.t expected, @ast.expr e,
fail;
}
}
e_1 = ast.expr_vec(es_1, ast.ann_type(t));
e_1 = ast.expr_vec(es_1, ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_tup(?es_0, ?ann)) {
auto t = demand(fcx, e.span, expected, ann_to_type(ann));
@ -1009,7 +1022,7 @@ fn demand_expr_full(&@fn_ctxt fcx, @ty.t expected, @ast.expr e,
fail;
}
}
e_1 = ast.expr_tup(elts_1, ast.ann_type(t));
e_1 = ast.expr_tup(elts_1, ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_rec(?fields_0, ?base_0, ?ann)) {
@ -1062,11 +1075,12 @@ fn demand_expr_full(&@fn_ctxt fcx, @ty.t expected, @ast.expr e,
fail;
}
}
e_1 = ast.expr_rec(fields_1, base_1, ast.ann_type(t));
e_1 = ast.expr_rec(fields_1, base_1,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_bind(?sube, ?es, ?ann)) {
auto t = demand(fcx, e.span, expected, ann_to_type(ann));
e_1 = ast.expr_bind(sube, es, ast.ann_type(t));
e_1 = ast.expr_bind(sube, es, ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_call(?sube, ?es, ?ann)) {
// NB: we call 'demand_full' and pass in adk only in cases where
@ -1074,25 +1088,28 @@ fn demand_expr_full(&@fn_ctxt fcx, @ty.t expected, @ast.expr e,
// like expr_binary or expr_bind can't, so there's no need.
auto t = demand_full(fcx, e.span, expected,
ann_to_type(ann), adk);
e_1 = ast.expr_call(sube, es, ast.ann_type(t));
e_1 = ast.expr_call(sube, es, ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_binary(?bop, ?lhs, ?rhs, ?ann)) {
auto t = demand(fcx, e.span, expected, ann_to_type(ann));
e_1 = ast.expr_binary(bop, lhs, rhs, ast.ann_type(t));
e_1 = ast.expr_binary(bop, lhs, rhs,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_unary(?uop, ?sube, ?ann)) {
// See note in expr_unary for why we're calling demand_full.
auto t = demand_full(fcx, e.span, expected,
ann_to_type(ann), adk);
e_1 = ast.expr_unary(uop, sube, ast.ann_type(t));
e_1 = ast.expr_unary(uop, sube,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_lit(?lit, ?ann)) {
auto t = demand(fcx, e.span, expected, ann_to_type(ann));
e_1 = ast.expr_lit(lit, ast.ann_type(t));
e_1 = ast.expr_lit(lit, ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_cast(?sube, ?ast_ty, ?ann)) {
auto t = demand(fcx, e.span, expected, ann_to_type(ann));
e_1 = ast.expr_cast(sube, ast_ty, ast.ann_type(t));
e_1 = ast.expr_cast(sube, ast_ty,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_if(?cond, ?then_0, ?elifs_0, ?else_0, ?ann)) {
auto t = demand_full(fcx, e.span, expected,
@ -1115,62 +1132,71 @@ fn demand_expr_full(&@fn_ctxt fcx, @ty.t expected, @ast.expr e,
else_1 = some[ast.block](b_1);
}
}
e_1 = ast.expr_if(cond, then_1, elifs_1, else_1, ast.ann_type(t));
e_1 = ast.expr_if(cond, then_1, elifs_1, else_1,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_for(?decl, ?seq, ?bloc, ?ann)) {
auto t = demand(fcx, e.span, expected, ann_to_type(ann));
e_1 = ast.expr_for(decl, seq, bloc, ast.ann_type(t));
e_1 = ast.expr_for(decl, seq, bloc,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_for_each(?decl, ?seq, ?bloc, ?ann)) {
auto t = demand(fcx, e.span, expected, ann_to_type(ann));
e_1 = ast.expr_for_each(decl, seq, bloc, ast.ann_type(t));
e_1 = ast.expr_for_each(decl, seq, bloc,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_while(?cond, ?bloc, ?ann)) {
auto t = demand(fcx, e.span, expected, ann_to_type(ann));
e_1 = ast.expr_while(cond, bloc, ast.ann_type(t));
e_1 = ast.expr_while(cond, bloc,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_do_while(?bloc, ?cond, ?ann)) {
auto t = demand(fcx, e.span, expected, ann_to_type(ann));
e_1 = ast.expr_do_while(bloc, cond, ast.ann_type(t));
e_1 = ast.expr_do_while(bloc, cond,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_block(?bloc, ?ann)) {
auto t = demand_full(fcx, e.span, expected,
ann_to_type(ann), adk);
e_1 = ast.expr_block(bloc, ast.ann_type(t));
e_1 = ast.expr_block(bloc, ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_assign(?lhs_0, ?rhs_0, ?ann)) {
auto t = demand_full(fcx, e.span, expected,
ann_to_type(ann), adk);
auto lhs_1 = demand_expr(fcx, expected, lhs_0);
auto rhs_1 = demand_expr(fcx, expected, rhs_0);
e_1 = ast.expr_assign(lhs_1, rhs_1, ast.ann_type(t));
e_1 = ast.expr_assign(lhs_1, rhs_1,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_assign_op(?op, ?lhs_0, ?rhs_0, ?ann)) {
auto t = demand_full(fcx, e.span, expected,
ann_to_type(ann), adk);
auto lhs_1 = demand_expr(fcx, expected, lhs_0);
auto rhs_1 = demand_expr(fcx, expected, rhs_0);
e_1 = ast.expr_assign_op(op, lhs_1, rhs_1, ast.ann_type(t));
e_1 = ast.expr_assign_op(op, lhs_1, rhs_1,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_field(?lhs, ?rhs, ?ann)) {
auto t = demand_full(fcx, e.span, expected,
ann_to_type(ann), adk);
e_1 = ast.expr_field(lhs, rhs, ast.ann_type(t));
e_1 = ast.expr_field(lhs, rhs, ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_index(?base, ?index, ?ann)) {
auto t = demand_full(fcx, e.span, expected,
ann_to_type(ann), adk);
e_1 = ast.expr_index(base, index, ast.ann_type(t));
e_1 = ast.expr_index(base, index,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_path(?pth, ?d, ?ann)) {
auto t = demand_full(fcx, e.span, expected,
ann_to_type(ann), adk);
e_1 = ast.expr_path(pth, d, ast.ann_type(t));
e_1 = ast.expr_path(pth, d, ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_ext(?p, ?args, ?body, ?expanded, ?ann)) {
auto t = demand_full(fcx, e.span, expected,
ann_to_type(ann), adk);
e_1 = ast.expr_ext(p, args, body, expanded, ast.ann_type(t));
e_1 = ast.expr_ext(p, args, body, expanded,
ast.ann_type(t, none[vec[@ty.t]]));
}
case (ast.expr_fail) { e_1 = e.node; }
case (ast.expr_log(_)) { e_1 = e.node; }
@ -1213,7 +1239,10 @@ fn writeback_local(&@fn_ctxt fcx, &span sp, @ast.local local)
+ local.ident);
}
auto local_ty = fcx.locals.get(local.id);
auto local_wb = @rec(ann=ast.ann_type(local_ty) with *local);
auto local_wb = @rec(
ann=ast.ann_type(local_ty, none[vec[@ty.t]])
with *local
);
ret @fold.respan[ast.decl_](sp, ast.decl_local(local_wb));
}
@ -1245,13 +1274,15 @@ fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat {
auto new_pat;
alt (pat.node) {
case (ast.pat_wild(_)) {
new_pat = ast.pat_wild(ast.ann_type(next_ty_var(fcx.ccx)));
new_pat = ast.pat_wild(ast.ann_type(next_ty_var(fcx.ccx),
none[vec[@ty.t]]));
}
case (ast.pat_lit(?lt, _)) {
new_pat = ast.pat_lit(lt, ast.ann_type(check_lit(lt)));
new_pat = ast.pat_lit(lt, ast.ann_type(check_lit(lt),
none[vec[@ty.t]]));
}
case (ast.pat_bind(?id, ?def_id, _)) {
auto ann = ast.ann_type(next_ty_var(fcx.ccx));
auto ann = ast.ann_type(next_ty_var(fcx.ccx), none[vec[@ty.t]]);
new_pat = ast.pat_bind(id, def_id, ann);
}
case (ast.pat_tag(?p, ?subpats, ?vdef_opt, _)) {
@ -1280,7 +1311,7 @@ fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat {
new_subpats += vec(check_pat(fcx, subpat));
}
auto ann = ast.ann_type(tag_ty);
auto ann = ast.ann_type(tag_ty, none[vec[@ty.t]]);
new_pat = ast.pat_tag(p, new_subpats, vdef_opt, ann);
}
@ -1302,7 +1333,8 @@ fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat {
}
let vec[@ty.t] tys = vec(); // FIXME
auto ann = ast.ann_type(plain_ty(ty.ty_tag(tid, tys)));
auto ann = ast.ann_type(plain_ty(ty.ty_tag(tid, tys)),
none[vec[@ty.t]]);
new_pat = ast.pat_tag(p, subpats, vdef_opt, ann);
}
}
@ -1399,9 +1431,9 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
alt (expr.node) {
case (ast.expr_lit(?lit, _)) {
auto ty = check_lit(lit);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_lit(lit, ast.ann_type(ty)));
auto typ = check_lit(lit);
auto ann = ast.ann_type(typ, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span, ast.expr_lit(lit, ann));
}
@ -1427,9 +1459,11 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
case (ast.gt) { t = plain_ty(ty.ty_bool); }
case (_) { /* fall through */ }
}
auto ann = ast.ann_type(t, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_binary(binop, lhs_1, rhs_1,
ast.ann_type(t)));
ann));
}
@ -1456,9 +1490,10 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
}
case (_) { oper_t = strip_boxes(oper_t); }
}
auto ann = ast.ann_type(oper_t, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_unary(unop, oper_1,
ast.ann_type(oper_t)));
ast.expr_unary(unop, oper_1, ann));
}
case (ast.expr_path(?pth, ?defopt, _)) {
@ -1552,17 +1587,18 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
}
}
auto ann = ast.ann_type(t, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_path(pth, defopt,
ast.ann_type(t)));
ast.expr_path(pth, defopt, ann));
}
case (ast.expr_ext(?p, ?args, ?body, ?expanded, _)) {
auto exp_ = check_expr(fcx, expanded);
auto t = expr_ty(exp_);
auto ann = ast.ann_type(t, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_ext(p, args, body, exp_,
ast.ann_type(t)));
ann));
}
case (ast.expr_fail) {
@ -1641,7 +1677,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
auto lhs_1 = demand_expr(fcx, rhs_t0, lhs_0);
auto rhs_1 = demand_expr(fcx, expr_ty(lhs_1), rhs_0);
auto ann = ast.ann_type(rhs_t0);
auto ann = ast.ann_type(rhs_t0, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_assign(lhs_1, rhs_1, ann));
}
@ -1655,7 +1691,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
auto lhs_1 = demand_expr(fcx, rhs_t0, lhs_0);
auto rhs_1 = demand_expr(fcx, expr_ty(lhs_1), rhs_0);
auto ann = ast.ann_type(rhs_t0);
auto ann = ast.ann_type(rhs_t0, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_assign_op(op, lhs_1, rhs_1,
ann));
@ -1700,10 +1736,10 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
auto thn_1 = demand_block(fcx, elsopt_t, thn_0);
auto ann = ast.ann_type(elsopt_t, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_if(cond_1, thn_1,
elifs_1, elsopt_1,
ast.ann_type(elsopt_t)));
elifs_1, elsopt_1, ann));
}
case (ast.expr_for(?decl, ?seq, ?body, _)) {
@ -1714,7 +1750,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
// FIXME: enforce that the type of the decl is the element type
// of the seq.
auto ann = ast.ann_type(plain_ty(ty.ty_nil));
auto ann = ast.ann_type(plain_ty(ty.ty_nil), none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_for(decl_1, seq_1,
body_1, ann));
@ -1725,7 +1761,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
auto seq_1 = check_expr(fcx, seq);
auto body_1 = check_block(fcx, body);
auto ann = ast.ann_type(plain_ty(ty.ty_nil));
auto ann = ast.ann_type(plain_ty(ty.ty_nil), none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_for_each(decl_1, seq_1,
body_1, ann));
@ -1736,7 +1772,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
auto cond_1 = demand_expr(fcx, plain_ty(ty.ty_bool), cond_0);
auto body_1 = check_block(fcx, body);
auto ann = ast.ann_type(plain_ty(ty.ty_nil));
auto ann = ast.ann_type(plain_ty(ty.ty_nil), none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_while(cond_1, body_1, ann));
}
@ -1746,7 +1782,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
auto cond_1 = demand_expr(fcx, plain_ty(ty.ty_bool), cond_0);
auto body_1 = check_block(fcx, body);
auto ann = ast.ann_type(block_ty(body_1));
auto ann = ast.ann_type(block_ty(body_1), none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_do_while(body_1, cond_1,
ann));
@ -1796,7 +1832,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
auto expr_1 = demand_expr(fcx, pattern_ty, expr_0);
auto ann = ast.ann_type(result_ty);
auto ann = ast.ann_type(result_ty, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_alt(expr_1, arms_1, ann));
}
@ -1806,10 +1842,10 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
auto ann;
alt (b_0.node.expr) {
case (some[@ast.expr](?expr)) {
ann = ast.ann_type(expr_ty(expr));
ann = ast.ann_type(expr_ty(expr), none[vec[@ty.t]]);
}
case (none[@ast.expr]) {
ann = ast.ann_type(plain_ty(ty.ty_nil));
ann = ast.ann_type(plain_ty(ty.ty_nil), none[vec[@ty.t]]);
}
}
ret @fold.respan[ast.expr_](expr.span,
@ -1849,9 +1885,10 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
}
auto t_1 = plain_ty(ty.ty_fn(proto_1, arg_tys_1, rt_1));
auto ann = ast.ann_type(t_1, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_bind(result._0, result._1,
ast.ann_type(t_1)));
ann));
}
case (ast.expr_call(?f, ?args, _)) {
@ -1880,9 +1917,10 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
}
}
auto ann = ast.ann_type(rt_1, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_call(result._0, args_1,
ast.ann_type(rt_1)));
ann));
}
case (ast.expr_cast(?e, ?t, _)) {
@ -1897,9 +1935,10 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
+ " as "
+ ty_to_str(t_1));
}
auto ann = ast.ann_type(t_1, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_cast(e_1, t,
ast.ann_type(t_1)));
ast.expr_cast(e_1, t, ann));
}
case (ast.expr_vec(?args, _)) {
@ -1922,7 +1961,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
demand(fcx, expr.span, t, expr_t);
append[@ast.expr](args_1,expr_1);
}
auto ann = ast.ann_type(plain_ty(ty.ty_vec(t)));
auto ann = ast.ann_type(plain_ty(ty.ty_vec(t)), none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_vec(args_1, ann));
}
@ -1941,7 +1980,8 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
append[@ty.t](elts_t, expr_t);
}
auto ann = ast.ann_type(plain_ty(ty.ty_tup(elts_t)));
auto ann = ast.ann_type(plain_ty(ty.ty_tup(elts_t)),
none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_tup(elts_1, ann));
}
@ -1967,7 +2007,8 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
alt (base) {
case (none[@ast.expr]) {
ann = ast.ann_type(plain_ty(ty.ty_rec(fields_t)));
ann = ast.ann_type(plain_ty(ty.ty_rec(fields_t)),
none[vec[@ty.t]]);
}
case (some[@ast.expr](?bexpr)) {
@ -1987,7 +2028,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
}
}
ann = ast.ann_type(bexpr_t);
ann = ast.ann_type(bexpr_t, none[vec[@ty.t]]);
for (ty.field f in fields_t) {
auto found = false;
@ -2022,7 +2063,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
fcx.ccx.sess.span_err(expr.span,
"bad index on tuple");
}
auto ann = ast.ann_type(args.(ix));
auto ann = ast.ann_type(args.(ix), none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_field(base_1,
field,
@ -2036,7 +2077,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
fcx.ccx.sess.span_err(expr.span,
"bad index on record");
}
auto ann = ast.ann_type(fields.(ix).ty);
auto ann = ast.ann_type(fields.(ix).ty, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_field(base_1,
field,
@ -2053,7 +2094,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
auto meth = methods.(ix);
auto t = plain_ty(ty.ty_fn(meth.proto,
meth.inputs, meth.output));
auto ann = ast.ann_type(t);
auto ann = ast.ann_type(t, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_field(base_1,
field,
@ -2083,7 +2124,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
"non-integral type of vec index: "
+ ty_to_str(idx_t));
}
auto ann = ast.ann_type(t);
auto ann = ast.ann_type(t, none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_index(base_1,
idx_1,
@ -2097,7 +2138,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
+ ty_to_str(idx_t));
}
auto t = ty.ty_machine(common.ty_u8);
auto ann = ast.ann_type(plain_ty(t));
auto ann = ast.ann_type(plain_ty(t), none[vec[@ty.t]]);
ret @fold.respan[ast.expr_](expr.span,
ast.expr_index(base_1,
idx_1,
@ -2272,7 +2313,7 @@ fn check_item_fn(&@crate_ctxt ccx, &span sp, ast.ident ident, &ast._fn f,
auto output_ty = ast_ty_to_ty_crate(ccx, f.decl.output);
auto fn_sty = ty.ty_fn(f.proto, inputs, output_ty);
auto fn_ann = ast.ann_type(plain_ty(fn_sty));
auto fn_ann = ast.ann_type(plain_ty(fn_sty), none[vec[@ty.t]]);
auto item = ast.item_fn(ident, f, ty_params, id, fn_ann);
ret @fold.respan[ast.item_](sp, item);