Hookup analysis_stats

Author: Veykril

crates/hir-def/src/expr_store.rs

@@ -319,7 +319,7 @@ impl ExpressionStoreBuilder {
             mut bindings,
             mut binding_owners,
             mut ident_hygiene,
-            const_expr_origins,
+            mut const_expr_origins,
             mut types,
             mut lifetimes,
 
@@ -379,6 +379,9 @@ impl ExpressionStoreBuilder {
 
         let store = {
             let expr_only = if has_exprs {
+                if let Some(const_expr_origins) = &mut const_expr_origins {
+                    const_expr_origins.shrink_to_fit();
+                }
                 Some(Box::new(ExpressionOnlyStore {
                     exprs,
                     pats,

crates/hir-def/src/resolver.rs

@@ -860,7 +860,15 @@ impl<'db> Resolver<'db> {
         owner: impl Into<ExpressionStoreOwner>,
         expr_id: ExprId,
     ) -> UpdateGuard {
-        let owner = owner.into();
+        self.update_to_inner_scope_(db, owner.into(), expr_id)
+    }
+
+    fn update_to_inner_scope_(
+        &mut self,
+        db: &'db dyn DefDatabase,
+        owner: ExpressionStoreOwner,
+        expr_id: ExprId,
+    ) -> UpdateGuard {
         #[inline(always)]
         fn append_expr_scope<'db>(
             db: &'db dyn DefDatabase,

crates/hir-ty/src/infer.rs

@@ -33,9 +33,9 @@ use std::{cell::OnceCell, convert::identity, iter};
 use base_db::Crate;
 use either::Either;
 use hir_def::{
-    AdtId, AnonConstId, AssocItemId, ConstId, ConstParamId, DefWithBodyId, ExpressionStoreOwner,
-    FieldId, FunctionId, GenericDefId, GenericParamId, ItemContainerId, LocalFieldId, Lookup,
-    TraitId, TupleFieldId, TupleId, TypeAliasId, TypeOrConstParamId, VariantId,
+    AdtId, AssocItemId, ConstId, ConstParamId, DefWithBodyId, ExpressionStoreOwner, FieldId,
+    FunctionId, GenericDefId, GenericParamId, ItemContainerId, LocalFieldId, Lookup, TraitId,
+    TupleFieldId, TupleId, TypeAliasId, TypeOrConstParamId, VariantId,
     expr_store::{ConstExprOrigin, ExpressionStore, HygieneId, path::Path},
     hir::{BindingAnnotation, BindingId, ExprId, ExprOrPatId, LabelId, PatId},
     lang_item::LangItems,
@@ -146,6 +146,10 @@ pub fn infer_query_with_inspect<'db>(
 
     ctx.infer_mut_body(body.body_expr);
 
+    finalize_infer(ctx)
+}
+
+fn finalize_infer(mut ctx: InferenceContext<'_, '_>) -> InferenceResult {
     ctx.handle_opaque_type_uses();
 
     ctx.type_inference_fallback();
@@ -213,9 +217,7 @@ fn infer_signature_query(db: &dyn HirDatabase, def: GenericDefId) -> InferenceRe
         ctx.infer_expr(root_expr, &expected, ExprIsRead::Yes);
     }
 
-    ctx.type_inference_fallback();
-    ctx.table.select_obligations_where_possible();
-    ctx.resolve_all()
+    finalize_infer(ctx)
 }
 
 fn infer_signature_cycle_result(
@@ -618,24 +620,6 @@ impl InferenceResult {
 }
 
 impl InferenceResult {
-    /// Look up inference results for a specific anonymous const in a signature.
-    ///
-    /// This delegates to [`Self::for_signature`] on the anon const's owner.
-    /// The returned `InferenceResult` contains types for *all* expressions in
-    /// the owner's signature store, not just this anon const's sub-tree.
-    /// Callers should index into it with `loc.expr` to get the root expression's
-    /// type.
-    // FIXME: This function doesn't make sense in that we can't return a full inference result here
-    // as the anon const is just part of an inference result.
-    pub fn for_anon_const(db: &dyn HirDatabase, id: AnonConstId) -> &InferenceResult {
-        match id.lookup(db).owner {
-            ExpressionStoreOwner::Signature(generic_def_id) => {
-                Self::for_signature(db, generic_def_id)
-            }
-            ExpressionStoreOwner::Body(def_with_body_id) => Self::for_body(db, def_with_body_id),
-        }
-    }
-
     fn new(error_ty: Ty<'_>) -> Self {
         Self {
             method_resolutions: Default::default(),
@@ -943,8 +927,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
                 db.trait_environment_for_body(def_with_body_id)
             }
         };
-        let table =
-            unify::InferenceTable::new(db, trait_env, resolver.krate(), owner.as_def_with_body());
+        let table = unify::InferenceTable::new(db, trait_env, resolver.krate(), Some(owner));
         let types = crate::next_solver::default_types(db);
         InferenceContext {
             result: InferenceResult::new(types.types.error),

crates/hir-ty/src/infer/unify.rs

@@ -3,7 +3,7 @@
 use std::fmt;
 
 use base_db::Crate;
-use hir_def::{AdtId, DefWithBodyId, GenericParamId};
+use hir_def::{AdtId, ExpressionStoreOwner, GenericParamId};
 use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::FxHashSet;
@@ -147,7 +147,7 @@ impl<'db> InferenceTable<'db> {
         db: &'db dyn HirDatabase,
         trait_env: ParamEnv<'db>,
         krate: Crate,
-        owner: Option<DefWithBodyId>,
+        owner: Option<ExpressionStoreOwner>,
     ) -> Self {
         let interner = DbInterner::new_with(db, krate);
         let typing_mode = match owner {

crates/hir-ty/src/next_solver/def_id.rs

@@ -2,8 +2,8 @@
 
 use hir_def::{
     AdtId, AnonConstId, AttrDefId, BuiltinDeriveImplId, CallableDefId, ConstId, DefWithBodyId,
-    EnumId, EnumVariantId, FunctionId, GeneralConstId, GenericDefId, ImplId, StaticId, StructId,
-    TraitId, TypeAliasId, UnionId,
+    EnumId, EnumVariantId, ExpressionStoreOwner, FunctionId, GeneralConstId, GenericDefId, ImplId,
+    StaticId, StructId, TraitId, TypeAliasId, UnionId,
 };
 use rustc_type_ir::inherent;
 use stdx::impl_from;
@@ -12,13 +12,13 @@ use crate::db::{InternedClosureId, InternedCoroutineId, InternedOpaqueTyId};
 
 use super::DbInterner;
 
-#[derive(Debug, PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash, salsa::Supertype)]
+#[derive(Debug, PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum Ctor {
     Struct(StructId),
     Enum(EnumVariantId),
 }
 
-#[derive(PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash, salsa::Supertype)]
+#[derive(PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum SolverDefId {
     AdtId(AdtId),
     ConstId(ConstId),
@@ -33,7 +33,6 @@ pub enum SolverDefId {
     InternedCoroutineId(InternedCoroutineId),
     InternedOpaqueTyId(InternedOpaqueTyId),
     EnumVariantId(EnumVariantId),
-    // FIXME(next-solver): Do we need the separation of `Ctor`? It duplicates some variants.
     Ctor(Ctor),
 }
 
@@ -139,6 +138,15 @@ impl From<GenericDefId> for SolverDefId {
     }
 }
 
+impl From<ExpressionStoreOwner> for SolverDefId {
+    fn from(value: ExpressionStoreOwner) -> Self {
+        match value {
+            ExpressionStoreOwner::Signature(generic_def_id) => generic_def_id.into(),
+            ExpressionStoreOwner::Body(def_with_body_id) => def_with_body_id.into(),
+        }
+    }
+}
+
 impl From<GeneralConstId> for SolverDefId {
     #[inline]
     fn from(value: GeneralConstId) -> Self {

crates/hir/src/lib.rs

@@ -508,6 +508,21 @@ impl ModuleDef {
         }
     }
 
+    pub fn as_generic_def(self) -> Option<GenericDef> {
+        match self {
+            ModuleDef::Function(it) => Some(it.into()),
+            ModuleDef::Adt(it) => Some(it.into()),
+            ModuleDef::Trait(it) => Some(it.into()),
+            ModuleDef::TypeAlias(it) => Some(it.into()),
+            ModuleDef::Static(it) => Some(it.into()),
+            ModuleDef::Const(it) => Some(it.into()),
+            ModuleDef::Variant(_)
+            | ModuleDef::Module(_)
+            | ModuleDef::BuiltinType(_)
+            | ModuleDef::Macro(_) => None,
+        }
+    }
+
     pub fn attrs(&self, db: &dyn HirDatabase) -> Option<AttrsWithOwner> {
         Some(match self {
             ModuleDef::Module(it) => it.attrs(db),
@@ -3972,6 +3987,30 @@ impl_from!(
 );
 
 impl GenericDef {
+    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
+        match self {
+            GenericDef::Function(it) => Some(it.name(db)),
+            GenericDef::Adt(it) => Some(it.name(db)),
+            GenericDef::Trait(it) => Some(it.name(db)),
+            GenericDef::TypeAlias(it) => Some(it.name(db)),
+            GenericDef::Impl(_) => None,
+            GenericDef::Const(it) => it.name(db),
+            GenericDef::Static(it) => Some(it.name(db)),
+        }
+    }
+
+    pub fn module(self, db: &dyn HirDatabase) -> Module {
+        match self {
+            GenericDef::Function(it) => it.module(db),
+            GenericDef::Adt(it) => it.module(db),
+            GenericDef::Trait(it) => it.module(db),
+            GenericDef::TypeAlias(it) => it.module(db),
+            GenericDef::Impl(it) => it.module(db),
+            GenericDef::Const(it) => it.module(db),
+            GenericDef::Static(it) => it.module(db),
+        }
+    }
+
     pub fn params(self, db: &dyn HirDatabase) -> Vec<GenericParam> {
         let Ok(id) = self.try_into() else {
             // Let's pretend builtin derive impls don't have generic parameters.

crates/hir/src/source_analyzer.rs

@@ -152,7 +152,7 @@ impl<'db> SourceAnalyzer<'db> {
         node: InFile<&SyntaxNode>,
         offset: Option<TextSize>,
     ) -> SourceAnalyzer<'db> {
-        Self::new_generic_def_(db, def, node, offset, Some(InferenceResult::for_signature(db, def)))
+        Self::new_generic_def_(db, def, node, offset, true)
     }
 
     pub(crate) fn new_generic_def_no_infer(
@@ -161,15 +161,15 @@ impl<'db> SourceAnalyzer<'db> {
         node: InFile<&SyntaxNode>,
         offset: Option<TextSize>,
     ) -> SourceAnalyzer<'db> {
-        Self::new_generic_def_(db, def, node, offset, None)
+        Self::new_generic_def_(db, def, node, offset, false)
     }
 
     pub(crate) fn new_generic_def_(
         db: &'db dyn HirDatabase,
         def: GenericDefId,
         node @ InFile { file_id, .. }: InFile<&SyntaxNode>,
         offset: Option<TextSize>,
-        infer: Option<&'db InferenceResult>,
+        infer: bool,
     ) -> SourceAnalyzer<'db> {
         let (generics, store, source_map) = db.generic_params_and_store_and_source_map(def);
         let scopes = db.expr_scopes(def.into());
@@ -186,6 +186,11 @@ impl<'db> SourceAnalyzer<'db> {
             }
         };
         let resolver = resolver_for_scope(db, def, scope);
+        let infer = if infer && !Arc::ptr_eq(&store, &ExpressionStore::empty_singleton().0) {
+            Some(InferenceResult::for_signature(db, def))
+        } else {
+            None
+        };
         SourceAnalyzer {
             resolver,
             body_or_sig: Some(BodyOrSig::Sig { def, store, source_map, generics, infer }),