---

yaml
---
r: 15348
b: refs/heads/try
c: 586b072
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 9de288c35f3f97025954d1f12bdc6cfcdb78f603
+refs/heads/try: 586b072eef6354d1c7b5e0a8fba43842826074c6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/rustc/middle/infer.rs

@@ -534,8 +534,13 @@ impl unify_methods for infer_ctxt {
     }
 
     fn tps(as: [ty::t], bs: [ty::t]) -> ures {
+        // Note: type parameters are always treated as *invariant*
+        // (otherwise the type system would be unsound).  In the
+        // future we could allow type parameters to declare a
+        // variance.  In that case, you would have to change c_tps()
+        // for LUB/GLB, which currently always returns `as`.
         if check vec::same_length(as, bs) {
-            iter2(as, bs) {|a, b| self.tys(a, b) }
+            iter2(as, bs) {|a, b| self.eq_tys(a, b) }
         } else {
             self.uerr(ty::terr_ty_param_size(bs.len(), as.len()))
         }
@@ -1080,12 +1085,8 @@ fn c_tuptys<C:combine>(self: C, as: [ty::t], bs: [ty::t])
 
 fn c_tps<C:combine>(self: C, _did: ast::def_id, as: [ty::t], bs: [ty::t])
     -> cres<[ty::t]> {
-    // FIXME #1973 lookup the declared variance of the type parameters
-    // based on did
-    if check vec::same_length(as, bs) {
-        map2(as, bs) {|a,b| self.c_tys(a, b) }
-    } else {
-        err(ty::terr_ty_param_size(bs.len(), as.len()))
+    self.infcx().tps(as, bs).then {||
+        ok(as)
     }
 }
 
@@ -1228,7 +1229,6 @@ fn c_tys<C:combine>(
 
       (ty::ty_class(a_id, a_tps), ty::ty_class(b_id, b_tps))
       if a_id == b_id {
-        // FIXME variance
         c_tps(self, a_id, a_tps, b_tps).chain {|tps|
             ok(ty::mk_class(tcx, a_id, tps))
         }

branches/try/src/test/compile-fail/tps-invariant-class.rs

@@ -0,0 +1,21 @@
+class box_impl<T> {
+    let mut f: T;
+
+    new(f: T) {
+        self.f = f;
+    }
+}
+
+fn set_box_impl<T>(b: box_impl<@const T>, v: @const T) {
+    b.f = v;
+}
+
+fn main() {
+    let b = box_impl::<@int>(@3);
+    set_box_impl(b, @mut 5);
+    //!^ ERROR values differ in mutability
+
+    // No error when type of parameter actually IS @const int
+    let b = box_impl::<@const int>(@3);
+    set_box_impl(b, @mut 5);
+}

branches/try/src/test/compile-fail/tps-invariant-enum.rs

@@ -0,0 +1,18 @@
+enum box_impl<T> = {
+    mut f: T
+};
+
+fn set_box_impl<T>(b: box_impl<@const T>, v: @const T) {
+    b.f = v;
+}
+
+fn main() {
+    let b = box_impl::<@int>({mut f: @3});
+    set_box_impl(b, @mut 5);
+    //!^ ERROR values differ in mutability
+
+    // No error when type of parameter actually IS @const int
+    let x: @const int = @3; // only way I could find to upcast
+    let b = box_impl::<@const int>({mut f: x});
+    set_box_impl(b, @mut 5);
+}

branches/try/src/test/compile-fail/tps-invariant-iface.rs

@@ -0,0 +1,29 @@
+iface box_iface<T> {
+    fn get() -> T;
+    fn set(t: T);
+}
+
+enum box_impl<T> = {
+    mut f: T
+};
+
+impl<T:copy> of box_iface<T> for box_impl<T> {
+    fn get() -> T { ret self.f; }
+    fn set(t: T) { self.f = t; }
+}
+
+fn set_box_iface<T>(b: box_iface<@const T>, v: @const T) {
+    b.set(v);
+}
+
+fn set_box_impl<T>(b: box_impl<@const T>, v: @const T) {
+    b.set(v);
+}
+
+fn main() {
+    let b = box_impl::<@int>({mut f: @3});
+    set_box_iface(b as box_iface::<@int>, @mut 5);
+    //!^ ERROR values differ in mutability
+    set_box_impl(b, @mut 5);
+    //!^ ERROR values differ in mutability
+}