Struct KindMatcher 

pub struct KindMatcher { /* private fields */ }

Matcher that finds AST nodes based on their syntactic type (kind).

KindMatcher is the simplest type of matcher - it matches nodes whose type matches a specific string. Every AST node has a “kind” that describes what syntax element it represents.

Examples

// Match all function declarations
let matcher = KindMatcher::new("function_declaration", &language);
let functions: Vec<_> = root.find_all(&matcher).collect();

// Match all identifiers
let id_matcher = KindMatcher::new("identifier", &language);
let identifiers: Vec<_> = root.find_all(&id_matcher).collect();

// Find syntax errors in code
let error_matcher = KindMatcher::error_matcher();
let errors: Vec<_> = root.find_all(&error_matcher).collect();

Common Node Kinds

The exact node kinds depend on the language, but common examples include:

• "function_declaration" - Function definitions
• "identifier" - Variable/function names
• "string_literal" - String values
• "number" - Numeric literals
• "ERROR" - Syntax errors

Implementations

impl KindMatcher

pub fn new<L: Language>(node_kind: &str, lang: &L) -> Self

pub fn try_new<L: Language>( node_kind: &str, lang: &L, ) -> Result<Self, KindMatcherError>

pub const fn from_id(kind: u16) -> Self

pub const fn is_invalid(&self) -> bool

Whether the kind matcher contains undefined tree-sitter kind.

pub const fn error_matcher() -> Self

Construct a matcher that only matches ERROR

Trait Implementations

impl Clone for KindMatcher

fn clone(&self) -> KindMatcher

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KindMatcher

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

Formats the value using the given formatter.

impl Matcher for KindMatcher

fn match_node_with_env<'tree, D: Doc>( &self, node: Node<'tree, D>, _env: &mut Cow<'_, MetaVarEnv<'tree, D>>, ) -> Option<Node<'tree, D>>

Attempt to match a node, updating the meta-variable environment.

fn potential_kinds(&self) -> Option<BitSet>

Provide a hint about which node types this matcher can match.

fn get_match_len<D: Doc>(&self, _node: Node<'_, D>) -> Option<usize>

Determine how much of a matched node should be replaced.