Struct SerializableRule 

pub struct SerializableRule {

    pub pattern: Maybe<PatternStyle>,
    pub kind: Maybe<String>,
    pub regex: Maybe<String>,
    pub nth_child: Maybe<SerializableNthChild>,
    pub range: Maybe<SerializableRange>,
    pub inside: Maybe<Box<Relation>>,
    pub has: Maybe<Box<Relation>>,
    pub precedes: Maybe<Box<Relation>>,
    pub follows: Maybe<Box<Relation>>,
    pub all: Maybe<Vec<SerializableRule>>,
    pub any: Maybe<Vec<SerializableRule>>,
    pub not: Maybe<Box<SerializableRule>>,
    pub matches: Maybe<SerializableMatches>,
}

A rule object to find matching AST nodes. We have three categories of rules in ast-grep.

• Atomic: the most basic rule to match AST. We have two variants: Pattern and Kind.

• Relational: filter matched target according to their position relative to other nodes.

• Composite: use logic operation all/any/not to compose the above rules to larger rules.

Every rule has it’s unique name so we can combine several rules in one object.

Fields

pattern: Maybe<PatternStyle>

A pattern string or a pattern object.

kind: Maybe<String>

The kind name of the node to match. You can look up code’s kind names in playground.

regex: Maybe<String>

A Rust regular expression to match the node’s text. https://docs.rs/regex/latest/regex/#syntax

nth_child: Maybe<SerializableNthChild>

nth_child accepts number, string or object. It specifies the position in nodes’ sibling list.

range: Maybe<SerializableRange>

range accepts a range object. the target node must exactly appear in the range.

inside: Maybe<Box<Relation>>

inside accepts a relational rule object. the target node must appear inside of another node matching the inside sub-rule.

has: Maybe<Box<Relation>>

has accepts a relational rule object. the target node must has a descendant node matching the has sub-rule.

precedes: Maybe<Box<Relation>>

precedes accepts a relational rule object. the target node must appear before another node matching the precedes sub-rule.

follows: Maybe<Box<Relation>>

follows accepts a relational rule object. the target node must appear after another node matching the follows sub-rule.

all: Maybe<Vec<SerializableRule>>

A list of sub rules and matches a node if all of sub rules match. The meta variables of the matched node contain all variables from the sub-rules.

any: Maybe<Vec<SerializableRule>>

A list of sub rules and matches a node if any of sub rules match. The meta variables of the matched node only contain those of the matched sub-rule.

not: Maybe<Box<SerializableRule>>

A single sub-rule and matches a node if the sub rule does not match.

matches: Maybe<SerializableMatches>

A utility rule id or parameterized utility call object. When multiple utility calls are present, they are combined with logical all.

Trait Implementations

impl Clone for SerializableRule

fn clone(&self) -> SerializableRule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for SerializableRule

fn default() -> SerializableRule

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SerializableRule

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for SerializableRule

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for SerializableRule

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

where __S: Serializer,

Serialize this value into the given Serde serializer.