Struct ParserRegistry 

pub struct ParserRegistry { /* private fields */ }

Registry of all full-AST parsers, keyed by protocol name.

Provides language detection by file extension and dispatches parse/emit operations to the appropriate language parser.

Implementations

impl ParserRegistry

pub fn new() -> Self

Create a new registry populated with all enabled language parsers.

With the grammars feature (default), this populates the registry from panproto-grammars, which provides up to 259 tree-sitter languages. Without the grammars feature, this returns an empty registry; call register to add parsers manually using individual grammar crates.

pub fn register(&mut self, parser: Box<dyn AstParser>)

Register a parser implementation.

In addition to keying the parser by its protocol name, this installs a LayoutEnricher adapter into the global enrichment registry so that a parse_emit_protolens(protocol, …) instantiation finds a synthesis driver without any further wiring.

pub fn register_external_grammar( &mut self, name: &'static str, extensions: Vec<&'static str>, language: Language, node_types_json: &'static [u8], tags_query: Option<&'static str>, grammar_json: Option<&'static [u8]>, ) -> Result<(), ParseError>

Register a tree-sitter language as a full-AST parser.

Used by panproto-grammars-* companion crates that ship grammars outside the default panproto-grammars build. The byte-slice arguments must outlive this registry; the canonical pattern is for the companion to bake the data into &'static rodata at compile time and pass references that are valid for the process lifetime.

walker_config is looked up by name from the bundled per-language configuration table. Languages without a tailored configuration fall back to the default walker config.

Errors

Returns ParseError if theory extraction from node_types_json fails or if the tags query rejects compilation.

pub fn register_external_grammar_owned( &mut self, name: String, extensions: Vec<String>, language: Language, node_types_json: Vec<u8>, tags_query: Option<String>, grammar_json: Option<Vec<u8>>, ) -> Result<(), ParseError>

Owned-data variant of register_external_grammar.

Accepts String / Vec<u8> rather than &'static references. The caller is presumed not to have process-lifetime rodata available (typical dev-time use: bytes read from disk via the Python binding’s override hook). To match the trait’s 'static lifetime requirement the inputs are leaked into the heap; the leak is one-time per override.

This is the registration primitive for grammar-author workflows where a grammar’s parser.c / grammar.json / node-types.json are evolving outside the panproto release cadence. Production builds should continue to use register_external_grammar with 'static data baked into the binary at compile time.

Errors

Returns ParseError if theory extraction or tags-query compilation fails.

pub fn unregister(&mut self, name: &str) -> bool

Remove a registration by protocol name.

Drops the parser and any extension mappings that pointed at it. Returns true if a parser was removed, false if no such registration existed. Primarily intended for grammar-author workflows where a registered grammar is being replaced by a freshly-compiled version mid-process.

pub fn override_grammar( &mut self, name: String, extensions: Vec<String>, language: Language, node_types_json: Vec<u8>, tags_query: Option<String>, grammar_json: Option<Vec<u8>>, ) -> Result<(), ParseError>

Override a registered grammar with new owned data.

Equivalent to unregister followed by register_external_grammar_owned, and intended for the same grammar-author dev workflow. Any extension mappings previously bound to name are replaced by the new extensions.

Errors

Returns ParseError if theory extraction or tags-query compilation fails on the new grammar; in that case the prior registration is already gone.

pub fn detect_language(&self, path: &Path) -> Option<&str>

Detect the language protocol for a file path by its extension.

Returns None if the extension is not recognized (caller should fall back to the raw_file protocol).

pub fn parse_file( &self, path: &Path, content: &[u8], ) -> Result<Schema, ParseError>

Parse a file by detecting its language from the file path.

Errors

Returns ParseError::UnknownLanguage if the file extension is not recognized. Returns other ParseError variants if parsing fails.

pub fn parse_with_protocol( &self, protocol: &str, content: &[u8], file_path: &str, ) -> Result<Schema, ParseError>

Parse source code with a specific protocol name.

Errors

Returns ParseError::UnknownLanguage if the protocol is not registered.

pub fn emit_with_protocol( &self, protocol: &str, schema: &Schema, ) -> Result<Vec<u8>, ParseError>

Emit a schema back to source code bytes using the specified protocol.

Errors

Returns ParseError::UnknownLanguage if the protocol is not registered.

pub fn emit_pretty_with_protocol( &self, protocol: &str, schema: &Schema, ) -> Result<Vec<u8>, ParseError>

Render a by-construction schema using the named protocol.

Errors

Returns ParseError::UnknownLanguage if the protocol is not registered, or ParseError::EmitFailed from the underlying parser’s emit_pretty.

pub fn decorate( &self, protocol: &str, abstract_schema: &AbstractSchema, policy: &LayoutPolicy, ) -> Result<DecoratedSchema, ParseError>

Decorate an AbstractSchema with the layout enrichment fibre required by emit_pretty_with_protocol and friends.

This is the put-direction of the parse / decorate / emit lens at protocol. The implementation routes through the same grammar walker as emit_pretty followed by parse, so the resulting DecoratedSchema carries a complete layout fibre recovered by the parse-side walker — start-byte, end-byte, every interstitial-N, chose-alt-fingerprint, and chose-alt-child-kinds.

The section law holds up to kind- and edge-multiset equivalence: forget_layout(decorate(a)) ≅ a modulo vertex-id renaming. Grammars where parsing consolidates tokens that the emitter rendered as separate sequences (e.g. lilypond’s c'4 re-parses to a single note) do not preserve a one-to-one vertex correspondence, so the result’s vertex IDs are always freshly minted by the parser.

Errors

Returns ParseError::UnknownLanguage when protocol is not registered, ParseError::SchemaConstruction when the abstract schema was built for a different protocol than protocol, ParseError::EmitFailed when the grammar walker cannot render the abstract schema (missing grammar.json, vertex kind not a rule), or any other parser error if the re-parse step rejects the canonical bytes (a regression in the parse/emit pipeline, not a user bug).

pub fn pretty_with_protocol( &self, protocol: &str, abstract_schema: &AbstractSchema, policy: &LayoutPolicy, ) -> Result<Vec<u8>, ParseError>

Render an AbstractSchema to canonical source bytes under policy.

Implementation note: this is exactly the first emit step of decorate — decorate then re-parses to recover the layout fibre, but if all the caller wants is the bytes, the re-parse is wasted work. Going through emit_pretty_with_policy directly preserves every field of policy in the output (separator, newline, indent_width, line_break_after, indent_open / indent_close).

Errors

See decorate.

pub fn parse_emit_protolens( &self, protocol: &str, policy: &LayoutPolicy, ) -> Result<Protolens, ParseError>

Return the canonical Protolens describing the parse / decorate / emit relationship at protocol.

The protolens encodes the schema-level structure of the relationship: source-side strips the layout enrichment fibre, target-side adds it via the registered LayoutEnricher. It composes with the rest of the panproto-lens protolens algebra for chain-law reasoning. The operational entry points for running the relationship on real schemas are decorate, pretty_with_protocol, and emit_pretty_with_protocol.

Errors

Returns ParseError::UnknownLanguage when protocol is not registered.

pub fn theory_meta(&self, protocol: &str) -> Option<&ExtractedTheoryMeta>

Get the theory metadata for a specific protocol.

pub fn protocol_names(&self) -> impl Iterator<Item = &str>

List all registered protocol names.

pub fn has_parser(&self, protocol: &str) -> bool

O(1) lookup: is a parser already registered for protocol?

Useful for dedup at the registration boundary. The umbrella panproto-grammars-all companion pack overlaps with both the built-in core grammars and every per-group pack; callers can short-circuit before re-registering rather than scanning protocol_names() linearly.

pub fn len(&self) -> usize

Get the number of registered parsers.

pub fn is_empty(&self) -> bool

Check if the registry is empty.

Trait Implementations

impl Default for ParserRegistry

fn default() -> Self

Returns the “default value” for a type.