Struct RuleNode 

pub struct RuleNode {

    pub pattern: Option<String>,
    pub kind: Option<String>,
    pub regex: Option<String>,
    pub inside: Option<Box<RuleNode>>,
    pub has: Option<Box<RuleNode>>,
    pub follows: Option<Box<RuleNode>>,
    pub precedes: Option<Box<RuleNode>>,
    pub stop_by: Option<StopBy>,
    pub field: Option<String>,
    pub all: Option<Vec<RuleNode>>,
    pub any: Option<Vec<RuleNode>>,
    pub not: Option<Box<RuleNode>>,
    pub matches: Option<String>,
}

The atomic-tier matcher. Exactly one of pattern / kind / regex must be set on a node that carries one; RuleNode::atomic resolves it.

A RuleNode is the recursive matching algebra: an optional atomic leaf (pattern / kind / regex), relational constraints (inside / has / follows / precedes, each a sub-node tuned by stop_by / field), and composite combinators (all / any / not / matches). Every key set on a node is ANDed: the node matches a tree-sitter node iff its atomic part matches and every relational and composite part holds.

Fields

pattern: Option<String>

A code snippet in the target grammar with $VAR metavariable holes.

kind: Option<String>

A bare tree-sitter node kind (e.g. "call_expression").

regex: Option<String>

A regular expression matched against node text.

inside: Option<Box<RuleNode>>

The node must be inside a node matching this sub-rule (ancestor).

has: Option<Box<RuleNode>>

The node must have a descendant matching this sub-rule.

follows: Option<Box<RuleNode>>

The node must follow a node matching this sub-rule (earlier).

precedes: Option<Box<RuleNode>>

The node must precede a node matching this sub-rule (later).

stop_by: Option<StopBy>

Relational reach (used when this node is an inside/has/… target): neighbor (direct only, default), end (transitive), or a rule that halts the walk. (TOML stopBy or stop_by.)

field: Option<String>

Restrict an inside/has relation to a specific tree-sitter field.

all: Option<Vec<RuleNode>>

Every sub-rule must match the node.

any: Option<Vec<RuleNode>>

At least one sub-rule must match the node.

not: Option<Box<RuleNode>>

The sub-rule must NOT match the node.

matches: Option<String>

Reference a utility rule by id (resolved from [utils]).

Implementations

impl RuleNode

pub fn atomic(&self) -> Result<Option<AtomicMatcher>, String>

Resolve this node’s atomic leaf. Ok(None) when the node is purely relational/composite; Err when more than one atomic key is set.

pub fn is_pure_regex(&self) -> bool

True when regex is the only key set — a top-level grep-style rule that scans source text rather than the tree.

pub fn is_empty(&self) -> bool

True when the node sets no matching keys at all (an empty node, which is a rule authoring error).

Trait Implementations

impl Clone for RuleNode

fn clone(&self) -> RuleNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RuleNode

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

Formats the value using the given formatter.

impl Default for RuleNode

fn default() -> RuleNode

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RuleNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.