diff --git a/crates/hir-ty/src/builtin_derive.rs b/crates/hir-ty/src/builtin_derive.rs
index baa7b87e457f..53a232adfc7a 100644
--- a/crates/hir-ty/src/builtin_derive.rs
+++ b/crates/hir-ty/src/builtin_derive.rs
@@ -195,7 +195,7 @@ pub fn predicates(db: &dyn HirDatabase, impl_: BuiltinDeriveImplId) -> GenericPr
             else {
                 // Malformed derive.
                 return GenericPredicates::from_explicit_own_predicates(StoredEarlyBinder::bind(
-                    Clauses::empty(interner).store(),
+                    Clauses::empty().store(),
                 ));
             };
             let duplicated_bounds =
diff --git a/crates/hir-ty/src/consteval.rs b/crates/hir-ty/src/consteval.rs
index d65f76cdf1ce..a1ed1e71aecc 100644
--- a/crates/hir-ty/src/consteval.rs
+++ b/crates/hir-ty/src/consteval.rs
@@ -253,7 +253,7 @@ pub fn try_const_usize<'db>(db: &'db dyn HirDatabase, c: Const<'db>) -> Option<u
             }
         },
         ConstKind::Value(val) => {
-            if val.ty == default_types(db).types.usize {
+            if val.ty == default_types().types.usize {
                 Some(val.value.inner().to_leaf().to_uint_unchecked())
             } else {
                 None
@@ -291,7 +291,7 @@ pub fn try_const_isize<'db>(db: &'db dyn HirDatabase, c: Const<'db>) -> Option<i
             }
         },
         ConstKind::Value(val) => {
-            if val.ty == default_types(db).types.isize {
+            if val.ty == default_types().types.isize {
                 Some(val.value.inner().to_leaf().to_int_unchecked())
             } else {
                 None
@@ -347,7 +347,7 @@ pub(crate) fn path_to_const<'a, 'db>(
         | ValueNs::StructId(_)
         | ValueNs::EnumVariantId(_) => return Err(CreateConstError::ResolveToNonConst),
     };
-    let args = GenericArgs::empty(interner);
+    let args = GenericArgs::empty();
     Ok(Const::new_unevaluated(interner, UnevaluatedConst { def: konst.into(), args }))
 }
 
@@ -411,7 +411,7 @@ pub(crate) fn create_anon_const<'a, 'db>(
             let args = if allow_using_generic_params {
                 GenericArgs::identity_for_item(interner, owner.generic_def(interner.db).into())
             } else {
-                GenericArgs::empty(interner)
+                GenericArgs::empty()
             };
             Ok(Const::new_unevaluated(
                 interner,
@@ -426,7 +426,6 @@ pub(crate) fn const_eval_discriminant_variant<'db>(
     db: &'db dyn HirDatabase,
     variant_id: EnumVariantId,
 ) -> Result<i128, ConstEvalError<'db>> {
-    let interner = DbInterner::new_no_crate(db);
     let def = variant_id.into();
     let body = Body::of(db, def);
     let loc = variant_id.lookup(db);
@@ -446,7 +445,7 @@ pub(crate) fn const_eval_discriminant_variant<'db>(
 
     let mir_body = db.monomorphized_mir_body(
         def.into(),
-        GenericArgs::empty(interner).store(),
+        GenericArgs::empty().store(),
         ParamEnvAndCrate {
             param_env: db.trait_environment(def.generic_def(db)),
             krate: def.krate(db),
@@ -561,10 +560,9 @@ pub(crate) fn const_eval_static<'db>(
         db: &'db dyn HirDatabase,
         def: StaticId,
     ) -> Result<StoredAllocation, ConstEvalError<'db>> {
-        let interner = DbInterner::new_no_crate(db);
         let body = db.monomorphized_mir_body(
             def.into(),
-            GenericArgs::empty(interner).store(),
+            GenericArgs::empty().store(),
             ParamEnvAndCrate { param_env: db.trait_environment(def.into()), krate: def.krate(db) }
                 .store(),
         )?;
diff --git a/crates/hir-ty/src/consteval/tests.rs b/crates/hir-ty/src/consteval/tests.rs
index 6ea8376e4874..b17df991f7af 100644
--- a/crates/hir-ty/src/consteval/tests.rs
+++ b/crates/hir-ty/src/consteval/tests.rs
@@ -14,7 +14,7 @@ use crate::{
     db::HirDatabase,
     display::DisplayTarget,
     mir::{IsSigned, pad16},
-    next_solver::{Allocation, DbInterner, GenericArgs},
+    next_solver::{Allocation, GenericArgs},
     setup_tracing,
     test_db::TestDB,
 };
@@ -120,7 +120,6 @@ fn pretty_print_err(e: ConstEvalError<'_>, db: &TestDB) -> String {
 
 fn eval_goal(db: &TestDB, file_id: EditionedFileId) -> Result<Allocation<'_>, ConstEvalError<'_>> {
     let _tracing = setup_tracing();
-    let interner = DbInterner::new_no_crate(db);
     let module_id = db.module_for_file(file_id.file_id(db));
     let def_map = module_id.def_map(db);
     let scope = &def_map[module_id].scope;
@@ -143,7 +142,7 @@ fn eval_goal(db: &TestDB, file_id: EditionedFileId) -> Result<Allocation<'_>, Co
             _ => None,
         })
         .expect("No const named GOAL found in the test");
-    db.const_eval(const_id, GenericArgs::empty(interner), None)
+    db.const_eval(const_id, GenericArgs::empty(), None)
 }
 
 #[test]
diff --git a/crates/hir-ty/src/display.rs b/crates/hir-ty/src/display.rs
index a87a55b3c898..e83962ec25ec 100644
--- a/crates/hir-ty/src/display.rs
+++ b/crates/hir-ty/src/display.rs
@@ -811,7 +811,7 @@ fn render_const_scalar<'db>(
     memory_map: &MemoryMap<'db>,
     ty: Ty<'db>,
 ) -> Result {
-    let param_env = ParamEnv::empty(f.interner);
+    let param_env = ParamEnv::empty();
     let infcx = f.interner.infer_ctxt().build(TypingMode::PostAnalysis);
     let ty = infcx.at(&ObligationCause::dummy(), param_env).deeply_normalize(ty).unwrap_or(ty);
     render_const_scalar_inner(f, b, memory_map, ty, param_env)
@@ -1086,7 +1086,7 @@ fn render_const_scalar_from_valtree<'db>(
     ty: Ty<'db>,
     valtree: ValTree<'db>,
 ) -> Result {
-    let param_env = ParamEnv::empty(f.interner);
+    let param_env = ParamEnv::empty();
     let infcx = f.interner.infer_ctxt().build(TypingMode::PostAnalysis);
     let ty = infcx.at(&ObligationCause::dummy(), param_env).deeply_normalize(ty).unwrap_or(ty);
     render_const_scalar_from_valtree_inner(f, ty, valtree, param_env)
diff --git a/crates/hir-ty/src/infer.rs b/crates/hir-ty/src/infer.rs
index f93c5a2ebbff..cbe5b671fe83 100644
--- a/crates/hir-ty/src/infer.rs
+++ b/crates/hir-ty/src/infer.rs
@@ -1424,7 +1424,7 @@ impl<'db> InferenceContext<'db> {
     ) -> Self {
         let trait_env = db.trait_environment(generic_def);
         let table = unify::InferenceTable::new(db, trait_env, resolver.krate(), owner);
-        let types = crate::next_solver::default_types(db);
+        let types = crate::next_solver::default_types();
         InferenceContext {
             result: InferenceResult::new(types.types.error),
             return_ty: types.types.error, // set in collect_* calls
diff --git a/crates/hir-ty/src/lower.rs b/crates/hir-ty/src/lower.rs
index b86585231cca..04e453fde3b9 100644
--- a/crates/hir-ty/src/lower.rs
+++ b/crates/hir-ty/src/lower.rs
@@ -252,7 +252,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
             db,
             // Can provide no block since we don't use it for trait solving.
             interner,
-            types: crate::next_solver::default_types(db),
+            types: crate::next_solver::default_types(),
             lang_items: interner.lang_items(),
             resolver,
             def,
@@ -635,7 +635,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                         // place even if we encounter more opaque types while
                         // lowering the bounds
                         let idx = self.impl_trait_mode.opaque_type_data.alloc(ImplTrait {
-                            predicates: StoredEarlyBinder::bind(Clauses::empty(interner).store()),
+                            predicates: StoredEarlyBinder::bind(Clauses::empty().store()),
                             assoc_ty_bounds_start: 0,
                         });
 
@@ -2372,12 +2372,12 @@ impl<'db> GenericPredicates {
 
 /// A cycle can occur from malformed code.
 fn generic_predicates_cycle_result<'db>(
-    db: &'db dyn HirDatabase,
+    _db: &'db dyn HirDatabase,
     _: salsa::Id,
     _def: GenericDefId,
 ) -> TyLoweringResult<'db, GenericPredicates> {
     TyLoweringResult::empty(GenericPredicates::from_explicit_own_predicates(
-        StoredEarlyBinder::bind(Clauses::empty(DbInterner::new_no_crate(db)).store()),
+        StoredEarlyBinder::bind(Clauses::empty().store()),
     ))
 }
 
diff --git a/crates/hir-ty/src/lower/path.rs b/crates/hir-ty/src/lower/path.rs
index c67c69520db1..7e55ef296316 100644
--- a/crates/hir-ty/src/lower/path.rs
+++ b/crates/hir-ty/src/lower/path.rs
@@ -576,7 +576,6 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
         lowering_assoc_type_generics: bool,
         span: Span,
     ) -> GenericArgs<'db> {
-        let interner = self.ctx.interner;
         let prev_current_segment_idx = self.current_segment_idx;
         let prev_current_segment = self.current_or_prev_segment;
 
@@ -586,7 +585,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
             ValueTyDefId::UnionId(it) => it.into(),
             ValueTyDefId::ConstId(it) => it.into(),
             ValueTyDefId::StaticId(_) => {
-                return GenericArgs::empty(interner);
+                return GenericArgs::empty();
             }
             ValueTyDefId::EnumVariantId(var) => {
                 // the generic args for an enum variant may be either specified
diff --git a/crates/hir-ty/src/mir/eval.rs b/crates/hir-ty/src/mir/eval.rs
index 32866c12e23e..37f3e2763181 100644
--- a/crates/hir-ty/src/mir/eval.rs
+++ b/crates/hir-ty/src/mir/eval.rs
@@ -1503,8 +1503,7 @@ impl<'a, 'db> Evaluator<'a, 'db> {
                         )?)
                     }
                     AggregateKind::Union(it, f) => {
-                        let layout =
-                            self.layout_adt((*it).into(), GenericArgs::empty(self.interner()))?;
+                        let layout = self.layout_adt((*it).into(), GenericArgs::empty())?;
                         let offset = layout
                             .fields
                             .offset(u32::from(f.local_id.into_raw()) as usize)
diff --git a/crates/hir-ty/src/mir/eval/shim.rs b/crates/hir-ty/src/mir/eval/shim.rs
index 5a4369623307..ca7c5c736680 100644
--- a/crates/hir-ty/src/mir/eval/shim.rs
+++ b/crates/hir-ty/src/mir/eval/shim.rs
@@ -1246,7 +1246,7 @@ impl<'a, 'db> Evaluator<'a, 'db> {
                         def,
                         &args,
                         // FIXME: wrong for manual impls of `FnOnce`
-                        GenericArgs::empty(self.interner()),
+                        GenericArgs::empty(),
                         locals,
                         destination,
                         None,
diff --git a/crates/hir-ty/src/mir/eval/tests.rs b/crates/hir-ty/src/mir/eval/tests.rs
index f09ac6f20d27..2ac3811f1769 100644
--- a/crates/hir-ty/src/mir/eval/tests.rs
+++ b/crates/hir-ty/src/mir/eval/tests.rs
@@ -5,19 +5,14 @@ use syntax::{TextRange, TextSize};
 use test_fixture::WithFixture;
 
 use crate::{
-    db::HirDatabase,
-    display::DisplayTarget,
-    mir::MirLowerError,
-    next_solver::{DbInterner, GenericArgs},
-    setup_tracing,
-    test_db::TestDB,
+    db::HirDatabase, display::DisplayTarget, mir::MirLowerError, next_solver::GenericArgs,
+    setup_tracing, test_db::TestDB,
 };
 
 use super::{MirEvalError, interpret_mir};
 
 fn eval_main(db: &TestDB, file_id: EditionedFileId) -> Result<(String, String), MirEvalError<'_>> {
     crate::attach_db(db, || {
-        let interner = DbInterner::new_no_crate(db);
         let module_id = db.module_for_file(file_id.file_id(db));
         let def_map = module_id.def_map(db);
         let scope = &def_map[module_id].scope;
@@ -39,7 +34,7 @@ fn eval_main(db: &TestDB, file_id: EditionedFileId) -> Result<(String, String),
         let body = db
             .monomorphized_mir_body(
                 func_id.into(),
-                GenericArgs::empty(interner).store(),
+                GenericArgs::empty().store(),
                 crate::ParamEnvAndCrate {
                     param_env: db.trait_environment(func_id.into()),
                     krate: func_id.krate(db),
diff --git a/crates/hir-ty/src/mir/lower.rs b/crates/hir-ty/src/mir/lower.rs
index da631c0d595e..3b82ed6f798e 100644
--- a/crates/hir-ty/src/mir/lower.rs
+++ b/crates/hir-ty/src/mir/lower.rs
@@ -324,7 +324,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> {
             db,
             infer,
             store,
-            types: crate::next_solver::default_types(db),
+            types: crate::next_solver::default_types(),
             owner,
             store_owner,
             resolver,
@@ -547,7 +547,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> {
                             const_id.into(),
                             current,
                             place,
-                            GenericArgs::empty(self.interner()),
+                            GenericArgs::empty(),
                             expr_id.into(),
                         )?;
                         Ok(Some(current))
@@ -1377,10 +1377,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> {
                 match pr {
                     ResolveValueResult::ValueNs(v) => {
                         if let ValueNs::ConstId(c) = v {
-                            self.lower_const_to_operand(
-                                GenericArgs::empty(self.interner()),
-                                c.into(),
-                            )
+                            self.lower_const_to_operand(GenericArgs::empty(), c.into())
                         } else {
                             not_supported!("bad path in range pattern");
                         }
diff --git a/crates/hir-ty/src/mir/lower/pattern_matching.rs b/crates/hir-ty/src/mir/lower/pattern_matching.rs
index a40199068191..ecc013506689 100644
--- a/crates/hir-ty/src/mir/lower/pattern_matching.rs
+++ b/crates/hir-ty/src/mir/lower/pattern_matching.rs
@@ -413,7 +413,7 @@ impl<'db> MirLowerCtx<'_, 'db> {
                             break 'b (c, x.1);
                         }
                         if let ResolveValueResult::ValueNs(ValueNs::ConstId(c)) = pr {
-                            break 'b (c, GenericArgs::empty(self.interner()));
+                            break 'b (c, GenericArgs::empty());
                         }
                         not_supported!("path in pattern position that is not const or variant")
                     };
diff --git a/crates/hir-ty/src/next_solver.rs b/crates/hir-ty/src/next_solver.rs
index 42fd31f2594d..626357128672 100644
--- a/crates/hir-ty/src/next_solver.rs
+++ b/crates/hir-ty/src/next_solver.rs
@@ -43,7 +43,6 @@ use rustc_type_ir::MayBeErased;
 pub use solver::*;
 pub use ty::*;
 
-use crate::db::HirDatabase;
 pub use crate::lower::ImplTraitIdx;
 pub use rustc_ast_ir::Mutability;
 
@@ -143,25 +142,24 @@ impl std::fmt::Debug for DefaultAny<'_> {
 }
 
 #[inline]
-pub fn default_types<'db>(db: &'db dyn HirDatabase) -> &'db DefaultAny<'db> {
+pub fn default_types<'db>() -> &'db DefaultAny<'db> {
     static TYPES: OnceLock<DefaultAny<'static>> = OnceLock::new();
 
-    let interner = DbInterner::new_no_crate(db);
     TYPES.get_or_init(|| {
         let create_ty = |kind| {
-            let ty = Ty::new(interner, kind);
+            let ty = Ty::new_without_interner(kind);
             // We need to increase the refcount (forever), so that the types won't be freed.
             let ty = ManuallyDrop::new(ty.store());
             ty.as_ref()
         };
         let create_const = |kind| {
-            let ty = Const::new(interner, kind);
+            let ty = Const::new_without_interner(kind);
             // We need to increase the refcount (forever), so that the types won't be freed.
             let ty = ManuallyDrop::new(ty.store());
             ty.as_ref()
         };
         let create_region = |kind| {
-            let ty = Region::new(interner, kind);
+            let ty = Region::new_without_interner(kind);
             // We need to increase the refcount (forever), so that the types won't be freed.
             let ty = ManuallyDrop::new(ty.store());
             ty.as_ref()
diff --git a/crates/hir-ty/src/next_solver/consts.rs b/crates/hir-ty/src/next_solver/consts.rs
index 1cabafa89bc4..a9cfafb2e489 100644
--- a/crates/hir-ty/src/next_solver/consts.rs
+++ b/crates/hir-ty/src/next_solver/consts.rs
@@ -48,7 +48,10 @@ const _: () = {
 };
 
 impl<'db> Const<'db> {
-    pub fn new(_interner: DbInterner<'db>, kind: ConstKind<'db>) -> Self {
+    /// You should avoid using this if you can, since we want `Ty` to be defined in `rustc_type_ir` and then this method
+    /// will become more difficult to use.
+    #[inline]
+    pub fn new_without_interner(kind: ConstKind<'db>) -> Self {
         let kind = unsafe { std::mem::transmute::<ConstKind<'db>, ConstKind<'static>>(kind) };
         let flags = FlagComputation::for_const_kind(&kind);
         let cached = WithCachedTypeInfo {
@@ -59,6 +62,10 @@ impl<'db> Const<'db> {
         Self { interned: Interned::new_gc(ConstInterned(cached)) }
     }
 
+    pub fn new(_interner: DbInterner<'db>, kind: ConstKind<'db>) -> Self {
+        Self::new_without_interner(kind)
+    }
+
     pub fn inner(&self) -> &WithCachedTypeInfo<ConstKind<'db>> {
         let inner = &self.interned.0;
         unsafe {
diff --git a/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs b/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
index 33e4c175d063..e6416eadc05e 100644
--- a/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
+++ b/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
@@ -498,7 +498,7 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
     {
         let base = Canonical {
             max_universe: UniverseIndex::ROOT,
-            var_kinds: CanonicalVarKinds::empty(tcx),
+            var_kinds: CanonicalVarKinds::empty(),
             value: (),
         };
         Canonicalizer::canonicalize_with_base(
diff --git a/crates/hir-ty/src/next_solver/interner.rs b/crates/hir-ty/src/next_solver/interner.rs
index 7b2a811a01af..df7c9bfe1ec4 100644
--- a/crates/hir-ty/src/next_solver/interner.rs
+++ b/crates/hir-ty/src/next_solver/interner.rs
@@ -90,8 +90,8 @@ macro_rules! interned_slice {
 
         impl<'db> $name<'db> {
             #[inline]
-            pub fn empty(interner: DbInterner<'db>) -> Self {
-                interner.default_types().empty.$default_types_field
+            pub fn empty() -> Self {
+                $crate::next_solver::default_types().empty.$default_types_field
             }
 
             #[inline]
@@ -168,7 +168,7 @@ macro_rules! interned_slice {
         impl<'db> Default for $name<'db> {
             #[inline]
             fn default() -> Self {
-                $name::empty(DbInterner::conjure())
+                $name::empty()
             }
         }
 
@@ -399,7 +399,7 @@ impl<'db> DbInterner<'db> {
 
     #[inline]
     pub fn default_types(&self) -> &'db crate::next_solver::DefaultAny<'db> {
-        crate::next_solver::default_types(self.db)
+        crate::next_solver::default_types()
     }
 
     #[inline]
@@ -1092,7 +1092,7 @@ impl<'db> Interner for DbInterner<'db> {
             | SolverDefId::InternedCoroutineId(_)
             | SolverDefId::InternedCoroutineClosureId(_)
             | SolverDefId::AnonConstId(_) => {
-                return VariancesOf::empty(self);
+                return VariancesOf::empty();
             }
         };
         self.db.variances_of(generic_def)
@@ -1345,7 +1345,7 @@ impl<'db> Interner for DbInterner<'db> {
         let own_bounds: FxHashSet<_> =
             self.item_self_bounds(def_id).skip_binder().into_iter().collect();
         if all_bounds.len() == own_bounds.len() {
-            EarlyBinder::bind(Clauses::empty(self))
+            EarlyBinder::bind(Clauses::empty())
         } else {
             EarlyBinder::bind(Clauses::new_from_iter(
                 self,
@@ -2172,7 +2172,7 @@ impl<'db> Interner for DbInterner<'db> {
         };
         EarlyBinder::bind(Const::new_unevaluated(
             self,
-            UnevaluatedConst { def: GeneralConstIdWrapper(id), args: GenericArgs::empty(self) },
+            UnevaluatedConst { def: GeneralConstIdWrapper(id), args: GenericArgs::empty() },
         ))
     }
 
diff --git a/crates/hir-ty/src/next_solver/predicate.rs b/crates/hir-ty/src/next_solver/predicate.rs
index cf492e65c3ff..a1e249eaf951 100644
--- a/crates/hir-ty/src/next_solver/predicate.rs
+++ b/crates/hir-ty/src/next_solver/predicate.rs
@@ -16,8 +16,8 @@ use rustc_type_ir::{
 };
 
 use crate::next_solver::{
-    GenericArg, TraitIdWrapper, impl_foldable_for_interned_slice, impl_stored_interned_slice,
-    interned_slice,
+    GenericArg, TraitIdWrapper, default_types, impl_foldable_for_interned_slice,
+    impl_stored_interned_slice, interned_slice,
 };
 
 use super::{Binder, BoundVarKinds, DbInterner, Region, Ty};
@@ -274,8 +274,8 @@ impl<'db> std::fmt::Debug for Clauses<'db> {
 
 impl<'db> Clauses<'db> {
     #[inline]
-    pub fn empty(interner: DbInterner<'db>) -> Self {
-        interner.default_types().empty.clauses
+    pub fn empty() -> Self {
+        default_types().empty.clauses
     }
 
     #[inline]
@@ -321,6 +321,13 @@ impl<'db> Clauses<'db> {
     }
 }
 
+impl Default for Clauses<'_> {
+    #[inline]
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
 impl<'db> IntoIterator for Clauses<'db> {
     type IntoIter = ::std::iter::Copied<::std::slice::Iter<'db, Clause<'db>>>;
     type Item = Clause<'db>;
@@ -437,8 +444,9 @@ pub struct ParamEnv<'db> {
 }
 
 impl<'db> ParamEnv<'db> {
-    pub fn empty(interner: DbInterner<'db>) -> Self {
-        ParamEnv { clauses: Clauses::empty(interner) }
+    #[inline]
+    pub fn empty() -> Self {
+        ParamEnv { clauses: Clauses::empty() }
     }
 
     pub fn clauses(self) -> Clauses<'db> {
diff --git a/crates/hir-ty/src/next_solver/region.rs b/crates/hir-ty/src/next_solver/region.rs
index a6facff7623d..53099f67fcd5 100644
--- a/crates/hir-ty/src/next_solver/region.rs
+++ b/crates/hir-ty/src/next_solver/region.rs
@@ -38,11 +38,17 @@ const _: () = {
 };
 
 impl<'db> Region<'db> {
-    pub fn new(_interner: DbInterner<'db>, kind: RegionKind<'db>) -> Self {
+    /// You should avoid using this if you can, since we want `Region` to be defined in `rustc_type_ir` and then this method
+    /// will become more difficult to use.
+    pub fn new_without_interner(kind: RegionKind<'db>) -> Self {
         let kind = unsafe { std::mem::transmute::<RegionKind<'db>, RegionKind<'static>>(kind) };
         Self { interned: Interned::new_gc(RegionInterned(kind)) }
     }
 
+    pub fn new(_interner: DbInterner<'db>, kind: RegionKind<'db>) -> Self {
+        Self::new_without_interner(kind)
+    }
+
     pub fn inner(&self) -> &RegionKind<'db> {
         let inner = &self.interned.0;
         unsafe { std::mem::transmute::<&RegionKind<'static>, &RegionKind<'db>>(inner) }
diff --git a/crates/hir-ty/src/next_solver/ty.rs b/crates/hir-ty/src/next_solver/ty.rs
index 6faf0357e358..c1810bc659c0 100644
--- a/crates/hir-ty/src/next_solver/ty.rs
+++ b/crates/hir-ty/src/next_solver/ty.rs
@@ -70,8 +70,10 @@ const _: () = {
 };
 
 impl<'db> Ty<'db> {
+    /// You should avoid using this if you can, since we want `Const` to be defined in `rustc_type_ir` and then this method
+    /// will become more difficult to use.
     #[inline]
-    pub fn new(_interner: DbInterner<'db>, kind: TyKind<'db>) -> Self {
+    pub fn new_without_interner(kind: TyKind<'db>) -> Self {
         let kind = unsafe { std::mem::transmute::<TyKind<'db>, TyKind<'static>>(kind) };
         let flags = FlagComputation::for_kind(&kind);
         let cached = WithCachedTypeInfo {
@@ -82,6 +84,11 @@ impl<'db> Ty<'db> {
         Self { interned: Interned::new_gc(TyInterned(cached)) }
     }
 
+    #[inline]
+    pub fn new(_interner: DbInterner<'db>, kind: TyKind<'db>) -> Self {
+        Self::new_without_interner(kind)
+    }
+
     #[inline]
     pub fn inner(&self) -> &WithCachedTypeInfo<TyKind<'db>> {
         let inner = &self.interned.0;
@@ -784,7 +791,7 @@ impl<'db> Ty<'db> {
                     let impl_bound = TraitRef::new_from_args(
                         interner,
                         future_trait.into(),
-                        GenericArgs::empty(interner),
+                        GenericArgs::empty(),
                     )
                     .upcast(interner);
                     Some(vec![impl_bound])
diff --git a/crates/hir-ty/src/variance.rs b/crates/hir-ty/src/variance.rs
index 269029728398..cce1b4caf44a 100644
--- a/crates/hir-ty/src/variance.rs
+++ b/crates/hir-ty/src/variance.rs
@@ -46,7 +46,7 @@ fn variances_of_query(db: &dyn HirDatabase, def: GenericDefId) -> StoredVariance
         GenericDefId::AdtId(adt) => {
             if let AdtId::StructId(id) = adt {
                 let flags = &StructSignature::of(db, id).flags;
-                let types = || crate::next_solver::default_types(db);
+                let types = || crate::next_solver::default_types();
                 if flags.contains(StructFlags::IS_UNSAFE_CELL) {
                     return types().one_invariant.store();
                 } else if flags.intersects(
@@ -56,13 +56,13 @@ fn variances_of_query(db: &dyn HirDatabase, def: GenericDefId) -> StoredVariance
                 }
             }
         }
-        _ => return VariancesOf::empty(DbInterner::new_no_crate(db)).store(),
+        _ => return VariancesOf::empty().store(),
     }
 
     let generics = generics(db, def);
     let count = generics.len(true);
     if count == 0 {
-        return VariancesOf::empty(DbInterner::new_no_crate(db)).store();
+        return VariancesOf::empty().store();
     }
     let variances =
         Context { generics, variances: vec![Variance::Bivariant; count].into_boxed_slice(), db }
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 43fc2bae26ee..f9073138e32d 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -1306,9 +1306,8 @@ impl<'db> AnonConst<'db> {
         self,
         db: &'db dyn HirDatabase,
     ) -> Result<EvaluatedConst<'db>, ConstEvalError<'db>> {
-        let interner = DbInterner::new_no_crate(db);
         let ty = self.id.loc(db).ty.get().instantiate_identity().skip_norm_wip();
-        db.anon_const_eval(self.id, GenericArgs::empty(interner), None).map(|it| EvaluatedConst {
+        db.anon_const_eval(self.id, GenericArgs::empty(), None).map(|it| EvaluatedConst {
             allocation: it,
             def: self.id.into(),
             ty,
@@ -1827,10 +1826,9 @@ impl Function {
                 "evaluation of builtin derive impl methods is not supported".to_owned(),
             )));
         };
-        let interner = DbInterner::new_no_crate(db);
         let body = db.monomorphized_mir_body(
             id.into(),
-            GenericArgs::empty(interner).store(),
+            GenericArgs::empty().store(),
             ParamEnvAndCrate {
                 param_env: db.trait_environment(id.into()),
                 krate: id.module(db).krate(db),
@@ -2109,9 +2107,8 @@ impl Const {
 
     /// Evaluate the constant.
     pub fn eval(self, db: &dyn HirDatabase) -> Result<EvaluatedConst<'_>, ConstEvalError<'_>> {
-        let interner = DbInterner::new_no_crate(db);
         let ty = db.value_ty(self.id.into()).unwrap().instantiate_identity().skip_norm_wip();
-        db.const_eval(self.id, GenericArgs::empty(interner), None).map(|it| EvaluatedConst {
+        db.const_eval(self.id, GenericArgs::empty(), None).map(|it| EvaluatedConst {
             allocation: it,
             def: self.id.into(),
             ty,
@@ -4510,7 +4507,7 @@ impl<'db> Type<'db> {
             TypeOwnerId::BuiltinDeriveImplId(def) => {
                 GenericArgs::error_for_item(interner, def.into())
             }
-            TypeOwnerId::NoParams(_) => GenericArgs::empty(interner),
+            TypeOwnerId::NoParams(_) => GenericArgs::empty(),
         };
         Type::no_params(krate, self.ty.instantiate(interner, args).skip_norm_wip())
     }
@@ -4523,9 +4520,7 @@ impl<'db> Type<'db> {
             TypeOwnerId::BuiltinDeriveImplId(def) => {
                 generic_args_from_tys(interner, def.into(), args)
             }
-            TypeOwnerId::NoParams(krate) => {
-                (GenericArgs::empty(interner), TypeOwnerId::NoParams(krate))
-            }
+            TypeOwnerId::NoParams(krate) => (GenericArgs::empty(), TypeOwnerId::NoParams(krate)),
         };
         Type { owner, ty: EarlyBinder::bind(self.ty.instantiate(interner, args).skip_norm_wip()) }
     }
@@ -4848,9 +4843,7 @@ impl<'db> Type<'db> {
                 param_env: hir_ty::builtin_derive::param_env(DbInterner::new_with(db, krate), def),
                 krate,
             },
-            TypeOwnerId::NoParams(_) => {
-                ParamEnvAndCrate { param_env: ParamEnv::empty(DbInterner::new_no_crate(db)), krate }
-            }
+            TypeOwnerId::NoParams(_) => ParamEnvAndCrate { param_env: ParamEnv::empty(), krate },
         }
     }
 
@@ -4974,8 +4967,7 @@ impl<'db> Type<'db> {
         trait_: Trait,
         args: &[Type<'db>],
     ) -> bool {
-        let interner = DbInterner::new_no_crate(db);
-        let env = ParamEnvAndCrate { param_env: ParamEnv::empty(interner), krate: self.krate(db) };
+        let env = ParamEnvAndCrate { param_env: ParamEnv::empty(), krate: self.krate(db) };
         traits::implements_trait_unique_with_infcx(db, env, trait_.id, &mut |infcx| {
             let mut args = Self::instantiate_many_with_infer(iter::once(self).chain(args), infcx);
             GenericArgs::for_item(infcx.interner, trait_.id.into(), |_, param, _, _| {
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 021b89677d28..368e5e3c147f 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -350,21 +350,18 @@ impl<'db> SourceAnalyzer<'db> {
     }
 
     fn trait_environment(&self, db: &'db dyn HirDatabase) -> ParamEnvAndCrate<'db> {
-        self.param_and(self.body_or_sig.as_ref().map_or_else(
-            || ParamEnv::empty(DbInterner::new_no_crate(db)),
-            |body_or_sig| {
-                let def = match *body_or_sig {
-                    BodyOrSig::Body { def, .. } => def.generic_def(db),
-                    BodyOrSig::VariantFields { def, .. } => match def {
-                        VariantId::EnumVariantId(def) => def.loc(db).parent.into(),
-                        VariantId::StructId(def) => def.into(),
-                        VariantId::UnionId(def) => def.into(),
-                    },
-                    BodyOrSig::Sig { def, .. } => def,
-                };
-                db.trait_environment(def)
-            },
-        ))
+        self.param_and(self.body_or_sig.as_ref().map_or_else(ParamEnv::empty, |body_or_sig| {
+            let def = match *body_or_sig {
+                BodyOrSig::Body { def, .. } => def.generic_def(db),
+                BodyOrSig::VariantFields { def, .. } => match def {
+                    VariantId::EnumVariantId(def) => def.loc(db).parent.into(),
+                    VariantId::StructId(def) => def.into(),
+                    VariantId::UnionId(def) => def.into(),
+                },
+                BodyOrSig::Sig { def, .. } => def,
+            };
+            db.trait_environment(def)
+        }))
     }
 
     pub(crate) fn evaluate_where_clause(
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 6cbb0c718c3e..8c8ad34f6c44 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -19,10 +19,7 @@ use hir_def::{
     expr_store::{Body, BodySourceMap, ExpressionStore},
     hir::{ExprId, PatId, generics::GenericParams},
 };
-use hir_ty::{
-    InferenceResult,
-    next_solver::{DbInterner, GenericArgs},
-};
+use hir_ty::{InferenceResult, next_solver::GenericArgs};
 use ide::{
     Analysis, AnalysisHost, AnnotationConfig, DiagnosticsConfig, Edition, InlayFieldsToResolve,
     InlayHintsConfig, LineCol, RaFixtureConfig, RootDatabase,
@@ -411,7 +408,6 @@ impl flags::AnalysisStats {
         let mut all = 0;
         let mut fail = 0;
         for &a in adts {
-            let interner = DbInterner::new_no_crate(db);
             let generic_params = GenericParams::of(db, a.into());
             if generic_params.iter_type_or_consts().next().is_some()
                 || generic_params.iter_lt().next().is_some()
@@ -422,7 +418,7 @@ impl flags::AnalysisStats {
             all += 1;
             let Err(e) = db.layout_of_adt(
                 hir_def::AdtId::from(a),
-                GenericArgs::empty(interner).store(),
+                GenericArgs::empty().store(),
                 hir_ty::ParamEnvAndCrate {
                     param_env: db.trait_environment(a.into()),
                     krate: a.krate(db).into(),