Remove the "leak check" in favor of "universes"

src/librustc/ich/impls_ty.rs

@@ -1066,7 +1066,6 @@ for ty::steal::Steal<T>
 
 impl_stable_hash_for!(struct ty::ParamEnv<'tcx> {
     caller_bounds,
-    universe,
     reveal
 });
 
@@ -1237,15 +1236,6 @@ for traits::VtableGeneratorData<'gcx, N> where N: HashStable<StableHashingContex
     }
 }
 
-impl<'a> HashStable<StableHashingContext<'a>>
-for ty::UniverseIndex {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        self.depth().hash_stable(hcx, hasher);
-    }
-}
-
 impl_stable_hash_for!(
     impl<'tcx, V> for struct infer::canonical::Canonical<'tcx, V> {
         variables, value

src/librustc/infer/anon_types/mod.rs

@@ -600,8 +600,7 @@ impl<'a, 'gcx, 'tcx> Instantiator<'a, 'gcx, 'tcx> {
             return anon_defn.concrete_ty;
         }
         let span = tcx.def_span(def_id);
-        let ty_var = infcx.next_ty_var(ty::UniverseIndex::ROOT,
-                                       TypeVariableOrigin::TypeInference(span));
+        let ty_var = infcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
 
         let predicates_of = tcx.predicates_of(def_id);
         let bounds = predicates_of.instantiate(tcx, substs);

src/librustc/infer/at.rs

@@ -209,8 +209,8 @@ impl<'a, 'gcx, 'tcx> Trace<'a, 'gcx, 'tcx> {
         debug!("sub({:?} <: {:?})", a, b);
         let Trace { at, trace, a_is_expected } = self;
         at.infcx.commit_if_ok(|_| {
-            let mut fields = at.infcx.combine_fields(trace, at.param_env);
-            fields.sub(a_is_expected)
+            let mut fields = at.infcx.combine_fields(trace);
+            fields.sub(at.param_env, a_is_expected)
                   .relate(a, b)
                   .map(move |_| InferOk { value: (), obligations: fields.obligations })
         })
@@ -227,8 +227,8 @@ impl<'a, 'gcx, 'tcx> Trace<'a, 'gcx, 'tcx> {
         debug!("eq({:?} == {:?})", a, b);
         let Trace { at, trace, a_is_expected } = self;
         at.infcx.commit_if_ok(|_| {
-            let mut fields = at.infcx.combine_fields(trace, at.param_env);
-            fields.equate(a_is_expected)
+            let mut fields = at.infcx.combine_fields(trace);
+            fields.equate(at.param_env, a_is_expected)
                   .relate(a, b)
                   .map(move |_| InferOk { value: (), obligations: fields.obligations })
         })
@@ -243,8 +243,8 @@ impl<'a, 'gcx, 'tcx> Trace<'a, 'gcx, 'tcx> {
         debug!("lub({:?} \\/ {:?})", a, b);
         let Trace { at, trace, a_is_expected } = self;
         at.infcx.commit_if_ok(|_| {
-            let mut fields = at.infcx.combine_fields(trace, at.param_env);
-            fields.lub(a_is_expected)
+            let mut fields = at.infcx.combine_fields(trace);
+            fields.lub(at.param_env, a_is_expected)
                   .relate(a, b)
                   .map(move |t| InferOk { value: t, obligations: fields.obligations })
         })
@@ -259,8 +259,8 @@ impl<'a, 'gcx, 'tcx> Trace<'a, 'gcx, 'tcx> {
         debug!("glb({:?} /\\ {:?})", a, b);
         let Trace { at, trace, a_is_expected } = self;
         at.infcx.commit_if_ok(|_| {
-            let mut fields = at.infcx.combine_fields(trace, at.param_env);
-            fields.glb(a_is_expected)
+            let mut fields = at.infcx.combine_fields(trace);
+            fields.glb(at.param_env, a_is_expected)
                   .relate(a, b)
                   .map(move |t| InferOk { value: t, obligations: fields.obligations })
         })

src/librustc/infer/canonical.rs

@@ -250,8 +250,6 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
                 let ty = match ty_kind {
                     CanonicalTyVarKind::General => {
                         self.next_ty_var(
-                            // FIXME(#48696) this handling of universes is not right.
-                            ty::UniverseIndex::ROOT,
                             TypeVariableOrigin::MiscVariable(span),
                         )
                     }

src/librustc/infer/combine.rs

@@ -55,7 +55,6 @@ pub struct CombineFields<'infcx, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {
     pub infcx: &'infcx InferCtxt<'infcx, 'gcx, 'tcx>,
     pub trace: TypeTrace<'tcx>,
     pub cause: Option<ty::relate::Cause>,
-    pub param_env: ty::ParamEnv<'tcx>,
     pub obligations: PredicateObligations<'tcx>,
 }
 
@@ -159,20 +158,32 @@ impl<'infcx, 'gcx, 'tcx> CombineFields<'infcx, 'gcx, 'tcx> {
         self.infcx.tcx
     }
 
-    pub fn equate<'a>(&'a mut self, a_is_expected: bool) -> Equate<'a, 'infcx, 'gcx, 'tcx> {
-        Equate::new(self, a_is_expected)
+    pub fn equate<'a>(&'a mut self,
+                      param_env: ty::ParamEnv<'tcx>,
+                      a_is_expected: bool)
+                      -> Equate<'a, 'infcx, 'gcx, 'tcx> {
+        Equate::new(self, param_env, a_is_expected)
     }
 
-    pub fn sub<'a>(&'a mut self, a_is_expected: bool) -> Sub<'a, 'infcx, 'gcx, 'tcx> {
-        Sub::new(self, a_is_expected)
+    pub fn sub<'a>(&'a mut self,
+                   param_env: ty::ParamEnv<'tcx>,
+                   a_is_expected: bool)
+                   -> Sub<'a, 'infcx, 'gcx, 'tcx> {
+        Sub::new(self, param_env, a_is_expected)
     }
 
-    pub fn lub<'a>(&'a mut self, a_is_expected: bool) -> Lub<'a, 'infcx, 'gcx, 'tcx> {
-        Lub::new(self, a_is_expected)
+    pub fn lub<'a>(&'a mut self,
+                   param_env: ty::ParamEnv<'tcx>,
+                   a_is_expected: bool)
+                   -> Lub<'a, 'infcx, 'gcx, 'tcx> {
+        Lub::new(self, param_env, a_is_expected)
     }
 
-    pub fn glb<'a>(&'a mut self, a_is_expected: bool) -> Glb<'a, 'infcx, 'gcx, 'tcx> {
-        Glb::new(self, a_is_expected)
+    pub fn glb<'a>(&'a mut self,
+                   param_env: ty::ParamEnv<'tcx>,
+                   a_is_expected: bool)
+                   -> Glb<'a, 'infcx, 'gcx, 'tcx> {
+        Glb::new(self, param_env, a_is_expected)
     }
 
     /// Here dir is either EqTo, SubtypeOf, or SupertypeOf. The
@@ -185,6 +196,7 @@ impl<'infcx, 'gcx, 'tcx> CombineFields<'infcx, 'gcx, 'tcx> {
     /// of `a_ty`. Generalization introduces other inference
     /// variables wherever subtyping could occur.
     pub fn instantiate(&mut self,
+                       param_env: ty::ParamEnv<'tcx>,
                        a_ty: Ty<'tcx>,
                        dir: RelationDir,
                        b_vid: ty::TyVid,
@@ -216,7 +228,7 @@ impl<'infcx, 'gcx, 'tcx> CombineFields<'infcx, 'gcx, 'tcx> {
 
         if needs_wf {
             self.obligations.push(Obligation::new(self.trace.cause.clone(),
-                                                  self.param_env,
+                                                  param_env,
                                                   ty::Predicate::WellFormed(b_ty)));
         }
 
@@ -227,9 +239,9 @@ impl<'infcx, 'gcx, 'tcx> CombineFields<'infcx, 'gcx, 'tcx> {
         // to associate causes/spans with each of the relations in
         // the stack to get this right.
         match dir {
-            EqTo => self.equate(a_is_expected).relate(&a_ty, &b_ty),
-            SubtypeOf => self.sub(a_is_expected).relate(&a_ty, &b_ty),
-            SupertypeOf => self.sub(a_is_expected).relate_with_variance(
+            EqTo => self.equate(param_env, a_is_expected).relate(&a_ty, &b_ty),
+            SubtypeOf => self.sub(param_env, a_is_expected).relate(&a_ty, &b_ty),
+            SupertypeOf => self.sub(param_env, a_is_expected).relate_with_variance(
                 ty::Contravariant, &a_ty, &b_ty),
         }?;
 

src/librustc/infer/equate.rs

@@ -22,13 +22,16 @@ use ty::relate::{self, Relate, RelateResult, TypeRelation};
 pub struct Equate<'combine, 'infcx: 'combine, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {
     fields: &'combine mut CombineFields<'infcx, 'gcx, 'tcx>,
     a_is_expected: bool,
+    param_env: ty::ParamEnv<'tcx>,
 }
 
 impl<'combine, 'infcx, 'gcx, 'tcx> Equate<'combine, 'infcx, 'gcx, 'tcx> {
-    pub fn new(fields: &'combine mut CombineFields<'infcx, 'gcx, 'tcx>, a_is_expected: bool)
+    pub fn new(fields: &'combine mut CombineFields<'infcx, 'gcx, 'tcx>,
+               param_env: ty::ParamEnv<'tcx>,
+               a_is_expected: bool)
         -> Equate<'combine, 'infcx, 'gcx, 'tcx>
     {
-        Equate { fields: fields, a_is_expected: a_is_expected }
+        Equate { fields, a_is_expected, param_env }
     }
 }
 
@@ -81,12 +84,20 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
             }
 
             (&ty::TyInfer(TyVar(a_id)), _) => {
-                self.fields.instantiate(b, RelationDir::EqTo, a_id, self.a_is_expected)?;
+                self.fields.instantiate(self.param_env,
+                                        b,
+                                        RelationDir::EqTo,
+                                        a_id,
+                                        self.a_is_expected)?;
                 Ok(a)
             }
 
             (_, &ty::TyInfer(TyVar(b_id))) => {
-                self.fields.instantiate(a, RelationDir::EqTo, b_id, self.a_is_expected)?;
+                self.fields.instantiate(self.param_env,
+                                        a,
+                                        RelationDir::EqTo,
+                                        b_id,
+                                        self.a_is_expected)?;
                 Ok(a)
             }
 
@@ -113,7 +124,7 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
                   -> RelateResult<'tcx, ty::Binder<T>>
         where T: Relate<'tcx>
     {
-        self.fields.higher_ranked_sub(a, b, self.a_is_expected)?;
-        self.fields.higher_ranked_sub(b, a, self.a_is_expected)
+        self.fields.higher_ranked_sub(self.param_env, a, b, self.a_is_expected)?;
+        self.fields.higher_ranked_sub(self.param_env, b, a, self.a_is_expected)
     }
 }

src/librustc/infer/error_reporting/mod.rs

@@ -933,7 +933,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         }
 
         self.check_and_note_conflicting_crates(diag, terr, span);
-        self.tcx.note_and_explain_type_err(diag, terr, span);
+        self.tcx.note_and_explain_type_err(diag, terr);
 
         // It reads better to have the error origin as the final
         // thing.

src/librustc/infer/fudge.rs

@@ -141,11 +141,7 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for RegionFudger<'a, 'gcx, 'tcx> {
                         // This variable was created during the
                         // fudging. Recreate it with a fresh variable
                         // here.
-                        //
-                        // The ROOT universe is fine because we only
-                        // ever invoke this routine at the
-                        // "item-level" of inference.
-                        self.infcx.next_ty_var(ty::UniverseIndex::ROOT, origin)
+                        self.infcx.next_ty_var(origin)
                     }
                 }
             }

src/librustc/infer/glb.rs

@@ -15,20 +15,22 @@ use super::Subtype;
 
 use traits::ObligationCause;
 use ty::{self, Ty, TyCtxt};
-use ty::error::TypeError;
 use ty::relate::{Relate, RelateResult, TypeRelation};
 
 /// "Greatest lower bound" (common subtype)
 pub struct Glb<'combine, 'infcx: 'combine, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {
     fields: &'combine mut CombineFields<'infcx, 'gcx, 'tcx>,
     a_is_expected: bool,
+    param_env: ty::ParamEnv<'tcx>,
 }
 
 impl<'combine, 'infcx, 'gcx, 'tcx> Glb<'combine, 'infcx, 'gcx, 'tcx> {
-    pub fn new(fields: &'combine mut CombineFields<'infcx, 'gcx, 'tcx>, a_is_expected: bool)
-        -> Glb<'combine, 'infcx, 'gcx, 'tcx>
+    pub fn new(fields: &'combine mut CombineFields<'infcx, 'gcx, 'tcx>,
+               param_env: ty::ParamEnv<'tcx>,
+               a_is_expected: bool)
+               -> Glb<'combine, 'infcx, 'gcx, 'tcx>
     {
-        Glb { fields: fields, a_is_expected: a_is_expected }
+        Glb { fields, a_is_expected, param_env }
     }
 }
 
@@ -48,11 +50,11 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
                                              -> RelateResult<'tcx, T>
     {
         match variance {
-            ty::Invariant => self.fields.equate(self.a_is_expected).relate(a, b),
+            ty::Invariant => self.fields.equate(self.param_env, self.a_is_expected).relate(a, b),
             ty::Covariant => self.relate(a, b),
             // FIXME(#41044) -- not correct, need test
             ty::Bivariant => Ok(a.clone()),
-            ty::Contravariant => self.fields.lub(self.a_is_expected).relate(a, b),
+            ty::Contravariant => self.fields.lub(self.param_env, self.a_is_expected).relate(a, b),
         }
     }
 
@@ -76,29 +78,15 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
         where T: Relate<'tcx>
     {
         debug!("binders(a={:?}, b={:?})", a, b);
-        let was_error = self.infcx().probe(|_snapshot| {
-            // Subtle: use a fresh combine-fields here because we recover
-            // from Err. Doing otherwise could propagate obligations out
-            // through our `self.obligations` field.
-            self.infcx()
-                .combine_fields(self.fields.trace.clone(), self.fields.param_env)
-                .higher_ranked_glb(a, b, self.a_is_expected)
-                .is_err()
-        });
-        debug!("binders: was_error={:?}", was_error);
 
         // When higher-ranked types are involved, computing the LUB is
         // very challenging, switch to invariance. This is obviously
         // overly conservative but works ok in practice.
         match self.relate_with_variance(ty::Variance::Invariant, a, b) {
             Ok(_) => Ok(a.clone()),
             Err(err) => {
-                debug!("binders: error occurred, was_error={:?}", was_error);
-                if !was_error {
-                    Err(TypeError::OldStyleLUB(Box::new(err)))
-                } else {
-                    Err(err)
-                }
+                debug!("binders: error occurred");
+                Err(err)
             }
         }
     }
@@ -116,7 +104,7 @@ impl<'combine, 'infcx, 'gcx, 'tcx> LatticeDir<'infcx, 'gcx, 'tcx>
     }
 
     fn relate_bound(&mut self, v: Ty<'tcx>, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, ()> {
-        let mut sub = self.fields.sub(self.a_is_expected);
+        let mut sub = self.fields.sub(self.param_env, self.a_is_expected);
         sub.relate(&v, &a)?;
         sub.relate(&v, &b)?;
         Ok(())