Remove contravariance; fix a bug in GLB; adjust tests

Author: nikomatsakis

src/librustc/middle/infer/higher_ranked/README.md

@@ -317,14 +317,13 @@ in computing the replacements for the various variables. For each
 region `R` that appears in the type `F`, we again compute `Tainted(R)`
 and examine the results:
 
-1. If `R` is not in `V`, it is not replaced.
-2. Else, if `Tainted(R)` contains only variables in `V`, and it
+1. If `Tainted(R)` contains only variables in `V`, and it
    contains exactly one variable from the LHS and one variable from
    the RHS, then `R` can be mapped to the bound version of the
    variable from the LHS.
-3. Else, if `Tainted(R)` contains no variable from the LHS and no
+2. Else, if `Tainted(R)` contains no variable from the LHS and no
    variable from the RHS, then `R` can be mapped to itself.
-4. Else, `R` is mapped to a fresh bound variable.
+3. Else, `R` is mapped to a fresh bound variable.
 
 These rules are pretty complex.  Let's look at some examples to see
 how they play out.

src/librustc/middle/infer/higher_ranked/mod.rs

@@ -247,11 +247,6 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
                              a_vars: &[ty::RegionVid],
                              b_vars: &[ty::RegionVid],
                              r0: ty::Region) -> ty::Region {
-            if !is_var_in_set(new_vars, r0) {
-                assert!(!r0.is_bound());
-                return r0;
-            }
-
             let tainted = infcx.tainted_regions(snapshot, r0);
 
             let mut a_r = None;

src/librustc/middle/ty_relate/mod.rs

@@ -290,8 +290,9 @@ fn relate_arg_vecs<'a,'tcx:'a,R>(relation: &mut R,
         return Err(ty::terr_arg_count);
     }
 
-    a_args.iter().zip(b_args)
-          .map(|(a, b)| relation.relate_with_variance(ty::Contravariant, a, b))
+    a_args.iter()
+          .zip(b_args)
+          .map(|(a, b)| relation.relate_with_variance(ty::Invariant, a, b))
           .collect()
 }
 

src/librustc_driver/test.rs

@@ -415,6 +415,8 @@ impl<'a, 'tcx> Env<'a, 'tcx> {
                 panic!("unexpected error computing LUB: {:?}", e)
             }
             Ok(t) => {
+                debug!("glb yielded: y={}", t);
+
                 self.assert_eq(t, t_glb);
 
                 // sanity check for good measure:

src/librustc_typeck/variance.rs

@@ -1027,9 +1027,9 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                                 generics: &ty::Generics<'tcx>,
                                 sig: &ty::PolyFnSig<'tcx>,
                                 variance: VarianceTermPtr<'a>) {
-        let contra = self.contravariant(variance);
+        let invariant = self.invariant(variance);
         for &input in &sig.0.inputs {
-            self.add_constraints_from_ty(generics, input, contra);
+            self.add_constraints_from_ty(generics, input, invariant);
         }
         if let ty::FnConverging(result_type) = sig.0.output {
             self.add_constraints_from_ty(generics, result_type, variance);

src/test/compile-fail/regions-assoc-type-outlives-container-hrtb.rs

@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Test that structs with higher-ranked where clauses don't generate
-// "outlives" requirements. Issue #22246.
+// Test structs with higher-ranked where clauses and "outlives"
+// requirements. Issue #22246.
 
 #![allow(dead_code)]
 #![feature(rustc_attrs)]
@@ -37,10 +37,9 @@ pub struct WithHrAssoc<T>
 }
 
 fn with_assoc<'a,'b>() {
-    // We get no error here because the where clause has a higher-ranked assoc type,
-    // which could not be projected from.
-
+    // We now get an error here because `&'a` can reach the `'b`:
     let _: &'a WithHrAssoc<TheType<'b>> = loop { };
+    //~^ ERROR cannot infer
 }
 
 ///////////////////////////////////////////////////////////////////////////
@@ -61,8 +60,7 @@ fn with_assoc_sub<'a,'b>() {
     // extends a trait in a HR way.
 
     let _: &'a WithHrAssocSub<TheType<'b>> = loop { };
+    //~^ ERROR cannot infer
 }
 
-#[rustc_error]
-fn main() { //~ ERROR compilation successful
-}
+fn main() {}

src/test/compile-fail/regions-assoc-type-outlives-container.rs

@@ -64,6 +64,7 @@ fn without_assoc<'a,'b>() {
     // that `'b:'a` holds.
 
     let _: &'a WithoutAssoc<TheType<'b>> = loop { };
+    //~^ ERROR cannot infer
 }
 
 fn call_with_assoc<'a,'b>() {
@@ -73,12 +74,14 @@ fn call_with_assoc<'a,'b>() {
 
     call::<&'a WithAssoc<TheType<'b>>>();
     //~^ ERROR cannot infer
+    //~| ERROR reference has a longer lifetime
 }
 
 fn call_without_assoc<'a,'b>() {
     // As `without_assoc`, but in a distinct scenario.
 
     call::<&'a WithoutAssoc<TheType<'b>>>();
+    //~^ ERROR reference has a longer lifetime
 }
 
 fn call<T>() { }

src/test/run-pass/regions-variance-covariant-use-covariant.rs renamed to src/test/compile-fail/regions-variance-covariant-use-covariant.rs

@@ -24,8 +24,9 @@ struct Covariant<'a> {
 }
 
 fn use_<'a>(c: Covariant<'a>) {
-    // OK Because Covariant<'a> <: Covariant<'static> iff 'a <= 'static
+    // fn arguments are invariant now
     let _: Covariant<'static> = c;
+    //~^ ERROR mismatched types
 }
 
 pub fn main() {}

src/test/compile-fail/variance-regions-direct.rs

@@ -25,7 +25,7 @@ struct Test2<'a, 'b, 'c> { //~ ERROR regions=[[-, -, -];[];[]]
 // Those same annotations in function arguments become covariant:
 
 #[rustc_variance]
-struct Test3<'a, 'b, 'c> { //~ ERROR regions=[[+, +, +];[];[]]
+struct Test3<'a, 'b, 'c> { //~ ERROR regions=[[o, o, o];[];[]]
     x: extern "Rust" fn(&'a isize),
     y: extern "Rust" fn(&'b [isize]),
     c: extern "Rust" fn(&'c str),
@@ -42,7 +42,7 @@ struct Test4<'a, 'b:'a> { //~ ERROR regions=[[-, o];[];[]]
 // contravariant context:
 
 #[rustc_variance]
-struct Test5<'a, 'b> { //~ ERROR regions=[[+, o];[];[]]
+struct Test5<'a, 'b> { //~ ERROR regions=[[o, o];[];[]]
     x: extern "Rust" fn(&'a mut &'b isize),
 }
 
@@ -67,7 +67,7 @@ struct Test7<'a> { //~ ERROR regions=[[*];[];[]]
 // Try enums too.
 
 #[rustc_variance]
-enum Test8<'a, 'b, 'c:'b> { //~ ERROR regions=[[+, -, o];[];[]]
+enum Test8<'a, 'b, 'c:'b> { //~ ERROR regions=[[o, -, o];[];[]]
     Test8A(extern "Rust" fn(&'a isize)),
     Test8B(&'b [isize]),
     Test8C(&'b mut &'c str),

src/test/compile-fail/variance-regions-indirect.rs

@@ -15,15 +15,15 @@
 #![feature(rustc_attrs)]
 
 #[rustc_variance]
-enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR regions=[[+, -, o, *];[];[]]
+enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR regions=[[o, -, o, *];[];[]]
     //~^ ERROR parameter `'d` is never used
     Test8A(extern "Rust" fn(&'a isize)),
     Test8B(&'b [isize]),
     Test8C(&'b mut &'c str),
 }
 
 #[rustc_variance]
-struct Derived1<'w, 'x:'y, 'y, 'z> { //~ ERROR regions=[[*, o, -, +];[];[]]
+struct Derived1<'w, 'x:'y, 'y, 'z> { //~ ERROR regions=[[*, o, -, o];[];[]]
     //~^ ERROR parameter `'w` is never used
     f: Base<'z, 'y, 'x, 'w>
 }
@@ -40,9 +40,4 @@ struct Derived3<'a:'b, 'b, 'c> { //~ ERROR regions=[[o, -, *];[];[]]
     f: Base<'a, 'b, 'a, 'c>
 }
 
-#[rustc_variance] // Combine + and * to yield + (just pay attention to 'a here)
-struct Derived4<'a, 'b, 'c:'b> { //~ ERROR regions=[[+, -, o];[];[]]
-    f: Base<'a, 'b, 'c, 'a>
-}
-
 fn main() {}