Merge pull request #21172 from ChayimFriedman2/no-block

internal: Remove the block from `DbInterner`

Author: ChayimFriedman2

src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs

@@ -38,7 +38,7 @@ pub fn autoderef<'db>(
     env: Arc<TraitEnvironment<'db>>,
     ty: Canonical<'db, Ty<'db>>,
 ) -> impl Iterator<Item = Ty<'db>> + use<'db> {
-    let interner = DbInterner::new_with(db, env.krate, env.block);
+    let interner = DbInterner::new_with(db, env.krate);
     let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
     let (ty, _) = infcx.instantiate_canonical(&ty);
     let autoderef = Autoderef::new(&infcx, &env, ty);

src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs

@@ -79,7 +79,7 @@ impl BodyValidationDiagnostic {
         let infer = InferenceResult::for_body(db, owner);
         let body = db.body(owner);
         let env = db.trait_environment_for_body(owner);
-        let interner = DbInterner::new_with(db, env.krate, env.block);
+        let interner = DbInterner::new_with(db, env.krate);
         let infcx =
             interner.infer_ctxt().build(TypingMode::typeck_for_body(interner, owner.into()));
         let mut validator = ExprValidator {

src/tools/rust-analyzer/crates/hir-ty/src/display.rs

@@ -309,7 +309,7 @@ pub trait HirDisplay<'db> {
         allow_opaque: bool,
     ) -> Result<String, DisplaySourceCodeError> {
         let mut result = String::new();
-        let interner = DbInterner::new_with(db, module_id.krate(), module_id.containing_block());
+        let interner = DbInterner::new_with(db, module_id.krate());
         match self.hir_fmt(&mut HirFormatter {
             db,
             interner,
@@ -544,11 +544,7 @@ pub enum ClosureStyle {
 impl<'db, T: HirDisplay<'db>> HirDisplayWrapper<'_, 'db, T> {
     pub fn write_to<F: HirWrite>(&self, f: &mut F) -> Result<(), HirDisplayError> {
         let krate = self.display_target.krate;
-        let block = match self.display_kind {
-            DisplayKind::SourceCode { target_module_id, .. } => target_module_id.containing_block(),
-            DisplayKind::Diagnostics | DisplayKind::Test => None,
-        };
-        let interner = DbInterner::new_with(self.db, krate, block);
+        let interner = DbInterner::new_with(self.db, krate);
         self.t.hir_fmt(&mut HirFormatter {
             db: self.db,
             interner,

src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs

@@ -131,7 +131,7 @@ pub fn dyn_compatibility_of_trait_query(
 
 pub fn generics_require_sized_self(db: &dyn HirDatabase, def: GenericDefId) -> bool {
     let krate = def.module(db).krate();
-    let interner = DbInterner::new_with(db, krate, None);
+    let interner = DbInterner::new_with(db, krate);
     let Some(sized) = interner.lang_items().Sized else {
         return false;
     };
@@ -402,7 +402,7 @@ fn receiver_is_dispatchable<'db>(
     let sig = sig.instantiate_identity();
 
     let module = trait_.module(db);
-    let interner = DbInterner::new_with(db, module.krate(), module.containing_block());
+    let interner = DbInterner::new_with(db, module.krate());
     let self_param_id = TypeParamId::from_unchecked(TypeOrConstParamId {
         parent: trait_.into(),
         local_id: LocalTypeOrConstParamId::from_raw(la_arena::RawIdx::from_u32(0)),

src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs

@@ -1576,7 +1576,7 @@ fn coerce<'db>(
     env: Arc<TraitEnvironment<'db>>,
     tys: &Canonical<'db, (Ty<'db>, Ty<'db>)>,
 ) -> Result<(Vec<Adjustment<'db>>, Ty<'db>), TypeError<DbInterner<'db>>> {
-    let interner = DbInterner::new_with(db, env.krate, env.block);
+    let interner = DbInterner::new_with(db, env.krate);
     let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
     let ((ty1_with_vars, ty2_with_vars), vars) = infcx.instantiate_canonical(tys);
 

src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs

@@ -1455,11 +1455,10 @@ impl<'db> InferenceContext<'_, 'db> {
     ) -> Ty<'db> {
         let coerce_ty = expected.coercion_target_type(&mut self.table);
         let g = self.resolver.update_to_inner_scope(self.db, self.owner, expr);
-        let prev_state = block_id.map(|block_id| {
+        let prev_env = block_id.map(|block_id| {
             let prev_env = self.table.trait_env.clone();
             TraitEnvironment::with_block(&mut self.table.trait_env, block_id);
-            let prev_block = self.table.infer_ctxt.interner.block.replace(block_id);
-            (prev_env, prev_block)
+            prev_env
         });
 
         let (break_ty, ty) =
@@ -1567,9 +1566,8 @@ impl<'db> InferenceContext<'_, 'db> {
                 }
             });
         self.resolver.reset_to_guard(g);
-        if let Some((prev_env, prev_block)) = prev_state {
+        if let Some(prev_env) = prev_env {
             self.table.trait_env = prev_env;
-            self.table.infer_ctxt.interner.block = prev_block;
         }
 
         break_ty.unwrap_or(ty)

src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs

@@ -113,7 +113,7 @@ fn could_unify_impl<'db>(
     tys: &Canonical<'db, (Ty<'db>, Ty<'db>)>,
     select: for<'a> fn(&mut ObligationCtxt<'a, 'db>) -> Vec<NextSolverError<'db>>,
 ) -> bool {
-    let interner = DbInterner::new_with(db, env.krate, env.block);
+    let interner = DbInterner::new_with(db, env.krate);
     let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
     let cause = ObligationCause::dummy();
     let at = infcx.at(&cause, env.env);
@@ -148,7 +148,7 @@ impl<'db> InferenceTable<'db> {
         trait_env: Arc<TraitEnvironment<'db>>,
         owner: Option<DefWithBodyId>,
     ) -> Self {
-        let interner = DbInterner::new_with(db, trait_env.krate, trait_env.block);
+        let interner = DbInterner::new_with(db, trait_env.krate);
         let typing_mode = match owner {
             Some(owner) => TypingMode::typeck_for_body(interner, owner.into()),
             // IDE things wants to reveal opaque types.

src/tools/rust-analyzer/crates/hir-ty/src/layout.rs

@@ -162,7 +162,7 @@ pub fn layout_of_ty_query<'db>(
     trait_env: Arc<TraitEnvironment<'db>>,
 ) -> Result<Arc<Layout>, LayoutError> {
     let krate = trait_env.krate;
-    let interner = DbInterner::new_with(db, krate, trait_env.block);
+    let interner = DbInterner::new_with(db, krate);
     let Ok(target) = db.target_data_layout(krate) else {
         return Err(LayoutError::TargetLayoutNotAvailable);
     };

src/tools/rust-analyzer/crates/hir-ty/src/lower.rs

@@ -194,7 +194,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
     ) -> Self {
         let impl_trait_mode = ImplTraitLoweringState::new(ImplTraitLoweringMode::Disallowed);
         let in_binders = DebruijnIndex::ZERO;
-        let interner = DbInterner::new_with(db, resolver.krate(), None);
+        let interner = DbInterner::new_with(db, resolver.krate());
         Self {
             db,
             // Can provide no block since we don't use it for trait solving.
@@ -1756,7 +1756,7 @@ pub(crate) fn trait_environment_query<'db>(
     def: GenericDefId,
 ) -> Arc<TraitEnvironment<'db>> {
     let module = def.module(db);
-    let interner = DbInterner::new_with(db, module.krate(), module.containing_block());
+    let interner = DbInterner::new_with(db, module.krate());
     let predicates = GenericPredicates::query_all(db, def);
     let traits_in_scope = predicates
         .iter_identity_copied()
@@ -2289,7 +2289,7 @@ pub(crate) fn associated_type_by_name_including_super_traits<'db>(
     name: &Name,
 ) -> Option<(TraitRef<'db>, TypeAliasId)> {
     let module = trait_ref.def_id.0.module(db);
-    let interner = DbInterner::new_with(db, module.krate(), module.containing_block());
+    let interner = DbInterner::new_with(db, module.krate());
     rustc_type_ir::elaborate::supertraits(interner, Binder::dummy(trait_ref)).find_map(|t| {
         let trait_id = t.as_ref().skip_binder().def_id.0;
         let assoc_type = trait_id.trait_items(db).associated_type_by_name(name)?;

src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs

@@ -419,7 +419,7 @@ pub(crate) fn lookup_impl_method_query<'db>(
     func: FunctionId,
     fn_subst: GenericArgs<'db>,
 ) -> (FunctionId, GenericArgs<'db>) {
-    let interner = DbInterner::new_with(db, env.krate, env.block);
+    let interner = DbInterner::new_with(db, env.krate);
     let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
 
     let ItemContainerId::TraitId(trait_id) = func.loc(db).container else {