---

yaml
---
r: 1325
b: refs/heads/master
c: ef50d0e
h: refs/heads/master
i:
  1323: 864640b
v: v3

Author: graydon

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: c848ed1e9862a527e0a6f16ef235b41f98baa419
+refs/heads/master: ef50d0e668635824cc5ed86aaa385dd6f3181b53

trunk/src/Makefile

@@ -447,7 +447,6 @@ TEST_XFAILS_RUSTC := $(filter-out \
                         div-mod.rs \
                         drop-bind-thunk-args.rs \
                         drop-on-ret.rs \
-                        else-if.rs \
                         fact.rs \
                         fn-lval.rs \
                         fun-call-variants.rs \

trunk/src/comp/front/parser.rs

@@ -895,7 +895,8 @@ impure fn parse_if_expr(parser p) -> @ast.expr {
     hi = thn.span;
     alt (p.peek()) {
         case (token.ELSE) {
-            auto eblk = parse_else_block(p);
+            p.bump();
+            auto eblk = parse_block(p);
             els = some(eblk);
             hi = eblk.span;
         }
@@ -904,21 +905,6 @@ impure fn parse_if_expr(parser p) -> @ast.expr {
     ret @spanned(lo, hi, ast.expr_if(cond, thn, els, ast.ann_none));
 }
 
-impure fn parse_else_block(parser p) -> ast.block {
-    expect(p, token.ELSE);
-    alt (p.peek()) {
-        case (token.IF) {
-            let vec[@ast.stmt] stmts = vec();
-            auto ifexpr = parse_if_expr(p);
-            auto bloc = index_block(stmts, some(ifexpr));
-            ret spanned(ifexpr.span, ifexpr.span, bloc);
-        }
-        case (_) {
-            ret parse_block(p);
-        }
-    }
-}
-
 impure fn parse_head_local(parser p) -> @ast.decl {
     auto lo = p.get_span();
     let @ast.local local;

trunk/src/comp/middle/trans.rs

@@ -997,7 +997,7 @@ fn get_tydesc(&@block_ctxt cx, @ty.t t) -> result {
                               vec(p2i(bcx.fcx.ccx.crate_ptr),
                                   sz.val,
                                   align.val,
-                                  C_int(n_params as int),
+                                  C_int((1u + n_params) as int),
                                   bcx.build.PtrToInt(tydescs, T_int())));
 
         ret res(v.bcx, v.bcx.build.IntToPtr(v.val, T_ptr(T_tydesc())));
@@ -2193,6 +2193,34 @@ fn lval_val(@block_ctxt cx, ValueRef val) -> lval_result {
             llobj=none[ValueRef]);
 }
 
+fn lval_generic_fn(@block_ctxt cx,
+                   ty.ty_params_and_ty tpt,
+                   ast.def_id fn_id,
+                   &ast.ann ann)
+    -> lval_result {
+
+    check (cx.fcx.ccx.fn_pairs.contains_key(fn_id));
+    auto lv = lval_val(cx, cx.fcx.ccx.fn_pairs.get(fn_id));
+    auto monoty = node_ann_type(cx.fcx.ccx, ann);
+    auto tys = ty.resolve_ty_params(tpt, monoty);
+
+    if (_vec.len[@ty.t](tys) != 0u) {
+        auto bcx = cx;
+        let vec[ValueRef] tydescs = vec();
+        for (@ty.t t in tys) {
+            auto td = get_tydesc(bcx, t);
+            bcx = td.bcx;
+            append[ValueRef](tydescs, td.val);
+        }
+        auto gen = rec( item_type = tpt._1,
+                        tydescs = tydescs );
+        lv = rec(res = res(bcx, lv.res.val),
+                 generic = some[generic_info](gen)
+                 with lv);
+    }
+    ret lv;
+}
+
 fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt,
               &ast.ann ann) -> lval_result {
     alt (dopt) {
@@ -2215,39 +2243,33 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt,
                     ret lval_mem(cx, cx.fcx.llobjfields.get(did));
                 }
                 case (ast.def_fn(?did)) {
-                    check (cx.fcx.ccx.fn_pairs.contains_key(did));
-                    check (cx.fcx.ccx.item_ids.contains_key(did));
-
+                    check (cx.fcx.ccx.items.contains_key(did));
                     auto fn_item = cx.fcx.ccx.items.get(did);
-                    auto lv = lval_val(cx, cx.fcx.ccx.fn_pairs.get(did));
-                    auto monoty = node_ann_type(cx.fcx.ccx, ann);
-                    auto tys = ty.resolve_ty_params(fn_item, monoty);
-
-                    if (_vec.len[@ty.t](tys) != 0u) {
-                        auto bcx = cx;
-                        let vec[ValueRef] tydescs = vec();
-                        for (@ty.t t in tys) {
-                            auto td = get_tydesc(bcx, t);
-                            bcx = td.bcx;
-                            append[ValueRef](tydescs, td.val);
-                        }
-                        auto gen = rec( item_type = ty.item_ty(fn_item)._1,
-                                        tydescs = tydescs );
-                        lv = rec(res = res(bcx, lv.res.val),
-                                 generic = some[generic_info](gen)
-                                 with lv);
-                    }
-
-                    ret lv;
+                    ret lval_generic_fn(cx, ty.item_ty(fn_item), did, ann);
                 }
                 case (ast.def_obj(?did)) {
-                    check (cx.fcx.ccx.fn_pairs.contains_key(did));
-                    ret lval_val(cx, cx.fcx.ccx.fn_pairs.get(did));
+                    check (cx.fcx.ccx.items.contains_key(did));
+                    auto fn_item = cx.fcx.ccx.items.get(did);
+                    ret lval_generic_fn(cx, ty.item_ty(fn_item), did, ann);
                 }
                 case (ast.def_variant(?tid, ?vid)) {
                     check (cx.fcx.ccx.tags.contains_key(tid));
                     if (cx.fcx.ccx.fn_pairs.contains_key(vid)) {
-                        ret lval_val(cx, cx.fcx.ccx.fn_pairs.get(vid));
+                        check (cx.fcx.ccx.items.contains_key(tid));
+                        auto tag_item = cx.fcx.ccx.items.get(tid);
+                        auto params = ty.item_ty(tag_item)._0;
+                        auto fty = ty.plain_ty(ty.ty_nil);
+                        alt (tag_item.node) {
+                            case (ast.item_tag(_, ?variants, _, _)) {
+                                for (ast.variant v in variants) {
+                                    if (v.id == vid) {
+                                        fty = node_ann_type(cx.fcx.ccx,
+                                                            v.ann);
+                                    }
+                                }
+                            }
+                        }
+                        ret lval_generic_fn(cx, tup(params, fty), vid, ann);
                     } else {
                         // Nullary variants are just scalar constants.
                         check (cx.fcx.ccx.item_ids.contains_key(vid));
@@ -3798,15 +3820,13 @@ fn collect_item(&@crate_ctxt cx, @ast.item i) -> @crate_ctxt {
 
     alt (i.node) {
         case (ast.item_fn(?name, ?f, _, ?fid, ?ann)) {
-            // TODO: type-params
             cx.items.insert(fid, i);
             if (! cx.obj_methods.contains_key(fid)) {
                 decl_fn_and_pair(cx, "fn", name, ann, fid);
             }
         }
 
         case (ast.item_obj(?name, ?ob, _, ?oid, ?ann)) {
-            // TODO: type-params
             cx.items.insert(oid, i);
             decl_fn_and_pair(cx, "obj_ctor", name, ann, oid);
             for (@ast.method m in ob.methods) {

trunk/src/comp/middle/ty.rs

@@ -571,7 +571,8 @@ fn is_fn_ty(@t fty) -> bool {
 
 // Given an item, returns the associated type as well as a list of the IDs of
 // its type parameters.
-fn item_ty(@ast.item it) -> tup(vec[ast.def_id], @t) {
+type ty_params_and_ty = tup(vec[ast.def_id], @t);
+fn item_ty(@ast.item it) -> ty_params_and_ty {
     let vec[ast.ty_param] ty_params;
     auto result_ty;
     alt (it.node) {
@@ -1233,7 +1234,8 @@ fn type_err_to_str(&ty.type_err err) -> str {
 
 // Type parameter resolution, used in translation
 
-fn resolve_ty_params(@ast.item item, @t monoty) -> vec[@t] {
+fn resolve_ty_params(ty_params_and_ty ty_params_and_polyty,
+                     @t monoty) -> vec[@t] {
     obj resolve_ty_params_handler(@hashmap[ast.def_id,@t] bindings) {
         fn resolve_local(ast.def_id id) -> @t { log "resolve local"; fail; }
         fn record_local(ast.def_id id, @t ty) { log "record local"; fail; }
@@ -1249,8 +1251,6 @@ fn resolve_ty_params(@ast.item item, @t monoty) -> vec[@t] {
         }
     }
 
-    auto ty_params_and_polyty = item_ty(item);
-
     auto bindings = @new_def_hash[@t]();
     auto handler = resolve_ty_params_handler(bindings);