consolidation

micahscopes · micahscopes · commit df5eec75f1c0 · 2025-09-08T15:02:44.000-05:00
diff --git a/crates/fe/src/main.rs b/crates/fe/src/main.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::print_stdout, clippy::print_stderr)]
+
 mod check;
 mod tree;
 
diff --git a/crates/hir-analysis/src/analysis_pass.rs b/crates/hir-analysis/src/analysis_pass.rs
@@ -41,22 +41,6 @@ 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,
diff --git a/crates/hir-analysis/src/lookup.rs b/crates/hir-analysis/src/lookup.rs
@@ -8,7 +8,7 @@ use crate::{diagnostics::SpannedHirAnalysisDb, HirAnalysisDb};
 /// Generic semantic identity at a source offset.
 /// This is compiler-facing and independent of any IDE layer types.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum SymbolIdentity<'db> {
+pub enum SymbolKey<'db> {
     Scope(hir::hir_def::scope_graph::ScopeId<'db>),
     EnumVariant(hir::hir_def::EnumVariant<'db>),
     FuncParam(hir::hir_def::ItemKind<'db>, u16),
@@ -32,14 +32,14 @@ fn enclosing_func<'db>(
     None
 }
 
-fn map_path_res<'db>(db: &'db dyn HirAnalysisDb, res: PathRes<'db>) -> Option<SymbolIdentity<'db>> {
+fn map_path_res<'db>(db: &'db dyn HirAnalysisDb, res: PathRes<'db>) -> Option<SymbolKey<'db>> {
     match res {
-        PathRes::EnumVariant(v) => Some(SymbolIdentity::EnumVariant(v.variant)),
-        PathRes::FuncParam(item, idx) => Some(SymbolIdentity::FuncParam(item, idx)),
+        PathRes::EnumVariant(v) => Some(SymbolKey::EnumVariant(v.variant)),
+        PathRes::FuncParam(item, idx) => Some(SymbolKey::FuncParam(item, idx)),
         PathRes::Method(..) => {
-            crate::name_resolution::method_func_def_from_res(&res).map(SymbolIdentity::Method)
+            crate::name_resolution::method_func_def_from_res(&res).map(SymbolKey::Method)
         }
-        _ => res.as_scope(db).map(SymbolIdentity::Scope),
+        _ => res.as_scope(db).map(SymbolKey::Scope),
     }
 }
 
@@ -50,24 +50,24 @@ pub fn identity_for_occurrence<'db>(
     db: &'db dyn SpannedHirAnalysisDb,
     top_mod: TopLevelMod<'db>,
     occ: &hir::source_index::OccurrencePayload<'db>,
-) -> Vec<SymbolIdentity<'db>> {
+) -> Vec<SymbolKey<'db>> {
     use hir::source_index::OccurrencePayload as OP;
 
     match *occ {
         OP::ItemHeaderName { scope, .. } => match scope {
             hir::hir_def::scope_graph::ScopeId::Item(ItemKind::Func(f)) => {
                 if let Some(fd) = crate::ty::func_def::lower_func(db, f) {
                     if fd.is_method(db) {
-                        return vec![SymbolIdentity::Method(fd)];
+                        return vec![SymbolKey::Method(fd)];
                     }
                 }
-                vec![SymbolIdentity::Scope(scope)]
+                vec![SymbolKey::Scope(scope)]
             }
             hir::hir_def::scope_graph::ScopeId::FuncParam(item, idx) => {
-                vec![SymbolIdentity::FuncParam(item, idx)]
+                vec![SymbolKey::FuncParam(item, idx)]
             }
-            hir::hir_def::scope_graph::ScopeId::Variant(v) => vec![SymbolIdentity::EnumVariant(v)],
-            other => vec![SymbolIdentity::Scope(other)],
+            hir::hir_def::scope_graph::ScopeId::Variant(v) => vec![SymbolKey::EnumVariant(v)],
+            other => vec![SymbolKey::Scope(other)],
         },
         OP::MethodName {
             scope,
@@ -100,19 +100,18 @@ pub fn identity_for_occurrence<'db>(
                             MethodCandidate::TraitMethod(tm)
                             | MethodCandidate::NeedsConfirmation(tm) => tm.method.0,
                         };
-                        vec![SymbolIdentity::Method(fd)]
+                        vec![SymbolKey::Method(fd)]
+                    }
+                    Err(MethodSelectionError::AmbiguousInherentMethod(methods)) => {
+                        methods.iter().map(|fd| SymbolKey::Method(*fd)).collect()
                     }
-                    Err(MethodSelectionError::AmbiguousInherentMethod(methods)) => methods
-                        .iter()
-                        .map(|fd| SymbolIdentity::Method(*fd))
-                        .collect(),
                     Err(MethodSelectionError::AmbiguousTraitMethod(traits)) => traits
                         .iter()
                         .filter_map(|trait_def| {
                             trait_def
                                 .methods(db)
                                 .get(&ident)
-                                .map(|tm| SymbolIdentity::Method(tm.0))
+                                .map(|tm| SymbolKey::Method(tm.0))
                         })
                         .collect(),
                     Err(_) => vec![],
@@ -133,9 +132,9 @@ pub fn identity_for_occurrence<'db>(
                 if let Some(bkey) = crate::ty::ty_check::expr_binding_key_for_expr(db, func, expr) {
                     return vec![match bkey {
                         crate::ty::ty_check::BindingKey::FuncParam(f, idx) => {
-                            SymbolIdentity::FuncParam(ItemKind::Func(f), idx)
+                            SymbolKey::FuncParam(ItemKind::Func(f), idx)
                         }
-                        other => SymbolIdentity::Local(func, other),
+                        other => SymbolKey::Local(func, other),
                     }];
                 }
             }
@@ -160,7 +159,7 @@ pub fn identity_for_occurrence<'db>(
         }
         OP::PathPatSeg { body, pat, .. } => {
             if let Some(func) = enclosing_func(db, body.scope()) {
-                vec![SymbolIdentity::Local(
+                vec![SymbolKey::Local(
                     func,
                     crate::ty::ty_check::BindingKey::LocalPat(pat),
                 )]
@@ -180,7 +179,7 @@ pub fn identity_for_occurrence<'db>(
                 if let Some(sc) =
                     crate::ty::ty_check::RecordLike::from_ty(recv_ty).record_field_scope(db, ident)
                 {
-                    return vec![SymbolIdentity::Scope(sc)];
+                    return vec![SymbolKey::Scope(sc)];
                 }
             }
             vec![]
@@ -210,7 +209,7 @@ pub fn identity_for_occurrence<'db>(
                         _ => None,
                     };
                     if let Some(target) = target {
-                        return vec![SymbolIdentity::Scope(target)];
+                        return vec![SymbolKey::Scope(target)];
                     }
                 }
             }
@@ -230,7 +229,7 @@ pub fn identity_for_occurrence<'db>(
                     {
                         match nr.kind {
                             crate::name_resolution::NameResKind::Scope(sc) => {
-                                return vec![SymbolIdentity::Scope(sc)];
+                                return vec![SymbolKey::Scope(sc)];
                             }
                             crate::name_resolution::NameResKind::Prim(_) => {}
                         }
@@ -329,7 +328,7 @@ fn find_ambiguous_candidates_for_path_seg<'db>(
     scope: ScopeId<'db>,
     path: PathId<'db>,
     seg_idx: usize,
-) -> Vec<SymbolIdentity<'db>> {
+) -> Vec<SymbolKey<'db>> {
     use crate::name_resolution::NameDomain;
 
     // Get the identifier from the path segment
@@ -367,14 +366,14 @@ fn find_ambiguous_candidates_for_path_seg<'db>(
         match bucket.pick(domain) {
             Ok(name_res) => {
                 if let crate::name_resolution::NameResKind::Scope(sc) = name_res.kind {
-                    candidates.push(SymbolIdentity::Scope(sc));
+                    candidates.push(SymbolKey::Scope(sc));
                 }
             }
             Err(crate::name_resolution::NameResolutionError::Ambiguous(ambiguous_candidates)) => {
                 // This is exactly what we want for ambiguous imports!
                 for name_res in ambiguous_candidates {
                     if let crate::name_resolution::NameResKind::Scope(sc) = name_res.kind {
-                        candidates.push(SymbolIdentity::Scope(sc));
+                        candidates.push(SymbolKey::Scope(sc));
                     }
                 }
             }
diff --git a/crates/hir-analysis/src/ty/trait_resolution/mod.rs b/crates/hir-analysis/src/ty/trait_resolution/mod.rs
@@ -16,10 +16,7 @@ use crate::{
 };
 use common::indexmap::IndexSet;
 use constraint::collect_constraints;
-use hir::{
-    hir_def::HirIngot,
-    Ingot,
-};
+use hir::{hir_def::HirIngot, Ingot};
 use salsa::Update;
 
 pub(crate) mod constraint;
diff --git a/crates/language-server/src/lsp_diagnostics.rs b/crates/language-server/src/lsp_diagnostics.rs
@@ -41,8 +41,8 @@ impl LspDiagnostics for DriverDataBase {
             // (to clear any previous diagnostics)
             result.entry(url.clone()).or_default();
 
-            // Use the stable file-based API to prevent stale TopLevelMod references
-            let diagnostics = pass_manager.run_on_file(self, file);
+            let top_mod = hir::lower::map_file_to_mod(self, file);
+            let diagnostics = pass_manager.run_on_module(self, top_mod);
             let mut finalized_diags: Vec<CompleteDiagnostic> = diagnostics
                 .iter()
                 .map(|d| d.to_complete(self).clone())
@@ -166,7 +166,7 @@ mod tests {
         for (uri, diags) in map.iter() {
             by_uri
                 .entry(uri.to_string())
-                .or_insert_with(Vec::new)
+                .or_default()
                 .extend(diags.iter().cloned());
         }
 
diff --git a/crates/language-server/src/test_utils.rs b/crates/language-server/src/test_utils.rs
@@ -21,7 +21,7 @@ pub fn load_ingot_from_directory(db: &mut DriverDataBase, ingot_dir: &Path) {
             }
             _ => {
                 // Log other diagnostics but don't panic
-                eprintln!("Test ingot diagnostic for {ingot_dir:?}: {diagnostic}");
+                tracing::debug!("Test ingot diagnostic for {ingot_dir:?}: {diagnostic}");
             }
         }
     }
diff --git a/crates/language-server/test_projects/comprehensive/diagnostics.snap b/crates/language-server/test_projects/comprehensive/diagnostics.snap
@@ -1,10 +1,9 @@
 ---
 source: crates/language-server/src/lsp_diagnostics.rs
-assertion_line: 238
 expression: snapshot
+input_file: test_projects/comprehensive/diagnostics.snap
 ---
-File: file:///home/micah/hacker-stuff-2023/fe-stuff/fe/crates/language-server/test_projects/comprehensive/src/lib.fe
+File: file:///home/micah/hacker-stuff-2023/fe-stuff/fe-B/crates/language-server/test_projects/comprehensive/src/lib.fe
   - code:8-0000 severity:Error @ 38:3..38:8
     type mismatch
 expected `()`, but `i32` is given
-
diff --git a/crates/semantic-query/src/hover.rs b/crates/semantic-query/src/hover.rs
@@ -1,4 +1,5 @@
 use hir_analysis::diagnostics::SpannedHirAnalysisDb;
+use hir_analysis::lookup::SymbolKey;
 
 use hir::hir_def::scope_graph::ScopeId;
 use hir::source_index::OccurrencePayload;
@@ -18,8 +19,7 @@ pub(crate) fn hover_for_occurrence<'db>(
     top_mod: hir::hir_def::TopLevelMod<'db>,
 ) -> Option<HoverSemantics<'db>> {
     // Use the canonical occurrence interpreter to get the symbol target
-    let target = crate::identity::occurrence_symbol_target(db, top_mod, occ)?;
-    let symbol_key = crate::occ_target_to_symbol_key(target);
+    let symbol_key = crate::identity::occurrence_symbol_target(db, top_mod, occ)?;
 
     // Get the span from the occurrence
     let span = get_span_from_occurrence(occ);
@@ -44,11 +44,11 @@ pub(crate) fn get_span_from_occurrence<'db>(occ: &OccurrencePayload<'db>) -> Dyn
 
 fn hover_data_from_symbol_key<'db>(
     db: &'db dyn SpannedHirAnalysisDb,
-    symbol_key: crate::SymbolKey<'db>,
+    symbol_key: SymbolKey<'db>,
     span: DynLazySpan<'db>,
 ) -> Option<HoverSemantics<'db>> {
     match symbol_key {
-        crate::SymbolKey::Scope(sc) => {
+        SymbolKey::Scope(sc) => {
             let signature = sc.pretty_path(db);
             let documentation = get_docstring(db, sc);
             let kind = sc.kind_name();
@@ -59,7 +59,7 @@ fn hover_data_from_symbol_key<'db>(
                 kind,
             })
         }
-        crate::SymbolKey::Method(fd) => {
+        SymbolKey::Method(fd) => {
             let meth = fd.name(db).data(db).to_string();
             let signature = Some(format!("method: {}", meth));
             let documentation = get_docstring(db, fd.scope(db));
@@ -70,7 +70,7 @@ fn hover_data_from_symbol_key<'db>(
                 kind: "method",
             })
         }
-        crate::SymbolKey::Local(_func, bkey) => {
+        SymbolKey::Local(_func, bkey) => {
             let signature = Some(format!("local binding: {:?}", bkey));
             Some(HoverSemantics {
                 span,
@@ -79,7 +79,7 @@ fn hover_data_from_symbol_key<'db>(
                 kind: "local",
             })
         }
-        crate::SymbolKey::FuncParam(item, idx) => {
+        SymbolKey::FuncParam(item, idx) => {
             let signature = Some(format!("parameter {} of {:?}", idx, item));
             Some(HoverSemantics {
                 span,
@@ -88,7 +88,7 @@ fn hover_data_from_symbol_key<'db>(
                 kind: "parameter",
             })
         }
-        crate::SymbolKey::EnumVariant(v) => {
+        SymbolKey::EnumVariant(v) => {
             let sc = v.scope();
             let signature = sc.pretty_path(db);
             let documentation = get_docstring(db, sc);
diff --git a/crates/semantic-query/src/identity.rs b/crates/semantic-query/src/identity.rs
@@ -1,48 +1,24 @@
-use hir::hir_def::{scope_graph::ScopeId, TopLevelMod};
-use hir::source_index::OccurrencePayload;
+use hir::{hir_def::TopLevelMod, source_index::OccurrencePayload};
 
-use hir_analysis::diagnostics::SpannedHirAnalysisDb;
-use hir_analysis::ty::{func_def::FuncDef, ty_check::BindingKey};
-
-/// Analysis-side identity for a single occurrence. Mirrors `SymbolKey` mapping
-/// without pulling semantic-query’s public type into analysis.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum OccTarget<'db> {
-    Scope(ScopeId<'db>),
-    EnumVariant(hir::hir_def::EnumVariant<'db>),
-    FuncParam(hir::hir_def::ItemKind<'db>, u16),
-    Method(FuncDef<'db>),
-    Local(hir::hir_def::item::Func<'db>, BindingKey<'db>),
-}
+use hir_analysis::{diagnostics::SpannedHirAnalysisDb, lookup::SymbolKey};
 
 /// Returns all possible symbol targets for an occurrence, including ambiguous cases.
+/// Now directly returns SymbolIdentity from hir-analysis without translation.
 pub(crate) fn occurrence_symbol_targets<'db>(
     db: &'db dyn SpannedHirAnalysisDb,
     top_mod: TopLevelMod<'db>,
     occ: &OccurrencePayload<'db>,
-) -> Vec<OccTarget<'db>> {
+) -> Vec<SymbolKey<'db>> {
     // Use hir-analysis as the single source of truth for occurrence interpretation
-    let identities = hir_analysis::lookup::identity_for_occurrence(db, top_mod, occ);
-    identities
-        .into_iter()
-        .map(|identity| match identity {
-            hir_analysis::lookup::SymbolIdentity::Scope(sc) => OccTarget::Scope(sc),
-            hir_analysis::lookup::SymbolIdentity::EnumVariant(v) => OccTarget::EnumVariant(v),
-            hir_analysis::lookup::SymbolIdentity::FuncParam(item, idx) => {
-                OccTarget::FuncParam(item, idx)
-            }
-            hir_analysis::lookup::SymbolIdentity::Method(fd) => OccTarget::Method(fd),
-            hir_analysis::lookup::SymbolIdentity::Local(func, bkey) => OccTarget::Local(func, bkey),
-        })
-        .collect()
+    hir_analysis::lookup::identity_for_occurrence(db, top_mod, occ)
 }
 
 /// Returns the first symbol target for an occurrence (backward compatibility).
 pub(crate) fn occurrence_symbol_target<'db>(
     db: &'db dyn SpannedHirAnalysisDb,
     top_mod: TopLevelMod<'db>,
     occ: &OccurrencePayload<'db>,
-) -> Option<OccTarget<'db>> {
+) -> Option<SymbolKey<'db>> {
     occurrence_symbol_targets(db, top_mod, occ)
         .into_iter()
         .next()
diff --git a/crates/semantic-query/src/lib.rs b/crates/semantic-query/src/lib.rs
diff --git a/crates/semantic-query/tests/symbol_keys_snap.rs b/crates/semantic-query/tests/symbol_keys_snap.rs

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+#![allow(clippy::print_stdout, clippy::print_stderr)]`
	`2`	`+`
`1`	`3`	`mod check;`
`2`	`4`	`mod tree;`
`3`	`5`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ pub fn load_ingot_from_directory(db: &mut DriverDataBase, ingot_dir: &Path) {`
`21`	`21`	`}`
`22`	`22`	`_ => {`
`23`	`23`	`// Log other diagnostics but don't panic`
`24`		`- eprintln!("Test ingot diagnostic for {ingot_dir:?}: {diagnostic}");`
	`24`	`+ tracing::debug!("Test ingot diagnostic for {ingot_dir:?}: {diagnostic}");`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`	`}`