Struct IncrementalParser 

pub struct IncrementalParser { /* private fields */ }

High-level incremental parser coordinating tree caching and re-parsing.

Combines TreeCache, InputEditCalculator, and tree-sitter’s incremental parsing to minimize re-parsing overhead when files change.

Workflow

1. Check if old tree is cached for the file
2. If cached and content changed:
   • Calculate InputEdit describing changes
   • Call tree.edit(InputEdit) to inform tree-sitter
   • Re-parse with the edited tree (tree-sitter reuses unchanged subtrees)
3. If not cached or edit fails:
   • Fall back to full parse
4. Cache the resulting tree for future incremental parses

Performance

• Cache hit + small edit: 5-10x faster than full parse
• Cache miss: Same as full parse (no overhead)
• Incremental parse failure: Automatic fallback to full parse

Thread Safety

The internal TreeCache uses a Mutex, so IncrementalParser is Send + Sync. Multiple threads can share the same parser instance safely.

Example

use sqry_core::ast::IncrementalParser;

let parser = IncrementalParser::with_default_capacity();

// First parse (cache miss)
let tree1 = parser.parse(&plugin, &path, &content1, None)?;

// Second parse after edit (cache hit, incremental)
let tree2 = parser.parse(&plugin, &path, &content2, Some(&content1))?;
// ↑ 5-10x faster than full re-parse

Implementations

impl IncrementalParser

pub fn new(capacity: usize) -> Self

Create a new incremental parser with the specified cache capacity.

Arguments

• capacity - Maximum number of trees to cache (must be > 0)

Panics

Panics if capacity is 0.

pub fn with_default_capacity() -> Self

Create a new incremental parser with default cache capacity (100 trees).

pub fn parse<P>( &self, plugin: &P, path: &Path, new_content: &[u8], old_content: Option<&[u8]>, ) -> Result<Tree, ParseError>

where P: LanguagePlugin + ?Sized,

Parse content using incremental parsing when possible.

Arguments

• plugin - Language plugin providing parse_ast() method
• path - Absolute path to the file (used as cache key)
• new_content - Current file content
• old_content - Previous file content (optional, for InputEdit calculation)

Returns

Parsed tree-sitter Tree. The tree is also cached for future incremental parses.

Incremental Parsing

Incremental parsing is used when:

1. Old tree is cached for this path
2. old_content is provided
3. Content actually changed (different hash)

Otherwise falls back to full parse (no performance penalty).

Errors

Returns error if parsing fails (both incremental and fallback).

pub fn clear_cache(&self)

Clear the tree cache.

pub fn cache_len(&self) -> usize

Get the number of cached trees.