Use const_eval_static query for statics

Veykril · Veykril · commit 7ba3c6546a65 · 2025-11-22T23:08:50.000+01:00
diff --git a/crates/hir-ty/src/consteval.rs b/crates/hir-ty/src/consteval.rs
@@ -5,7 +5,7 @@ mod tests;
 
 use base_db::Crate;
 use hir_def::{
-    EnumVariantId, GeneralConstId, HasModule, StaticId,
+    ConstId, EnumVariantId, StaticId,
     expr_store::Body,
     hir::{Expr, ExprId},
     type_ref::LiteralConstRef,
@@ -139,16 +139,18 @@ pub fn try_const_usize<'db>(db: &'db dyn HirDatabase, c: Const<'db>) -> Option<u
         ConstKind::Infer(_) => None,
         ConstKind::Bound(_, _) => None,
         ConstKind::Placeholder(_) => None,
-        ConstKind::Unevaluated(unevaluated_const) => {
-            let c = match unevaluated_const.def {
-                SolverDefId::ConstId(id) => GeneralConstId::ConstId(id),
-                SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
-                _ => unreachable!(),
-            };
-            let subst = unevaluated_const.args;
-            let ec = db.const_eval(c, subst, None).ok()?;
-            try_const_usize(db, ec)
-        }
+        ConstKind::Unevaluated(unevaluated_const) => match unevaluated_const.def {
+            SolverDefId::ConstId(id) => {
+                let subst = unevaluated_const.args;
+                let ec = db.const_eval(id, subst, None).ok()?;
+                try_const_usize(db, ec)
+            }
+            SolverDefId::StaticId(id) => {
+                let ec = db.const_eval_static(id).ok()?;
+                try_const_usize(db, ec)
+            }
+            _ => unreachable!(),
+        },
         ConstKind::Value(val) => Some(u128::from_le_bytes(pad16(&val.value.inner().memory, false))),
         ConstKind::Error(_) => None,
         ConstKind::Expr(_) => None,
@@ -161,16 +163,18 @@ pub fn try_const_isize<'db>(db: &'db dyn HirDatabase, c: &Const<'db>) -> Option<
         ConstKind::Infer(_) => None,
         ConstKind::Bound(_, _) => None,
         ConstKind::Placeholder(_) => None,
-        ConstKind::Unevaluated(unevaluated_const) => {
-            let c = match unevaluated_const.def {
-                SolverDefId::ConstId(id) => GeneralConstId::ConstId(id),
-                SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
-                _ => unreachable!(),
-            };
-            let subst = unevaluated_const.args;
-            let ec = db.const_eval(c, subst, None).ok()?;
-            try_const_isize(db, &ec)
-        }
+        ConstKind::Unevaluated(unevaluated_const) => match unevaluated_const.def {
+            SolverDefId::ConstId(id) => {
+                let subst = unevaluated_const.args;
+                let ec = db.const_eval(id, subst, None).ok()?;
+                try_const_isize(db, &ec)
+            }
+            SolverDefId::StaticId(id) => {
+                let ec = db.const_eval_static(id).ok()?;
+                try_const_isize(db, &ec)
+            }
+            _ => unreachable!(),
+        },
         ConstKind::Value(val) => Some(i128::from_le_bytes(pad16(&val.value.inner().memory, true))),
         ConstKind::Error(_) => None,
         ConstKind::Expr(_) => None,
@@ -254,7 +258,7 @@ pub(crate) fn eval_to_const<'db>(expr: ExprId, ctx: &mut InferenceContext<'_, 'd
 
 pub(crate) fn const_eval_cycle_result<'db>(
     _: &'db dyn HirDatabase,
-    _: GeneralConstId,
+    _: ConstId,
     _: GenericArgs<'db>,
     _: Option<Arc<TraitEnvironment<'db>>>,
 ) -> Result<Const<'db>, ConstEvalError<'db>> {
@@ -277,19 +281,11 @@ pub(crate) fn const_eval_discriminant_cycle_result<'db>(
 
 pub(crate) fn const_eval_query<'db>(
     db: &'db dyn HirDatabase,
-    def: GeneralConstId,
+    def: ConstId,
     subst: GenericArgs<'db>,
     trait_env: Option<Arc<TraitEnvironment<'db>>>,
 ) -> Result<Const<'db>, ConstEvalError<'db>> {
-    let body = match def {
-        GeneralConstId::ConstId(c) => {
-            db.monomorphized_mir_body(c.into(), subst, db.trait_environment(c.into()))?
-        }
-        GeneralConstId::StaticId(s) => {
-            let krate = s.module(db).krate();
-            db.monomorphized_mir_body(s.into(), subst, TraitEnvironment::empty(krate))?
-        }
-    };
+    let body = db.monomorphized_mir_body(def.into(), subst, db.trait_environment(def.into()))?;
     let c = interpret_mir(db, body, false, trait_env)?.0?;
     Ok(c)
 }
diff --git a/crates/hir-ty/src/db.rs b/crates/hir-ty/src/db.rs
@@ -3,7 +3,7 @@
 
 use base_db::{Crate, target::TargetLoadError};
 use hir_def::{
-    AdtId, CallableDefId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId, GeneralConstId,
+    AdtId, CallableDefId, ConstId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId,
     GenericDefId, ImplId, LifetimeParamId, LocalFieldId, StaticId, TraitId, TypeAliasId,
     TypeOrConstParamId, VariantId, db::DefDatabase, hir::ExprId, layout::TargetDataLayout,
 };
@@ -29,6 +29,8 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     // region:mir
 
+    // FXME: Collapse `mir_body_for_closure` into `mir_body`
+    // and `monomorphized_mir_body_for_closure` into `monomorphized_mir_body`
     #[salsa::invoke(crate::mir::mir_body_query)]
     #[salsa::cycle(cycle_result = crate::mir::mir_body_cycle_result)]
     fn mir_body<'db>(
@@ -70,7 +72,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     #[salsa::cycle(cycle_result = crate::consteval::const_eval_cycle_result)]
     fn const_eval<'db>(
         &'db self,
-        def: GeneralConstId,
+        def: ConstId,
         subst: GenericArgs<'db>,
         trait_env: Option<Arc<TraitEnvironment<'db>>>,
     ) -> Result<Const<'db>, ConstEvalError<'db>>;
@@ -232,13 +234,6 @@ fn hir_database_is_dyn_compatible() {
     fn _assert_dyn_compatible(_: &dyn HirDatabase) {}
 }
 
-#[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
-#[derive(PartialOrd, Ord)]
-pub struct InternedTypeOrConstParamId {
-    /// This stores the param and its index.
-    pub loc: (TypeOrConstParamId, u32),
-}
-
 #[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
 #[derive(PartialOrd, Ord)]
 pub struct InternedLifetimeParamId {
diff --git a/crates/hir-ty/src/mir/eval.rs b/crates/hir-ty/src/mir/eval.rs
@@ -1917,24 +1917,32 @@ impl<'db> Evaluator<'db> {
         let value = match konst.kind() {
             ConstKind::Value(value) => value,
             ConstKind::Unevaluated(UnevaluatedConst { def: const_id, args: subst }) => 'b: {
-                let mut const_id = match const_id {
+                let mut id = match const_id {
                     SolverDefId::ConstId(it) => GeneralConstId::from(it),
                     SolverDefId::StaticId(it) => it.into(),
                     _ => unreachable!("unevaluated consts should be consts or statics"),
                 };
                 let mut subst = subst;
-                if let hir_def::GeneralConstId::ConstId(c) = const_id {
+                if let hir_def::GeneralConstId::ConstId(c) = id {
                     let (c, s) = lookup_impl_const(&self.infcx, self.trait_env.clone(), c, subst);
-                    const_id = hir_def::GeneralConstId::ConstId(c);
+                    id = hir_def::GeneralConstId::ConstId(c);
                     subst = s;
                 }
-                result_owner = self
-                    .db
-                    .const_eval(const_id, subst, Some(self.trait_env.clone()))
-                    .map_err(|e| {
-                        let name = const_id.name(self.db);
-                        MirEvalError::ConstEvalError(name, Box::new(e))
-                    })?;
+                result_owner = match id {
+                    GeneralConstId::ConstId(const_id) => self
+                        .db
+                        .const_eval(const_id, subst, Some(self.trait_env.clone()))
+                        .map_err(|e| {
+                            let name = id.name(self.db);
+                            MirEvalError::ConstEvalError(name, Box::new(e))
+                        })?,
+                    GeneralConstId::StaticId(static_id) => {
+                        self.db.const_eval_static(static_id).map_err(|e| {
+                            let name = id.name(self.db);
+                            MirEvalError::ConstEvalError(name, Box::new(e))
+                        })?
+                    }
+                };
                 if let ConstKind::Value(value) = result_owner.kind() {
                     break 'b value;
                 }
diff --git a/crates/hir-ty/src/mir/lower.rs b/crates/hir-ty/src/mir/lower.rs
@@ -1532,10 +1532,20 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> {
                 UnevaluatedConst { def: const_id.into(), args: subst },
             )
         } else {
-            let name = const_id.name(self.db);
-            self.db
-                .const_eval(const_id, subst, None)
-                .map_err(|e| MirLowerError::ConstEvalError(name.into(), Box::new(e)))?
+            match const_id {
+                id @ GeneralConstId::ConstId(const_id) => {
+                    self.db.const_eval(const_id, subst, None).map_err(|e| {
+                        let name = id.name(self.db);
+                        MirLowerError::ConstEvalError(name.into(), Box::new(e))
+                    })?
+                }
+                GeneralConstId::StaticId(static_id) => {
+                    self.db.const_eval_static(static_id).map_err(|e| {
+                        let name = const_id.name(self.db);
+                        MirLowerError::ConstEvalError(name.into(), Box::new(e))
+                    })?
+                }
+            }
         };
         let ty = self
             .db
diff --git a/crates/hir-ty/src/next_solver/generic_arg.rs b/crates/hir-ty/src/next_solver/generic_arg.rs
@@ -17,7 +17,7 @@ use super::{
     generics::Generics,
 };
 
-#[derive(Copy, Clone, PartialEq, Eq, Hash, TypeVisitable, TypeFoldable)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, TypeVisitable, TypeFoldable, salsa::Supertype)]
 pub enum GenericArg<'db> {
     Ty(Ty<'db>),
     Lifetime(Region<'db>),
@@ -196,6 +196,11 @@ impl<'db> GenericArgs<'db> {
     {
         let defs = interner.generics_of(def_id);
         let count = defs.count();
+
+        if count == 0 {
+            return Default::default();
+        }
+
         let mut args = SmallVec::with_capacity(count);
         Self::fill_item(&mut args, interner, defs, &mut mk_kind);
         interner.mk_args(&args)
diff --git a/crates/hir-ty/src/next_solver/interner.rs b/crates/hir-ty/src/next_solver/interner.rs
@@ -214,6 +214,10 @@ macro_rules! _interned_vec_db {
         }
 
         impl<'db> $name<'db> {
+            pub fn empty(interner: DbInterner<'db>) -> Self {
+                $name::new_(interner.db(), smallvec::SmallVec::new())
+            }
+
             pub fn new_from_iter(
                 interner: DbInterner<'db>,
                 data: impl IntoIterator<Item = $ty<'db>>,
diff --git a/crates/hir-ty/src/next_solver/solver.rs b/crates/hir-ty/src/next_solver/solver.rs
@@ -1,6 +1,6 @@
 //! Defining `SolverContext` for next-trait-solver.
 
-use hir_def::{AssocItemId, GeneralConstId};
+use hir_def::AssocItemId;
 use rustc_next_trait_solver::delegate::SolverDelegate;
 use rustc_type_ir::{
     AliasTyKind, GenericArgKind, InferCtxtLike, Interner, PredicatePolarity, TypeFlags,
@@ -233,14 +233,18 @@ impl<'db> SolverDelegate for SolverContext<'db> {
         _param_env: ParamEnv<'db>,
         uv: rustc_type_ir::UnevaluatedConst<Self::Interner>,
     ) -> Option<<Self::Interner as rustc_type_ir::Interner>::Const> {
-        let c = match uv.def {
-            SolverDefId::ConstId(c) => GeneralConstId::ConstId(c),
-            SolverDefId::StaticId(c) => GeneralConstId::StaticId(c),
+        match uv.def {
+            SolverDefId::ConstId(c) => {
+                let subst = uv.args;
+                let ec = self.cx().db.const_eval(c, subst, None).ok()?;
+                Some(ec)
+            }
+            SolverDefId::StaticId(c) => {
+                let ec = self.cx().db.const_eval_static(c).ok()?;
+                Some(ec)
+            }
             _ => unreachable!(),
-        };
-        let subst = uv.args;
-        let ec = self.cx().db.const_eval(c, subst, None).ok()?;
-        Some(ec)
+        }
     }
 
     fn compute_goal_fast_path(
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
@@ -2885,10 +2885,12 @@ impl Static {
 
     /// Evaluate the static initializer.
     pub fn eval(self, db: &dyn HirDatabase) -> Result<EvaluatedConst<'_>, ConstEvalError<'_>> {
-        let interner = DbInterner::new_with(db, None, None);
         let ty = db.value_ty(self.id.into()).unwrap().instantiate_identity();
-        db.const_eval(self.id.into(), GenericArgs::new_from_iter(interner, []), None)
-            .map(|it| EvaluatedConst { const_: it, def: self.id.into(), ty })
+        db.const_eval_static(self.id).map(|it| EvaluatedConst {
+            const_: it,
+            def: self.id.into(),
+            ty,
+        })
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -2885,10 +2885,12 @@ impl Static {`
`2885`	`2885`
`2886`	`2886`	`/// Evaluate the static initializer.`
`2887`	`2887`	`pub fn eval(self, db: &dyn HirDatabase) -> Result<EvaluatedConst<'_>, ConstEvalError<'_>> {`
`2888`		`- let interner = DbInterner::new_with(db, None, None);`
`2889`	`2888`	`let ty = db.value_ty(self.id.into()).unwrap().instantiate_identity();`
`2890`		`- db.const_eval(self.id.into(), GenericArgs::new_from_iter(interner, []), None)`
`2891`		`- .map(\|it\| EvaluatedConst { const_: it, def: self.id.into(), ty })`
	`2889`	`+ db.const_eval_static(self.id).map(\|it\| EvaluatedConst {`
	`2890`	`+ const_: it,`
	`2891`	`+ def: self.id.into(),`
	`2892`	`+ ty,`
	`2893`	`+ })`
`2892`	`2894`	`}`
`2893`	`2895`	`}`
`2894`	`2896`