Struct Pattern 

pub struct Pattern {
    pub node: PatternNode,
    pub strictness: MatchStrictness,
    /* private fields */
}

Structural pattern for matching AST nodes based on their shape and content.

Patterns represent code structures with support for meta-variables (like $VAR) that can capture parts of the matched code. They’re built from source code strings and compiled into efficient matching structures.

Example

// Pattern for variable declarations
let pattern = Pattern::new("let $NAME = $VALUE", language);

// Can match: "let x = 42", "let result = calculate()", etc.

Fields

node: PatternNode

The root pattern node containing the matching logic

strictness: MatchStrictness

How strictly the pattern should match

Implementations

impl Pattern

pub const fn has_error(&self) -> bool

pub fn fixed_string(&self) -> Cow<'_, str>

pub fn defined_vars(&self) -> RapidSet<&str>

Get all defined variables in the pattern. Used for validating rules and report undefined variables.

impl Pattern

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

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

pub const fn with_strictness(self, strictness: MatchStrictness) -> Self

pub fn contextual<L: Language>( context: &str, selector: &str, lang: &L, ) -> Result<Self, PatternError>

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Pattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Pattern

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

Formats the value using the given formatter.

impl<'r, D: Doc> From<Node<'r, D>> for Pattern

fn from(node: Node<'r, D>) -> Self

Converts to this type from the input type.

impl Matcher for Pattern

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.