wip on moving const RHS special-casing

Author: camelid

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -294,29 +294,6 @@ pub fn eval_to_const_value_raw_provider<'tcx>(
                 )
             },
         );
-    } else if let ty::InstanceKind::Item(def_id) = key.value.instance.def
-        && matches!(tcx.def_kind(def_id), DefKind::Const | DefKind::AssocConst)
-    {
-        let ct = tcx.const_of_item(def_id).instantiate(tcx, key.value.instance.args);
-        match ct.kind() {
-            ty::ConstKind::Unevaluated(_) => {
-                return Err(ErrorHandled::TooGeneric(DUMMY_SP));
-            }
-            ty::ConstKind::Value(cv) => return Ok(tcx.valtree_to_const_val(cv)),
-            ty::ConstKind::Error(guar) => {
-                return Err(ErrorHandled::Reported(
-                    ReportedErrorInfo::const_eval_error(guar),
-                    DUMMY_SP,
-                ));
-            }
-            ty::ConstKind::Expr(_) => return Err(ErrorHandled::TooGeneric(DUMMY_SP)),
-            ty::ConstKind::Param(_) | ty::ConstKind::Placeholder(_) => {
-                return Err(ErrorHandled::TooGeneric(DUMMY_SP));
-            }
-            ty::ConstKind::Infer(_) | ty::ConstKind::Bound(..) => {
-                bug!("unexpected constant {ct:?}")
-            }
-        }
     }
 
     tcx.eval_to_allocation_raw(key).map(|val| turn_into_const_value(tcx, val, key))
@@ -374,6 +351,31 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
         trace!("const eval: {:?} ({})", key, instance);
     }
 
+    if let ty::InstanceKind::Item(def_id) = key.value.instance.def
+        && matches!(tcx.def_kind(def_id), DefKind::Const | DefKind::AssocConst)
+    {
+        let ct = tcx.const_of_item(def_id).instantiate(tcx, key.value.instance.args);
+        match ct.kind() {
+            ty::ConstKind::Unevaluated(_) => {
+                return Err(ErrorHandled::TooGeneric(DUMMY_SP));
+            }
+            ty::ConstKind::Value(cv) => return Ok(tcx.valtree_to_const_alloc(cv)),
+            ty::ConstKind::Error(guar) => {
+                return Err(ErrorHandled::Reported(
+                    ReportedErrorInfo::const_eval_error(guar),
+                    DUMMY_SP,
+                ));
+            }
+            ty::ConstKind::Expr(_) => return Err(ErrorHandled::TooGeneric(DUMMY_SP)),
+            ty::ConstKind::Param(_) | ty::ConstKind::Placeholder(_) => {
+                return Err(ErrorHandled::TooGeneric(DUMMY_SP));
+            }
+            ty::ConstKind::Infer(_) | ty::ConstKind::Bound(..) => {
+                bug!("unexpected constant {ct:?}")
+            }
+        }
+    }
+
     eval_in_interpreter(tcx, key.value, key.typing_env)
 }
 

compiler/rustc_const_eval/src/const_eval/mod.rs

@@ -21,7 +21,7 @@ pub use self::error::*;
 pub use self::eval_queries::*;
 pub use self::fn_queries::*;
 pub use self::machine::*;
-pub(crate) use self::valtrees::{eval_to_valtree, valtree_to_const_value};
+pub(crate) use self::valtrees::{eval_to_valtree, valtree_to_const_alloc, valtree_to_const_value};
 
 // We forbid type-level constants that contain more than `VALTREE_MAX_NODES` nodes.
 const VALTREE_MAX_NODES: usize = 100000;

compiler/rustc_const_eval/src/const_eval/valtrees.rs

@@ -9,7 +9,9 @@ use tracing::{debug, instrument, trace};
 
 use super::eval_queries::{mk_eval_cx_to_read_const_val, op_to_const};
 use super::machine::CompileTimeInterpCx;
-use super::{VALTREE_MAX_NODES, ValTreeCreationError, ValTreeCreationResult};
+use super::{
+    InterpretationResult as _, VALTREE_MAX_NODES, ValTreeCreationError, ValTreeCreationResult,
+};
 use crate::const_eval::CanAccessMutGlobal;
 use crate::errors::MaxNumNodesInConstErr;
 use crate::interpret::{
@@ -365,6 +367,18 @@ pub fn valtree_to_const_value<'tcx>(
     }
 }
 
+#[instrument(skip(tcx), level = "debug", ret)]
+pub(crate) fn valtree_to_const_alloc<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    env: ty::TypingEnv<'tcx>,
+    val: ty::Value<'tcx>,
+) -> mir::ConstAlloc<'tcx> {
+    let mut ecx = mk_eval_cx_to_read_const_val(tcx, DUMMY_SP, env, CanAccessMutGlobal::No);
+    let layout = ecx.layout_of(val.ty).unwrap();
+    let mplace = create_valtree_place(&mut ecx, layout, val.valtree);
+    mir::ConstAlloc::make_result(mplace, &mut ecx)
+}
+
 /// Put a valtree into memory and return a reference to that.
 fn valtree_to_ref<'tcx>(
     ecx: &mut CompileTimeInterpCx<'tcx>,

compiler/rustc_const_eval/src/lib.rs

@@ -46,6 +46,8 @@ pub fn provide(providers: &mut Providers) {
         const_eval::try_destructure_mir_constant_for_user_output;
     providers.valtree_to_const_val =
         |tcx, cv| const_eval::valtree_to_const_value(tcx, ty::TypingEnv::fully_monomorphized(), cv);
+    providers.valtree_to_const_alloc =
+        |tcx, cv| const_eval::valtree_to_const_alloc(tcx, ty::TypingEnv::fully_monomorphized(), cv);
     providers.check_validity_requirement = |tcx, (init_kind, param_env_and_ty)| {
         util::check_validity_requirement(tcx, init_kind, param_env_and_ty)
     };

compiler/rustc_middle/src/query/mod.rs

@@ -1329,6 +1329,11 @@ rustc_queries! {
         desc { "converting type-level constant value to MIR constant value"}
     }
 
+    /// Converts a type-level constant value into a MIR constant allocation.
+    query valtree_to_const_alloc(key: ty::Value<'tcx>) -> mir::ConstAlloc<'tcx> {
+        desc { "converting type-level constant value to MIR constant allocation"}
+    }
+
     /// Destructures array, ADT or tuple constants into the constants
     /// of their fields.
     query destructure_const(key: ty::Const<'tcx>) -> ty::DestructuredConst<'tcx> {