Struct DocumentStore 

pub struct DocumentStore { /* private fields */ }

Implementations

impl DocumentStore

pub fn new() -> Self

pub fn analysis_session(&self, php_version: PhpVersion) -> Arc<AnalysisSession>

Get or build the AnalysisSession for the given PHP version. Rebuilds when the version changes (e.g. user flipped config). The session owns its own salsa db and AnalysisCache; lazy-loads vendor files via the shared PSR-4 map.

pub fn workspace_php_version(&self) -> PhpVersion

Current PHP version tracked by the workspace input.

pub fn psr4_arc(&self) -> Arc<RwLock<Psr4Map>>

Return the Arc<RwLock<Psr4Map>> so callers can share it. Backend clones this arc at construction time so writes to the lock (e.g. loading composer.json on initialized) are immediately visible to lazy_load_psr4_imports without extra plumbing.

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 mirror_text_arc(&self, uri: &Url, text_arc: Arc<str>) -> SourceFile

Like [mirror_text] but takes an already-allocated Arc<str>.

Callers that already hold an Arc<str> (e.g. index_from_doc reusing ParsedDoc::source_arc()) use this to avoid a second allocation and to ensure text_cache and parsed_cache hold the same Arc pointer — enabling Arc::ptr_eq validation in get_parsed_cached.

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)

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). Reuses the Arc<str> already owned by doc so that text_cache and SourceFile::text share the same pointer — enabling the Arc::ptr_eq fast path in get_parsed_cached on the first subsequent salsa query, without an extra Arc::from(source) allocation.

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_symbol_refs_salsa( &self, _key: &str, ) -> Vec<(Arc<str>, u32, u16, u16)>

Stub kept for the legacy RefLookup closure shape consumed by find_references_codebase_with_target. Always returns empty; the AST walker handles all reference scanning. Session-backed refs go through Self::session_references_to instead.

pub fn session_references_to( &self, symbol: &Symbol, ) -> Vec<(Arc<str>, u32, u32, u32)>

Session-backed workspace reference lookup. Returns (file, line, col) locations for every occurrence of symbol in the files that the AnalysisSession has ingested so far. The session’s reference index is built incrementally during ingest_file, so refs for files the session hasn’t seen yet (background-indexed but never opened) won’t appear here — those are covered by the AST-walker fallback in the references handler.

Returns LSP-style 0-based line/column.

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)

No-op after mir 0.22 migration. The session manages its own warm-up via ingest_file / analyze_dependents_of; there’s nothing for us to pre-warm here.

pub fn source_text(&self, uri: &Url) -> Option<Arc<str>>

Return the raw source text for uri if it has been mirrored into the salsa workspace. Used by the references handler to pre-filter session results by checking whether a file mentions the owning class name.

pub fn ensure_all_files_ingested(&self)

Run Pass 1 + Pass 2 analysis on every mirrored workspace file so that type-aware queries (e.g. session.references_to) see the full workspace.

Reference locations are only recorded during Pass 2 (FileAnalyzer::analyze). ingest_file alone (Pass 1) is not sufficient. Only needed for cross-file queries like textDocument/references that rely on the reference index. The session’s internal cache makes re-analysis of unchanged files cheap.

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: Arc<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<Arc<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]>>

Raw semantic issues for a file, computed via mir’s session-based FileAnalyzer. The session lazy-loads dependencies via PSR-4 so the LSP no longer needs to mirror vendor up-front. Callers apply their own DiagnosticsConfig filter via crate::semantic_diagnostics::issues_to_diagnostics.

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.