stop using fresh inference vars

lcnr · lcnr · commit 4d1fc2257baf · 2022-09-23T20:40:47.000+02:00
diff --git a/compiler/rustc_middle/src/traits/select.rs b/compiler/rustc_middle/src/traits/select.rs
@@ -5,25 +5,24 @@
 use self::EvaluationResult::*;
 
 use super::{SelectionError, SelectionResult};
-use rustc_errors::ErrorGuaranteed;
-
+use crate::traits::Canonical;
 use crate::ty;
-
+use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def_id::DefId;
 use rustc_query_system::cache::Cache;
 
 pub type SelectionCache<'tcx> = Cache<
     // This cache does not use `ParamEnvAnd` in its keys because `ParamEnv::and` can replace
     // caller bounds with an empty list if the `TraitPredicate` looks global, which may happen
     // after erasing lifetimes from the predicate.
-    (ty::ParamEnv<'tcx>, ty::TraitPredicate<'tcx>),
+    (ty::ParamEnv<'tcx>, Canonical<'tcx, ty::PolyTraitPredicate<'tcx>>),
     SelectionResult<'tcx, SelectionCandidate<'tcx>>,
 >;
 
 pub type EvaluationCache<'tcx> = Cache<
     // See above: this cache does not use `ParamEnvAnd` in its keys due to sometimes incorrectly
     // caching with the wrong `ParamEnv`.
-    (ty::ParamEnv<'tcx>, ty::PolyTraitPredicate<'tcx>),
+    (ty::ParamEnv<'tcx>, Canonical<'tcx, ty::PolyTraitPredicate<'tcx>>),
     EvaluationResult,
 >;
 
diff --git a/compiler/rustc_middle/src/ty/_match.rs b/compiler/rustc_middle/src/ty/_match.rs
@@ -1,17 +1,15 @@
 use crate::ty::error::TypeError;
 use crate::ty::relate::{self, Relate, RelateResult, TypeRelation};
-use crate::ty::{self, InferConst, Ty, TyCtxt};
+use crate::ty::{self, Ty, TyCtxt};
 
-/// A type "A" *matches* "B" if the fresh types in B could be
-/// substituted with values so as to make it equal to A. Matching is
-/// intended to be used only on freshened types, and it basically
-/// indicates if the non-freshened versions of A and B could have been
-/// unified.
+/// A type "A" *matches* "B" if the inference variables in B could be
+/// substituted with values so as to make it equal to A.
+/// Matching  basically indicates whether A would contain B.
 ///
 /// It is only an approximation. If it yields false, unification would
 /// definitely fail, but a true result doesn't mean unification would
 /// succeed. This is because we don't track the "side-constraints" on
-/// type variables, nor do we track if the same freshened type appears
+/// type variables, nor do we track if the same inference variable appears
 /// more than once. To some extent these approximations could be
 /// fixed, given effort.
 ///
@@ -69,16 +67,9 @@ impl<'tcx> TypeRelation<'tcx> for Match<'tcx> {
         }
 
         match (a.kind(), b.kind()) {
-            (
-                _,
-                &ty::Infer(ty::FreshTy(_))
-                | &ty::Infer(ty::FreshIntTy(_))
-                | &ty::Infer(ty::FreshFloatTy(_)),
-            ) => Ok(a),
-
-            (&ty::Infer(_), _) | (_, &ty::Infer(_)) => {
-                Err(TypeError::Sorts(relate::expected_found(self, a, b)))
-            }
+            (_, &ty::Infer(_)) => Ok(a),
+
+            (&ty::Infer(_), _) => Err(TypeError::Sorts(relate::expected_found(self, a, b))),
 
             (&ty::Error(_), _) | (_, &ty::Error(_)) => Ok(self.tcx().ty_error()),
 
@@ -97,11 +88,11 @@ impl<'tcx> TypeRelation<'tcx> for Match<'tcx> {
         }
 
         match (a.kind(), b.kind()) {
-            (_, ty::ConstKind::Infer(InferConst::Fresh(_))) => {
+            (_, ty::ConstKind::Infer(_)) => {
                 return Ok(a);
             }
 
-            (ty::ConstKind::Infer(_), _) | (_, ty::ConstKind::Infer(_)) => {
+            (ty::ConstKind::Infer(_), _) => {
                 return Err(TypeError::ConstMismatch(relate::expected_found(self, a, b)));
             }
 
diff --git a/compiler/rustc_middle/src/ty/erase_regions.rs b/compiler/rustc_middle/src/ty/erase_regions.rs
@@ -30,6 +30,24 @@ impl<'tcx> TyCtxt<'tcx> {
         debug!("erase_regions = {:?}", value1);
         value1
     }
+
+    pub fn erase_regions_keep_static<T>(self, value: T) -> T
+    where
+        T: TypeFoldable<'tcx>,
+    {
+        if value.has_free_regions() {
+            self.fold_regions(value, |r, _| match r.kind() {
+                ty::ReLateBound(_, _) | ty::ReStatic => r,
+                ty::ReEarlyBound(_)
+                | ty::ReFree(_)
+                | ty::ReVar(_)
+                | ty::RePlaceholder(_)
+                | ty::ReErased => self.lifetimes.re_erased,
+            })
+        } else {
+            value
+        }
+    }
 }
 
 struct RegionEraserVisitor<'tcx> {
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@@ -7,6 +7,7 @@ use crate::errors::UnableToConstructConstantValue;
 use crate::infer::region_constraints::{Constraint, RegionConstraintData};
 use crate::infer::InferCtxt;
 use crate::traits::project::ProjectAndUnifyResult;
+use rustc_middle::infer::canonical::{Canonical, OriginalQueryValues};
 use rustc_middle::mir::interpret::ErrorHandled;
 use rustc_middle::ty::fold::{TypeFolder, TypeSuperFoldable};
 use rustc_middle::ty::visit::TypeVisitable;
@@ -160,7 +161,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
             // SomeTrait' doesn't hold, then we don't need to care about the 'SomeItem = K'
             //
             // We fix the first assumption by manually clearing out all of the InferCtxt's caches
-            // in between calls to SelectionContext.select. This allows us to keep all of the
+            // in between calls to `selcx.select`. This allows us to keep all of the
             // intermediate types we create bound to the 'tcx lifetime, rather than needing to lift
             // them between calls.
             //
@@ -233,7 +234,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
 impl<'tcx> AutoTraitFinder<'tcx> {
     /// The core logic responsible for computing the bounds for our synthesized impl.
     ///
-    /// To calculate the bounds, we call `SelectionContext.select` in a loop. Like
+    /// To calculate the bounds, we call `selcx.select` in a loop. Like
     /// `FulfillmentContext`, we recursively select the nested obligations of predicates we
     /// encounter. However, whenever we encounter an `UnimplementedError` involving a type
     /// parameter, we add it to our `ParamEnv`. Since our goal is to determine when a particular
@@ -277,7 +278,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
         ty: Ty<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         user_env: ty::ParamEnv<'tcx>,
-        fresh_preds: &mut FxHashSet<ty::Predicate<'tcx>>,
+        deduplicated_preds: &mut FxHashSet<Canonical<'tcx, ty::Predicate<'tcx>>>,
         only_projections: bool,
     ) -> Option<(ty::ParamEnv<'tcx>, ty::ParamEnv<'tcx>)> {
         let tcx = infcx.tcx;
@@ -286,10 +287,13 @@ impl<'tcx> AutoTraitFinder<'tcx> {
         // that are already in the `ParamEnv` (modulo regions): we already
         // know that they must hold.
         for predicate in param_env.caller_bounds() {
-            fresh_preds.insert(self.clean_pred(infcx, predicate));
+            deduplicated_preds.insert(
+                infcx
+                    .canonicalize_query_keep_static(predicate, &mut OriginalQueryValues::default()),
+            );
         }
 
-        let mut select = SelectionContext::new(&infcx);
+        let mut selcx = SelectionContext::new(&infcx);
 
         let mut already_visited = FxHashSet::default();
         let mut predicates = VecDeque::new();
@@ -320,7 +324,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
             // get rid of any inference variables.
             let obligation =
                 infcx.resolve_vars_if_possible(Obligation::new(dummy_cause.clone(), new_env, pred));
-            let result = select.select(&obligation);
+            let result = selcx.select(&obligation);
 
             match result {
                 Ok(Some(ref impl_source)) => {
@@ -348,9 +352,9 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                         ty,
                         obligations,
                         &mut user_computed_preds,
-                        fresh_preds,
+                        deduplicated_preds,
                         &mut predicates,
-                        &mut select,
+                        &mut selcx,
                         only_projections,
                     ) {
                         return None;
@@ -403,7 +407,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
     }
 
     /// This method is designed to work around the following issue:
-    /// When we compute auto trait bounds, we repeatedly call `SelectionContext.select`,
+    /// When we compute auto trait bounds, we repeatedly call `selcx.select`,
     /// progressively building a `ParamEnv` based on the results we get.
     /// However, our usage of `SelectionContext` differs from its normal use within the compiler,
     /// in that we capture and re-reprocess predicates from `Unimplemented` errors.
@@ -624,19 +628,22 @@ impl<'tcx> AutoTraitFinder<'tcx> {
         ty: Ty<'_>,
         nested: impl Iterator<Item = Obligation<'tcx, ty::Predicate<'tcx>>>,
         computed_preds: &mut FxHashSet<ty::Predicate<'tcx>>,
-        fresh_preds: &mut FxHashSet<ty::Predicate<'tcx>>,
+        deduplicated_preds: &mut FxHashSet<Canonical<'tcx, ty::Predicate<'tcx>>>,
         predicates: &mut VecDeque<ty::PolyTraitPredicate<'tcx>>,
-        select: &mut SelectionContext<'_, 'tcx>,
+        selcx: &mut SelectionContext<'_, 'tcx>,
         only_projections: bool,
     ) -> bool {
         let dummy_cause = ObligationCause::dummy();
 
         for obligation in nested {
             let is_new_pred =
-                fresh_preds.insert(self.clean_pred(select.infcx(), obligation.predicate));
+                deduplicated_preds.insert(selcx.infcx().canonicalize_query_keep_static(
+                    obligation.predicate,
+                    &mut OriginalQueryValues::default(),
+                ));
 
             // Resolve any inference variables that we can, to help selection succeed
-            let predicate = select.infcx().resolve_vars_if_possible(obligation.predicate);
+            let predicate = selcx.infcx().resolve_vars_if_possible(obligation.predicate);
 
             // We only add a predicate as a user-displayable bound if
             // it involves a generic parameter, and doesn't contain
@@ -744,7 +751,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                     // and turn them into an explicit negative impl for our type.
                     debug!("Projecting and unifying projection predicate {:?}", predicate);
 
-                    match project::poly_project_and_unify_type(select, &obligation.with(p)) {
+                    match project::poly_project_and_unify_type(selcx, &obligation.with(p)) {
                         ProjectAndUnifyResult::MismatchedProjectionTypes(e) => {
                             debug!(
                                 "evaluate_nested_obligations: Unable to unify predicate \
@@ -767,9 +774,9 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                                     ty,
                                     v.into_iter(),
                                     computed_preds,
-                                    fresh_preds,
+                                    deduplicated_preds,
                                     predicates,
-                                    select,
+                                    selcx,
                                     only_projections,
                                 ) {
                                     return false;
@@ -792,7 +799,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                 }
                 ty::PredicateKind::RegionOutlives(binder) => {
                     let binder = bound_predicate.rebind(binder);
-                    select.infcx().region_outlives_predicate(&dummy_cause, binder)
+                    selcx.infcx().region_outlives_predicate(&dummy_cause, binder)
                 }
                 ty::PredicateKind::TypeOutlives(binder) => {
                     let binder = bound_predicate.rebind(binder);
@@ -801,14 +808,14 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                         binder.map_bound_ref(|pred| pred.0).no_bound_vars(),
                     ) {
                         (None, Some(t_a)) => {
-                            select.infcx().register_region_obligation_with_cause(
+                            selcx.infcx().register_region_obligation_with_cause(
                                 t_a,
-                                select.infcx().tcx.lifetimes.re_static,
+                                selcx.infcx().tcx.lifetimes.re_static,
                                 &dummy_cause,
                             );
                         }
                         (Some(ty::OutlivesPredicate(t_a, r_b)), _) => {
-                            select.infcx().register_region_obligation_with_cause(
+                            selcx.infcx().register_region_obligation_with_cause(
                                 t_a,
                                 r_b,
                                 &dummy_cause,
@@ -820,13 +827,13 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                 ty::PredicateKind::ConstEquate(c1, c2) => {
                     let evaluate = |c: ty::Const<'tcx>| {
                         if let ty::ConstKind::Unevaluated(unevaluated) = c.kind() {
-                            match select.infcx().const_eval_resolve(
+                            match selcx.infcx().const_eval_resolve(
                                 obligation.param_env,
                                 unevaluated,
                                 Some(obligation.cause.span),
                             ) {
                                 Ok(Some(valtree)) => {
-                                    Ok(ty::Const::from_value(select.tcx(), valtree, c.ty()))
+                                    Ok(ty::Const::from_value(selcx.tcx(), valtree, c.ty()))
                                 }
                                 Ok(None) => {
                                     let tcx = self.tcx;
@@ -847,7 +854,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
 
                     match (evaluate(c1), evaluate(c2)) {
                         (Ok(c1), Ok(c2)) => {
-                            match select
+                            match selcx
                                 .infcx()
                                 .at(&obligation.cause, obligation.param_env)
                                 .eq(c1, c2)
@@ -874,14 +881,6 @@ impl<'tcx> AutoTraitFinder<'tcx> {
         }
         true
     }
-
-    pub fn clean_pred(
-        &self,
-        infcx: &InferCtxt<'_, 'tcx>,
-        p: ty::Predicate<'tcx>,
-    ) -> ty::Predicate<'tcx> {
-        infcx.freshen(p)
-    }
 }
 
 // Replaces all ReVars in a type with ty::Region's, using the provided map
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -5,6 +5,11 @@
 //! candidates. See the [rustc dev guide] for more details.
 //!
 //! [rustc dev guide]:https://rustc-dev-guide.rust-lang.org/traits/resolution.html#candidate-assembly
+use crate::traits;
+use crate::traits::coherence::Conflict;
+use crate::traits::query::evaluate_obligation::InferCtxtExt;
+use crate::traits::{util, SelectionResult};
+use crate::traits::{Ambiguous, ErrorReporting, Overflow, Unimplemented};
 use hir::LangItem;
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
@@ -15,12 +20,6 @@ use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{self, ToPredicate, Ty, TypeVisitable};
 use rustc_target::spec::abi::Abi;
 
-use crate::traits;
-use crate::traits::coherence::Conflict;
-use crate::traits::query::evaluate_obligation::InferCtxtExt;
-use crate::traits::{util, SelectionResult};
-use crate::traits::{Ambiguous, ErrorReporting, Overflow, Unimplemented};
-
 use super::BuiltinImplConditions;
 use super::IntercrateAmbiguityCause;
 use super::OverflowError;
@@ -41,13 +40,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         // separately rather than using `stack.fresh_trait_ref` --
         // this is because we want the unbound variables to be
         // replaced with fresh types starting from index 0.
-        let cache_fresh_trait_pred = self.infcx.freshen(stack.obligation.predicate);
-        debug!(?cache_fresh_trait_pred);
+        let cache_entry =
+            self.canonicalize_for_cache(stack.obligation.param_env, stack.obligation.predicate);
         debug_assert!(!stack.obligation.predicate.has_escaping_bound_vars());
 
-        if let Some(c) =
-            self.check_candidate_cache(stack.obligation.param_env, cache_fresh_trait_pred)
-        {
+        if let Some(c) = self.check_candidate_cache(cache_entry) {
             debug!("CACHE HIT");
             return c;
         }
@@ -62,12 +59,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             self.in_task(|this| this.candidate_from_obligation_no_cache(stack));
 
         debug!("CACHE MISS");
-        self.insert_candidate_cache(
-            stack.obligation.param_env,
-            cache_fresh_trait_pred,
-            dep_node,
-            candidate.clone(),
-        );
+        self.insert_candidate_cache(cache_entry, dep_node, candidate.clone());
         candidate
     }
 
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
