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>>,
}

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.

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.

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.