---

yaml
---
r: 7022
b: refs/heads/master
c: a7e1a35
h: refs/heads/master
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: d1ffe5034b341a9a522c01705cafdb19bac9cedb
+refs/heads/master: a7e1a35f8836f78894a4499ac7bebcc76472f172

trunk/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) {

trunk/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} {

trunk/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)}
 }