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.

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 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.