Struct TextMateEngine 

pub struct TextMateEngine { /* private fields */ }

TextMate highlighting engine with marker-based parse state checkpoints.

Syntect’s parser is a sequential state machine that must process text from the start of the file to correctly track embedded language transitions (e.g. CSS inside HTML <style> tags).

Checkpoint positions are stored as markers in an internal MarkerList which automatically adjusts byte offsets when the buffer is edited. The associated ParseState + ScopeStack are stored in a side HashMap.

On edit, checkpoint positions auto-adjust and a dirty_from marker is set. On the next render, a convergence walk re-parses from the checkpoint before the dirty point forward, stopping as soon as the new parse state matches an existing checkpoint’s stored state (VSCode-style convergence). This means most single-character edits only re-parse 1-2 checkpoints (~500 bytes).

For large files where no checkpoint reaches the viewport, we fall back to a fresh ParseState from context_bytes before the viewport.

Implementations

impl TextMateEngine

pub fn new(syntax_set: Arc<SyntaxSet>, syntax_index: usize) -> Self

Create a new TextMate engine for the given syntax

pub fn with_language( syntax_set: Arc<SyntaxSet>, syntax_index: usize, ts_language: Option<Language>, ) -> Self

Create a new TextMate engine with a tree-sitter language for non-highlighting features

pub fn stats(&self) -> &HighlightStats

Get performance stats for testing and diagnostics.

pub fn reset_stats(&mut self)

Reset performance counters.

pub fn language(&self) -> Option<&Language>

Get the tree-sitter language (for indentation, semantic highlighting, etc.)

pub fn notify_insert(&mut self, position: usize, length: usize)

Notify the checkpoint system of a buffer insert. Markers auto-adjust positions. Also shifts cached span byte offsets after the insert point so the span cache remains valid for the partial-update / convergence path.

pub fn notify_delete(&mut self, position: usize, length: usize)

Notify the checkpoint system of a buffer delete. Markers auto-adjust positions. Also adjusts cached span byte offsets after the delete point.

pub fn highlight_viewport( &mut self, buffer: &Buffer, viewport_start: usize, viewport_end: usize, theme: &Theme, context_bytes: usize, ) -> Vec<HighlightSpan>

Highlight the visible viewport range.

If the span cache is valid and there are no dirty edits, returns cached spans. If there are dirty edits, re-parses only from the dirty point until convergence (parse state matches an existing checkpoint), then splices the new spans into the cache. This means most single-character edits only re-parse ~256-512 bytes.

pub fn invalidate_range(&mut self, _edit_range: Range<usize>)

Invalidate span cache for an edited range. Checkpoint positions are handled by notify_insert/notify_delete. The span cache is NOT cleared here — it will be patched (partial update) during the next highlight_viewport call using convergence. Only dirty_from (set by notify_insert/notify_delete) controls re-parsing scope.

pub fn invalidate_all(&mut self)

Invalidate all cache and checkpoints (file reload, language change, etc.)

pub fn category_at_position(&self, position: usize) -> Option<HighlightCategory>

Get the highlight category at a byte position from the cache.

Returns the category if the position falls within a cached highlight span. The position must be within the last highlighted viewport range for a result.

pub fn syntax_name(&self) -> &str

Get syntax name