bendns' repos / rust-analyzer
Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'crates/hir-ty/src/mir/eval.rs')
-rw-r--r--crates/hir-ty/src/mir/eval.rs69
1 files changed, 41 insertions, 28 deletions
diff --git a/crates/hir-ty/src/mir/eval.rs b/crates/hir-ty/src/mir/eval.rs
index da15ca695e..02e322f037 100644
--- a/crates/hir-ty/src/mir/eval.rs
+++ b/crates/hir-ty/src/mir/eval.rs
@@ -9,7 +9,7 @@ use hir_def::{
Lookup, StaticId, VariantId,
expr_store::HygieneId,
item_tree::FieldsShape,
- lang_item::LangItem,
+ lang_item::LangItems,
layout::{TagEncoding, Variants},
resolver::{HasResolver, TypeNs, ValueNs},
signatures::{StaticFlags, StructFlags},
@@ -34,7 +34,7 @@ use syntax::{SyntaxNodePtr, TextRange};
use triomphe::Arc;
use crate::{
- CallableDefId, ComplexMemoryMap, MemoryMap, TraitEnvironment,
+ CallableDefId, ComplexMemoryMap, InferenceResult, MemoryMap, ParamEnvAndCrate,
consteval::{self, ConstEvalError, try_const_usize},
db::{HirDatabase, InternedClosure, InternedClosureId},
display::{ClosureStyle, DisplayTarget, HirDisplay},
@@ -165,7 +165,7 @@ enum MirOrDynIndex<'db> {
pub struct Evaluator<'db> {
db: &'db dyn HirDatabase,
- trait_env: Arc<TraitEnvironment<'db>>,
+ param_env: ParamEnvAndCrate<'db>,
target_data_layout: Arc<TargetDataLayout>,
stack: Vec<u8>,
heap: Vec<u8>,
@@ -594,7 +594,7 @@ pub fn interpret_mir<'db>(
// a zero size, hoping that they are all outside of our current body. Even without a fix for #7434, we can
// (and probably should) do better here, for example by excluding bindings outside of the target expression.
assert_placeholder_ty_is_unused: bool,
- trait_env: Option<Arc<TraitEnvironment<'db>>>,
+ trait_env: Option<ParamEnvAndCrate<'db>>,
) -> Result<'db, (Result<'db, Const<'db>>, MirOutput)> {
let ty = body.locals[return_slot()].ty;
let mut evaluator = Evaluator::new(db, body.owner, assert_placeholder_ty_is_unused, trait_env)?;
@@ -632,7 +632,7 @@ impl<'db> Evaluator<'db> {
db: &'db dyn HirDatabase,
owner: DefWithBodyId,
assert_placeholder_ty_is_unused: bool,
- trait_env: Option<Arc<TraitEnvironment<'db>>>,
+ trait_env: Option<ParamEnvAndCrate<'db>>,
) -> Result<'db, Evaluator<'db>> {
let module = owner.module(db);
let crate_id = module.krate();
@@ -641,8 +641,9 @@ impl<'db> Evaluator<'db> {
Err(e) => return Err(MirEvalError::TargetDataLayoutNotAvailable(e)),
};
let cached_ptr_size = target_data_layout.pointer_size().bytes_usize();
- let interner = DbInterner::new_with(db, Some(crate_id), module.containing_block());
+ let interner = DbInterner::new_with(db, crate_id);
let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
+ let lang_items = interner.lang_items();
Ok(Evaluator {
target_data_layout,
stack: vec![0],
@@ -653,7 +654,10 @@ impl<'db> Evaluator<'db> {
static_locations: Default::default(),
db,
random_state: oorandom::Rand64::new(0),
- trait_env: trait_env.unwrap_or_else(|| db.trait_environment_for_body(owner)),
+ param_env: trait_env.unwrap_or_else(|| ParamEnvAndCrate {
+ param_env: db.trait_environment_for_body(owner),
+ krate: crate_id,
+ }),
crate_id,
stdout: vec![],
stderr: vec![],
@@ -667,13 +671,13 @@ impl<'db> Evaluator<'db> {
mir_or_dyn_index_cache: RefCell::new(Default::default()),
unused_locals_store: RefCell::new(Default::default()),
cached_ptr_size,
- cached_fn_trait_func: LangItem::Fn
- .resolve_trait(db, crate_id)
+ cached_fn_trait_func: lang_items
+ .Fn
.and_then(|x| x.trait_items(db).method_by_name(&Name::new_symbol_root(sym::call))),
- cached_fn_mut_trait_func: LangItem::FnMut.resolve_trait(db, crate_id).and_then(|x| {
+ cached_fn_mut_trait_func: lang_items.FnMut.and_then(|x| {
x.trait_items(db).method_by_name(&Name::new_symbol_root(sym::call_mut))
}),
- cached_fn_once_trait_func: LangItem::FnOnce.resolve_trait(db, crate_id).and_then(|x| {
+ cached_fn_once_trait_func: lang_items.FnOnce.and_then(|x| {
x.trait_items(db).method_by_name(&Name::new_symbol_root(sym::call_once))
}),
infcx,
@@ -685,6 +689,11 @@ impl<'db> Evaluator<'db> {
self.infcx.interner
}
+ #[inline]
+ fn lang_items(&self) -> &'db LangItems {
+ self.infcx.interner.lang_items()
+ }
+
fn place_addr(&self, p: &Place<'db>, locals: &Locals<'db>) -> Result<'db, Address> {
Ok(self.place_addr_and_ty_and_metadata(p, locals)?.0)
}
@@ -716,7 +725,7 @@ impl<'db> Evaluator<'db> {
ty,
|c, subst, f| {
let InternedClosure(def, _) = self.db.lookup_intern_closure(c);
- let infer = self.db.infer(def);
+ let infer = InferenceResult::for_body(self.db, def);
let (captures, _) = infer.closure_info(c);
let parent_subst = subst.split_closure_args_untupled().parent_args;
captures
@@ -858,7 +867,7 @@ impl<'db> Evaluator<'db> {
}
let r = self
.db
- .layout_of_ty(ty, self.trait_env.clone())
+ .layout_of_ty(ty, self.param_env)
.map_err(|e| MirEvalError::LayoutError(e, ty))?;
self.layout_cache.borrow_mut().insert(ty, r.clone());
Ok(r)
@@ -877,7 +886,8 @@ impl<'db> Evaluator<'db> {
OperandKind::Copy(p) | OperandKind::Move(p) => self.place_ty(p, locals)?,
OperandKind::Constant { konst: _, ty } => *ty,
&OperandKind::Static(s) => {
- let ty = self.db.infer(s.into())[self.db.body(s.into()).body_expr];
+ let ty =
+ InferenceResult::for_body(self.db, s.into())[self.db.body(s.into()).body_expr];
Ty::new_ref(
self.interner(),
Region::new_static(self.interner()),
@@ -1920,18 +1930,17 @@ impl<'db> Evaluator<'db> {
let mut id = const_id.0;
let mut subst = subst;
if let hir_def::GeneralConstId::ConstId(c) = id {
- let (c, s) = lookup_impl_const(&self.infcx, self.trait_env.clone(), c, subst);
+ let (c, s) = lookup_impl_const(&self.infcx, self.param_env.param_env, c, subst);
id = hir_def::GeneralConstId::ConstId(c);
subst = s;
}
result_owner = match id {
- GeneralConstId::ConstId(const_id) => self
- .db
- .const_eval(const_id, subst, Some(self.trait_env.clone()))
- .map_err(|e| {
+ GeneralConstId::ConstId(const_id) => {
+ self.db.const_eval(const_id, subst, Some(self.param_env)).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);
@@ -2324,7 +2333,7 @@ impl<'db> Evaluator<'db> {
let ty = ocx
.structurally_normalize_ty(
&ObligationCause::dummy(),
- this.trait_env.env,
+ this.param_env.param_env,
ty,
)
.map_err(|_| MirEvalError::NotSupported("couldn't normalize".to_owned()))?;
@@ -2503,7 +2512,7 @@ impl<'db> Evaluator<'db> {
) -> Result<'db, Option<StackFrame<'db>>> {
let mir_body = self
.db
- .monomorphized_mir_body_for_closure(closure, generic_args, self.trait_env.clone())
+ .monomorphized_mir_body_for_closure(closure, generic_args, self.param_env)
.map_err(|it| MirEvalError::MirLowerErrorForClosure(closure, it))?;
let closure_data = if mir_body.locals[mir_body.param_locals[0]].ty.as_reference().is_some()
{
@@ -2599,16 +2608,19 @@ impl<'db> Evaluator<'db> {
}
let (def, generic_args) = pair;
let r = if let Some(self_ty_idx) =
- is_dyn_method(self.interner(), self.trait_env.clone(), def, generic_args)
+ is_dyn_method(self.interner(), self.param_env.param_env, def, generic_args)
{
MirOrDynIndex::Dyn(self_ty_idx)
} else {
- let (imp, generic_args) =
- self.db.lookup_impl_method(self.trait_env.clone(), def, generic_args);
+ let (imp, generic_args) = self.db.lookup_impl_method(
+ ParamEnvAndCrate { param_env: self.param_env.param_env, krate: self.crate_id },
+ def,
+ generic_args,
+ );
let mir_body = self
.db
- .monomorphized_mir_body(imp.into(), generic_args, self.trait_env.clone())
+ .monomorphized_mir_body(imp.into(), generic_args, self.param_env)
.map_err(|e| {
MirEvalError::InFunction(
Box::new(MirEvalError::MirLowerError(imp, e)),
@@ -2803,7 +2815,8 @@ impl<'db> Evaluator<'db> {
})?;
self.allocate_const_in_heap(locals, konst)?
} else {
- let ty = self.db.infer(st.into())[self.db.body(st.into()).body_expr];
+ let ty =
+ InferenceResult::for_body(self.db, st.into())[self.db.body(st.into()).body_expr];
let Some((size, align)) = self.size_align_of(ty, locals)? else {
not_supported!("unsized extern static");
};
@@ -2864,7 +2877,7 @@ impl<'db> Evaluator<'db> {
span: MirSpan,
) -> Result<'db, ()> {
let Some(drop_fn) = (|| {
- let drop_trait = LangItem::Drop.resolve_trait(self.db, self.crate_id)?;
+ let drop_trait = self.lang_items().Drop?;
drop_trait.trait_items(self.db).method_by_name(&Name::new_symbol_root(sym::drop))
})() else {
// in some tests we don't have drop trait in minicore, and