change evaluate_const to take a UnevaluatedConst

Author: khyperia

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -1468,23 +1468,25 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let ct = self.resolve_vars_with_obligations(ct);
 
         if self.next_trait_solver()
-            && let ty::ConstKind::Unevaluated(..) = ct.kind()
+            && let ty::ConstKind::Unevaluated(uv) = ct.kind()
         {
             // We need to use a separate variable here as otherwise the temporary for
             // `self.fulfillment_cx.borrow_mut()` is alive in the `Err` branch, resulting
             // in a reentrant borrow, causing an ICE.
             let result = self
                 .at(&self.misc(sp), self.param_env)
-                .structurally_normalize_const(ct, &mut **self.fulfillment_cx.borrow_mut());
+                .structurally_normalize_const(uv, &mut **self.fulfillment_cx.borrow_mut());
             match result {
                 Ok(normalized_ct) => normalized_ct,
                 Err(errors) => {
                     let guar = self.err_ctxt().report_fulfillment_errors(errors);
                     return ty::Const::new_error(self.tcx, guar);
                 }
             }
-        } else if self.tcx.features().generic_const_exprs() {
-            rustc_trait_selection::traits::evaluate_const(&self.infcx, ct, self.param_env)
+        } else if self.tcx.features().generic_const_exprs()
+            && let ty::ConstKind::Unevaluated(uv) = ct.kind()
+        {
+            rustc_trait_selection::traits::evaluate_const(&self.infcx, uv, self.param_env)
         } else {
             ct
         }

compiler/rustc_trait_selection/src/solve/delegate.rs

@@ -178,9 +178,7 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
         param_env: ty::ParamEnv<'tcx>,
         uv: ty::UnevaluatedConst<'tcx>,
     ) -> Option<ty::Const<'tcx>> {
-        let ct = ty::Const::new_unevaluated(self.tcx, uv);
-
-        match crate::traits::try_evaluate_const(&self.0, ct, param_env) {
+        match crate::traits::try_evaluate_const(&self.0, uv, param_env) {
             Ok(ct) => Some(ct),
             Err(EvaluateConstErr::EvaluationFailure(e)) => Some(ty::Const::new_error(self.tcx, e)),
             Err(

compiler/rustc_trait_selection/src/traits/auto_trait.rs

@@ -765,7 +765,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                         if let ty::ConstKind::Unevaluated(unevaluated) = c.kind() {
                             let ct = super::try_evaluate_const(
                                 selcx.infcx,
-                                c,
+                                unevaluated,
                                 obligation.param_env,
                             );
 

compiler/rustc_trait_selection/src/traits/const_evaluatable.rs

@@ -68,8 +68,8 @@ pub fn is_const_evaluatable<'tcx>(
                 // here.
                 tcx.dcx().span_bug(span, "evaluating `ConstKind::Expr` is not currently supported");
             }
-            ty::ConstKind::Unevaluated(_) => {
-                match crate::traits::try_evaluate_const(infcx, unexpanded_ct, param_env) {
+            ty::ConstKind::Unevaluated(uv) => {
+                match crate::traits::try_evaluate_const(infcx, uv, param_env) {
                     Err(EvaluateConstErr::HasGenericsOrInfers) => {
                         Err(NotConstEvaluatable::Error(infcx.dcx().span_delayed_bug(
                             span,
@@ -89,7 +89,14 @@ pub fn is_const_evaluatable<'tcx>(
         // This is a sanity check to make sure that non-generics consts are checked to
         // be evaluatable in case they aren't cchecked elsewhere. This will NOT error
         // if the const uses generics, as desired.
-        crate::traits::evaluate_const(infcx, unexpanded_ct, param_env);
+        let uv = match unexpanded_ct.kind() {
+            ty::ConstKind::Unevaluated(uv) => uv,
+            ty::ConstKind::Expr(_) => {
+                bug!("`ConstKind::Expr` without `feature(generic_const_exprs)` enabled")
+            }
+            _ => bug!("unexpected constkind in `is_const_evalautable: {unexpanded_ct:?}`"),
+        };
+        crate::traits::evaluate_const(infcx, uv, param_env);
         Ok(())
     } else {
         let uv = match unexpanded_ct.kind() {
@@ -100,7 +107,7 @@ pub fn is_const_evaluatable<'tcx>(
             _ => bug!("unexpected constkind in `is_const_evalautable: {unexpanded_ct:?}`"),
         };
 
-        match crate::traits::try_evaluate_const(infcx, unexpanded_ct, param_env) {
+        match crate::traits::try_evaluate_const(infcx, uv, param_env) {
             // If we're evaluating a generic foreign constant, under a nightly compiler while
             // the current crate does not enable `feature(generic_const_exprs)`, abort
             // compilation with a useful error.

compiler/rustc_trait_selection/src/traits/engine.rs

@@ -368,9 +368,13 @@ where
         param_env: ty::ParamEnv<'tcx>,
         value: ty::Const<'tcx>,
     ) -> Result<ty::Const<'tcx>, Vec<E>> {
-        self.infcx
-            .at(cause, param_env)
-            .structurally_normalize_const(value, &mut **self.engine.borrow_mut())
+        if let ty::ConstKind::Unevaluated(uv) = value.kind() {
+            self.infcx
+                .at(cause, param_env)
+                .structurally_normalize_const(uv, &mut **self.engine.borrow_mut())
+        } else {
+            Ok(value)
+        }
     }
 
     pub fn structurally_normalize_term(

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -731,7 +731,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                         if let ty::ConstKind::Unevaluated(unevaluated) = c.kind() {
                             match super::try_evaluate_const(
                                 self.selcx.infcx,
-                                c,
+                                unevaluated,
                                 obligation.param_env,
                             ) {
                                 Ok(val) => Ok(val),