Struct PatternMatcher 

pub struct PatternMatcher { /* private fields */ }

Pattern matcher using ast-grep’s metavariable syntax.

Metavariable Syntax

• $NAME - Matches a single node and captures it
• $$$NAME - Matches zero or more nodes (variadic)
• $_ - Matches any single node (anonymous)

Example Patterns

fn $NAME($$$PARAMS) { $$$BODY }     // Match function definition
struct $NAME { $$$FIELDS }           // Match struct definition
$EXPR.clone()                        // Match .clone() calls
OtelExporter::$VARIANT               // Match enum variants

Implementations

impl PatternMatcher

pub fn new(source: &str) -> Self

Create a new pattern matcher for the given source code.

pub fn find_all(&self, pattern: &str) -> Result<Vec<PatternMatch>, AstGrepError>

Find all matches for a pattern.

pub fn find_unique(&self, pattern: &str) -> Result<PatternMatch, AstGrepError>

Find exactly one match for a pattern.

pub fn has_match(&self, pattern: &str) -> bool

Check if a pattern has any matches.

pub fn find_in_range( &self, pattern: &str, start: usize, end: usize, ) -> Result<Vec<PatternMatch>, AstGrepError>

Find matches within a specific byte range (for context constraints).

pub fn find_in_function( &self, pattern: &str, function_name: &str, ) -> Result<Vec<PatternMatch>, AstGrepError>

Find matches that are inside a function with the given name.

pub fn source(&self) -> &str

Get the source code.

pub fn find_by_kind_with_field( &self, kind: &str, field_filter: Option<(&str, &str)>, ) -> Result<Vec<PatternMatch>, AstGrepError>

Find all nodes of a specific kind, optionally filtering by a pattern on a field.

This is useful for constructs that aren’t valid standalone Rust syntax, like match arms (PAT => BODY). Since match arms can’t be parsed in isolation, we find them by kind and optionally filter by matching a pattern against a specific field.

Example

// Find all match arms where the pattern is OtelExporter::Statsig
let arms = matcher.find_by_kind_with_field(
    "match_arm",
    Some(("pattern", "OtelExporter::Statsig")),
)?;

pub fn find_match_arms( &self, pattern: &str, ) -> Result<Vec<PatternMatch>, AstGrepError>

Find match arms by their pattern.

Convenience method for finding match arms since they can’t be matched directly with patterns (not valid standalone Rust syntax).

Example

let arms = matcher.find_match_arms("OtelExporter::Statsig")?;
for arm in arms {
    println!("Found arm: {}", arm.text);
}