Enum IndexState 

pub enum IndexState {
    Building {
        phase: IndexPhase,
        indexed_count: usize,
        total_count: usize,
        started_at: Instant,
    },
    Ready {
        symbol_count: usize,
        file_count: usize,
        completed_at: Instant,
    },
    Degraded {
        reason: DegradationReason,
        available_symbols: usize,
        since: Instant,
    },
}

Index readiness state - explicit lifecycle management

Represents the current operational state of the workspace index, enabling LSP handlers to provide appropriate responses based on index availability. This state machine prevents blocking operations and ensures graceful degradation when the index is not fully ready.

State Transitions

• Building → Ready: Workspace scan completes successfully
• Building → Degraded: Scan timeout, IO error, or resource limit
• Ready → Building: Workspace folder change or file watching events
• Ready → Degraded: Parse storm (>10 pending) or IO error
• Degraded → Building: Recovery attempt after cooldown
• Degraded → Ready: Successful re-scan after recovery

Invariants

• During a single build attempt, phase advances monotonically (Idle → Scanning → Indexing).
• indexed_count must not exceed total_count; callers should keep totals updated.
• Ready and Degraded counts are snapshots captured at transition time.

Usage

use perl_parser::workspace_index::{IndexPhase, IndexState};
use std::time::Instant;

let state = IndexState::Building {
    phase: IndexPhase::Indexing,
    indexed_count: 50,
    total_count: 100,
    started_at: Instant::now(),
};

Variants

Building

Index is being constructed (workspace scan in progress)

Fields

phase: IndexPhase

Current build phase (Idle → Scanning → Indexing)

indexed_count: usize

Files indexed so far

total_count: usize

Total files discovered

started_at: Instant

Started at

Ready

Index is consistent and ready for queries

Fields

symbol_count: usize

Total symbols indexed

file_count: usize

Total files indexed

completed_at: Instant

Timestamp of last successful index

Degraded

Index is serving but degraded

Fields

reason: DegradationReason

Why we degraded

available_symbols: usize

What’s still available

since: Instant

When degradation occurred

Implementations

impl IndexState

pub fn kind(&self) -> IndexStateKind

Return the coarse state kind for instrumentation and routing decisions

pub fn phase(&self) -> Option<IndexPhase>

Return the current build phase when in Building state

pub fn state_started_at(&self) -> Instant

Timestamp of when the current state began

Trait Implementations

impl Clone for IndexState

fn clone(&self) -> IndexState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for IndexState

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

Formats the value using the given formatter.