Deduplicate layout_of_adt

crates/hir-ty/src/db.rs

@@ -94,11 +94,11 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     #[salsa::invoke(crate::layout::layout_of_adt_query)]
     #[salsa::cycle(cycle_result = crate::layout::layout_of_adt_cycle_result)]
-    fn layout_of_adt(
-        &self,
+    fn layout_of_adt<'db>(
+        &'db self,
         def: AdtId,
-        subst: Substitution,
-        env: Arc<TraitEnvironment>,
+        args: crate::next_solver::GenericArgs<'db>,
+        trait_env: Arc<TraitEnvironment>,
     ) -> Result<Arc<Layout>, LayoutError>;
 
     #[salsa::invoke(crate::layout::layout_of_ty_query)]
@@ -300,15 +300,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     // next trait solver
 
-    #[salsa::invoke(crate::layout::layout_of_adt_ns_query)]
-    #[salsa::cycle(cycle_result = crate::layout::layout_of_adt_ns_cycle_result)]
-    fn layout_of_adt_ns<'db>(
-        &'db self,
-        def: AdtId,
-        args: crate::next_solver::GenericArgs<'db>,
-        trait_env: Arc<TraitEnvironment>,
-    ) -> Result<Arc<Layout>, LayoutError>;
-
     #[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>(

crates/hir-ty/src/display.rs

@@ -944,7 +944,7 @@ fn render_const_scalar_inner(
                 SolverDefId::AdtId(def) => def,
                 _ => unreachable!(),
             };
-            let Ok(layout) = f.db.layout_of_adt_ns(def, args, trait_env.clone()) else {
+            let Ok(layout) = f.db.layout_of_adt(def, args, trait_env.clone()) else {
                 return f.write_str("<layout-error>");
             };
             match def {

crates/hir-ty/src/layout.rs

@@ -31,11 +31,8 @@ use crate::{
     },
 };
 
-pub(crate) use self::adt::{layout_of_adt_cycle_result, layout_of_adt_ns_cycle_result};
-pub use self::{
-    adt::{layout_of_adt_ns_query, layout_of_adt_query},
-    target::target_data_layout_query,
-};
+pub(crate) use self::adt::layout_of_adt_cycle_result;
+pub use self::{adt::layout_of_adt_query, target::target_data_layout_query};
 
 pub(crate) mod adt;
 pub(crate) mod target;
@@ -197,7 +194,7 @@ pub fn layout_of_ty_ns_query<'db>(
                 }
                 _ => {}
             }
-            return db.layout_of_adt_ns(def.inner().id, args, trait_env);
+            return db.layout_of_adt(def.inner().id, args, trait_env);
         }
         TyKind::Bool => Layout::scalar(
             dl,

crates/hir-ty/src/layout/adt.rs

@@ -13,23 +13,13 @@ use smallvec::SmallVec;
 use triomphe::Arc;
 
 use crate::{
-    Substitution, TraitEnvironment,
+    TraitEnvironment,
     db::HirDatabase,
     layout::{Layout, LayoutCx, LayoutError, field_ty},
-    next_solver::{DbInterner, GenericArgs, mapping::ChalkToNextSolver},
+    next_solver::GenericArgs,
 };
 
-pub fn layout_of_adt_query(
-    db: &dyn HirDatabase,
-    def: AdtId,
-    subst: Substitution,
-    trait_env: Arc<TraitEnvironment>,
-) -> Result<Arc<Layout>, LayoutError> {
-    let interner = DbInterner::new_with(db, Some(trait_env.krate), trait_env.block);
-    db.layout_of_adt_ns(def, subst.to_nextsolver(interner), trait_env)
-}
-
-pub fn layout_of_adt_ns_query<'db>(
+pub fn layout_of_adt_query<'db>(
     db: &'db dyn HirDatabase,
     def: AdtId,
     args: GenericArgs<'db>,
@@ -105,16 +95,7 @@ pub fn layout_of_adt_ns_query<'db>(
     Ok(Arc::new(result))
 }
 
-pub(crate) fn layout_of_adt_cycle_result(
-    _: &dyn HirDatabase,
-    _: AdtId,
-    _: Substitution,
-    _: Arc<TraitEnvironment>,
-) -> Result<Arc<Layout>, LayoutError> {
-    Err(LayoutError::RecursiveTypeWithoutIndirection)
-}
-
-pub(crate) fn layout_of_adt_ns_cycle_result<'db>(
+pub(crate) fn layout_of_adt_cycle_result<'db>(
     _: &'db dyn HirDatabase,
     _def: AdtId,
     _args: GenericArgs<'db>,

crates/hir/src/lib.rs

@@ -1818,7 +1818,7 @@ impl Adt {
     pub fn layout(self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {
         let env = db.trait_environment(self.into());
         let interner = DbInterner::new_with(db, Some(env.krate), env.block);
-        db.layout_of_adt_ns(
+        db.layout_of_adt(
             self.into(),
             TyBuilder::adt(db, self.into())
                 .fill_with_defaults(db, || TyKind::Error.intern(Interner))

crates/rust-analyzer/src/cli/analysis_stats.rs

@@ -10,15 +10,17 @@ use std::{
 
 use cfg::{CfgAtom, CfgDiff};
 use hir::{
-    Adt, AssocItem, Crate, DefWithBody, HasSource, HirDisplay, ImportPathConfig, ModuleDef, Name,
+    Adt, AssocItem, Crate, DefWithBody, HasCrate, HasSource, HirDisplay, ImportPathConfig,
+    ModuleDef, Name,
     db::{DefDatabase, ExpandDatabase, HirDatabase},
+    next_solver::{DbInterner, GenericArgs},
 };
 use hir_def::{
     SyntheticSyntax,
     expr_store::BodySourceMap,
     hir::{ExprId, PatId},
 };
-use hir_ty::{Interner, Substitution, TyExt, TypeFlags};
+use hir_ty::{Interner, TyExt, TypeFlags};
 use ide::{
     Analysis, AnalysisHost, AnnotationConfig, DiagnosticsConfig, Edition, InlayFieldsToResolve,
     InlayHintsConfig, LineCol, RootDatabase,
@@ -361,6 +363,7 @@ impl flags::AnalysisStats {
         let mut all = 0;
         let mut fail = 0;
         for &a in adts {
+            let interner = DbInterner::new_with(db, Some(a.krate(db).base()), None);
             let generic_params = db.generic_params(a.into());
             if generic_params.iter_type_or_consts().next().is_some()
                 || generic_params.iter_lt().next().is_some()
@@ -371,7 +374,7 @@ impl flags::AnalysisStats {
             all += 1;
             let Err(e) = db.layout_of_adt(
                 hir_def::AdtId::from(a),
-                Substitution::empty(Interner),
+                GenericArgs::new_from_iter(interner, []),
                 db.trait_environment(a.into()),
             ) else {
                 continue;