Struct SyntaxWorker 

pub struct SyntaxWorker { /* private fields */ }

Background worker that owns the Highlighter and the retained tree-sitter Tree. Communicates with the main thread via a Mutex<Pending> + Condvar for submits, and an mpsc channel for rendered output.

Examples

use std::sync::Arc;
use hjkl_syntax::SyntaxWorker;
use hjkl_bonsai::DotFallbackTheme;
use hjkl_lang::LanguageDirectory;

let theme = Arc::new(DotFallbackTheme::dark());
let dir = Arc::new(LanguageDirectory::new().unwrap());
let worker = SyntaxWorker::spawn(theme, dir);
drop(worker); // joins the thread

Implementations

impl SyntaxWorker

pub fn spawn( theme: Arc<dyn Theme + Send + Sync>, directory: Arc<LanguageDirectory>, ) -> Self

Spawn a fresh worker thread with the given theme and language directory.

pub fn set_language(&self, id: BufferId, grammar: Option<Arc<Grammar>>)

Set / replace the highlighter for a buffer. None detaches.

pub fn forget(&self, id: BufferId)

Forget all worker state for a buffer (highlighter + tree). Sent on buffer close.

pub fn set_theme(&self, theme: Arc<dyn Theme + Send + Sync>)

Replace the theme used for capture → style resolution.

pub fn try_recv_latest(&self) -> Option<RenderOutput>

Drain all available render results, returning the most recent one. Earlier results are discarded — they’d just be overwritten by the latest install anyway, and this keeps the install path O(1) per frame regardless of backlog depth.

pub fn try_recv_all(&self) -> Vec<RenderOutput>

Drain all available render results, returning them all (one per (buffer_id, kind) pair that completed). Unlike Self::try_recv_latest this does not discard earlier results — required so pre-warmed results for non-active buffers can be routed to the right slot cache.

pub fn wait_for_latest(&self, timeout: Duration) -> Option<RenderOutput>

Wait up to timeout for the next result, then drain anything else that arrived after it and return the latest.

pub fn wait_then_recv_all(&self, timeout: Duration) -> Vec<RenderOutput>

Wait up to timeout for the first result to arrive, then drain every additional result already in the channel. Returns ALL results in arrival order (latest per (buffer_id, kind) coalesced).

Unlike Self::wait_for_latest this does NOT discard earlier results — required when pre-warming non-active buffers so both the active buffer’s result and pre-warm results reach their slot caches.

Trait Implementations

impl Drop for SyntaxWorker

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.