Auto merge of #140549 - BoxyUwU:proper_const_norm, r=lcnr

Set groundwork for proper const normalization

r? lcnr

Updates a lot of our normalization/alias infrastructure to be setup to handle mgca aliases and normalization once const items are represented more like aliases than bodies. Inherent associated consts are still super busted, I didn't update the assertions that IACs the right arg setup because that winds up being somewhat involved to do *before* proper support for normalizing const aliases is implemented.

I dont *intend* for this to have any effect on stable. We continue normalizing via ctfe on stable and the codepaths in `project` for consts should only be reachable with mgca or ace.

1 files changed, 17 insertions, 8 deletions

diff --git a/compiler/rustc_infer/src/infer/projection.rs b/compiler/rustc_infer/src/infer/projection.rs
index 1bee9632110..2a4f9db8963 100644
--- a/compiler/rustc_infer/src/infer/projection.rs
+++ b/compiler/rustc_infer/src/infer/projection.rs
@@ -1,7 +1,8 @@
 use rustc_middle::traits::ObligationCause;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty;
 
 use super::InferCtxt;
+use crate::infer::Term;
 use crate::traits::{Obligation, PredicateObligations};
 
 impl<'tcx> InferCtxt<'tcx> {
@@ -11,24 +12,32 @@ impl<'tcx> InferCtxt<'tcx> {
     /// of the given projection. This allows us to proceed with projections
     /// while they cannot be resolved yet due to missing information or
     /// simply due to the lack of access to the trait resolution machinery.
-    pub fn projection_ty_to_infer(
+    pub fn projection_term_to_infer(
         &self,
         param_env: ty::ParamEnv<'tcx>,
-        projection_ty: ty::AliasTy<'tcx>,
+        alias_term: ty::AliasTerm<'tcx>,
         cause: ObligationCause<'tcx>,
         recursion_depth: usize,
         obligations: &mut PredicateObligations<'tcx>,
-    ) -> Ty<'tcx> {
+    ) -> Term<'tcx> {
         debug_assert!(!self.next_trait_solver());
-        let ty_var = self.next_ty_var(self.tcx.def_span(projection_ty.def_id));
+
+        let span = self.tcx.def_span(alias_term.def_id);
+        let infer_var = if alias_term.kind(self.tcx).is_type() {
+            self.next_ty_var(span).into()
+        } else {
+            self.next_const_var(span).into()
+        };
+
         let projection =
             ty::PredicateKind::Clause(ty::ClauseKind::Projection(ty::ProjectionPredicate {
-                projection_term: projection_ty.into(),
-                term: ty_var.into(),
+                projection_term: alias_term,
+                term: infer_var,
             }));
         let obligation =
             Obligation::with_depth(self.tcx, cause, recursion_depth, param_env, projection);
         obligations.push(obligation);
-        ty_var
+
+        infer_var
     }
 }