avoid some ValTree-ConstValue roundtrips

Author: RalfJung

compiler/rustc_middle/src/mir/mod.rs

@@ -2373,17 +2373,22 @@ impl<'tcx> ConstantKind<'tcx> {
         param_env: ty::ParamEnv<'tcx>,
         span: Option<Span>,
     ) -> Result<interpret::ConstValue<'tcx>, ErrorHandled> {
-        match self {
+        let uneval = match self {
             ConstantKind::Ty(c) => {
-                let val = c.eval(tcx, param_env, span)?;
-                Ok(tcx.valtree_to_const_val((self.ty(), val)))
-            }
-            ConstantKind::Unevaluated(uneval, _) => {
-                // FIXME: We might want to have a `try_eval`-like function on `Unevaluated`
-                tcx.const_eval_resolve(param_env, uneval, span)
+                if let ty::ConstKind::Unevaluated(uv) = c.kind() {
+                    // Avoid the round-trip via valtree, evaluate directly to ConstValue.
+                    uv.expand()
+                } else {
+                    // It's already a valtree, or an error.
+                    let val = c.eval(tcx, param_env, span)?;
+                    return Ok(tcx.valtree_to_const_val((self.ty(), val)));
+                }
             }
-            ConstantKind::Val(val, _) => Ok(val),
-        }
+            ConstantKind::Unevaluated(uneval, _) => uneval,
+            ConstantKind::Val(val, _) => return Ok(val),
+        };
+        // FIXME: We might want to have a `try_eval`-like function on `Unevaluated`
+        tcx.const_eval_resolve(param_env, uneval, span)
     }
 
     /// Normalizes the constant to a value if possible.