Struct RecursionLimits 

pub struct RecursionLimits {
    pub file_ops_depth: usize,
    pub expr_depth: usize,
    pub expr_fuel: usize,
}

Recursion limits configuration

Controls maximum depth for recursive operations to prevent stack overflow from pathological inputs (deeply nested AST structures, complex expressions).

Fields

file_ops_depth: usize

Maximum depth for file operation recursion (AST traversal, directory walking)

Controls how deep the AST traversal can go when processing source files. This prevents stack overflow from pathological code like:

fn f0() { fn f1() { fn f2() { ... fn f1000() {} ... } } }

Validation

• Minimum: 50 (must handle moderately nested code)
• Maximum: 150 (recommended for deeply nested code)
• Hard cap: 200 (absolute maximum, NON-NEGOTIABLE security constraint)

Environment Override

Can be overridden with SQRY_RECURSION_FILE_OPS_DEPTH environment variable.

expr_depth: usize

Maximum depth for expression evaluation (query expressions, AST patterns)

Controls how deep expression trees can be when evaluating queries. This prevents stack overflow from complex nested boolean expressions:

(((((a AND b) OR c) AND d) OR e) AND ...)

Validation

• Minimum: 10 (must handle basic expressions)
• Maximum: 100 (recommended)
• Hard cap: 200 (absolute maximum, security constraint)

Environment Override

Can be overridden with SQRY_RECURSION_EXPR_DEPTH environment variable.

expr_fuel: usize

Fuel limit for expression evaluation (operation counter)

Alternative to depth limiting using an operation counter (“fuel”). Each recursive call consumes fuel, preventing both deep and wide recursion patterns.

Validation

• Minimum: 100 (must handle basic queries)
• Maximum: 5000 (recommended)
• Hard cap: 10,000 (absolute maximum, NON-NEGOTIABLE security constraint)

Environment Override

Can be overridden with SQRY_RECURSION_EXPR_FUEL environment variable.

Implementations

impl RecursionLimits

pub const MIN_FILE_OPS_DEPTH: usize = 50

Minimum allowed file ops depth

pub const MAX_FILE_OPS_DEPTH: usize = 150

Maximum recommended file ops depth

pub const ABSOLUTE_MAX_FILE_OPS_DEPTH: usize = 200

Absolute hard cap for file ops depth (NON-NEGOTIABLE)

Set to 200 (2x default) to handle legitimate deep directory structures while preventing resource exhaustion. This limit has been security-reviewed and balances usability with protection against stack overflow attacks.

pub const MIN_EXPR_DEPTH: usize = 10

Minimum allowed expression depth

pub const MAX_EXPR_DEPTH: usize = 100

Maximum recommended expression depth

pub const ABSOLUTE_MAX_EXPR_DEPTH: usize = 200

Absolute hard cap for expression depth

pub const MIN_EXPR_FUEL: usize = 100

Minimum allowed expression fuel

pub const MAX_EXPR_FUEL: usize = 5_000

Maximum recommended expression fuel

pub const ABSOLUTE_MAX_EXPR_FUEL: usize = 10_000

Absolute hard cap for expression fuel (NON-NEGOTIABLE)

Set to 10,000 to prevent expression bombs (deeply nested operators) from causing stack overflows during query validation and normalization. This limit has been security-reviewed and prevents resource exhaustion attacks.

pub fn new( file_ops_depth: usize, expr_depth: usize, expr_fuel: usize, ) -> Result<Self>

Create a new recursion limits configuration with custom values

Errors

Returns an error if the provided values violate safety constraints (e.g., values are below minimum thresholds or exceed maximum limits).

pub fn load_or_default() -> Result<Self>

Load configuration with environment variable overrides

Errors

Returns an error if environment variables contain invalid values or if the resulting configuration violates safety constraints.

pub fn effective_file_ops_depth(&self) -> Result<usize>

Get effective file ops depth with validation

Errors

Returns an error if the configured value is 0 (unlimited not allowed), below the minimum threshold, or exceeds the absolute maximum limit.

pub fn effective_expr_depth(&self) -> Result<usize>

Get effective expression depth with validation

Errors

Returns an error if the configured value is 0 (unlimited not allowed), below the minimum threshold, or exceeds the absolute maximum limit.

pub fn effective_expr_fuel(&self) -> Result<usize>

Get effective expression fuel with validation

Errors

Returns an error if the configured value is 0 (unlimited not allowed), below the minimum threshold, or exceeds the absolute maximum limit.

Trait Implementations

impl Clone for RecursionLimits

fn clone(&self) -> RecursionLimits

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RecursionLimits

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

Formats the value using the given formatter.

impl Default for RecursionLimits

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RecursionLimits

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for RecursionLimits

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.