Struct Grammar 

#[non_exhaustive]
pub struct Grammar {
    pub name: String,
    pub rules: BTreeMap<String, Production>,
    pub supertypes: HashSet<String>,
    pub extras: HashSet<String>,
    pub subtypes: HashMap<String, HashSet<String>>,
    pub yield_sets: HashMap<String, HashSet<String>>,
    pub node_type_children: HashMap<String, HashSet<String>>,
    pub external_alias_map: HashMap<String, String>,
    pub inline_brace_rules: HashSet<String>,
}

A grammar’s production-rule table, deserialized from grammar.json.

Only the fields the emitter consumes are decoded; precedences, conflicts, externals, and other parser-only metadata are ignored.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

name: String

Grammar name (e.g. "rust", "typescript").

rules: BTreeMap<String, Production>

Map from rule name (a vertex kind on the schema side) to production. Entries are kept in lexical order so iteration is deterministic.

supertypes: HashSet<String>

Supertypes declared in the grammar’s supertypes field. A supertype is a rule whose body is a CHOICE of SYMBOL references; tree-sitter parsers report a node’s kind as one of the subtypes (e.g. identifier, typed_parameter) rather than the supertype name (parameter), so the emitter needs to know that a child kind in a subtype set should match the supertype name when a SYMBOL references it.

extras: HashSet<String>

Tree-sitter extras rules: the named symbols (typically comments) that tree-sitter skips at parse time but records as children of the surrounding vertex. They appear nowhere in the production grammar, so the rule walker cannot reconcile them against the cursor — the emit pass therefore drains them as a side channel: at vertex entry and between REPEAT iterations any leading extras-kind edges are consumed and emitted directly. The set is populated at Grammar::from_bytes by collecting every SYMBOL { name } and named ALIAS { value, named: true } under the top-level extras array. Pattern-only extras (e.g. \s whitespace) are not vertex kinds and are excluded.

subtypes: HashMap<String, HashSet<String>>

Precomputed subtyping closure: subtypes[symbol_name] is the set of vertex kinds that satisfy a SYMBOL symbol_name reference on the schema side.

Built once at Grammar::from_bytes time by walking each hidden rule (_-prefixed), declared supertype, and named ALIAS { value: K, ... } production to its leaf SYMBOLs and recording the closure. This replaces the prior heuristic kind_satisfies_symbol that walked the rule body on every query: lookups are now O(1) and the relation is exactly the transitive closure of “is reachable via hidden / supertype / alias dispatch”, with no over-expansion through non-hidden non-supertype rule references.

yield_sets: HashMap<String, HashSet<String>>

Precomputed Yield sets: yield_sets[rule_name] is the set of concrete vertex kinds that can appear as the first named child when that rule’s production is taken.

Defined inductively:

• Yield(SYMBOL S) where S is hidden/supertype = Yield(rules[S])
• Yield(SYMBOL S) where S is concrete = {S}
• Yield(SEQ [M1, ...]) = Yield(M1) (only first member)
• Yield(CHOICE [M1, ..., Mn]) = ⋃ Yield(Mi)
• Yield(OPTIONAL { c }) = Yield(c) ∪ {ε}
• Yield(BLANK) = {ε}
• Wrappers (PREC*, TOKEN, FIELD, REPEAT, etc.) = Yield(content)
• Yield(STRING) = Yield(PATTERN) = ∅
• Yield(ALIAS { value: V, named: true }) = {V}

Epsilon is represented as the empty string "".

node_type_children: HashMap<String, HashSet<String>>

Child kinds allowed per parent kind, derived from node-types.json. Maps parent kind to the set of ALL named child kinds that tree-sitter’s parser can produce for that parent (from both children.types and fields.*.types). Used by augment_subtypes_from_node_types to close the grammar/parser divergence gap.

external_alias_map: HashMap<String, String>

Anonymous ALIAS values for external scanner tokens. Maps external symbol name (e.g. _ternary_qmark) to the ALIAS value string (e.g. "?"). Built by scanning grammar.json rule bodies for ALIAS { content: SYMBOL S, named: false, value: V } where S has no grammar rule.

inline_brace_rules: HashSet<String>

Rules whose {/} STRING tokens are inline delimiters (e.g. string interpolation) rather than block scopes. Identified structurally: a rule whose SEQ contains { and } but no REPEAT/REPEAT1 between them.

Implementations

impl Grammar

pub fn from_bytes(protocol: &str, bytes: &[u8]) -> Result<Self, ParseError>

Parse a grammar’s grammar.json bytes.

Builds the subtyping closure as part of construction so every downstream lookup is O(1). The closure is the least relation containing (K, K) for every rule key K and closed under:

• hidden-rule expansion: if S is hidden and a SYMBOL S may reach SYMBOL K, then K ⊑ S.
• supertype expansion: if S is in the grammar’s supertypes block and K is one of S’s alternatives, then K ⊑ S.
• alias renaming: if a rule body contains ALIAS { content: SYMBOL R, value: A, named: true } where R reaches kind K (or K = R when no further hop), then A ⊑ R and K ⊑ A.

Errors

Returns ParseError::EmitFailed when the bytes are not a valid grammar.json document.

pub fn from_bytes_with_node_types( protocol: &str, grammar_bytes: &[u8], node_types_bytes: Option<&[u8]>, ) -> Result<Self, ParseError>

Parse a grammar from both grammar.json and optionally node-types.json bytes.

Errors

Returns ParseError::EmitFailed when grammar_bytes is not a valid grammar.json document.

Trait Implementations

impl Clone for Grammar

fn clone(&self) -> Grammar

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Grammar

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Grammar

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.