perf: incremental indexing and preprocessor caching

.gitignore

@@ -19,9 +19,7 @@ tags
 
 # generated files
 generated.rs
-docs/public/vide-lab/
-docs/public/schemas/
-docs/hir-def/
+/docs/
 editors/zed/extension.wasm
 editors/zed/grammars/systemverilog/
 

Cargo.toml

@@ -14,9 +14,9 @@ description = "Language server for Verilog and System-Verilog"
 members = [
   ".",
   "crates/base-db",
+  "crates/design-graph",
   "crates/hir-def",
   "crates/hir-semantics",
-  "crates/hir-ty",
   "crates/ide",
   "crates/preproc",
   "crates/preproc-expand",
@@ -78,9 +78,9 @@ triomphe.workspace = true
 
 [workspace.dependencies]
 base-db = { path = "./crates/base-db/", version = "0.0.0" }
+design-graph = { path = "./crates/design-graph/", version = "0.0.0" }
 hir-def = { path = "./crates/hir-def/", version = "0.0.0" }
 hir-semantics = { path = "./crates/hir-semantics/", version = "0.0.0" }
-hir-ty = { path = "./crates/hir-ty/", version = "0.0.0" }
 ide = { path = "./crates/ide/", version = "0.0.0" }
 preproc = { path = "./crates/preproc/", version = "0.0.0" }
 preproc-expand = { path = "./crates/preproc-expand/", version = "0.0.0" }

crates/base-db/src/change.rs

@@ -71,7 +71,14 @@ impl Change {
             }
 
             let text = changed_file.text().unwrap_or_else(|| Arc::from(""));
-            db.set_file_kind_with_durability(file_id, kind, durability);
+            // Salsa treats every input write as a new revision, even when the
+            // value is unchanged. Rewriting kind on a body-only Modify dirties
+            // every query that reads `file_kind` (workspace catalogs,
+            // `unit_scope`, fold filters). Skip the write when the salsa
+            // input already exists and already holds this kind.
+            if !db.files().contains(&file_id) || db.file_kind(file_id) != kind {
+                db.set_file_kind_with_durability(file_id, kind, durability);
+            }
             db.set_file_text_with_durability(file_id, text, durability);
         }
 

crates/hir-ty/Cargo.toml → crates/design-graph/Cargo.toml

@@ -1,18 +1,16 @@
 [package]
-name = "hir-ty"
+name = "design-graph"
 version = "0.0.0"
+description = "Compilation-unit design-unit facts and name join"
 edition.workspace = true
 
 [dependencies]
 base-db.workspace = true
-hir-def.workspace = true
 rustc-hash.workspace = true
 salsa.workspace = true
+smallvec.workspace = true
 smol_str.workspace = true
 syntax.workspace = true
 triomphe.workspace = true
 utils.workspace = true
 vfs.workspace = true
-
-[dev-dependencies]
-preproc-expand.workspace = true

crates/design-graph/src/db.rs

@@ -0,0 +1,126 @@
+//! Salsa `file_facts` over an unexpanded parse.
+
+use std::cell::Cell;
+
+use base_db::{salsa, source_db::SourceRootDb};
+use syntax::{SyntaxTree, SyntaxTreeOptions};
+use triomphe::Arc;
+use vfs::FileId;
+
+use crate::{
+    facts::{DeclIndex, FileFacts, extract},
+    graph::{GeneratedUnits, UnitCatalog},
+};
+
+thread_local! {
+    pub static SOURCE_CATALOG_RUNS: Cell<u32> = const { Cell::new(0) };
+}
+
+#[salsa::interned(unsafe(no_lifetime), revisions = usize::MAX, debug)]
+pub struct FileFactsKey {
+    #[returns(copy)]
+    pub file_id: FileId,
+}
+
+/// Workspace database that can extract unexpanded design-unit facts.
+#[salsa::db]
+pub trait DesignGraphDb: SourceRootDb {}
+
+fn default_source_buffer_path(db: &dyn SourceRootDb, file_id: FileId) -> String {
+    db.file_path(file_id).map(|path| path.to_string()).unwrap_or_else(|| {
+        if cfg!(windows) {
+            format!(r"C:\__vide_virtual__\{}", file_id.index())
+        } else {
+            format!("/__vide_virtual__/{}", file_id.index())
+        }
+    })
+}
+
+#[salsa::tracked(lru = 256, returns(clone))]
+pub fn file_facts_query(db: &dyn DesignGraphDb, key: FileFactsKey) -> Arc<FileFacts> {
+    let file_id = key.file_id(db);
+    let text = db.file_text(file_id);
+    let path = default_source_buffer_path(db, file_id);
+    let name =
+        db.file_path(file_id).map(|path| path.to_string()).unwrap_or_else(|| "source".into());
+    let profile_id = db.file_compilation_profile(file_id);
+    let predefines = db.project_config().preprocess_for_profile(profile_id).predefine_strings();
+    // U2: profile predefines, no include expansion. This is not
+    // `SyntaxTreeOptions::without_include_expansion()`: that helper ships
+    // empty predefines so `source_model` (U1) stays file-local. FileFacts
+    // must see the same `ifdef` view the profile will compile, or gated
+    // units disappear from the name catalog. It also cannot share U3
+    // (`literal_include_targets`): that scan needs a preprocessor `Trace`,
+    // and attaching a Trace here would make every L0 fact pay for include
+    // resolution. Sharing one salsa query would hide gated units, invalidate
+    // the file-local preprocessor model, or both.
+    //
+    // `preprocessor_independent` is `syntax::preprocessor_independent` —
+    // the same directive-trivia walk U1 uses. The boolean cannot diverge;
+    // the trees can, because predefines differ.
+    let options = SyntaxTreeOptions {
+        predefines,
+        include_paths: Vec::new(),
+        include_buffers: Vec::new(),
+        expand_includes: false,
+        collect_expected_syntax: false,
+        expected_syntax_offset: None,
+    };
+    syntax::record_unexpanded_parse("file_facts");
+    let tree = SyntaxTree::from_file_in_memory_with_options(&text, &name, &path, &options);
+    Arc::new(extract::from_tree(file_id, &tree, &text))
+}
+
+/// Position-free and small: must not share the parse LRU with `file_facts`.
+/// A workspace larger than that LRU would otherwise re-extract every evicted
+/// file's decls on the next revision, which re-parses `file_facts` with them.
+#[salsa::tracked(returns(clone))]
+pub fn file_decls_query(db: &dyn DesignGraphDb, key: FileFactsKey) -> Arc<DeclIndex> {
+    Arc::new(file_facts_query(db, key).decls())
+}
+
+#[salsa::interned(unsafe(no_lifetime), revisions = usize::MAX, debug)]
+pub struct UnitCatalogKey {
+    #[returns(copy)]
+    pub _unit: (),
+}
+
+/// L0 name catalog of source decls. Production resolution uses this as a
+/// name → file locator. Generated names are not merged here; they live on
+/// the paid-parse owner table (`HirFileId::Macro`).
+#[salsa::tracked(lru = 4, returns(clone))]
+pub fn source_unit_catalog_query(
+    db: &dyn DesignGraphDb,
+    _key: UnitCatalogKey,
+) -> triomphe::Arc<UnitCatalog> {
+    SOURCE_CATALOG_RUNS.with(|runs| runs.set(runs.get() + 1));
+    let decls: Vec<_> = db
+        .files()
+        .iter()
+        .copied()
+        .filter(|&file_id| db.file_kind(file_id).is_semantic_compilation_unit())
+        .map(|file_id| db.file_decls(file_id))
+        .collect();
+    triomphe::Arc::new(UnitCatalog::from_decls(
+        decls.iter().map(std::convert::AsRef::as_ref),
+        &GeneratedUnits::default(),
+    ))
+}
+
+pub fn set_file_facts_lru_capacity(db: &mut dyn DesignGraphDb, capacity: usize) {
+    file_facts_query::set_lru_capacity(db, capacity);
+}
+
+impl dyn DesignGraphDb + '_ {
+    pub fn file_facts(&self, file_id: FileId) -> Arc<FileFacts> {
+        file_facts_query(self, FileFactsKey::new(self, file_id))
+    }
+
+    pub fn file_decls(&self, file_id: FileId) -> Arc<DeclIndex> {
+        file_decls_query(self, FileFactsKey::new(self, file_id))
+    }
+
+    pub fn source_unit_catalog(&self) -> triomphe::Arc<UnitCatalog> {
+        source_unit_catalog_query(self, UnitCatalogKey::new(self, ()))
+    }
+}

crates/design-graph/src/facts.rs

@@ -0,0 +1,182 @@
+//! Per-file unexpanded design-unit facts.
+
+use rustc_hash::FxHashMap;
+use smallvec::SmallVec;
+use smol_str::SmolStr;
+use syntax::TokenKind;
+use utils::line_index::{TextRange, TextSize};
+use vfs::FileId;
+
+use crate::unit::{InstantiationRole, UnitId, UnitNode, UnitOrigin};
+
+pub mod extract;
+
+/// One name-like token, unresolved.
+///
+/// `emitted` is the preprocessor-trace index when the extract tree assigned
+/// one. Macro-expanded tokens share display ranges, so later recovery on the
+/// authoritative parse needs this identity when the two traces agree.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Mention {
+    pub name: smol_str::SmolStr,
+    pub kind: TokenKind,
+    pub range: TextRange,
+    pub emitted: Option<u32>,
+}
+
+/// Instantiation type-name token. Primitive instantiations are not recorded.
+///
+/// `container` is the compilation-unit that directly contains the site.
+/// Nested-module bodies leave it empty — those are not CU graph edges.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct InstantiationSite {
+    pub file: FileId,
+    pub name: smol_str::SmolStr,
+    pub range: TextRange,
+    pub role: InstantiationRole,
+    pub emitted: Option<u32>,
+    pub container: Option<UnitId>,
+}
+
+/// `import p::x` / `import p::*`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImportSpec {
+    pub package: smol_str::SmolStr,
+    pub item: Option<smol_str::SmolStr>,
+    /// Package-name token in display coordinates.
+    pub range: TextRange,
+}
+
+/// Left identifier of a non-dot `ScopedName` (`p::y`).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PackageRefSite {
+    pub name: smol_str::SmolStr,
+    pub range: TextRange,
+    pub emitted: Option<u32>,
+}
+
+/// Position-free CU declaration index. This is what salsa backdates;
+/// ranges live on [`Mentions`] and must not enter the global catalog.
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct DeclIndex {
+    pub units: Box<[DeclUnit]>,
+    pub imports: Box<[(SmolStr, Option<SmolStr>)]>,
+    pub preprocessor_independent: bool,
+    pub has_compilation_unit_locals: bool,
+}
+
+/// One CU declaration without source ranges.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DeclUnit {
+    pub id: UnitId,
+    pub origin: UnitOrigin,
+    pub header_fingerprint: u64,
+}
+
+/// Name-like tokens of one file, with a name → offset inverted index.
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct Mentions {
+    pub entries: Box<[Mention]>,
+    by_name: FxHashMap<SmolStr, SmallVec<[u32; 2]>>,
+}
+
+impl Mentions {
+    pub fn from_entries(entries: Box<[Mention]>) -> Self {
+        let mut by_name: FxHashMap<SmolStr, SmallVec<[u32; 2]>> = FxHashMap::default();
+        for (index, mention) in entries.iter().enumerate() {
+            by_name.entry(mention.name.clone()).or_default().push(index as u32);
+        }
+        Self { entries, by_name }
+    }
+
+    pub fn mentions_name(&self, name: &str) -> bool {
+        self.by_name.contains_key(name)
+    }
+
+    pub fn mentions_of(&self, name: &str) -> impl Iterator<Item = &Mention> {
+        self.by_name.get(name).into_iter().flatten().map(|&index| &self.entries[index as usize])
+    }
+}
+
+/// Compact unexpanded slice of one file. No syntax tree, no interned owner.
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct FileFacts {
+    pub units: Box<[UnitNode]>,
+    pub mentions: Mentions,
+    pub imports: Box<[ImportSpec]>,
+    pub instantiations: Box<[InstantiationSite]>,
+    pub package_refs: Box<[PackageRefSite]>,
+    pub preprocessor_independent: bool,
+    pub has_compilation_unit_locals: bool,
+}
+
+impl FileFacts {
+    pub fn decls(&self) -> DeclIndex {
+        DeclIndex {
+            units: self
+                .units
+                .iter()
+                .map(|unit| DeclUnit {
+                    id: unit.id.clone(),
+                    origin: unit.origin,
+                    header_fingerprint: unit.header_fingerprint,
+                })
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+            imports: self
+                .imports
+                .iter()
+                .map(|import| (import.package.clone(), import.item.clone()))
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+            preprocessor_independent: self.preprocessor_independent,
+            has_compilation_unit_locals: self.has_compilation_unit_locals,
+        }
+    }
+
+    pub fn mentions_name(&self, name: &str) -> bool {
+        self.mentions.mentions_name(name)
+    }
+
+    pub fn mentions_of(&self, name: &str) -> impl Iterator<Item = &Mention> {
+        self.mentions.mentions_of(name)
+    }
+
+    pub fn has_compilation_unit_locals(&self) -> bool {
+        self.has_compilation_unit_locals
+    }
+
+    /// Design-unit whose recorded name token covers `offset`.
+    pub fn design_unit_at(&self, offset: TextSize) -> Option<&UnitNode> {
+        self.units.iter().find(|unit| unit.name_range.is_some_and(|range| range.contains(offset)))
+    }
+
+    pub fn unit(&self, id: UnitId) -> Option<&UnitNode> {
+        self.units.iter().find(|unit| unit.id == id)
+    }
+
+    pub fn instantiation_at(&self, offset: TextSize) -> Option<&InstantiationSite> {
+        self.instantiations.iter().find(|site| site.range.contains(offset))
+    }
+
+    pub fn unit_at_name_range(&self, range: TextRange) -> Option<&UnitNode> {
+        self.units.iter().find(|unit| unit.name_range == Some(range))
+    }
+
+    /// Import package token or `::` left ident covering `offset`.
+    pub fn package_token_at(&self, offset: TextSize) -> Option<(smol_str::SmolStr, TextRange)> {
+        if let Some(import) = self.imports.iter().find(|import| import.range.contains(offset)) {
+            return Some((import.package.clone(), import.range));
+        }
+        self.package_refs
+            .iter()
+            .find(|site| site.range.contains(offset))
+            .map(|site| (site.name.clone(), site.range))
+    }
+
+    /// Whether CU units and import *names* match. Mentions, instantiations,
+    /// package-ref sites, and source ranges do not move the structure clock.
+    pub fn same_structure(&self, other: &Self) -> bool {
+        self.decls() == other.decls()
+    }
+}