itsscb/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-01 11:31:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replace layout_of_ty with layout_of_ty_ns

Browse Source
This commit is contained in:
jackh726 2025-08-12 22:21:48 +00:00
parent da6fbda16c
commit 7f0ec8b69f
12 changed files with 75 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
crates/hir-ty/src/consteval.rs
View File

@ -15,8 +15,14 @@ use triomphe::Arc;
use crate::{ use crate::{
Const, ConstData, ConstScalar, ConstValue, GenericArg, Interner, MemoryMap, Substitution, Const, ConstData, ConstScalar, ConstValue, GenericArg, Interner, MemoryMap, Substitution,
TraitEnvironment, Ty, TyBuilder, db::HirDatabase, display::DisplayTarget, generics::Generics, TraitEnvironment, Ty, TyBuilder,
infer::InferenceContext, lower::ParamLoweringMode, to_placeholder_idx, db::HirDatabase,
display::DisplayTarget,
generics::Generics,
infer::InferenceContext,
lower::ParamLoweringMode,
next_solver::{DbInterner, mapping::ChalkToNextSolver},
to_placeholder_idx,
}; };
use super::mir::{MirEvalError, MirLowerError, interpret_mir, lower_to_mir, pad16}; use super::mir::{MirEvalError, MirLowerError, interpret_mir, lower_to_mir, pad16};
@ -157,7 +163,8 @@ pub fn intern_const_ref(
ty: Ty, ty: Ty,
krate: Crate, krate: Crate,
) -> Const { ) -> Const {
let layout = || db.layout_of_ty(ty.clone(), TraitEnvironment::empty(krate)); let interner = DbInterner::new_with(db, Some(krate), None);
let layout = || db.layout_of_ty(ty.to_nextsolver(interner), TraitEnvironment::empty(krate));
let bytes = match value { let bytes = match value {
LiteralConstRef::Int(i) => { LiteralConstRef::Int(i) => {
// FIXME: We should handle failure of layout better. // FIXME: We should handle failure of layout better.

2
crates/hir-ty/src/consteval_nextsolver.rs
View File

@ -92,7 +92,7 @@ pub fn intern_const_ref<'a>(
krate: Crate, krate: Crate,
) -> Const<'a> { ) -> Const<'a> {
let interner = DbInterner::new_with(db, Some(krate), None); let interner = DbInterner::new_with(db, Some(krate), None);
let layout = db.layout_of_ty_ns(ty, TraitEnvironment::empty(krate)); let layout = db.layout_of_ty(ty, TraitEnvironment::empty(krate));
let kind = match value { let kind = match value {
LiteralConstRef::Int(i) => { LiteralConstRef::Int(i) => {
// FIXME: We should handle failure of layout better. // FIXME: We should handle failure of layout better.

14
crates/hir-ty/src/db.rs
View File

@ -103,7 +103,11 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
#[salsa::invoke(crate::layout::layout_of_ty_query)] #[salsa::invoke(crate::layout::layout_of_ty_query)]
#[salsa::cycle(cycle_result = crate::layout::layout_of_ty_cycle_result)] #[salsa::cycle(cycle_result = crate::layout::layout_of_ty_cycle_result)]
fn layout_of_ty(&self, ty: Ty, env: Arc<TraitEnvironment>) -> Result<Arc<Layout>, LayoutError>; fn layout_of_ty<'db>(
&'db self,
ty: crate::next_solver::Ty<'db>,
env: Arc<TraitEnvironment>,
) -> Result<Arc<Layout>, LayoutError>;
#[salsa::invoke(crate::layout::target_data_layout_query)] #[salsa::invoke(crate::layout::target_data_layout_query)]
fn target_data_layout(&self, krate: Crate) -> Result<Arc<TargetDataLayout>, Arc<str>>; fn target_data_layout(&self, krate: Crate) -> Result<Arc<TargetDataLayout>, Arc<str>>;
@ -300,14 +304,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
// next trait solver // next trait solver
#[salsa::invoke(crate::layout::layout_of_ty_ns_query)]
#[salsa::cycle(cycle_result = crate::layout::layout_of_ty_ns_cycle_result)]
fn layout_of_ty_ns<'db>(
&'db self,
ty: crate::next_solver::Ty<'db>,
env: Arc<TraitEnvironment>,
) -> Result<Arc<Layout>, LayoutError>;
#[salsa::invoke(crate::lower_nextsolver::ty_query)] #[salsa::invoke(crate::lower_nextsolver::ty_query)]
#[salsa::transparent] #[salsa::transparent]
fn ty_ns<'db>( fn ty_ns<'db>(

15
crates/hir-ty/src/display.rs
View File

@ -840,7 +840,7 @@ fn render_const_scalar_inner(
TyKind::Slice(ty) => { TyKind::Slice(ty) => {
let addr = usize::from_le_bytes(b[0..b.len() / 2].try_into().unwrap()); let addr = usize::from_le_bytes(b[0..b.len() / 2].try_into().unwrap());
let count = usize::from_le_bytes(b[b.len() / 2..].try_into().unwrap()); let count = usize::from_le_bytes(b[b.len() / 2..].try_into().unwrap());
let Ok(layout) = f.db.layout_of_ty_ns(ty, trait_env) else { let Ok(layout) = f.db.layout_of_ty(ty, trait_env) else {
return f.write_str("<layout-error>"); return f.write_str("<layout-error>");
}; };
let size_one = layout.size.bytes_usize(); let size_one = layout.size.bytes_usize();
@ -874,7 +874,7 @@ fn render_const_scalar_inner(
let Ok(t) = memory_map.vtable_ty(ty_id) else { let Ok(t) = memory_map.vtable_ty(ty_id) else {
return f.write_str("<ty-missing-in-vtable-map>"); return f.write_str("<ty-missing-in-vtable-map>");
}; };
let Ok(layout) = f.db.layout_of_ty_ns(t, trait_env) else { let Ok(layout) = f.db.layout_of_ty(t, trait_env) else {
return f.write_str("<layout-error>"); return f.write_str("<layout-error>");
}; };
let size = layout.size.bytes_usize(); let size = layout.size.bytes_usize();
@ -905,7 +905,7 @@ fn render_const_scalar_inner(
return f.write_str("<layout-error>"); return f.write_str("<layout-error>");
} }
}); });
let Ok(layout) = f.db.layout_of_ty_ns(t, trait_env) else { let Ok(layout) = f.db.layout_of_ty(t, trait_env) else {
return f.write_str("<layout-error>"); return f.write_str("<layout-error>");
}; };
let size = layout.size.bytes_usize(); let size = layout.size.bytes_usize();
@ -917,7 +917,7 @@ fn render_const_scalar_inner(
} }
}, },
TyKind::Tuple(tys) => { TyKind::Tuple(tys) => {
let Ok(layout) = f.db.layout_of_ty_ns(ty, trait_env.clone()) else { let Ok(layout) = f.db.layout_of_ty(ty, trait_env.clone()) else {
return f.write_str("<layout-error>"); return f.write_str("<layout-error>");
}; };
f.write_str("(")?; f.write_str("(")?;
@ -929,7 +929,7 @@ fn render_const_scalar_inner(
f.write_str(", ")?; f.write_str(", ")?;
} }
let offset = layout.fields.offset(id).bytes_usize(); let offset = layout.fields.offset(id).bytes_usize();
let Ok(layout) = f.db.layout_of_ty_ns(ty, trait_env.clone()) else { let Ok(layout) = f.db.layout_of_ty(ty, trait_env.clone()) else {
f.write_str("<layout-error>")?; f.write_str("<layout-error>")?;
continue; continue;
}; };
@ -1006,7 +1006,7 @@ fn render_const_scalar_inner(
let Some(len) = consteval_nextsolver::try_const_usize(f.db, len) else { let Some(len) = consteval_nextsolver::try_const_usize(f.db, len) else {
return f.write_str("<unknown-array-len>"); return f.write_str("<unknown-array-len>");
}; };
let Ok(layout) = f.db.layout_of_ty_ns(ty, trait_env) else { let Ok(layout) = f.db.layout_of_ty(ty, trait_env) else {
return f.write_str("<layout-error>"); return f.write_str("<layout-error>");
}; };
let size_one = layout.size.bytes_usize(); let size_one = layout.size.bytes_usize();
@ -1061,7 +1061,8 @@ fn render_variant_after_name(
let ty = field_types[id] let ty = field_types[id]
.clone() .clone()
.substitute(Interner, &convert_args_for_result(interner, args.as_slice())); .substitute(Interner, &convert_args_for_result(interner, args.as_slice()));
let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env.clone()) else { let Ok(layout) = f.db.layout_of_ty(ty.to_nextsolver(interner), trait_env.clone())
else {
return f.write_str("<layout-error>"); return f.write_str("<layout-error>");
}; };
let size = layout.size.bytes_usize(); let size = layout.size.bytes_usize();

32
crates/hir-ty/src/layout.rs
View File

@ -151,23 +151,13 @@ fn layout_of_simd_ty<'db>(
}; };
let e_len = try_const_usize(db, e_len).ok_or(LayoutError::HasErrorConst)? as u64; let e_len = try_const_usize(db, e_len).ok_or(LayoutError::HasErrorConst)? as u64;
let e_ly = db.layout_of_ty_ns(e_ty, env)?; let e_ly = db.layout_of_ty(e_ty, env)?;
let cx = LayoutCx::new(dl); let cx = LayoutCx::new(dl);
Ok(Arc::new(cx.calc.simd_type(e_ly, e_len, repr_packed)?)) Ok(Arc::new(cx.calc.simd_type(e_ly, e_len, repr_packed)?))
} }
pub fn layout_of_ty_query( pub fn layout_of_ty_query<'db>(
db: &dyn HirDatabase,
ty: crate::Ty,
trait_env: Arc<TraitEnvironment>,
) -> Result<Arc<Layout>, LayoutError> {
let krate = trait_env.krate;
let interner = DbInterner::new_with(db, Some(krate), trait_env.block);
db.layout_of_ty_ns(ty.to_nextsolver(interner), trait_env)
}
pub fn layout_of_ty_ns_query<'db>(
db: &'db dyn HirDatabase, db: &'db dyn HirDatabase,
ty: Ty<'db>, ty: Ty<'db>,
trait_env: Arc<TraitEnvironment>, trait_env: Arc<TraitEnvironment>,
@ -262,7 +252,7 @@ pub fn layout_of_ty_ns_query<'db>(
let fields = tys let fields = tys
.iter() .iter()
.map(|k| db.layout_of_ty_ns(k, trait_env.clone())) .map(|k| db.layout_of_ty(k, trait_env.clone()))
.collect::<Result<Vec<_>, _>>()?; .collect::<Result<Vec<_>, _>>()?;
let fields = fields.iter().map(|it| &**it).collect::<Vec<_>>(); let fields = fields.iter().map(|it| &**it).collect::<Vec<_>>();
let fields = fields.iter().collect::<IndexVec<_, _>>(); let fields = fields.iter().collect::<IndexVec<_, _>>();
@ -270,11 +260,11 @@ pub fn layout_of_ty_ns_query<'db>(
} }
TyKind::Array(element, count) => { TyKind::Array(element, count) => {
let count = try_const_usize(db, count).ok_or(LayoutError::HasErrorConst)? as u64; let count = try_const_usize(db, count).ok_or(LayoutError::HasErrorConst)? as u64;
let element = db.layout_of_ty_ns(element, trait_env)?; let element = db.layout_of_ty(element, trait_env)?;
cx.calc.array_like::<_, _, ()>(&element, Some(count))? cx.calc.array_like::<_, _, ()>(&element, Some(count))?
} }
TyKind::Slice(element) => { TyKind::Slice(element) => {
let element = db.layout_of_ty_ns(element, trait_env)?; let element = db.layout_of_ty(element, trait_env)?;
cx.calc.array_like::<_, _, ()>(&element, None)? cx.calc.array_like::<_, _, ()>(&element, None)?
} }
TyKind::Str => { TyKind::Str => {
@ -346,7 +336,7 @@ pub fn layout_of_ty_ns_query<'db>(
let ty = let ty =
convert_binder_to_early_binder(interner, it.ty.to_nextsolver(interner)) convert_binder_to_early_binder(interner, it.ty.to_nextsolver(interner))
.instantiate(interner, args); .instantiate(interner, args);
db.layout_of_ty_ns(ty, trait_env.clone()) db.layout_of_ty(ty, trait_env.clone())
}) })
.collect::<Result<Vec<_>, _>>()?; .collect::<Result<Vec<_>, _>>()?;
let fields = fields.iter().map(|it| &**it).collect::<Vec<_>>(); let fields = fields.iter().map(|it| &**it).collect::<Vec<_>>();
@ -376,15 +366,7 @@ pub fn layout_of_ty_ns_query<'db>(
Ok(Arc::new(result)) Ok(Arc::new(result))
} }
pub(crate) fn layout_of_ty_cycle_result( pub(crate) fn layout_of_ty_cycle_result<'db>(
_: &dyn HirDatabase,
_: crate::Ty,
_: Arc<TraitEnvironment>,
) -> Result<Arc<Layout>, LayoutError> {
Err(LayoutError::RecursiveTypeWithoutIndirection)
}
pub(crate) fn layout_of_ty_ns_cycle_result<'db>(
_: &dyn HirDatabase, _: &dyn HirDatabase,
_: Ty<'db>, _: Ty<'db>,
_: Arc<TraitEnvironment>, _: Arc<TraitEnvironment>,

2
crates/hir-ty/src/layout/adt.rs
View File

@ -34,7 +34,7 @@ pub fn layout_of_adt_query<'db>(
let handle_variant = |def: VariantId, var: &VariantFields| { let handle_variant = |def: VariantId, var: &VariantFields| {
var.fields() var.fields()
.iter() .iter()
.map(|(fd, _)| db.layout_of_ty_ns(field_ty(db, def, fd, &args), trait_env.clone())) .map(|(fd, _)| db.layout_of_ty(field_ty(db, def, fd, &args), trait_env.clone()))
.collect::<Result<Vec<_>, _>>() .collect::<Result<Vec<_>, _>>()
}; };
let (variants, repr, is_special_no_niche) = match def { let (variants, repr, is_special_no_niche) = match def {

23
crates/hir-ty/src/layout/tests.rs
View File

@ -11,6 +11,7 @@ use crate::{
Interner, Substitution, Interner, Substitution,
db::HirDatabase, db::HirDatabase,
layout::{Layout, LayoutError}, layout::{Layout, LayoutError},
next_solver::{DbInterner, mapping::ChalkToNextSolver},
setup_tracing, setup_tracing,
test_db::TestDB, test_db::TestDB,
}; };
@ -85,13 +86,16 @@ fn eval_goal(
db.ty(ty_id.into()).substitute(Interner, &Substitution::empty(Interner)) db.ty(ty_id.into()).substitute(Interner, &Substitution::empty(Interner))
} }
}; };
db.layout_of_ty( salsa::attach(&db, || {
goal_ty, let interner = DbInterner::new_with(&db, None, None);
db.trait_environment(match adt_or_type_alias_id { db.layout_of_ty(
Either::Left(adt) => hir_def::GenericDefId::AdtId(adt), goal_ty.to_nextsolver(interner),
Either::Right(ty) => hir_def::GenericDefId::TypeAliasId(ty), db.trait_environment(match adt_or_type_alias_id {
}), Either::Left(adt) => hir_def::GenericDefId::AdtId(adt),
) Either::Right(ty) => hir_def::GenericDefId::TypeAliasId(ty),
}),
)
})
} }
/// A version of `eval_goal` for types that can not be expressed in ADTs, like closures and `impl Trait` /// A version of `eval_goal` for types that can not be expressed in ADTs, like closures and `impl Trait`
@ -128,7 +132,10 @@ fn eval_expr(
.0; .0;
let infer = db.infer(function_id.into()); let infer = db.infer(function_id.into());
let goal_ty = infer.type_of_binding[b].clone(); let goal_ty = infer.type_of_binding[b].clone();
db.layout_of_ty(goal_ty, db.trait_environment(function_id.into())) salsa::attach(&db, || {
let interner = DbInterner::new_with(&db, None, None);
db.layout_of_ty(goal_ty.to_nextsolver(interner), db.trait_environment(function_id.into()))
})
} }
#[track_caller] #[track_caller]

2
crates/hir-ty/src/mir/eval.rs
View File

@ -854,7 +854,7 @@ impl<'db> Evaluator<'db> {
let interner = DbInterner::new_with(self.db, None, None); let interner = DbInterner::new_with(self.db, None, None);
let r = self let r = self
.db .db
.layout_of_ty_ns(ty, self.trait_env.clone()) .layout_of_ty(ty, self.trait_env.clone())
.map_err(|e| MirEvalError::LayoutError(e, convert_ty_for_result(interner, ty)))?; .map_err(|e| MirEvalError::LayoutError(e, convert_ty_for_result(interner, ty)))?;
self.layout_cache.borrow_mut().insert(ty, r.clone()); self.layout_cache.borrow_mut().insert(ty, r.clone());
Ok(r) Ok(r)

9
crates/hir-ty/src/mir/lower.rs
View File

@ -43,6 +43,7 @@ use crate::{
Terminator, TerminatorKind, TupleFieldId, Ty, UnOp, VariantId, intern_const_scalar, Terminator, TerminatorKind, TupleFieldId, Ty, UnOp, VariantId, intern_const_scalar,
return_slot, return_slot,
}, },
next_solver::{DbInterner, mapping::ChalkToNextSolver},
static_lifetime, static_lifetime,
traits::FnTrait, traits::FnTrait,
utils::ClosureSubst, utils::ClosureSubst,
@ -1411,8 +1412,12 @@ impl<'ctx> MirLowerCtx<'ctx> {
} }
fn lower_literal_to_operand(&mut self, ty: Ty, l: &Literal) -> Result<Operand> { fn lower_literal_to_operand(&mut self, ty: Ty, l: &Literal) -> Result<Operand> {
let size = let interner = DbInterner::new_with(self.db, None, None);
|| self.db.layout_of_ty(ty.clone(), self.env.clone()).map(|it| it.size.bytes_usize()); let size = || {
self.db
.layout_of_ty(ty.to_nextsolver(interner), self.env.clone())
.map(|it| it.size.bytes_usize())
};
const USIZE_SIZE: usize = size_of::<usize>(); const USIZE_SIZE: usize = size_of::<usize>();
let bytes: Box<[_]> = match l { let bytes: Box<[_]> = match l {
hir_def::hir::Literal::String(b) => { hir_def::hir::Literal::String(b) => {

6
crates/hir/src/lib.rs
View File

@ -1389,8 +1389,9 @@ impl Field {
} }
pub fn layout(&self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> { pub fn layout(&self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {
let interner = DbInterner::new_with(db, None, None);
db.layout_of_ty( db.layout_of_ty(
self.ty(db).ty, self.ty(db).ty.to_nextsolver(interner),
db.trait_environment(match hir_def::VariantId::from(self.parent) { db.trait_environment(match hir_def::VariantId::from(self.parent) {
hir_def::VariantId::EnumVariantId(id) => { hir_def::VariantId::EnumVariantId(id) => {
GenericDefId::AdtId(id.lookup(db).parent.into()) GenericDefId::AdtId(id.lookup(db).parent.into())
@ -5906,7 +5907,8 @@ impl<'db> Type<'db> {
} }
pub fn layout(&self, db: &'db dyn HirDatabase) -> Result<Layout, LayoutError> { pub fn layout(&self, db: &'db dyn HirDatabase) -> Result<Layout, LayoutError> {
db.layout_of_ty(self.ty.clone(), self.env.clone()) let interner = DbInterner::new_with(db, None, None);
db.layout_of_ty(self.ty.to_nextsolver(interner), self.env.clone())
.map(|layout| Layout(layout, db.target_data_layout(self.env.krate).unwrap())) .map(|layout| Layout(layout, db.target_data_layout(self.env.krate).unwrap()))
} }

26
crates/ide/src/hover.rs
View File

@ -137,18 +137,20 @@ pub(crate) fn hover(
let edition = let edition =
sema.attach_first_edition(file_id).map(|it| it.edition(db)).unwrap_or(Edition::CURRENT); sema.attach_first_edition(file_id).map(|it| it.edition(db)).unwrap_or(Edition::CURRENT);
let display_target = sema.first_crate(file_id)?.to_display_target(db); let display_target = sema.first_crate(file_id)?.to_display_target(db);
let mut res = if range.is_empty() { let mut res = salsa::attach(sema.db, || {
hover_offset( if range.is_empty() {
sema, hover_offset(
FilePosition { file_id, offset: range.start() }, sema,
file, FilePosition { file_id, offset: range.start() },
config, file,
edition, config,
display_target, edition,
) display_target,
} else { )
hover_ranged(sema, frange, file, config, edition, display_target) } else {
}?; hover_ranged(sema, frange, file, config, edition, display_target)
}
})?;
if let HoverDocFormat::PlainText = config.format { if let HoverDocFormat::PlainText = config.format {
res.info.markup = remove_markdown(res.info.markup.as_str()).into(); res.info.markup = remove_markdown(res.info.markup.as_str()).into();

4
crates/ide/src/view_memory_layout.rs
View File

@ -139,7 +139,7 @@ pub(crate) fn view_memory_layout(
nodes[parent_idx].children_len = fields.len() as u64; nodes[parent_idx].children_len = fields.len() as u64;
for (field, child_ty) in fields.iter() { for (field, child_ty) in fields.iter() {
if let Ok(child_layout) = child_ty.layout(db) { if let Ok(child_layout) = salsa::attach(db, || child_ty.layout(db)) {
nodes.push(MemoryLayoutNode { nodes.push(MemoryLayoutNode {
item_name: field.name(db), item_name: field.name(db),
typename: salsa::attach(db, || { typename: salsa::attach(db, || {
@ -172,7 +172,7 @@ pub(crate) fn view_memory_layout(
} }
for (i, (_, child_ty)) in fields.iter().enumerate() { for (i, (_, child_ty)) in fields.iter().enumerate() {
if let Ok(child_layout) = child_ty.layout(db) { if let Ok(child_layout) = salsa::attach(db, || child_ty.layout(db)) {
read_layout(nodes, db, child_ty, &child_layout, children_start + i, display_target); read_layout(nodes, db, child_ty, &child_layout, children_start + i, display_target);
} }
} }