rust-analyzer

diff --git a/crates/hir-ty/src/consteval.rs b/crates/hir-ty/src/consteval.rs
index 18ebe7d7a5..621ebc7bd5 100644
--- 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
index 98f42098f3..9ccbd462a3 100644
--- 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>>;

@@ -234,13 +236,6 @@ fn hir_database_is_dyn_compatible() {

#[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 {

/// This stores the param and its index.

pub loc: (LifetimeParamId, u32),

diff --git a/crates/hir-ty/src/mir/eval.rs b/crates/hir-ty/src/mir/eval.rs
index 6e62bcbbdd..08f42410a7 100644
--- 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
index 67040121d5..7f457ca59a 100644
--- 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
index dedd6a1a6d..2205cba374 100644
--- 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
index 39de17e9a8..b77b30541e 100644
--- 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
index 8fae340dde..68b6ebf7e9 100644
--- 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
index b2fa4b6b20..06f826d0df 100644
--- 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,

+ })

}