Immutable and mutable? are covariant on their inner types

Whereas [mutable T] is invariant with respect to T, [T] and [mutable? T]
are covariant with respect to T.

Author: brson

src/comp/middle/ty.rs

@@ -1947,9 +1947,16 @@ mod unify {
                  variance: variance) ->
        option::t<(ast::mutability, variance)> {
 
-        // If you're unifying mutability then the thing inside
-        // will be invariant on anything it contains
-        let newvariance = variance_transform(variance, invariant);
+        // If you're unifying on something mutable then we have to
+        // be invariant on the inner type
+        let newvariance = alt expected {
+          ast::mut. {
+            variance_transform(variance, invariant)
+          }
+          _ {
+            variance_transform(variance, covariant)
+          }
+        };
 
         if expected == actual { ret some((expected, newvariance)); }
         if variance == covariant {

src/test/run-pass/mutable-huh-variance-vec1.rs

@@ -0,0 +1,13 @@
+// error-pattern: mismatched types
+
+fn main() {
+    let v = [[0]];
+
+    // This is ok because the outer vec is covariant with respect
+    // to the inner vec. If the outer vec was mutable then we
+    // couldn't do this.
+    fn f(&&v: [[mutable? int]]) {
+    }
+
+    f(v);
+}

src/test/run-pass/mutable-huh-variance-vec2.rs

@@ -0,0 +1,13 @@
+// error-pattern: mismatched types
+
+fn main() {
+    let v = [[0]];
+
+    // This is ok because the outer vec is covariant with respect
+    // to the inner vec. If the outer vec was mutable then we
+    // couldn't do this.
+    fn f(&&v: [mutable? [mutable? int]]) {
+    }
+
+    f(v);
+}