Properly typecheck and compile invocations of generic methods.

Aligning the type parameters of the ifaces, impls, and methods
correctly in typeck is almost brain surgery. Seems to work now for
everything I threw at it, but might still break in other corner cases.

Issue #1227

Author: marijnh

src/comp/middle/resolve.rs

@@ -37,7 +37,7 @@ tag scope {
     scope_loop(@ast::local); // there's only 1 decl per loop.
     scope_block(ast::blk, @mutable uint, @mutable uint);
     scope_arm(ast::arm);
-    scope_self(ast::node_id);
+    scope_method(ast::node_id, [ast::ty_param]);
 }
 
 type scopes = list<scope>;
@@ -404,9 +404,17 @@ fn visit_item_with_scope(i: @ast::item, sc: scopes, v: vt<scopes>) {
         alt ifce { some(ty) { v.visit_ty(ty, sc, v); } _ {} }
         v.visit_ty(sty, sc, v);
         for m in methods {
-            v.visit_fn(visit::fk_method(m.ident, tps + m.tps),
-                       m.decl, m.body, m.span,
-                       m.id, sc, v);
+            let msc = cons(scope_method(i.id, tps + m.tps), @sc);
+            v.visit_fn(visit::fk_method(m.ident, []),
+                       m.decl, m.body, m.span, m.id, msc, v);
+        }
+      }
+      ast::item_iface(tps, methods) {
+        visit::visit_ty_params(tps, sc, v);
+        for m in methods {
+            let msc = cons(scope_method(i.id, tps + m.tps), @sc);
+            for a in m.decl.inputs { v.visit_ty(a.ty, msc, v); }
+            v.visit_ty(m.decl.output, msc, v);
         }
       }
       _ { visit::visit_item(i, sc, v); }
@@ -437,8 +445,8 @@ fn visit_fn_with_scope(e: @env, fk: visit::fn_kind, decl: ast::fn_decl,
     // for f's constrs in the table.
     for c: @ast::constr in decl.constraints { resolve_constr(e, c, sc, v); }
     let scope = alt fk {
-      visit::fk_item_fn(_, tps) | visit::fk_method(_, tps) |
-      visit::fk_res(_, tps) {
+      visit::fk_item_fn(_, tps) | visit::fk_res(_, tps) |
+      visit::fk_method(_, tps) {
         scope_bare_fn(decl, id, tps)
       }
       visit::fk_anon(_) | visit::fk_fn_block. {
@@ -491,7 +499,7 @@ fn visit_expr_with_scope(x: @ast::expr, sc: scopes, v: vt<scopes>) {
         v.visit_block(blk, new_sc, v);
       }
       ast::expr_anon_obj(_) {
-        visit::visit_expr(x, cons(scope_self(x.id), @sc), v);
+        visit::visit_expr(x, cons(scope_method(x.id, []), @sc), v);
       }
       _ { visit::visit_expr(x, sc, v); }
     }
@@ -801,9 +809,6 @@ fn lookup_in_scope(e: env, sc: scopes, sp: span, name: ident, ns: namespace)
                 ret lookup_in_obj(name, ob, ty_params, ns, it.id);
               }
               ast::item_impl(ty_params, _, _, _) {
-                if (name == "self" && ns == ns_value) {
-                    ret some(ast::def_self(local_def(it.id)));
-                }
                 if ns == ns_type { ret lookup_in_ty_params(name, ty_params); }
               }
               ast::item_iface(tps, _) | ast::item_tag(_, tps) |
@@ -819,9 +824,11 @@ fn lookup_in_scope(e: env, sc: scopes, sp: span, name: ident, ns: namespace)
               _ { }
             }
           }
-          scope_self(id) {
+          scope_method(id, tps) {
             if (name == "self" && ns == ns_value) {
                 ret some(ast::def_self(local_def(id)));
+            } else if ns == ns_type {
+                ret lookup_in_ty_params(name, tps);
             }
           }
           scope_native_item(it) {

src/comp/middle/trans_impl.rs

@@ -37,12 +37,13 @@ fn trans_static_callee(bcx: @block_ctxt, e: @ast::expr, base: @ast::expr,
     {env: obj_env(val) with lval_static_fn(bcx, did, e.id)}
 }
 
-fn trans_dict_callee(bcx: @block_ctxt, _e: @ast::expr, base: @ast::expr,
+fn trans_dict_callee(bcx: @block_ctxt, e: @ast::expr, base: @ast::expr,
                      iface_id: ast::def_id, n_method: uint,
                      n_param: uint, n_bound: uint) -> lval_maybe_callee {
+    let tcx = bcx_tcx(bcx);
     let {bcx, val} = trans_self_arg(bcx, base);
     let dict = option::get(bcx.fcx.lltyparams[n_param].dicts)[n_bound];
-    let method = ty::iface_methods(bcx_tcx(bcx), iface_id)[n_method];
+    let method = ty::iface_methods(tcx, iface_id)[n_method];
     let bare_fn_ty = type_of_fn(bcx_ccx(bcx), ast_util::dummy_sp(),
                                 false, method.fty.inputs, method.fty.output,
                                 *method.tps);
@@ -51,9 +52,26 @@ fn trans_dict_callee(bcx: @block_ctxt, _e: @ast::expr, base: @ast::expr,
     let vtable = PointerCast(bcx, Load(bcx, GEPi(bcx, dict, [0, 0])),
                              T_ptr(T_array(T_ptr(fn_ty), n_method + 1u)));
     let mptr = Load(bcx, GEPi(bcx, vtable, [0, n_method as int]));
+    let generic = none;
+    if vec::len(*method.tps) > 0u {
+        let tydescs = [], tis = [];
+        for t in ty::node_id_to_type_params(tcx, e.id) {
+            // TODO: Doesn't always escape.
+            let ti = none;
+            let td = get_tydesc(bcx, t, true, tps_normal, ti).result;
+            tis += [ti];
+            tydescs += [td.val];
+            bcx = td.bcx;
+        }
+        generic = some({item_type: ty::mk_fn(tcx, method.fty),
+                        static_tis: tis,
+                        tydescs: tydescs,
+                        param_bounds: method.tps,
+                        origins: bcx_ccx(bcx).dict_map.find(e.id)});
+    }
     {bcx: bcx, val: mptr, kind: owned,
      env: dict_env(dict, val),
-     generic: none} // FIXME[impl] fetch generic info for method
+     generic: generic}
 }
 
 fn llfn_arg_tys(ft: TypeRef) -> {inputs: [TypeRef], output: TypeRef} {

src/comp/middle/ty.rs

@@ -18,7 +18,7 @@ import util::common::*;
 import syntax::util::interner;
 import util::ppaux::ty_to_str;
 import util::ppaux::ty_constr_to_str;
-import util::ppaux::mode_str_1;
+import util::ppaux::mode_str;
 import syntax::print::pprust::*;
 
 export node_id_to_monotype;
@@ -1739,7 +1739,7 @@ mod unify {
     export ures_ok;
     export ures_err;
     export var_bindings;
-    export precise, in_bindings, bind_params;
+    export precise, in_bindings;
 
     tag result { ures_ok(t); ures_err(type_err); }
     tag union_result { unres_ok; unres_err(type_err); }
@@ -1753,7 +1753,6 @@ mod unify {
     tag unify_style {
         precise;
         in_bindings(@var_bindings);
-        bind_params(@mutable [mutable option::t<t>]);
     }
     type ctxt = {st: unify_style, tcx: ty_ctxt};
 
@@ -2172,16 +2171,6 @@ mod unify {
             }
             ret ures_ok(mk_var(cx.tcx, actual_id));
           }
-          ty::ty_param(n, _) {
-            alt cx.st {
-              bind_params(cell) {
-                while vec::len(*cell) < n + 1u { *cell += [mutable none]; }
-                cell[n] = some(expected);
-                ret ures_ok(expected);
-              }
-              _ {}
-            }
-          }
           _ {/* empty */ }
         }
         alt struct(cx.tcx, expected) {
@@ -2627,8 +2616,8 @@ fn type_err_to_str(err: ty::type_err) -> str {
                 "' but found one with method '" + a_meth + "'";
       }
       terr_mode_mismatch(e_mode, a_mode) {
-        ret "expected argument mode " + mode_str_1(e_mode) + " but found " +
-                mode_str_1(a_mode);
+        ret "expected argument mode " + mode_str(e_mode) + " but found " +
+                mode_str(a_mode);
       }
       terr_constr_len(e_len, a_len) {
         ret "Expected a type with " + uint::str(e_len) +
@@ -2646,24 +2635,17 @@ fn type_err_to_str(err: ty::type_err) -> str {
 
 // Converts type parameters in a type to type variables and returns the
 // resulting type along with a list of type variable IDs.
-fn bind_params_in_type(sp: span, cx: ctxt, next_ty_var: fn@() -> int, typ: t,
+fn bind_params_in_type(cx: ctxt, next_ty_var: block() -> int, typ: t,
                        ty_param_count: uint) -> {ids: [int], ty: t} {
-    let param_var_ids: @mutable [int] = @mutable [];
-    let i = 0u;
-    while i < ty_param_count { *param_var_ids += [next_ty_var()]; i += 1u; }
-    fn binder(sp: span, cx: ctxt, param_var_ids: @mutable [int],
-              _next_ty_var: fn@() -> int, index: uint, _did: def_id) -> t {
-        if index < vec::len(*param_var_ids) {
-            ret mk_var(cx, param_var_ids[index]);
-        } else {
-            cx.sess.span_fatal(sp, "Unbound type parameter in callee's type");
-        }
-    }
-    let new_typ =
-        fold_ty(cx,
-                fm_param(bind binder(sp, cx, param_var_ids, next_ty_var, _,
-                                     _)), typ);
-    ret {ids: *param_var_ids, ty: new_typ};
+    let param_var_ids = [], i = 0u;
+    while i < ty_param_count { param_var_ids += [next_ty_var()]; i += 1u; }
+    let param_var_ids = @param_var_ids;
+    fn binder(cx: ctxt, param_var_ids: @[int], index: uint,
+              _did: def_id) -> t {
+        ret mk_var(cx, param_var_ids[index]);
+    }
+    {ids: *param_var_ids,
+     ty: fold_ty(cx, fm_param(bind binder(cx, param_var_ids, _, _)), typ)}
 }