Skip to main content

draxl_rust/parse/
mod.rs

1mod error;
2mod lexer;
3mod parser;
4mod syntax;
5
6use draxl_ast::{
7    CommentNode, DocNode, Expr, Field, File, Item, MatchArm, Param, Pattern, Stmt, Type, Variant,
8};
9
10pub use error::ParseError;
11
12/// Parses Draxl Rust-profile source into the bootstrap AST.
13pub fn parse_file(source: &str) -> Result<File, ParseError> {
14    let tokens = lexer::lex(source)?;
15    parser::Parser::new(source, tokens).parse_file()
16}
17
18/// Parses a single item fragment for patch resolution.
19pub fn parse_item_fragment(source: &str) -> Result<Item, ParseError> {
20    let tokens = lexer::lex(source)?;
21    parser::Parser::new(source, tokens).parse_item_fragment()
22}
23
24/// Parses a single struct field fragment for patch resolution.
25pub fn parse_field_fragment(source: &str) -> Result<Field, ParseError> {
26    let tokens = lexer::lex(source)?;
27    parser::Parser::new(source, tokens).parse_field_fragment()
28}
29
30/// Parses a single enum variant fragment for patch resolution.
31pub fn parse_variant_fragment(source: &str) -> Result<Variant, ParseError> {
32    let tokens = lexer::lex(source)?;
33    parser::Parser::new(source, tokens).parse_variant_fragment()
34}
35
36/// Parses a single function parameter fragment for patch resolution.
37pub fn parse_param_fragment(source: &str) -> Result<Param, ParseError> {
38    let tokens = lexer::lex(source)?;
39    parser::Parser::new(source, tokens).parse_param_fragment()
40}
41
42/// Parses a single statement fragment for patch resolution.
43pub fn parse_stmt_fragment(source: &str) -> Result<Stmt, ParseError> {
44    let tokens = lexer::lex(source)?;
45    parser::Parser::new(source, tokens).parse_stmt_fragment()
46}
47
48/// Parses a single match arm fragment for patch resolution.
49pub fn parse_match_arm_fragment(source: &str) -> Result<MatchArm, ParseError> {
50    let tokens = lexer::lex(source)?;
51    parser::Parser::new(source, tokens).parse_match_arm_fragment()
52}
53
54/// Parses a single expression fragment for patch resolution.
55pub fn parse_expr_fragment(source: &str) -> Result<Expr, ParseError> {
56    let tokens = lexer::lex(source)?;
57    parser::Parser::new(source, tokens).parse_expr_fragment()
58}
59
60/// Parses a single type fragment for patch resolution.
61pub fn parse_type_fragment(source: &str) -> Result<Type, ParseError> {
62    let tokens = lexer::lex(source)?;
63    parser::Parser::new(source, tokens).parse_type_fragment()
64}
65
66/// Parses a single pattern fragment for patch resolution.
67pub fn parse_pattern_fragment(source: &str) -> Result<Pattern, ParseError> {
68    let tokens = lexer::lex(source)?;
69    parser::Parser::new(source, tokens).parse_pattern_fragment()
70}
71
72/// Parses a single doc comment fragment for patch resolution.
73pub fn parse_doc_fragment(source: &str) -> Result<DocNode, ParseError> {
74    let tokens = lexer::lex(source)?;
75    parser::Parser::new(source, tokens).parse_doc_fragment()
76}
77
78/// Parses a single line comment fragment for patch resolution.
79pub fn parse_comment_fragment(source: &str) -> Result<CommentNode, ParseError> {
80    let tokens = lexer::lex(source)?;
81    parser::Parser::new(source, tokens).parse_comment_fragment()
82}