add goto implementation and rename via SemanticQuery

Author: micahscopes

crates/hir-analysis/src/analysis_pass.rs

@@ -41,6 +41,22 @@ impl AnalysisPassManager {
         diags
     }
 
+    /// Stable alternative to run_on_module that uses File as the key.
+    /// This prevents issues with stale TopLevelMod references during incremental recompilation.
+    pub fn run_on_file<'db, DB>(
+        &mut self,
+        db: &'db DB,
+        file: common::file::File,
+    ) -> Vec<Box<dyn DiagnosticVoucher + 'db>>
+    where
+        DB: HirAnalysisDb + hir::LowerHirDb,
+    {
+        // Convert File to fresh TopLevelMod using the stable API
+        let top_mod = hir::lower::map_file_to_mod(db, file);
+        // Use the existing analysis logic
+        self.run_on_module(db, top_mod)
+    }
+
     pub fn run_on_module_tree<'db>(
         &mut self,
         db: &'db dyn HirAnalysisDb,

crates/hir-analysis/src/lib.rs

@@ -8,9 +8,9 @@ pub trait HirAnalysisDb: HirDb {}
 #[salsa::db]
 impl<T> HirAnalysisDb for T where T: HirDb {}
 
+pub mod lookup;
 pub mod name_resolution;
 pub mod ty;
-pub mod lookup;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Spanned<'db, T> {

crates/hir-analysis/src/lookup.rs

@@ -1,33 +1,8 @@
-use hir::hir_def::{scope_graph::ScopeId, IdentId};
-
 use crate::{
-    name_resolution::{
-        method_selection::{select_method_candidate, MethodCandidate},
-        PathRes,
-    },
-    ty::{func_def::FuncDef, trait_resolution::PredicateListId},
-    HirAnalysisDb,
+    name_resolution::{method_selection::MethodCandidate, PathRes},
+    ty::func_def::FuncDef,
 };
 
-/// High-level façade for method lookup. Wraps the low-level selector and
-/// provides a stable API for consumers.
-/// Returns the function definition of the selected method if resolution succeeds.
-pub fn find_method_id<'db>(
-    db: &'db dyn HirAnalysisDb,
-    receiver_ty: crate::ty::canonical::Canonical<crate::ty::ty_def::TyId<'db>>,
-    method_name: IdentId<'db>,
-    scope: ScopeId<'db>,
-    assumptions: PredicateListId<'db>,
-) -> Option<FuncDef<'db>> {
-    match select_method_candidate(db, receiver_ty, method_name, scope, assumptions) {
-        Ok(MethodCandidate::InherentMethod(fd)) => Some(fd),
-        Ok(MethodCandidate::TraitMethod(tm)) | Ok(MethodCandidate::NeedsConfirmation(tm)) => {
-            Some(tm.method.0)
-        }
-        Err(_) => None,
-    }
-}
-
 /// Extract the underlying function definition for a resolved method PathRes.
 /// Returns None if the PathRes is not a method.
 pub fn method_func_def_from_res<'db>(

crates/hir-analysis/src/name_resolution/method_api.rs

@@ -20,7 +20,7 @@ pub use name_resolver::{
 // NOTE: `resolve_path` is the low-level resolver that still requires callers to
 // pass a boolean domain hint. Prefer `resolve_with_policy` for new call-sites
 // to avoid boolean flags at API boundaries.
-pub use method_api::{find_method_id, method_func_def_from_res};
+pub use method_api::method_func_def_from_res;
 pub use path_resolver::{
     find_associated_type, resolve_ident_to_bucket, resolve_name_res, resolve_path,
     resolve_path_with_observer, PathRes, PathResError, PathResErrorKind, ResolvedVariant,

crates/hir-analysis/src/name_resolution/mod.rs

@@ -2,8 +2,8 @@ use common::indexmap::IndexMap;
 use either::Either;
 use hir::{
     hir_def::{
-        scope_graph::ScopeId, Body, Enum, EnumVariant, ExprId, GenericParamOwner, IdentId, ImplTrait, ItemKind,
-        Partial, PathId, PathKind, Trait, TypeBound, TypeId, VariantKind,
+        scope_graph::ScopeId, Body, Enum, EnumVariant, ExprId, GenericParamOwner, IdentId,
+        ImplTrait, ItemKind, Partial, PathId, PathKind, Trait, TypeBound, TypeId, VariantKind,
     },
     span::DynLazySpan,
 };

crates/hir-analysis/src/name_resolution/path_resolver.rs

@@ -35,5 +35,3 @@ pub fn resolve_with_policy<'db>(
         }
     }
 }
-
-// Legacy convenience wrapper removed; prefer `resolve_with_policy` directly

crates/hir-analysis/src/name_resolution/policy.rs

@@ -1525,8 +1525,7 @@ fn find_const_ty_param<'db>(
         scope,
         PredicateListId::empty_list(db),
         DomainPreference::Value,
-    )
-    else {
+    ) else {
         return None;
     };
     match ty.data(db) {

crates/hir-analysis/src/ty/def_analysis.rs

@@ -16,13 +16,15 @@ use crate::{
 };
 use common::indexmap::IndexSet;
 use constraint::collect_constraints;
-use hir::{hir_def::{HirIngot, Func}, Ingot};
+use hir::{
+    hir_def::HirIngot,
+    Ingot,
+};
 use salsa::Update;
 
 pub(crate) mod constraint;
 mod proof_forest;
 
-
 #[salsa::tracked(return_ref)]
 pub fn is_goal_satisfiable<'db>(
     db: &'db dyn HirAnalysisDb,
@@ -38,30 +40,6 @@ pub fn is_goal_satisfiable<'db>(
     ProofForest::new(db, ingot, goal, assumptions).solve()
 }
 
-/// A minimal, user-facing explanation of trait goal satisfiability.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum GoalExplanation<'db> {
-    Success,
-    ContainsInvalid,
-    NeedsConfirmation,
-    Failure { subgoal: Option<super::trait_def::TraitInstId<'db>> },
-}
-
-/// Facade: Explain why a goal is (not) satisfiable, reusing existing solver.
-pub fn explain_goal<'db>(
-    db: &'db dyn HirAnalysisDb,
-    ingot: Ingot<'db>,
-    goal: Canonical<TraitInstId<'db>>,
-    assumptions: PredicateListId<'db>,
-) -> GoalExplanation<'db> {
-    match is_goal_satisfiable(db, ingot, goal, assumptions) {
-        GoalSatisfiability::Satisfied(_) => GoalExplanation::Success,
-        GoalSatisfiability::ContainsInvalid => GoalExplanation::ContainsInvalid,
-        GoalSatisfiability::NeedsConfirmation(_) => GoalExplanation::NeedsConfirmation,
-        GoalSatisfiability::UnSat(sub) => GoalExplanation::Failure { subgoal: sub.map(|s| s.value) },
-    }
-}
-
 /// Checks if the given type is well-formed, i.e., the arguments of the given
 /// type applications satisfies the constraints under the given assumptions.
 #[salsa::tracked]
@@ -318,13 +296,3 @@ impl<'db> PredicateListId<'db> {
         Self::new(db, all_predicates.into_iter().collect::<Vec<_>>())
     }
 }
-
-/// Public helper: collect full assumptions (constraints) applicable to a function definition,
-/// including parent trait/impl bounds when relevant.
-pub fn func_assumptions_for_func<'db>(
-    db: &'db dyn HirAnalysisDb,
-    func: Func<'db>,
-) -> PredicateListId<'db> {
-    constraint::collect_func_def_constraints(db, super::func_def::HirFuncDefKind::Func(func), true)
-        .instantiate_identity()
-}

crates/hir-analysis/src/ty/trait_resolution/mod.rs

@@ -446,7 +446,7 @@ impl<'db> TyChecker<'db> {
                         ExpectedPathKind::Value
                     };
 
-                    if let Some(diag) = err.into_diag(self.db, *path, span.into(), expected_kind) {
+                    if let Some(diag) = err.into_diag(self.db, *path, span, expected_kind) {
                         self.push_diag(diag)
                     }
                     ResolvedPathInBody::Invalid