Properly generalize unevaluated consts

Author: khyperia

compiler/rustc_borrowck/src/type_check/relate_tys.rs

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

compiler/rustc_infer/src/infer/mod.rs

@@ -855,6 +855,18 @@ impl<'tcx> InferCtxt<'tcx> {
         }
     }
 
+    pub fn next_term_var_of_alias_kind(
+        &self,
+        alias: ty::AliasTerm<'tcx>,
+        span: Span,
+    ) -> ty::Term<'tcx> {
+        if alias.kind(self.tcx).is_type() {
+            self.next_ty_var(span).into()
+        } else {
+            self.next_const_var(span).into()
+        }
+    }
+
     /// Return the universe that the region `r` was created in. For
     /// most regions (e.g., `'static`, named regions from the user,
     /// etc) this is the root universe U0. For inference variables or
@@ -1533,8 +1545,8 @@ impl<'tcx> InferCtxt<'tcx> {
         &'a self,
         param_env: ty::ParamEnv<'tcx>,
         span: Span,
-        alias: ty::AliasTy<'tcx>,
-    ) -> Ty<'tcx> {
+        alias: ty::AliasTerm<'tcx>,
+    ) -> Term<'tcx> {
         let erased =
             unsafe { mem::transmute::<&'a InferCtxt<'tcx>, TypeErasedInfcx<'a, 'tcx>>(self) };
         self.tcx.try_eagerly_normalize_alias(erased, param_env, span, alias)

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

@@ -300,7 +300,7 @@ impl<'tcx> PredicateEmittingRelation<InferCtxt<'tcx>> for LatticeOp<'_, 'tcx> {
         ))]);
     }
 
-    fn try_eagerly_normalize_alias(&mut self, alias: ty::AliasTy<'tcx>) -> Ty<'tcx> {
+    fn try_eagerly_normalize_alias(&mut self, alias: ty::AliasTerm<'tcx>) -> ty::Term<'tcx> {
         self.infcx.try_eagerly_normalize_alias(self.param_env(), self.span(), alias)
     }
 }

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

@@ -399,8 +399,8 @@ 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
+        _alias: rustc_type_ir::AliasTerm<<InferCtxt<'tcx> as rustc_type_ir::InferCtxtLike>::Interner>,
+    ) -> <<InferCtxt<'tcx> as rustc_type_ir::InferCtxtLike>::Interner as rustc_type_ir::Interner>::Term
     {
         // We only try to eagerly normalize aliases if we're using the new solver.
         unreachable!()

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

@@ -110,6 +110,13 @@ impl<'tcx> ConstVariableValue<'tcx> {
             ConstVariableValue::Known { value } => Some(value),
         }
     }
+
+    pub(crate) fn is_unknown(&self) -> bool {
+        match *self {
+            ConstVariableValue::Unknown { .. } => true,
+            ConstVariableValue::Known { .. } => false,
+        }
+    }
 }
 
 #[derive(PartialEq, Copy, Clone, Debug)]

compiler/rustc_infer/src/infer/unify_key.rs

@@ -126,8 +126,8 @@ declare_hooks! {
         type_erased_infcx: TypeErasedInfcx<'_, 'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         span: Span,
-        alias: ty::AliasTy<'tcx>
-    ) -> Ty<'tcx>;
+        alias: ty::AliasTerm<'tcx>
+    ) -> ty::Term<'tcx>;
 }
 
 /// The `try_eagerly_normalize_alias` hook passes an `Infcx` from where it's called (in `rustc_infer`)

compiler/rustc_middle/src/hooks/mod.rs

@@ -323,6 +323,17 @@ impl<'tcx> Const<'tcx> {
         matches!(self.kind(), ty::ConstKind::Infer(_))
     }
 
+    pub fn is_ct_var(self) -> bool {
+        matches!(self.kind(), ConstKind::Infer(ty::InferConst::Var(_)))
+    }
+
+    pub fn ct_vid(self) -> Option<ty::ConstVid> {
+        match self.kind() {
+            ConstKind::Infer(ty::InferConst::Var(vid)) => Some(vid),
+            _ => None,
+        }
+    }
+
     /// Iterator that walks `self` and any types reachable from
     /// `self`, in depth-first order. Note that just walks the types
     /// that appear in `self`, it does not descend into the fields of

compiler/rustc_middle/src/ty/consts.rs

@@ -1051,15 +1051,16 @@ where
         let delegate = self.delegate;
         let origin_span = self.origin_span;
 
-        let mut normalize = |alias: ty::AliasTy<I>| {
-            let inference_var = self.next_ty_infer();
+        let mut normalize = |alias: ty::AliasTerm<I>| {
+            let term = alias.to_term(cx);
+            let inference_var = self.next_term_infer_of_kind(term);
 
             let goal = Goal::new(
                 cx,
                 param_env,
                 ty::PredicateKind::AliasRelate(
-                    alias.to_ty(cx).into(),
-                    inference_var.into(),
+                    term,
+                    inference_var,
                     ty::AliasRelationDirection::Equate,
                 ),
             );

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -18,7 +18,7 @@ pub use normalize::{
     deeply_normalize, deeply_normalize_with_skipped_universes,
     deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals,
 };
-use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_middle::ty::{self, TyCtxt};
 use rustc_middle::util::Providers;
 use rustc_span::Span;
 pub use select::InferCtxtSelectExt;
@@ -40,15 +40,15 @@ fn try_eagerly_normalize_alias<'a, 'tcx>(
     type_erased_infcx: TypeErasedInfcx<'a, 'tcx>,
     param_env: ty::ParamEnv<'tcx>,
     span: Span,
-    alias: ty::AliasTy<'tcx>,
-) -> Ty<'tcx> {
+    alias: ty::AliasTerm<'tcx>,
+) -> ty::Term<'tcx> {
     let infcx = unsafe {
         mem::transmute::<TypeErasedInfcx<'a, 'tcx>, &'a InferCtxt<'tcx>>(type_erased_infcx)
     };
 
     let ocx = ObligationCtxt::new(infcx);
 
-    let infer_term = infcx.next_ty_var(span);
+    let infer_term = infcx.next_term_var_of_alias_kind(alias, span);
 
     // Dummy because we ignore the error anyway.
     // We do provide a span, because this span is used when registering opaque types.
@@ -59,8 +59,8 @@ fn try_eagerly_normalize_alias<'a, 'tcx>(
         cause,
         param_env,
         ty::PredicateKind::AliasRelate(
-            alias.to_ty(tcx).into(),
-            infer_term.into(),
+            alias.to_term(tcx),
+            infer_term,
             ty::AliasRelationDirection::Equate,
         ),
     );