rantlr-core 0.2.0

Rantlr core: .gr lexer, parser, linter, and in-process runtime
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

//! # rantlr-core
//!
//! Architecture
//!
//! ```text
//!  .gr source
//!       │
//!       ▼
//!  ┌─────────┐    Token stream + Spans     ┌──────────┐
//!  │  Lexer  │ ──────────────────────────► │  Parser  │
//!  └─────────┘                             └────┬─────┘
//!                                               │
//!                                               ▼
//!                                         ┌──────────┐
//!                                         │   AST    │  Grammar / Rule / TokenDecl
//!                                         └────┬─────┘
//!                          ┌───────────────────┼───────────────────┐
//!                          ▼                   ▼                   ▼
//!                     ┌────────┐         ┌──────────┐        ┌──────────┐
//!                     │ Linter │         │ rantlr-gen│       │ runtime  │
//!                     └────────┘         └──────────┘        └──────────┘
//! ```
//!
//! Design choices:
//! - Hand-written lexer + recursive-descent parser for clear diagnostics / auto-fixes.
//! - Keywords over operators: `rule`, `token`, `match`, `repeat`, `optional`.
//! - `repeat` / `optional` are first-class AST nodes (not desugared away).
//! - Built-in types (`Number`, `QuotedString`, …) are recognized as dedicated tokens.

pub mod ast;
pub mod diagnostic;
pub mod error;
pub mod fix_hint;
pub mod lexer;
pub mod linter;
pub mod parser;
pub mod rule_graph;
pub mod runtime;
pub mod span;
pub mod token;

pub use ast::{
    ExampleDecl, Expr, Grammar, GrammarItem, ImportDecl, RuleDecl, TokenBody, TokenDecl,
};
pub use diagnostic::{Diagnostic, DiagnosticKind, Severity};
pub use error::{ErrorKind, RantlrError};
pub use fix_hint::FixHint;
pub use lexer::{lex, Lexer, LexerError};
pub use linter::{lint, lint_all};
pub use parser::parse;
pub use rule_graph::{rule_graph, RuleEdge, RuleGraph, RuleNode};
pub use runtime::{
    analyze_and_parse, diagnose, parse_input, AnalyzeResult, DiagnosticJson, ParseTree,
};
pub use span::{BytePos, Span};
pub use token::{BuiltinType, Keyword, Token, TokenKind};

/// Parse a `.gr` grammar and run the smart linter.
pub fn analyze(source: &str) -> Result<Grammar, RantlrError> {
    let grammar = parse(source)?;
    lint(source, &grammar)?;
    Ok(grammar)
}