---

yaml
---
r: 8101
b: refs/heads/snap-stage3
c: e0fa5cd
h: refs/heads/master
i:
  8099: 09e8a7c
v: v3

Author: marijnh

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 2898dcc5d97da9427ac367542382b6239d9c0bbf
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 5c42e3df9c811be18a220f33fbcb229702922104
+refs/heads/snap-stage3: e0fa5cd2edbbb611ff3759a31357a70ca9582245
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/snap-stage3/src/comp/metadata/tydecode.rs

@@ -216,6 +216,13 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         let did = parse_def(st, conv);
         ret ty::mk_param(st.tcx, parse_int(st) as uint, did);
       }
+      's' {
+        assert next(st) as char == '[';
+        let params = [];
+        while peek(st) as char != ']' { params += [parse_ty(st, conv)]; }
+        st.pos += 1u;
+        ret ty::mk_self(st.tcx, params);
+      }
       '@' { ret ty::mk_box(st.tcx, parse_mt(st, conv)); }
       '~' { ret ty::mk_uniq(st.tcx, parse_mt(st, conv)); }
       '*' { ret ty::mk_ptr(st.tcx, parse_mt(st, conv)); }

branches/snap-stage3/src/comp/metadata/tyencode.rs

@@ -169,6 +169,11 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
         w.write_char('|');
         w.write_str(uint::str(id));
       }
+      ty::ty_self(tps) {
+        w.write_str("s[");
+        for t in tps { enc_ty(w, cx, t); }
+        w.write_char(']');
+      }
       ty::ty_type { w.write_char('Y'); }
       ty::ty_send_type { w.write_char('y'); }
       ty::ty_opaque_closure_ptr(ty::ck_block) { w.write_str("C&"); }

branches/snap-stage3/src/comp/middle/resolve.rs

@@ -888,10 +888,17 @@ fn lookup_in_scope(e: env, sc: scopes, sp: span, name: ident, ns: namespace)
               ast::item_impl(tps, _, _, _) {
                 if ns == ns_type { ret lookup_in_ty_params(e, name, tps); }
               }
-              ast::item_iface(tps, _) | ast::item_enum(_, tps) |
-              ast::item_ty(_, tps) {
+              ast::item_enum(_, tps) | ast::item_ty(_, tps) {
                 if ns == ns_type { ret lookup_in_ty_params(e, name, tps); }
               }
+              ast::item_iface(tps, _) {
+                if ns == ns_type {
+                    if name == "self" {
+                        ret some(def_self(local_def(it.id)));
+                    }
+                    ret lookup_in_ty_params(e, name, tps);
+                }
+              }
               ast::item_mod(_) {
                 ret lookup_in_local_mod(e, it.id, sp, name, ns, inside);
               }

branches/snap-stage3/src/comp/middle/shape.rs

@@ -421,9 +421,6 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint]) -> [u8] {
         add_substr(s, shape_of(ccx, subt, ty_param_map));
 
       }
-      ty::ty_var(n) {
-        fail "shape_of ty_var";
-      }
       ty::ty_param(n, _) {
         // Find the type parameter in the parameter list.
         alt vec::position_elt(ty_param_map, n) {
@@ -450,8 +447,8 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint]) -> [u8] {
       ty::ty_constr(inner_t, _) {
         s += shape_of(ccx, inner_t, ty_param_map);
       }
-      ty::ty_named(_, _) {
-        ccx.tcx.sess.bug("shape_of: shouldn't see a ty_named");
+      ty::ty_var(_) | ty::ty_named(_, _) | ty::ty_self(_) {
+        ccx.tcx.sess.bug("shape_of: unexpected type struct found");
       }
     }
 

branches/snap-stage3/src/comp/middle/trans/base.rs

@@ -5315,7 +5315,10 @@ fn trans_constant(ccx: @crate_ctxt, it: @ast::item) {
         impl::trans_impl_vtable(ccx, item_path(ccx, it), i_did, ms, tps, it);
       }
       ast::item_iface(_, _) {
-        impl::trans_iface_vtable(ccx, item_path(ccx, it), it);
+        if !vec::any(*ty::iface_methods(ccx.tcx, local_def(it.id)), {|m|
+            ty::type_contains_vars(ccx.tcx, ty::mk_fn(ccx.tcx, m.fty))}) {
+            impl::trans_iface_vtable(ccx, item_path(ccx, it), it);
+        }
       }
       _ { }
     }

branches/snap-stage3/src/comp/middle/trans/impl.rs

@@ -94,10 +94,9 @@ fn trans_static_callee(bcx: @block_ctxt, callee_id: ast::node_id,
     {env: self_env(val) with lval_static_fn(bcx, did, callee_id)}
 }
 
-fn wrapper_fn_ty(ccx: @crate_ctxt, dict_ty: TypeRef, m: ty::method)
-    -> {ty: ty::t, llty: TypeRef} {
-    let fty = ty::mk_fn(ccx.tcx, m.fty);
-    let bare_fn_ty = type_of_fn_from_ty(ccx, fty, *m.tps);
+fn wrapper_fn_ty(ccx: @crate_ctxt, dict_ty: TypeRef, fty: ty::t,
+                 tps: @[ty::param_bounds]) -> {ty: ty::t, llty: TypeRef} {
+    let bare_fn_ty = type_of_fn_from_ty(ccx, fty, *tps);
     let {inputs, output} = llfn_arg_tys(bare_fn_ty);
     {ty: fty, llty: T_fn([dict_ty] + inputs, output)}
 }
@@ -107,7 +106,9 @@ fn trans_vtable_callee(bcx: @block_ctxt, self: ValueRef, dict: ValueRef,
                        n_method: uint) -> lval_maybe_callee {
     let bcx = bcx, ccx = bcx_ccx(bcx), tcx = ccx.tcx;
     let method = ty::iface_methods(tcx, iface_id)[n_method];
-    let {ty: fty, llty: llfty} = wrapper_fn_ty(ccx, val_ty(dict), method);
+    let {ty: fty, llty: llfty} =
+        wrapper_fn_ty(ccx, val_ty(dict), ty::node_id_to_type(tcx, callee_id),
+                      method.tps);
     let vtable = PointerCast(bcx, Load(bcx, GEPi(bcx, dict, [0, 0])),
                              T_ptr(T_array(T_ptr(llfty), n_method + 1u)));
     let mptr = Load(bcx, GEPi(bcx, vtable, [0, n_method as int]));
@@ -266,7 +267,8 @@ fn trans_impl_vtable(ccx: @crate_ctxt, pt: path,
 
 fn trans_iface_wrapper(ccx: @crate_ctxt, pt: path, m: ty::method,
                        n: uint) -> ValueRef {
-    let {llty: llfty, _} = wrapper_fn_ty(ccx, T_ptr(T_i8()), m);
+    let {llty: llfty, _} = wrapper_fn_ty(ccx, T_ptr(T_i8()),
+                                         ty::mk_fn(ccx.tcx, m.fty), m.tps);
     trans_wrapper(ccx, pt, llfty, {|llfn, bcx|
         let self = Load(bcx, PointerCast(bcx,
                                          LLVMGetParam(llfn, 2u as c_uint),
@@ -358,10 +360,7 @@ fn dict_id(tcx: ty::ctxt, origin: typeck::dict_origin) -> dict_id {
                     d_params += [dict_param_dict(dict_id(tcx, origs[orig]))];
                     orig += 1u;
                   }
-                  _ {
-                    tcx.sess.bug("Someone forgot to document an invariant in \
-                      dict_id");
-                  }
+                  _ {}
                 }
             }
         }

branches/snap-stage3/src/comp/middle/ty.rs

@@ -80,6 +80,7 @@ export mk_send_type;
 export mk_uint;
 export mk_uniq;
 export mk_var;
+export mk_self;
 export mk_opaque_closure_ptr;
 export mk_named;
 export gen_ty;
@@ -126,6 +127,7 @@ export ty_send_type;
 export ty_uint;
 export ty_uniq;
 export ty_var;
+export ty_self;
 export ty_named;
 export same_type;
 export ty_var_id;
@@ -266,9 +268,10 @@ enum sty {
     ty_iface(def_id, [t]),
     ty_res(def_id, t, [t]),
     ty_tup([t]),
-    ty_var(int), // type variable
 
-    ty_param(uint, def_id), // fn/enum type param
+    ty_var(int), // type variable during typechecking
+    ty_param(uint, def_id), // type parameter
+    ty_self([t]), // interface method self type
 
     ty_type, // type_desc*
     ty_send_type, // type_desc* that has been cloned into exchange heap
@@ -324,45 +327,25 @@ type ty_param_bounds_and_ty = {bounds: @[param_bounds], ty: t};
 type type_cache = hashmap<ast::def_id, ty_param_bounds_and_ty>;
 
 const idx_nil: uint = 0u;
-
 const idx_bool: uint = 1u;
-
 const idx_int: uint = 2u;
-
 const idx_float: uint = 3u;
-
 const idx_uint: uint = 4u;
-
 const idx_i8: uint = 5u;
-
 const idx_i16: uint = 6u;
-
 const idx_i32: uint = 7u;
-
 const idx_i64: uint = 8u;
-
 const idx_u8: uint = 9u;
-
 const idx_u16: uint = 10u;
-
 const idx_u32: uint = 11u;
-
 const idx_u64: uint = 12u;
-
 const idx_f32: uint = 13u;
-
 const idx_f64: uint = 14u;
-
 const idx_char: uint = 15u;
-
 const idx_str: uint = 16u;
-
 const idx_type: uint = 17u;
-
 const idx_send_type: uint = 18u;
-
 const idx_bot: uint = 19u;
-
 const idx_first_others: uint = 20u;
 
 type type_store = interner::interner<@raw_t>;
@@ -462,7 +445,7 @@ fn mk_raw_ty(cx: ctxt, st: sty) -> @raw_t {
       ty_nil | ty_bot | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) |
       ty_str | ty_type | ty_send_type | ty_opaque_closure_ptr(_) {}
       ty_param(_, _) { has_params = true; }
-      ty_var(_) { has_vars = true; }
+      ty_var(_) | ty_self(_) { has_vars = true; }
       ty_enum(_, tys) | ty_iface(_, tys) {
         for tt: t in tys { derive_flags_t(cx, has_params, has_vars, tt); }
       }
@@ -598,6 +581,8 @@ fn mk_res(cx: ctxt, did: ast::def_id, inner: t, tps: [t]) -> t {
 
 fn mk_var(cx: ctxt, v: int) -> t { ret gen_ty(cx, ty_var(v)); }
 
+fn mk_self(cx: ctxt, tps: [t]) -> t { ret gen_ty(cx, ty_self(tps)); }
+
 fn mk_param(cx: ctxt, n: uint, k: def_id) -> t {
     ret gen_ty(cx, ty_param(n, k));
 }
@@ -653,7 +638,6 @@ pure fn ty_name(cx: ctxt, typ: t) -> option<@str> {
 }
 
 fn default_arg_mode_for_ty(tcx: ty::ctxt, ty: ty::t) -> ast::rmode {
-    assert !ty::type_contains_vars(tcx, ty);
     if ty::type_is_immediate(tcx, ty) { ast::by_val }
     else { ast::by_ref }
 }
@@ -664,7 +648,7 @@ fn walk_ty(cx: ctxt, ty: t, f: fn(t)) {
       ty_str | ty_send_type | ty_type |
       ty_opaque_closure_ptr(_) | ty_var(_) | ty_param(_, _) {}
       ty_box(tm) | ty_vec(tm) | ty_ptr(tm) { walk_ty(cx, tm.ty, f); }
-      ty_enum(_, subtys) | ty_iface(_, subtys) {
+      ty_enum(_, subtys) | ty_iface(_, subtys) | ty_self(subtys) {
         for subty: t in subtys { walk_ty(cx, subty, f); }
       }
       ty_rec(fields) {
@@ -728,6 +712,9 @@ fn fold_ty(cx: ctxt, fld: fold_mode, ty_0: t) -> t {
       ty_iface(did, subtys) {
         ty = mk_iface(cx, did, vec::map(subtys, {|t| fold_ty(cx, fld, t) }));
       }
+      ty_self(subtys) {
+        ty = mk_self(cx, vec::map(subtys, {|t| fold_ty(cx, fld, t) }));
+      }
       ty_rec(fields) {
         let new_fields: [field] = [];
         for fl: field in fields {
@@ -1189,15 +1176,9 @@ fn type_is_pod(cx: ctxt, ty: t) -> bool {
         result = type_is_pod(cx, substitute_type_params(cx, tps, inner));
       }
       ty_constr(subt, _) { result = type_is_pod(cx, subt); }
-      ty_var(_) {
-          cx.sess.bug("ty_var in type_is_pod");
-      }
       ty_param(_, _) { result = false; }
       ty_opaque_closure_ptr(_) { result = true; }
-      ty_named(_,_) {
-          cx.sess.bug("ty_named in type_is_pod");
-      }
-
+      _ { cx.sess.bug("unexpected type in type_is_pod"); }
     }
 
     ret result;
@@ -1352,6 +1333,11 @@ fn hash_type_structure(st: sty) -> uint {
       ty_fn(f) { ret hash_fn(27u, f.inputs, f.output); }
       ty_var(v) { ret hash_uint(30u, v as uint); }
       ty_param(pid, _) { ret hash_uint(31u, pid); }
+      ty_self(ts) {
+        let h = 28u;
+        for t in ts { h += (h << 5u) + t; }
+        ret h;
+      }
       ty_type { ret 32u; }
       ty_bot { ret 34u; }
       ty_ptr(mt) { ret hash_subty(35u, mt.ty); }
@@ -2548,19 +2534,8 @@ fn type_err_to_str(err: ty::type_err) -> str {
 // Replaces type parameters in the given type using the given list of
 // substitions.
 fn substitute_type_params(cx: ctxt, substs: [ty::t], typ: t) -> t {
-   if !type_contains_params(cx, typ) { ret typ; }
     // Precondition? idx < vec::len(substs)
-    fn substituter(_cx: ctxt, substs: @[ty::t], idx: uint, _did: def_id)
-        -> t {
-        if idx < vec::len(*substs) {
-            ret substs[idx];
-        }
-        else {
-            fail #fmt("Internal error in substituter (substitute_type_params)\
-             %u %u", vec::len(*substs), idx);
-        }
-    }
-    ret fold_ty(cx, fm_param(bind substituter(cx, @substs, _, _)), typ);
+    fold_ty(cx, fm_param({|idx, _id| substs[idx]}), typ)
 }
 
 fn def_has_ty_params(def: ast::def) -> bool {