Rollup merge of #89675 - oli-obk:type_checker, r=davidtwco

Re-use TypeChecker instead of passing around some of its fields

In the future (for lazy TAIT) we will need more of its fields, but even ignoring that, this change seems reasonable on its own to me.

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1153,28 +1153,6 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         .convert_all(data);
     }
 
-    /// Convenient wrapper around `relate_tys::relate_types` -- see
-    /// that fn for docs.
-    fn relate_types(
-        &mut self,
-        a: Ty<'tcx>,
-        v: ty::Variance,
-        b: Ty<'tcx>,
-        locations: Locations,
-        category: ConstraintCategory,
-    ) -> Fallible<()> {
-        relate_tys::relate_types(
-            self.infcx,
-            self.param_env,
-            a,
-            v,
-            b,
-            locations,
-            category,
-            self.borrowck_context,
-        )
-    }
-
     /// Try to relate `sub <: sup`
     fn sub_types(
         &mut self,

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -1,5 +1,5 @@
 use rustc_infer::infer::nll_relate::{NormalizationStrategy, TypeRelating, TypeRelatingDelegate};
-use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin};
+use rustc_infer::infer::NllRegionVariableOrigin;
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::ty::relate::TypeRelation;
 use rustc_middle::ty::{self, Const, Ty};
@@ -7,48 +7,38 @@ use rustc_trait_selection::traits::query::Fallible;
 
 use crate::constraints::OutlivesConstraint;
 use crate::diagnostics::UniverseInfo;
-use crate::type_check::{BorrowCheckContext, Locations};
+use crate::type_check::{Locations, TypeChecker};
 
-/// Adds sufficient constraints to ensure that `a R b` where `R` depends on `v`:
+impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
-///
+    /// Adds sufficient constraints to ensure that `a R b` where `R` depends on `v`:
-/// - "Covariant" `a <: b`
+    ///
-/// - "Invariant" `a == b`
+    /// - "Covariant" `a <: b`
-/// - "Contravariant" `a :> b`
+    /// - "Invariant" `a == b`
-///
+    /// - "Contravariant" `a :> b`
-/// N.B., the type `a` is permitted to have unresolved inference
+    ///
-/// variables, but not the type `b`.
+    /// N.B., the type `a` is permitted to have unresolved inference
-#[instrument(skip(infcx, param_env, borrowck_context), level = "debug")]
+    /// variables, but not the type `b`.
-pub(super) fn relate_types<'tcx>(
+    #[instrument(skip(self), level = "debug")]
-    infcx: &InferCtxt<'_, 'tcx>,
+    pub(super) fn relate_types(
-    param_env: ty::ParamEnv<'tcx>,
+        &mut self,
-    a: Ty<'tcx>,
+        a: Ty<'tcx>,
-    v: ty::Variance,
+        v: ty::Variance,
-    b: Ty<'tcx>,
+        b: Ty<'tcx>,
-    locations: Locations,
+        locations: Locations,
-    category: ConstraintCategory,
+        category: ConstraintCategory,
-    borrowck_context: &mut BorrowCheckContext<'_, 'tcx>,
+    ) -> Fallible<()> {
-) -> Fallible<()> {
+        TypeRelating::new(
-    TypeRelating::new(
+            self.infcx,
-        infcx,
+            NllTypeRelatingDelegate::new(self, locations, category, UniverseInfo::relate(a, b)),
-        NllTypeRelatingDelegate::new(
+            v,
-            infcx,
+        )
-            borrowck_context,
+        .relate(a, b)?;
-            param_env,
+        Ok(())
-            locations,
+    }
-            category,
-            UniverseInfo::relate(a, b),
-        ),
-        v,
-    )
-    .relate(a, b)?;
-    Ok(())
 }
 
 struct NllTypeRelatingDelegate<'me, 'bccx, 'tcx> {
-    infcx: &'me InferCtxt<'me, 'tcx>,
+    type_checker: &'me mut TypeChecker<'bccx, 'tcx>,
-    borrowck_context: &'me mut BorrowCheckContext<'bccx, 'tcx>,
-
-    param_env: ty::ParamEnv<'tcx>,
 
     /// Where (and why) is this relation taking place?
     locations: Locations,
@@ -63,25 +53,24 @@ struct NllTypeRelatingDelegate<'me, 'bccx, 'tcx> {
 
 impl NllTypeRelatingDelegate<'me, 'bccx, 'tcx> {
     fn new(
-        infcx: &'me InferCtxt<'me, 'tcx>,
+        type_checker: &'me mut TypeChecker<'bccx, 'tcx>,
-        borrowck_context: &'me mut BorrowCheckContext<'bccx, 'tcx>,
-        param_env: ty::ParamEnv<'tcx>,
         locations: Locations,
         category: ConstraintCategory,
         universe_info: UniverseInfo<'tcx>,
     ) -> Self {
-        Self { infcx, borrowck_context, param_env, locations, category, universe_info }
+        Self { type_checker, locations, category, universe_info }
     }
 }
 
 impl TypeRelatingDelegate<'tcx> for NllTypeRelatingDelegate<'_, '_, 'tcx> {
     fn param_env(&self) -> ty::ParamEnv<'tcx> {
-        self.param_env
+        self.type_checker.param_env
     }
 
     fn create_next_universe(&mut self) -> ty::UniverseIndex {
-        let universe = self.infcx.create_next_universe();
+        let universe = self.type_checker.infcx.create_next_universe();
-        self.borrowck_context
+        self.type_checker
+            .borrowck_context
             .constraints
             .universe_causes
             .insert(universe, self.universe_info.clone());
@@ -90,15 +79,18 @@ impl TypeRelatingDelegate<'tcx> for NllTypeRelatingDelegate<'_, '_, 'tcx> {
 
     fn next_existential_region_var(&mut self, from_forall: bool) -> ty::Region<'tcx> {
         let origin = NllRegionVariableOrigin::Existential { from_forall };
-        self.infcx.next_nll_region_var(origin)
+        self.type_checker.infcx.next_nll_region_var(origin)
     }
 
     fn next_placeholder_region(&mut self, placeholder: ty::PlaceholderRegion) -> ty::Region<'tcx> {
-        self.borrowck_context.constraints.placeholder_region(self.infcx, placeholder)
+        self.type_checker
+            .borrowck_context
+            .constraints
+            .placeholder_region(self.type_checker.infcx, placeholder)
     }
 
     fn generalize_existential(&mut self, universe: ty::UniverseIndex) -> ty::Region<'tcx> {
-        self.infcx.next_nll_region_var_in_universe(
+        self.type_checker.infcx.next_nll_region_var_in_universe(
             NllRegionVariableOrigin::Existential { from_forall: false },
             universe,
         )
@@ -110,15 +102,17 @@ impl TypeRelatingDelegate<'tcx> for NllTypeRelatingDelegate<'_, '_, 'tcx> {
         sub: ty::Region<'tcx>,
         info: ty::VarianceDiagInfo<'tcx>,
     ) {
-        let sub = self.borrowck_context.universal_regions.to_region_vid(sub);
+        let sub = self.type_checker.borrowck_context.universal_regions.to_region_vid(sub);
-        let sup = self.borrowck_context.universal_regions.to_region_vid(sup);
+        let sup = self.type_checker.borrowck_context.universal_regions.to_region_vid(sup);
-        self.borrowck_context.constraints.outlives_constraints.push(OutlivesConstraint {
+        self.type_checker.borrowck_context.constraints.outlives_constraints.push(
-            sup,
+            OutlivesConstraint {
-            sub,
+                sup,
-            locations: self.locations,
+                sub,
-            category: self.category,
+                locations: self.locations,
-            variance_info: info,
+                category: self.category,
-        });
+                variance_info: info,
+            },
+        );
     }
 
     // We don't have to worry about the equality of consts during borrow checking