use TypeFolder in generalization instead of Relate

This kills the annoying `relate(a, a)` hack

Author: arielb1

src/librustc/infer/combine.rs

@@ -29,13 +29,13 @@ use super::lub::Lub;
 use super::sub::Sub;
 use super::type_variable::TypeVariableValue;
 
-use crate::hir::def_id::DefId;
 use crate::ty::{IntType, UintType};
 use crate::ty::{self, Ty, TyCtxt};
+use crate::ty::fold::{TypeFoldable, TypeFolder};
 use crate::ty::error::TypeError;
-use crate::ty::relate::{self, Relate, RelateResult, TypeRelation};
-use crate::ty::subst::SubstsRef;
+use crate::ty::relate::{RelateResult, TypeRelation};
 use crate::traits::{Obligation, PredicateObligations};
+use crate::util::common::ErrorReported;
 
 use syntax::ast;
 use syntax_pos::Span;
@@ -278,7 +278,7 @@ impl<'infcx, 'gcx, 'tcx> CombineFields<'infcx, 'gcx, 'tcx> {
             root_ty: ty,
         };
 
-        let ty = match generalize.relate(&ty, &ty) {
+        let ty = match ty.fold_with(&mut generalize) {
             Ok(ty) => ty,
             Err(e) => {
                 debug!("generalize: failure {:?}", e);
@@ -351,60 +351,40 @@ struct Generalization<'tcx> {
     needs_wf: bool,
 }
 
-impl<'cx, 'gcx, 'tcx> TypeRelation<'cx, 'gcx, 'tcx> for Generalizer<'cx, 'gcx, 'tcx> {
-    fn tcx(&self) -> TyCtxt<'cx, 'gcx, 'tcx> {
-        self.infcx.tcx
-    }
-
-    fn tag(&self) -> &'static str {
-        "Generalizer"
-    }
+impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for Generalizer<'cx, 'gcx, 'tcx> {
+    type Error = TypeError<'tcx>;
 
-    fn a_is_expected(&self) -> bool {
-        true
-    }
-
-    fn binders<T>(&mut self, a: &ty::Binder<T>, b: &ty::Binder<T>)
-                  -> RelateResult<'tcx, ty::Binder<T>>
-        where T: Relate<'tcx>
-    {
-        Ok(ty::Binder::bind(self.relate(a.skip_binder(), b.skip_binder())?))
+    fn tcx(&self) -> TyCtxt<'_, 'gcx, 'tcx> {
+        self.infcx.tcx
     }
 
-    fn relate_item_substs(&mut self,
-                          item_def_id: DefId,
-                          a_subst: SubstsRef<'tcx>,
-                          b_subst: SubstsRef<'tcx>)
-                          -> RelateResult<'tcx, SubstsRef<'tcx>>
-    {
+    fn use_variances(&self) -> bool {
         if self.ambient_variance == ty::Variance::Invariant {
             // Avoid fetching the variance if we are in an invariant
             // context; no need, and it can induce dependency cycles
             // (e.g., #41849).
-            relate::relate_substs(self, None, a_subst, b_subst)
+            false
         } else {
-            let opt_variances = self.tcx().variances_of(item_def_id);
-            relate::relate_substs(self, Some(&opt_variances), a_subst, b_subst)
+            true
         }
     }
 
-    fn relate_with_variance<T: Relate<'tcx>>(&mut self,
-                                             variance: ty::Variance,
-                                             a: &T,
-                                             b: &T)
-                                             -> RelateResult<'tcx, T>
+    fn fold_with_variance<T: TypeFoldable<'tcx>>(&mut self,
+                                                 variance: ty::Variance,
+                                                 a: &T)
+                                                 -> RelateResult<'tcx, T>
     {
         let old_ambient_variance = self.ambient_variance;
+        debug!("Generalize: fold_with_variance({:?}, {:?}, old_variance={:?})", variance, a, old_ambient_variance);
         self.ambient_variance = self.ambient_variance.xform(variance);
 
-        let result = self.relate(a, b);
+        let result = a.fold_with(self);
         self.ambient_variance = old_ambient_variance;
         result
     }
 
-    fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
-        assert_eq!(t, t2); // we are abusing TypeRelation here; both LHS and RHS ought to be ==
-
+    fn fold_ty(&mut self, t: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
+        debug!("Generalize: fold_ty({:?}, variance={:?})", t, self.ambient_variance);
         debug!("generalize: t={:?}", t);
 
         // Check to see whether the type we are genealizing references
@@ -425,7 +405,7 @@ impl<'cx, 'gcx, 'tcx> TypeRelation<'cx, 'gcx, 'tcx> for Generalizer<'cx, 'gcx, '
                         TypeVariableValue::Known { value: u } => {
                             drop(variables);
                             debug!("generalize: known value {:?}", u);
-                            self.relate(&u, &u)
+                            u.fold_with(self)
                         }
                         TypeVariableValue::Unknown { universe } => {
                             match self.ambient_variance {
@@ -449,7 +429,7 @@ impl<'cx, 'gcx, 'tcx> TypeRelation<'cx, 'gcx, 'tcx> for Generalizer<'cx, 'gcx, '
 
                             let origin = *variables.var_origin(vid);
                             let new_var_id = variables.new_var(self.for_universe, false, origin);
-                            let u = self.tcx().mk_var(new_var_id);
+                            let u = self.infcx.tcx.mk_var(new_var_id);
                             debug!("generalize: replacing original vid={:?} with new={:?}",
                                    vid, u);
                             return Ok(u);
@@ -459,21 +439,33 @@ impl<'cx, 'gcx, 'tcx> TypeRelation<'cx, 'gcx, 'tcx> for Generalizer<'cx, 'gcx, '
             }
             ty::Infer(ty::IntVar(_)) |
             ty::Infer(ty::FloatVar(_)) => {
-                // No matter what mode we are in,
-                // integer/floating-point types must be equal to be
-                // relatable.
                 Ok(t)
             }
+            ty::Array(_, sz) => {
+                // HACK, not sure how desirable this is: propagate errors from
+                // array lengths to the array type itself. This makes error
+                // messages a bit nicer, and used to be the case before because
+                // we used `ty::relate` instead of `TypeFoldable`, so I'll keep
+                // it here.
+                //
+                // This does not serve any functional purpose, but it does
+                // avoid some "duplicate" errors.
+                match self.infcx.tcx.force_eval_array_length(*sz) {
+                    Ok(_) => t.super_fold_with(self),
+                    Err(ErrorReported) => {
+                        Ok(self.infcx.tcx.types.err)
+                    }
+                }
+            }
             _ => {
-                relate::super_relate_tys(self, t, t)
+                t.super_fold_with(self)
             }
         }
     }
 
-    fn regions(&mut self, r: ty::Region<'tcx>, r2: ty::Region<'tcx>)
+    fn fold_region(&mut self, r: ty::Region<'tcx>)
                -> RelateResult<'tcx, ty::Region<'tcx>> {
-        assert_eq!(r, r2); // we are abusing TypeRelation here; both LHS and RHS ought to be ==
-
+        debug!("Generalize: fold_region({:?}, variance={:?})", r, self.ambient_variance);
         debug!("generalize: regions r={:?}", r);
 
         match *r {

src/librustc/infer/nll_relate/mod.rs

@@ -22,8 +22,8 @@
 //!   constituents)
 
 use crate::infer::InferCtxt;
-use crate::ty::fold::{TypeFoldable, TypeVisitor};
-use crate::ty::relate::{self, Relate, RelateResult, TypeRelation};
+use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
+use crate::ty::relate::{Relate, RelateResult, TypeRelation};
 use crate::ty::subst::Kind;
 use crate::ty::{self, Ty, TyCtxt};
 use crate::ty::error::TypeError;
@@ -344,7 +344,7 @@ where
         result
     }
 
-    fn generalize_value<T: Relate<'tcx>>(
+    fn generalize_value<T: TypeFoldable<'tcx>>(
         &mut self,
         value: T,
         for_vid: ty::TyVid
@@ -360,7 +360,7 @@ where
             universe,
         };
 
-        generalizer.relate(&value, &value)
+        value.fold_with(&mut generalizer)
     }
 }
 
@@ -680,54 +680,58 @@ where
     universe: ty::UniverseIndex,
 }
 
-impl<D> TypeRelation<'me, 'gcx, 'tcx> for TypeGeneralizer<'me, 'gcx, 'tcx, D>
+impl<D> TypeFolder<'gcx, 'tcx> for TypeGeneralizer<'me, 'gcx, 'tcx, D>
 where
     D: TypeRelatingDelegate<'tcx>,
 {
-    fn tcx(&self) -> TyCtxt<'me, 'gcx, 'tcx> {
-        self.infcx.tcx
-    }
+    type Error = TypeError<'tcx>;
 
-    fn tag(&self) -> &'static str {
-        "nll::generalizer"
+    fn tcx(&self) -> TyCtxt<'_, 'gcx, 'tcx> {
+        self.infcx.tcx
     }
 
-    fn a_is_expected(&self) -> bool {
-        true
+    fn use_variances(&self) -> bool {
+        if self.ambient_variance == ty::Variance::Invariant {
+            // Avoid fetching the variance if we are in an invariant
+            // context; no need, and it can induce dependency cycles
+            // (e.g., #41849).
+            false
+        } else {
+            true
+        }
     }
 
-    fn relate_with_variance<T: Relate<'tcx>>(
+    fn fold_with_variance<T: TypeFoldable<'tcx>>(
         &mut self,
         variance: ty::Variance,
         a: &T,
-        b: &T,
     ) -> RelateResult<'tcx, T> {
         debug!(
-            "TypeGeneralizer::relate_with_variance(variance={:?}, a={:?}, b={:?})",
-            variance, a, b
+            "TypeGeneralizer::fold_with_variance(variance={:?}, a={:?})",
+            variance, a
         );
 
         let old_ambient_variance = self.ambient_variance;
         self.ambient_variance = self.ambient_variance.xform(variance);
 
         debug!(
-            "TypeGeneralizer::relate_with_variance: ambient_variance = {:?}",
+            "TypeGeneralizer::fold_with_variance: ambient_variance = {:?}",
             self.ambient_variance
         );
 
-        let r = self.relate(a, b)?;
+        let r = a.super_fold_with(self)?;
 
         self.ambient_variance = old_ambient_variance;
 
-        debug!("TypeGeneralizer::relate_with_variance: r={:?}", r);
+        debug!("TypeGeneralizer::fold_with_variance: r={:?}", r);
 
         Ok(r)
     }
 
-    fn tys(&mut self, a: Ty<'tcx>, _: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
+    fn fold_ty(&mut self, a: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
         use crate::infer::type_variable::TypeVariableValue;
 
-        debug!("TypeGeneralizer::tys(a={:?})", a,);
+        debug!("TypeGeneralizer::fold_ty(a={:?})", a,);
 
         match a.sty {
             ty::Infer(ty::TyVar(_)) | ty::Infer(ty::IntVar(_)) | ty::Infer(ty::FloatVar(_))
@@ -746,13 +750,13 @@ where
                 if sub_vid == self.for_vid_sub_root {
                     // If sub-roots are equal, then `for_vid` and
                     // `vid` are related via subtyping.
-                    debug!("TypeGeneralizer::tys: occurs check failed");
+                    debug!("TypeGeneralizer::fold_ty: occurs check failed");
                     return Err(TypeError::Mismatch);
                 } else {
                     match variables.probe(vid) {
                         TypeVariableValue::Known { value: u } => {
                             drop(variables);
-                            self.relate(&u, &u)
+                            u.fold_with(self)
                         }
                         TypeVariableValue::Unknown { universe: _universe } => {
                             if self.ambient_variance == ty::Bivariant {
@@ -789,7 +793,7 @@ where
             ty::Placeholder(placeholder) => {
                 if self.universe.cannot_name(placeholder.universe) {
                     debug!(
-                        "TypeGeneralizer::tys: root universe {:?} cannot name\
+                        "TypeGeneralizer::fold_ty: root universe {:?} cannot name\
                         placeholder in universe {:?}",
                         self.universe,
                         placeholder.universe
@@ -801,17 +805,16 @@ where
             }
 
             _ => {
-                relate::super_relate_tys(self, a, a)
+                a.super_fold_with(self)
             }
         }
     }
 
-    fn regions(
+    fn fold_region(
         &mut self,
         a: ty::Region<'tcx>,
-        _: ty::Region<'tcx>,
     ) -> RelateResult<'tcx, ty::Region<'tcx>> {
-        debug!("TypeGeneralizer::regions(a={:?})", a,);
+        debug!("TypeGeneralizer::fold_region(a={:?})", a,);
 
         if let ty::ReLateBound(debruijn, _) = a {
             if *debruijn < self.first_free_index {
@@ -840,18 +843,17 @@ where
         Ok(replacement_region_vid)
     }
 
-    fn binders<T>(
+    fn fold_binder<T>(
         &mut self,
         a: &ty::Binder<T>,
-        _: &ty::Binder<T>,
     ) -> RelateResult<'tcx, ty::Binder<T>>
     where
-        T: Relate<'tcx>,
+        T: TypeFoldable<'tcx>,
     {
-        debug!("TypeGeneralizer::binders(a={:?})", a,);
+        debug!("TypeGeneralizer::fold_binder(a={:?})", a,);
 
         self.first_free_index.shift_in(1);
-        let result = self.relate(a.skip_binder(), a.skip_binder())?;
+        let result = a.skip_binder().fold_with(self)?;
         self.first_free_index.shift_out(1);
         Ok(ty::Binder::bind(result))
     }

src/librustc/ty/relate.rs

@@ -8,9 +8,7 @@ use crate::hir::def_id::DefId;
 use crate::ty::subst::{Kind, UnpackedKind, SubstsRef};
 use crate::ty::{self, Ty, TyCtxt, TypeFoldable};
 use crate::ty::error::{ExpectedFound, TypeError};
-use crate::mir::interpret::GlobalId;
 use crate::util::common::ErrorReported;
-use syntax_pos::DUMMY_SP;
 use std::rc::Rc;
 use std::iter;
 use rustc_target::spec::abi;
@@ -468,42 +466,8 @@ pub fn super_relate_tys<'a, 'gcx, 'tcx, R>(relation: &mut R,
         (&ty::Array(a_t, sz_a), &ty::Array(b_t, sz_b)) =>
         {
             let t = relation.relate(&a_t, &b_t)?;
-            let to_u64 = |x: ty::LazyConst<'tcx>| -> Result<u64, ErrorReported> {
-                match x {
-                    ty::LazyConst::Unevaluated(def_id, substs) => {
-                        // FIXME(eddyb) get the right param_env.
-                        let param_env = ty::ParamEnv::empty();
-                        if let Some(substs) = tcx.lift_to_global(&substs) {
-                            let instance = ty::Instance::resolve(
-                                tcx.global_tcx(),
-                                param_env,
-                                def_id,
-                                substs,
-                            );
-                            if let Some(instance) = instance {
-                                let cid = GlobalId {
-                                    instance,
-                                    promoted: None
-                                };
-                                if let Some(s) = tcx.const_eval(param_env.and(cid))
-                                                    .ok()
-                                                    .map(|c| c.unwrap_usize(tcx)) {
-                                    return Ok(s)
-                                }
-                            }
-                        }
-                        tcx.sess.delay_span_bug(tcx.def_span(def_id),
-                            "array length could not be evaluated");
-                        Err(ErrorReported)
-                    }
-                    ty::LazyConst::Evaluated(c) => c.assert_usize(tcx).ok_or_else(|| {
-                        tcx.sess.delay_span_bug(DUMMY_SP,
-                            "array length could not be evaluated");
-                        ErrorReported
-                    })
-                }
-            };
-            match (to_u64(*sz_a), to_u64(*sz_b)) {
+            match (tcx.force_eval_array_length(*sz_a),
+                   tcx.force_eval_array_length(*sz_b)) {
                 (Ok(sz_a_u64), Ok(sz_b_u64)) => {
                     if sz_a_u64 == sz_b_u64 {
                         Ok(tcx.mk_ty(ty::Array(t, sz_a)))