Rollup merge of #154257 - jdonszelmann:revert-eagerly-normalize-in-generalize, r=lcnr

Revert eagerly normalize in generalize

r? @lcnr

Reverts #151746

We'll likely pull eager normalization out of generalization

Fixes #154173
Fixes #154244

Author: JonathanBrouwer

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -616,9 +616,4 @@ impl<'b, 'tcx> PredicateEmittingRelation<InferCtxt<'tcx>> for NllTypeRelating<'_
             }
         })]);
     }
-
-    fn try_eagerly_normalize_alias(&mut self, _alias: ty::AliasTy<'tcx>) -> Ty<'tcx> {
-        // Past hir typeck, so we don't have to worry about type inference anymore.
-        self.type_checker.infcx.next_ty_var(self.span())
-    }
 }

compiler/rustc_infer/src/infer/at.rs

@@ -140,9 +140,6 @@ impl<'a, 'tcx> At<'a, 'tcx> {
                 ty::Contravariant,
                 actual,
                 self.cause.span,
-                &mut |alias| {
-                    self.infcx.try_eagerly_normalize_alias(self.param_env, self.cause.span, alias)
-                },
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
@@ -176,9 +173,6 @@ impl<'a, 'tcx> At<'a, 'tcx> {
                 ty::Covariant,
                 actual,
                 self.cause.span,
-                &mut |alias| {
-                    self.infcx.try_eagerly_normalize_alias(self.param_env, self.cause.span, alias)
-                },
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
@@ -231,9 +225,6 @@ impl<'a, 'tcx> At<'a, 'tcx> {
                 ty::Invariant,
                 actual,
                 self.cause.span,
-                &mut |alias| {
-                    self.infcx.try_eagerly_normalize_alias(self.param_env, self.cause.span, alias)
-                },
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {

compiler/rustc_infer/src/infer/mod.rs

@@ -1,5 +1,5 @@
 use std::cell::{Cell, RefCell};
-use std::{fmt, mem};
+use std::fmt;
 
 pub use at::DefineOpaqueTypes;
 use free_regions::RegionRelations;
@@ -21,7 +21,6 @@ use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_macros::extension;
 pub use rustc_macros::{TypeFoldable, TypeVisitable};
 use rustc_middle::bug;
-use rustc_middle::hooks::TypeErasedInfcx;
 use rustc_middle::infer::canonical::{CanonicalQueryInput, CanonicalVarValues};
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::traits::select;
@@ -1529,17 +1528,6 @@ impl<'tcx> InferCtxt<'tcx> {
         }
     }
 
-    pub fn try_eagerly_normalize_alias<'a>(
-        &'a self,
-        param_env: ty::ParamEnv<'tcx>,
-        span: Span,
-        alias: ty::AliasTy<'tcx>,
-    ) -> Ty<'tcx> {
-        let erased =
-            unsafe { mem::transmute::<&'a InferCtxt<'tcx>, TypeErasedInfcx<'a, 'tcx>>(self) };
-        self.tcx.try_eagerly_normalize_alias(erased, param_env, span, alias)
-    }
-
     /// Attach a callback to be invoked on each root obligation evaluated in the new trait solver.
     pub fn attach_obligation_inspector(&self, inspector: ObligationInspector<'tcx>) {
         debug_assert!(

compiler/rustc_infer/src/infer/relate/generalize.rs

@@ -299,8 +299,4 @@ impl<'tcx> PredicateEmittingRelation<InferCtxt<'tcx>> for LatticeOp<'_, 'tcx> {
             ty::AliasRelationDirection::Equate,
         ))]);
     }
-
-    fn try_eagerly_normalize_alias(&mut self, alias: ty::AliasTy<'tcx>) -> Ty<'tcx> {
-        self.infcx.try_eagerly_normalize_alias(self.param_env(), self.span(), alias)
-    }
 }

compiler/rustc_infer/src/infer/relate/lattice.rs

@@ -396,13 +396,4 @@ impl<'tcx> PredicateEmittingRelation<InferCtxt<'tcx>> for TypeRelating<'_, 'tcx>
             }
         })]);
     }
-
-    fn try_eagerly_normalize_alias(
-        &mut self,
-        _alias: rustc_type_ir::AliasTy<<InferCtxt<'tcx> as rustc_type_ir::InferCtxtLike>::Interner>,
-    ) -> <<InferCtxt<'tcx> as rustc_type_ir::InferCtxtLike>::Interner as rustc_type_ir::Interner>::Ty
-    {
-        // We only try to eagerly normalize aliases if we're using the new solver.
-        unreachable!()
-    }
 }

compiler/rustc_infer/src/infer/relate/type_relating.rs

@@ -904,7 +904,7 @@ pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
     rustc_hir_typeck::provide(&mut providers.queries);
     ty::provide(&mut providers.queries);
     traits::provide(&mut providers.queries);
-    solve::provide(providers);
+    solve::provide(&mut providers.queries);
     rustc_passes::provide(&mut providers.queries);
     rustc_traits::provide(&mut providers.queries);
     rustc_ty_utils::provide(&mut providers.queries);

compiler/rustc_interface/src/passes.rs

@@ -3,16 +3,14 @@
 //! similar to queries, but queries come with a lot of machinery for caching and incremental
 //! compilation, whereas hooks are just plain function pointers without any of the query magic.
 
-use std::marker::PhantomData;
-
 use rustc_hir::def_id::{DefId, DefPathHash};
 use rustc_session::StableCrateId;
 use rustc_span::def_id::{CrateNum, LocalDefId};
-use rustc_span::{ExpnHash, ExpnId, Span};
+use rustc_span::{ExpnHash, ExpnId};
 
+use crate::mir;
 use crate::query::on_disk_cache::{CacheEncoder, EncodedDepNodeIndex};
 use crate::ty::{Ty, TyCtxt};
-use crate::{mir, ty};
 
 macro_rules! declare_hooks {
     ($($(#[$attr:meta])*hook $name:ident($($arg:ident: $K:ty),*) -> $V:ty;)*) => {
@@ -117,29 +115,6 @@ declare_hooks! {
         encoder: &mut CacheEncoder<'_, 'tcx>,
         query_result_index: &mut EncodedDepNodeIndex
     ) -> ();
-
-    /// Tries to normalize an alias, ignoring any errors.
-    ///
-    /// Generalization with the new trait solver calls into this,
-    /// when generalizing outside of the trait solver in `hir_typeck`.
-    hook try_eagerly_normalize_alias(
-        type_erased_infcx: TypeErasedInfcx<'_, 'tcx>,
-        param_env: ty::ParamEnv<'tcx>,
-        span: Span,
-        alias: ty::AliasTy<'tcx>
-    ) -> Ty<'tcx>;
-}
-
-/// The `try_eagerly_normalize_alias` hook passes an `Infcx` from where it's called (in `rustc_infer`)
-/// to where it's provided (in `rustc_trait_selection`).
-/// Both of those crates have that type available, but `rustc_middle` does not.
-/// Instead we pass this type-erased `Infcx` and transmute on both sides.
-///
-/// Has to be `repr(transparent)` so we can transmute a `&'a Infcx<'tcx>` to this struct.
-#[repr(transparent)]
-pub struct TypeErasedInfcx<'a, 'tcx> {
-    _infcx: *const (),
-    phantom: PhantomData<&'a mut &'tcx ()>,
 }
 
 #[cold]

compiler/rustc_middle/src/hooks/mod.rs

@@ -177,11 +177,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                 cache: Default::default(),
             };
             let param_env = param_env.fold_with(&mut env_canonicalizer);
-            debug_assert!(
-                env_canonicalizer.sub_root_lookup_table.is_empty(),
-                "{:?}",
-                env_canonicalizer.sub_root_lookup_table
-            );
+            debug_assert!(env_canonicalizer.sub_root_lookup_table.is_empty());
             (
                 param_env,
                 env_canonicalizer.variables,

compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs

@@ -987,12 +987,7 @@ where
         let replacement = self.ecx.instantiate_binder_with_infer(*replacement);
         self.nested.extend(
             self.ecx
-                .relate_and_get_goals(
-                    self.param_env,
-                    alias_term,
-                    ty::Invariant,
-                    replacement.projection_term,
-                )
+                .eq_and_get_goals(self.param_env, alias_term, replacement.projection_term)
                 .expect("expected to be able to unify goal projection with dyn's projection"),
         );