Struct DocumentStore 

pub struct DocumentStore { /* private fields */ }

Implementations

impl DocumentStore

pub fn new() -> Self

pub fn mirror_text(&self, uri: &Url, text: &str) -> SourceFile

Mirror a file’s current text into the salsa layer. Creates the SourceFile input on first sight, otherwise updates text on the existing input (bumping the salsa revision so downstream queries invalidate). Returns the SourceFile handle for this uri.

B4a: called from every text-changing mutation site. Reads still come from the legacy map — this mirror is not yet observed by production code paths.

pub fn source_file(&self, uri: &Url) -> Option<SourceFile>

Return the salsa SourceFile handle for a URL, if one exists.

pub fn seed_cached_slice(&self, uri: &Url, slice: Arc<StubSlice>) -> bool

Phase K2: pre-seed a StubSlice loaded from the on-disk cache onto the SourceFile input for uri. The next file_definitions call for that file returns the cached slice directly, skipping parse + DefinitionCollector.

Must be called before any file_definitions(db, sf) call for this file — otherwise salsa has already memoized the fresh-parse result and setting cached_slice now would only bump the revision without actually using the cache. In practice the workspace-scan path seeds immediately after mirror_text and before any query runs.

Returns false when uri was not mirrored (caller should mirror first); returns true on success.

pub fn with_host<R>(&self, f: impl FnOnce(&AnalysisHost) -> R) -> R

Run f with a borrow of the AnalysisHost. Used by tests and by the upcoming *_salsa accessors to query the salsa layer.

pub fn evict_token_cache(&self, uri: &Url)

Evict the semantic-tokens cache for uri. Called by Backend when a file is closed; diff-based tokens computed against the old revision are no longer meaningful.

pub fn index(&self, uri: Url, text: &str)

Register a file in the salsa layer without marking it open.

Salsa’s parsed_doc query parses lazily on first read; diagnostics are populated by did_open when the editor actually opens the file.

pub fn index_from_doc( &self, uri: Url, doc: &ParsedDoc, _diagnostics: Vec<Diagnostic>, )

Index a file using an already-parsed ParsedDoc, avoiding a second parse.

Prefer this over [index] when the caller already has a ParsedDoc (e.g. after running DefinitionCollector during workspace scan).

_diagnostics is accepted for call-site compatibility; parse diagnostics for background-indexed files are never consulted (callers gate on get_doc_salsa returning Some).

pub fn remove(&self, uri: &Url)

pub fn get_doc_salsa(&self, uri: &Url) -> Option<Arc<ParsedDoc>>

Salsa-backed parsed document.

Salsa-backed parsed document for any mirrored file (open or background-indexed). Returns None only when the file is not known to the store. Callers that want “only if open” should gate on Backend::open_files at the call site (see Backend::get_doc).

pub fn get_index_salsa(&self, uri: &Url) -> Option<Arc<FileIndex>>

Salsa-backed compact symbol index.

pub fn sync_workspace_files(&self)

Refresh workspace.files to mirror the current source_files set.

Called by get_codebase_salsa. Skips the setter when the file list hasn’t changed — salsa’s set_field unconditionally bumps revision, which would invalidate every downstream query (codebase, file_refs). Dedup is essential for memoization across LSP requests.

pub fn set_php_version(&self, version: PhpVersion)

Update the PHP version tracked by the workspace. Salsa will invalidate all semantic_issues queries so diagnostics are re-evaluated. Skips the setter when the version hasn’t changed to avoid spurious query invalidation.

pub fn get_codebase_salsa(&self) -> Arc<Codebase>

Salsa-backed finalized Codebase. Aggregates every known file’s StubSlice via codebase_from_parts, memoized by salsa.

Phase C step 3: this runs in parallel with Backend’s imperative Arc<Codebase>. Comparison tests validate parity; readers migrate in a follow-up.

pub fn get_symbol_refs_salsa(&self, key: &str) -> Vec<(Arc<str>, u32, u32)>

Salsa-backed reference lookup — drop-in replacement for Codebase::get_reference_locations. First call per key runs file_refs over every workspace file; subsequent calls hit the symbol_refs memo.

pub fn get_workspace_index_salsa(&self) -> Arc<WorkspaceIndexData>

Phase J: salsa-memoized aggregate workspace index.

Returns the shared Arc<WorkspaceIndexData> with flat (Url, Arc<FileIndex>) list plus pre-built classes_by_name and subtypes_of reverse maps. Used by workspace_symbols, prepare_type_hierarchy, supertypes_of, subtypes_of, and find_implementations so they don’t each rebuild the aggregate per request. Invalidates automatically when any file’s file_index changes.

pub fn warm_reference_index(&self)

Phase L: force file_refs to run for every workspace file so that subsequent textDocument/references / prepare_rename / call-hierarchy lookups hit the memo instead of paying first-call latency.

Uses parallel warming (warm_file_refs_parallel) so all file_refs complete concurrently; symbol_refs then only aggregates memos.

pub fn slice_for(&self, uri: &Url) -> Option<Arc<StubSlice>>

Phase K2b: run file_definitions for uri and return the resulting StubSlice. Used by the workspace-scan write path to persist slices to disk after a cache miss.

pub fn get_method_returns_salsa( &self, uri: &Url, ) -> Option<Arc<MethodReturnsMap>>

Salsa-backed per-file method-return-type map.

pub fn store_token_cache( &self, uri: &Url, result_id: String, tokens: Vec<SemanticToken>, )

Cache the semantic tokens computed for a delta response. result_id is an opaque string (a hash of the token data) returned to the client.

pub fn get_token_cache( &self, uri: &Url, result_id: &str, ) -> Option<Vec<SemanticToken>>

Return the cached tokens if result_id matches the stored one.

pub fn get_semantic_issues_salsa(&self, uri: &Url) -> Option<Arc<[Issue]>>

Phase I: salsa-memoized raw semantic issues for a file. Callers apply their own DiagnosticsConfig filter via crate::semantic_diagnostics::issues_to_diagnostics — keeping the filter outside the query preserves memoization across config toggles.

pub fn docs_for(&self, open_urls: &[Url]) -> Vec<(Url, Arc<ParsedDoc>)>

Returns (uri, doc) for files currently open in the editor.

Resolve open_urls (from Backend::open_urls()) to parsed docs. Files not mirrored in the salsa layer are filtered out silently.

pub fn doc_with_others( &self, uri: &Url, doc: Arc<ParsedDoc>, open_urls: &[Url], ) -> Vec<(Url, Arc<ParsedDoc>)>

(primary, doc) first, then every other open file’s parsed doc. The open_urls slice should include uri — this helper filters it out.

pub fn other_docs( &self, uri: &Url, open_urls: &[Url], ) -> Vec<(Url, Arc<ParsedDoc>)>

Parsed docs for every entry in open_urls except uri.

pub fn other_docs_with_returns( &self, uri: &Url, open_urls: &[Url], ) -> Vec<(Url, Arc<ParsedDoc>, Arc<MethodReturnsMap>)>

Batched salsa fetch for every entry in open_urls except uri: returns each (uri, ParsedDoc, MethodReturnsMap) triple in a single snapshot_query so cancellation retries don’t run N times.

pub fn all_indexes(&self) -> Vec<(Url, Arc<FileIndex>)>

Compact symbol index for every mirrored file.

pub fn other_indexes(&self, uri: &Url) -> Vec<(Url, Arc<FileIndex>)>

Same as all_indexes but excludes uri.

pub fn all_docs_for_scan(&self) -> Vec<(Url, Arc<ParsedDoc>)>

Parsed documents for every mirrored file (open or background-indexed). Suitable for full-scan operations: find-references, rename, call_hierarchy, code_lens.

Trait Implementations

impl Default for DocumentStore

fn default() -> Self

Returns the “default value” for a type.