Replace layout_of_ty with layout_of_ty_ns

12 files changed, 75 insertions, 73 deletions

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
index f30ec839a00..abf97f3d0e3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
@@ -15,8 +15,14 @@ use triomphe::Arc;
 
 use crate::{
     Const, ConstData, ConstScalar, ConstValue, GenericArg, Interner, MemoryMap, Substitution,
-    TraitEnvironment, Ty, TyBuilder, db::HirDatabase, display::DisplayTarget, generics::Generics,
-    infer::InferenceContext, lower::ParamLoweringMode, to_placeholder_idx,
+    TraitEnvironment, Ty, TyBuilder,
+    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};
@@ -157,7 +163,8 @@ pub fn intern_const_ref(
     ty: Ty,
     krate: Crate,
 ) -> 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 {
         LiteralConstRef::Int(i) => {
             // FIXME: We should handle failure of layout better.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
index cdf861290ab..00fc4e5610d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
@@ -92,7 +92,7 @@ pub fn intern_const_ref<'a>(
     krate: Crate,
 ) -> Const<'a> {
     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 {
         LiteralConstRef::Int(i) => {
             // FIXME: We should handle failure of layout better.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 161ad31e579..9affd3b48c5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -103,7 +103,11 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     #[salsa::invoke(crate::layout::layout_of_ty_query)]
     #[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)]
     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
 
-    #[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::transparent]
     fn ty_ns<'db>(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
index 5adbea75a67..cdf6085b653 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -840,7 +840,7 @@ fn render_const_scalar_inner(
             TyKind::Slice(ty) => {
                 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 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>");
                 };
                 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 {
                     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>");
                 };
                 let size = layout.size.bytes_usize();
@@ -905,7 +905,7 @@ fn render_const_scalar_inner(
                         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>");
                 };
                 let size = layout.size.bytes_usize();
@@ -917,7 +917,7 @@ fn render_const_scalar_inner(
             }
         },
         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>");
             };
             f.write_str("(")?;
@@ -929,7 +929,7 @@ fn render_const_scalar_inner(
                     f.write_str(", ")?;
                 }
                 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>")?;
                     continue;
                 };
@@ -1006,7 +1006,7 @@ fn render_const_scalar_inner(
             let Some(len) = consteval_nextsolver::try_const_usize(f.db, len) else {
                 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>");
             };
             let size_one = layout.size.bytes_usize();
@@ -1061,7 +1061,8 @@ fn render_variant_after_name(
                 let ty = field_types[id]
                     .clone()
                     .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>");
                 };
                 let size = layout.size.bytes_usize();
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index 0a8ec949b7c..e2ee8935a88 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -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_ly = db.layout_of_ty_ns(e_ty, env)?;
+    let e_ly = db.layout_of_ty(e_ty, env)?;
 
     let cx = LayoutCx::new(dl);
     Ok(Arc::new(cx.calc.simd_type(e_ly, e_len, repr_packed)?))
 }
 
-pub fn layout_of_ty_query(
-    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>(
+pub fn layout_of_ty_query<'db>(
     db: &'db dyn HirDatabase,
     ty: Ty<'db>,
     trait_env: Arc<TraitEnvironment>,
@@ -262,7 +252,7 @@ pub fn layout_of_ty_ns_query<'db>(
 
             let fields = tys
                 .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<_>, _>>()?;
             let fields = fields.iter().map(|it| &**it).collect::<Vec<_>>();
             let fields = fields.iter().collect::<IndexVec<_, _>>();
@@ -270,11 +260,11 @@ pub fn layout_of_ty_ns_query<'db>(
         }
         TyKind::Array(element, count) => {
             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))?
         }
         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)?
         }
         TyKind::Str => {
@@ -346,7 +336,7 @@ pub fn layout_of_ty_ns_query<'db>(
                     let ty =
                         convert_binder_to_early_binder(interner, it.ty.to_nextsolver(interner))
                             .instantiate(interner, args);
-                    db.layout_of_ty_ns(ty, trait_env.clone())
+                    db.layout_of_ty(ty, trait_env.clone())
                 })
                 .collect::<Result<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))
 }
 
-pub(crate) fn layout_of_ty_cycle_result(
-    _: &dyn HirDatabase,
-    _: crate::Ty,
-    _: Arc<TraitEnvironment>,
-) -> Result<Arc<Layout>, LayoutError> {
-    Err(LayoutError::RecursiveTypeWithoutIndirection)
-}
-
-pub(crate) fn layout_of_ty_ns_cycle_result<'db>(
+pub(crate) fn layout_of_ty_cycle_result<'db>(
     _: &dyn HirDatabase,
     _: Ty<'db>,
     _: Arc<TraitEnvironment>,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
index fefa3f26174..9a746ca8885 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
@@ -34,7 +34,7 @@ pub fn layout_of_adt_query<'db>(
     let handle_variant = |def: VariantId, var: &VariantFields| {
         var.fields()
             .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<_>, _>>()
     };
     let (variants, repr, is_special_no_niche) = match def {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
index 93f2e123dca..90de7e5ca63 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
@@ -11,6 +11,7 @@ use crate::{
     Interner, Substitution,
     db::HirDatabase,
     layout::{Layout, LayoutError},
+    next_solver::{DbInterner, mapping::ChalkToNextSolver},
     setup_tracing,
     test_db::TestDB,
 };
@@ -85,13 +86,16 @@ fn eval_goal(
             db.ty(ty_id.into()).substitute(Interner, &Substitution::empty(Interner))
         }
     };
-    db.layout_of_ty(
-        goal_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),
-        }),
-    )
+    salsa::attach(&db, || {
+        let interner = DbInterner::new_with(&db, None, None);
+        db.layout_of_ty(
+            goal_ty.to_nextsolver(interner),
+            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`
@@ -128,7 +132,10 @@ fn eval_expr(
         .0;
     let infer = db.infer(function_id.into());
     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]
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index d0ae92961ef..9deaa4ac5a6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -854,7 +854,7 @@ impl<'db> Evaluator<'db> {
         let interner = DbInterner::new_with(self.db, None, None);
         let r = self
             .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)))?;
         self.layout_cache.borrow_mut().insert(ty, r.clone());
         Ok(r)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 0bb8e6fe79d..052be11e433 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -43,6 +43,7 @@ use crate::{
         Terminator, TerminatorKind, TupleFieldId, Ty, UnOp, VariantId, intern_const_scalar,
         return_slot,
     },
+    next_solver::{DbInterner, mapping::ChalkToNextSolver},
     static_lifetime,
     traits::FnTrait,
     utils::ClosureSubst,
@@ -1411,8 +1412,12 @@ impl<'ctx> MirLowerCtx<'ctx> {
     }
 
     fn lower_literal_to_operand(&mut self, ty: Ty, l: &Literal) -> Result<Operand> {
-        let size =
-            || self.db.layout_of_ty(ty.clone(), self.env.clone()).map(|it| it.size.bytes_usize());
+        let interner = DbInterner::new_with(self.db, None, None);
+        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>();
         let bytes: Box<[_]> = match l {
             hir_def::hir::Literal::String(b) => {
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 18c3ea05614..e423d2c07c1 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -1389,8 +1389,9 @@ impl Field {
     }
 
     pub fn layout(&self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {
+        let interner = DbInterner::new_with(db, None, None);
         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) {
                 hir_def::VariantId::EnumVariantId(id) => {
                     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> {
-        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()))
     }
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover.rs b/src/tools/rust-analyzer/crates/ide/src/hover.rs
index fc45dc3faf4..b0ef83e0501 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover.rs
@@ -137,18 +137,20 @@ pub(crate) fn hover(
     let edition =
         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 mut res = if range.is_empty() {
-        hover_offset(
-            sema,
-            FilePosition { file_id, offset: range.start() },
-            file,
-            config,
-            edition,
-            display_target,
-        )
-    } else {
-        hover_ranged(sema, frange, file, config, edition, display_target)
-    }?;
+    let mut res = salsa::attach(sema.db, || {
+        if range.is_empty() {
+            hover_offset(
+                sema,
+                FilePosition { file_id, offset: range.start() },
+                file,
+                config,
+                edition,
+                display_target,
+            )
+        } else {
+            hover_ranged(sema, frange, file, config, edition, display_target)
+        }
+    })?;
 
     if let HoverDocFormat::PlainText = config.format {
         res.info.markup = remove_markdown(res.info.markup.as_str()).into();
diff --git a/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs b/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
index 1eb0fd4fd8b..950f3f6c647 100644
--- a/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
@@ -139,7 +139,7 @@ pub(crate) fn view_memory_layout(
         nodes[parent_idx].children_len = fields.len() as u64;
 
         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 {
                     item_name: field.name(db),
                     typename: salsa::attach(db, || {
@@ -172,7 +172,7 @@ pub(crate) fn view_memory_layout(
         }
 
         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);
             }
         }