Struct AnalysisSession 

pub struct AnalysisSession { /* private fields */ }

Reusable engine session for one resolved project.

The session owns the resolved config and discovered file set so future consumers can share graph-sensitive inputs without each surface recreating its own partial orchestration.

Implementations

impl AnalysisSession

pub fn load(root: &Path, config_path: Option<&Path>) -> EngineResult<Self>

Load config and discover files for a project root.

Errors

Returns an error when config loading fails.

pub fn load_with_config( root: &Path, config_path: Option<&Path>, configure: impl FnOnce(&mut ResolvedConfig), ) -> EngineResult<Self>

Load config, apply one caller-supplied config adjustment, then discover files for a project root.

Errors

Returns an error when config loading fails.

pub fn load_with_config_options( root: &Path, config_path: Option<&Path>, load_options: ConfigLoadOptions, configure: impl FnOnce(&mut ResolvedConfig), ) -> EngineResult<Self>

Load config with an explicit inheritance trust policy, apply one caller-supplied adjustment, then discover project files.

Errors

Returns an error when config loading fails.

pub fn load_default(root: &Path) -> Self

Build a session from built-in defaults, ignoring project config files.

This is intended for editor fallback paths that have already reported a config-load warning but should still surface best-effort diagnostics.

pub fn from_config(project_config: ProjectConfig) -> Self

Build a session from a previously resolved config.

pub fn with_cancellation(self, cancellation: Arc<AtomicBool>) -> Self

Attach a caller-owned cancellation token to this session.

Analyses that run through the session check the token at each pipeline stage boundary and inside the per-file parse loop, and return crate::EngineError::cancelled instead of a partial result once it is set. A session without a token can never be cancelled, so existing callers keep their current behavior.

The stop is cooperative, and how long it takes is bounded by the longest stage that holds no check, not by any promised latency. Only the parse loop stops per file. Duplication detection (tokenization plus suffix-array matching) and the dead-code detectors run to the end of the stage once entered, and on a large repository either is seconds of work. A caller that needs a bounded stop has to kill the process instead.

pub fn with_warm_parse(self, store: Option<Arc<WarmParseStore>>) -> Self

Use store for parsed modules across sessions, in place of the store that the process installed with crate::warm_parse::install. None makes the session parse through the persisted cache only.

pub fn set_cancellation(&mut self, cancellation: Arc<AtomicBool>)

Replace the cancellation token of a session that serves several runs.

A long-lived session gets the token of each new run, so a set token of an earlier run does not stop the next one.

pub fn parse_counts(&self) -> SessionParseCounts

The parse work of this session since it was created.

pub fn refresh_discovery(&mut self) -> bool

Walk the project again and keep the parsed modules when the file set did not change.

A session that serves several runs calls this before each run, so a created or deleted file reaches the analysis without a config reload. When the file set changed, the file ids move, so the session writes its parsed modules to the persisted parse cache and drops them. The next parse then reads that cache. Returns whether the file set changed.

The session also drops its modules when a fingerprint of the cached parse cannot stand in for the file content, as on a platform without ctime. A same-size edit with a restored mtime keeps such a fingerprint, so only the persisted cache, which then compares content hashes, can tell whether the module is current.

pub fn flush_parse_cache(&self)

Write the modules of incremental parses to the persisted parse cache.

Each module is stored with the fingerprint that the session read before it parsed the file. A file that changed after that parse then misses the cache instead of serving the older module. Does nothing when no incremental parse happened since the last write, or when the cache is off.

The session does not write these modules when it is dropped. A caller that parses again after files changed, such as a session that lives across editor runs, calls this method before it drops the session. A session that parses once needs no call: the full parse writes the persisted cache itself. The editor server is the only caller now.

pub fn prewarm_parsed_modules(&self, need_complexity: bool) -> EngineResult<()>

Parse the discovered files into the module cache of the session, without analysis. A later run of this session then starts from warm modules.

Errors

Returns crate::EngineError::cancelled when the token of the session is set.

pub fn is_cancelled(&self) -> bool

Whether this session’s caller has requested cancellation.

pub fn from_resolved_config(config: ResolvedConfig) -> EngineResult<Self>

Build a session from a resolved config when the caller already owns command-specific config loading.

Errors

Returns an engine error when root manifest loading fails during workspace discovery, matching ProjectConfig::load.

pub fn root(&self) -> &Path

Resolved project root.

pub fn config(&self) -> &ResolvedConfig

Resolved project config.

pub fn config_path(&self) -> Option<&Path>

Config file path when one was loaded.

pub const fn config_inputs(&self) -> &ConfigInputs

The plugin files, rule packs and autoDiscover directories that config resolution read. A session built from a resolved config lists none.

pub const fn config_inputs_before_resolve(&self) -> &ConfigInputsSnapshot

The content of Self::config_inputs just before config resolution read them. A snapshot after the load that differs from this one tells that an input changed during the load.

pub fn retained_bytes_estimate(&self) -> u64

The estimated heap memory of the parsed modules that the session keeps between calls, with the estimate of crate::warm_parse::estimated_retained_bytes. Zero before the first parse.

pub fn files(&self) -> &[DiscoveredFile]

Discovered files for this session.

pub fn workspaces(&self) -> &[WorkspaceInfo]

Workspace packages discovered during config/session setup.

pub fn workspace_diagnostics(&self) -> &[WorkspaceDiagnostic]

Workspace and source-discovery diagnostics captured for this session.

pub fn current_workspace_diagnostics(&self) -> Vec<WorkspaceDiagnostic>

Current diagnostics, including the source read failures the parse stage discovers and the analysis-stage entries the analyze pass records, both of which land in the registry after the session was created.

The live read goes through fallow_config::registry_diagnostics_to_fold, which drops walk-recorded entries for the same reason the constructor does: a concurrent walk on the same root replaces that set, so importing it here would make this session’s list depend on which walk wrote last, and the combined root’s union would come out in a different ORDER between runs of the same command (issue #2366). This session’s own walk-recorded entries are already in the snapshot, by value, from its own walk.

pub fn into_parts(self) -> AnalysisSessionParts

Consume the session and return the resolved config plus discovery data.

pub fn into_parsed_parts( self, need_complexity: bool, ) -> ParsedAnalysisSessionParts

Consume the session, load the parser cache, and parse discovered files.

pub fn parsed_parts(&self, need_complexity: bool) -> ParsedAnalysisSessionParts

Parse discovered files without consuming the session.

pub fn parsed_parts_uncached( &self, need_complexity: bool, ) -> ParsedAnalysisSessionParts

Parse discovered files without consuming the session or retaining parser output in the session cache.

pub fn analyze_dead_code(&self) -> EngineResult<DeadCodeAnalysis>

Run dead-code analysis for this session.

Errors

Returns an error if parsing or analysis fails.

pub fn analyze_dead_code_with_complexity( &self, ) -> EngineResult<DeadCodeAnalysisOutput>

Run dead-code analysis with retained complexity artifacts.

Errors

Returns an error if parsing or analysis fails.

pub fn analyze_dead_code_with_artifacts( &self, need_complexity: bool, retain_graph: bool, ) -> EngineResult<DeadCodeAnalysisArtifacts>

Run dead-code analysis with retained modules, discovered files and graph.

Errors

Returns an error if parsing or analysis fails.

pub fn analyze_dead_code_retaining_files( &self, need_complexity: bool, retain_graph: bool, ) -> EngineResult<DeadCodeAnalysisArtifacts>

Run dead-code analysis while retaining discovered files for downstream command stages that reuse discovery but do not need parser modules.

Errors

Returns an error if parsing or analysis fails.

pub fn analyze_dead_code_with_parsed_modules( &self, modules: &[ModuleInfo], ) -> EngineResult<DeadCodeAnalysisArtifacts>

Run dead-code analysis from modules already parsed through this session.

This preserves the session’s resolved config and discovered file set for follow-up analyses that reuse parser output without redoing discovery.

Errors

Returns an error if graph construction or analysis fails.

pub fn analyze_dead_code_with_session_artifacts( &self, need_complexity: bool, retain_graph: bool, changed_files: Option<FxHashSet<PathBuf>>, ) -> EngineResult<AnalysisSessionArtifacts>

Run dead-code analysis and return the session-scoped reuse artifacts.

Callers pass a changed-file set they have already resolved for the command. The returned value keeps that set beside parser, graph, and source-fingerprint data so downstream runners do not have to rebuild or rediscover the same inputs.

Errors

Returns an error if parsing or analysis fails.

pub fn analyze_project_with( &self, duplicates_config: &DuplicatesConfig, retain_complexity_artifacts: bool, ) -> EngineResult<ProjectAnalysisOutput>

Run dead-code and duplication analysis for this session.

When retain_complexity_artifacts is true, the dead-code result keeps parser artifacts needed by editor overlays such as inline complexity.

Errors

Returns an error if dead-code parsing or analysis fails.

pub fn analyze_project_with_artifacts( &self, duplicates_config: &DuplicatesConfig, options: ProjectAnalysisArtifactOptions, ) -> EngineResult<ProjectAnalysisArtifacts>

Run dead-code and duplication analysis with retained session reuse data.

This is the engine-owned project artifact boundary for callers that need to hand one analysis result across audit, decision, editor, or follow-up analysis surfaces without rediscovering session metadata.

Errors

Returns an error if dead-code parsing or analysis fails.

pub fn find_duplicates_with_defaults( &self, config: &DuplicatesConfig, cache_dir: Option<&Path>, ) -> DuplicationAnalysis

Run duplication detection and return report sidecar metadata.

pub fn find_duplicates_touching_files_with_defaults( &self, config: &DuplicatesConfig, changed_files: &[PathBuf], cache_dir: Option<&Path>, ) -> DuplicationAnalysis

Run focused duplication detection for a changed-file set.

Trait Implementations

impl Debug for AnalysisSession

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.