Struct SafeParser 

pub struct SafeParser { /* private fields */ }

Safe parser with resource limits and cancellation support.

SafeParser wraps tree-sitter parsing with:

• Input size validation (prevents unbounded allocation)
• Parse timeout (prevents exponential backtracking)
• External cancellation (allows proactive abort)

All language plugins should use this utility instead of creating parsers directly to ensure consistent security policy.

Thread Safety

SafeParser is Send + Sync but the underlying tree-sitter Parser is created per-call. This is intentional to avoid thread-safety issues with tree-sitter’s internal state.

Example

use sqry_core::plugin::safe_parse::{SafeParser, SafeParserConfig};
use tree_sitter_rust::LANGUAGE;

let parser = SafeParser::new(SafeParserConfig::default());
let content = b"fn main() {}";

match parser.parse(&LANGUAGE.into(), content, None) {
    Ok(tree) => println!("Parsed {} nodes", tree.root_node().child_count()),
    Err(e) => eprintln!("Parse failed: {}", e),
}

Implementations

impl SafeParser

pub fn new(config: SafeParserConfig) -> Self

Create a new safe parser with the given configuration.

pub fn with_defaults() -> Self

Create a safe parser with default configuration.

pub fn with_cancellation_flag(self, flag: CancellationFlag) -> Self

Set a cancellation flag for external abort signaling.

pub fn config(&self) -> &SafeParserConfig

Get the current configuration.

pub fn parse( &self, language: &Language, content: &[u8], file: Option<&Path>, ) -> Result<Tree, ParseError>

Parse source code with resource limits.

Arguments

• language - Tree-sitter language to use
• content - Source code as bytes (UTF-8 encoded)
• file - Optional file path for error context

Returns

Parsed tree-sitter AST on success.

Errors

• ParseError::InputTooLarge - Input exceeds size limit
• ParseError::ParseTimedOut - Parsing exceeded timeout
• ParseError::ParseCancelled - Parsing was cancelled via flag
• ParseError::LanguageSetFailed - Failed to configure parser
• ParseError::TreeSitterFailed - Tree-sitter returned no tree

Performance

Creates a new Parser per call. This is intentional:

• Avoids thread-safety issues with tree-sitter’s state
• Parser creation is cheap (~1µs)
• Timeout/cancellation state is per-parse

Implementation Note

Uses the direct parser.parse() API with set_timeout_micros() instead of parse_with_options() with a chunked callback. The callback-based API has compatibility issues with some grammars (e.g., tree-sitter-groovy on multi- function files). The direct API works universally.

While set_timeout_micros is deprecated in tree-sitter 0.25, it remains functional and provides better grammar compatibility than the callback approach.

Cancellation Limitation

Mid-parse cancellation is not supported with the direct API. Cancellation is checked before and after parsing, but not during. For most source files (which parse in <100ms), this is acceptable. For very large files, the timeout provides protection.

pub fn parse_file( &self, language: &Language, content: &[u8], file: &Path, ) -> Result<Tree, ParseError>

Parse source code with file path context.

Convenience method that always includes file path in errors.

Errors

Same as parse.

pub fn log_config(&self)

Log a summary of the current configuration.

Call this once at startup to record active limits for incident triage.

Trait Implementations

impl Clone for SafeParser

fn clone(&self) -> SafeParser

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SafeParser

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

Formats the value using the given formatter.

impl Default for SafeParser

fn default() -> Self

Returns the “default value” for a type.