reduce self type to a special type parameter

Author: nikomatsakis

src/rustc/metadata/tydecode.rs

@@ -199,12 +199,16 @@ fn parse_vstore(st: @pstate) -> ty::vstore {
 fn parse_substs(st: @pstate, conv: conv_did) -> ty::substs {
     let self_r = parse_opt(st) {|| parse_region(st) };
 
+    let self_ty = parse_opt(st) {|| parse_ty(st, conv) };
+
     assert next(st) == '[';
     let mut params: [ty::t] = [];
     while peek(st) != ']' { params += [parse_ty(st, conv)]; }
     st.pos = st.pos + 1u;
 
-    ret {self_r: self_r, tps: params};
+    ret {self_r: self_r,
+         self_ty: self_ty,
+         tps: params};
 }
 
 fn parse_bound_region(st: @pstate) -> ty::bound_region {
@@ -298,10 +302,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         ret ty::mk_param(st.tcx, parse_int(st) as uint, did);
       }
       's' {
-        assert next(st) == '[';
-        let substs = parse_substs(st, conv);
-        assert next(st) == ']';
-        ret ty::mk_self(st.tcx, substs);
+        ret ty::mk_self(st.tcx);
       }
       '@' { ret ty::mk_box(st.tcx, parse_mt(st, conv)); }
       '~' { ret ty::mk_uniq(st.tcx, parse_mt(st, conv)); }

src/rustc/metadata/tyencode.rs

@@ -115,6 +115,7 @@ fn enc_opt<T>(w: io::writer, t: option<T>, enc_f: fn(T)) {
 
 fn enc_substs(w: io::writer, cx: @ctxt, substs: ty::substs) {
     enc_opt(w, substs.self_r) { |r| enc_region(w, cx, r) }
+    enc_opt(w, substs.self_ty) { |t| enc_ty(w, cx, t) }
     w.write_char('[');
     for substs.tps.each { |t| enc_ty(w, cx, t); }
     w.write_char(']');
@@ -281,10 +282,8 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
         w.write_char('|');
         w.write_str(uint::str(id));
       }
-      ty::ty_self(substs) {
-        w.write_str("s["/&);
-        enc_substs(w, cx, substs);
-        w.write_char(']');
+      ty::ty_self {
+        w.write_char('s');
       }
       ty::ty_type { w.write_char('Y'); }
       ty::ty_opaque_closure_ptr(ty::ck_block) { w.write_str("C&"/&); }

src/rustc/middle/infer.rs

@@ -630,12 +630,15 @@ impl methods for resolve_state {
     fn resolve1(typ: ty::t) -> ty::t {
         #debug("Resolve1(%s)", typ.to_str(self.infcx));
         indent(fn&() -> ty::t {
-            if !ty::get(typ).has_vars { ret typ; }
+            if !ty::type_needs_infer(typ) { ret typ; }
 
-            let tb = ty::get(typ);
-            alt tb.struct {
-              ty::ty_var(vid) { self.resolve_ty_var(vid) }
-              _ if !tb.has_regions && !self.deep { typ }
+            alt ty::get(typ).struct {
+              ty::ty_var(vid) {
+                self.resolve_ty_var(vid)
+              }
+              _ if !ty::type_has_regions(typ) && !self.deep {
+                typ
+              }
               _ {
                 ty::fold_regions_and_ty(
                     self.infcx.tcx, typ,
@@ -935,6 +938,7 @@ iface combine {
     fn contratys(a: ty::t, b: ty::t) -> cres<ty::t>;
     fn tys(a: ty::t, b: ty::t) -> cres<ty::t>;
     fn tps(as: [ty::t], bs: [ty::t]) -> cres<[ty::t]>;
+    fn self_tys(a: option<ty::t>, b: option<ty::t>) -> cres<option<ty::t>>;
     fn substs(as: ty::substs, bs: ty::substs) -> cres<ty::substs>;
     fn fns(a: ty::fn_ty, b: ty::fn_ty) -> cres<ty::fn_ty>;
     fn flds(a: ty::field, b: ty::field) -> cres<ty::field>;
@@ -982,8 +986,10 @@ fn super_substs<C:combine>(
     }
 
     self.tps(a.tps, b.tps).chain { |tps|
-        eq_opt_regions(self.infcx(), a.self_r, b.self_r).chain { |self_r|
-            ok({self_r: self_r, tps: tps})
+        self.self_tys(a.self_ty, b.self_ty).chain { |self_ty|
+            eq_opt_regions(self.infcx(), a.self_r, b.self_r).chain { |self_r|
+                ok({self_r: self_r, self_ty: self_ty, tps: tps})
+            }
         }
     }
 }
@@ -995,6 +1001,7 @@ fn super_tps<C:combine>(
     // (otherwise the type system would be unsound).  In the
     // future we could allow type parameters to declare a
     // variance.
+
     if check vec::same_length(as, bs) {
         iter2(as, bs) {|a, b| self.infcx().eq_tys(a, b) }.then {||
             ok(as)
@@ -1004,6 +1011,31 @@ fn super_tps<C:combine>(
     }
 }
 
+fn super_self_tys<C:combine>(
+    self: C, a: option<ty::t>, b: option<ty::t>) -> cres<option<ty::t>> {
+
+    // Note: the self type parameter is (currently) always treated as
+    // *invariant* (otherwise the type system would be unsound).
+
+    alt (a, b) {
+      (none, none) {
+        ok(none)
+      }
+      (some(a), some(b)) {
+        self.infcx().eq_tys(a, b).then {||
+            ok(some(a))
+        }
+      }
+      (none, some(_)) |
+      (some(_), none) {
+        // I think it should never happen that we unify two substs and
+        // one of them has a self_ty and one doesn't...? I could be
+        // wrong about this.
+        err(ty::terr_self_substs)
+      }
+    }
+}
+
 fn super_flds<C:combine>(
     self: C, a: ty::field, b: ty::field) -> cres<ty::field> {
 
@@ -1374,6 +1406,10 @@ impl of combine for sub {
     fn tps(as: [ty::t], bs: [ty::t]) -> cres<[ty::t]> {
         super_tps(self, as, bs)
     }
+
+    fn self_tys(a: option<ty::t>, b: option<ty::t>) -> cres<option<ty::t>> {
+        super_self_tys(self, a, b)
+    }
 }
 
 impl of combine for lub {
@@ -1549,6 +1585,10 @@ impl of combine for lub {
     fn tps(as: [ty::t], bs: [ty::t]) -> cres<[ty::t]> {
         super_tps(self, as, bs)
     }
+
+    fn self_tys(a: option<ty::t>, b: option<ty::t>) -> cres<option<ty::t>> {
+        super_self_tys(self, a, b)
+    }
 }
 
 impl of combine for glb {
@@ -1739,6 +1779,10 @@ impl of combine for glb {
     fn tps(as: [ty::t], bs: [ty::t]) -> cres<[ty::t]> {
         super_tps(self, as, bs)
     }
+
+    fn self_tys(a: option<ty::t>, b: option<ty::t>) -> cres<option<ty::t>> {
+        super_self_tys(self, a, b)
+    }
 }
 
 // ______________________________________________________________________

src/rustc/middle/trans/common.rs

@@ -916,7 +916,9 @@ fn field_idx_strict(cx: ty::ctxt, sp: span, ident: ast::ident,
 }
 
 fn dummy_substs(tps: [ty::t]) -> ty::substs {
-    {self_r: some(ty::re_bound(ty::br_self)), tps: tps}
+    {self_r: some(ty::re_bound(ty::br_self)),
+     self_ty: none,
+     tps: tps}
 }
 
 //

src/rustc/middle/trans/impl.rs

@@ -256,7 +256,7 @@ fn make_impl_vtable(ccx: @crate_ctxt, impl_id: ast::def_id, substs: [ty::t],
     let has_tps = (*ty::lookup_item_type(ccx.tcx, impl_id).bounds).len() > 0u;
     make_vtable(ccx, vec::map(*ty::iface_methods(tcx, ifce_id)) {|im|
         let fty = ty::subst_tps(tcx, substs, ty::mk_fn(tcx, im.fty));
-        if (*im.tps).len() > 0u || ty::type_has_vars(fty) {
+        if (*im.tps).len() > 0u || ty::type_has_self(fty) {
             C_null(T_ptr(T_nil()))
         } else {
             let m_id = method_with_name(ccx, impl_id, im.ident);

src/rustc/middle/trans/shape.rs

@@ -457,7 +457,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint]) -> [u8] {
       ty::ty_fn({proto: ast::proto_bare, _}) { [shape_bare_fn] }
       ty::ty_opaque_closure_ptr(_) { [shape_opaque_closure_ptr] }
       ty::ty_constr(inner_t, _) { shape_of(ccx, inner_t, ty_param_map) }
-      ty::ty_var(_) | ty::ty_self(_) {
+      ty::ty_var(_) | ty::ty_self {
         ccx.sess.bug("shape_of: unexpected type struct found");
       }
     }

src/rustc/middle/trans/type_of.rs

@@ -44,7 +44,7 @@ fn type_of_fn_from_ty(cx: @crate_ctxt, fty: ty::t) -> TypeRef {
 }
 
 fn type_of_non_gc_box(cx: @crate_ctxt, t: ty::t) -> TypeRef {
-    assert !ty::type_has_vars(t);
+    assert !ty::type_needs_infer(t);
 
     let t_norm = ty::normalize_ty(cx.tcx, t);
     if t != t_norm {
@@ -62,7 +62,7 @@ fn type_of_non_gc_box(cx: @crate_ctxt, t: ty::t) -> TypeRef {
 }
 
 fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
-    assert !ty::type_has_vars(t);
+    assert !ty::type_needs_infer(t);
 
     #debug("type_of %?: %?", t, ty::get(t));
 
@@ -149,8 +149,7 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
             };
             T_struct(tys)
           }
-          ty::ty_self(_) { cx.tcx.sess.unimpl("type_of: ty_self \
-                                               not implemented"); }
+          ty::ty_self { cx.tcx.sess.unimpl("type_of: ty_self"); }
           ty::ty_var(_) { cx.tcx.sess.bug("type_of shouldn't see a ty_var"); }
         }
     };