kotlin_parser/parse/declaration/
mod.rs

1pub mod annotation;
2pub mod constructor;
3pub mod entity;
4pub mod enum_entry;
5pub mod function;
6pub mod init;
7pub mod property;
8pub mod typealias;
9
10use crate::ast::*;
11use annotation::annotations_parser;
12use chumsky::prelude::*;
13use constructor::constructor_parser;
14use entity::entity_parser;
15use enum_entry::enum_entry_parser;
16use function::function_parser;
17use init::init_block_parser;
18use property::property_parser;
19use typealias::typealias_parser;
20
21use super::expression::expression_parser;
22
23pub fn declaration_parser<'a>(
24    stmt_parser: impl Parser<char, Statement, Error = Simple<char>> + Clone + 'a,
25) -> impl Parser<char, Declaration, Error = Simple<char>> + 'a {
26    let expr_parser = expression_parser(stmt_parser.clone()).boxed();
27    recursive(|decl| {
28        annotations_parser(expr_parser.clone())
29            .repeated()
30            .or_not()
31            .then(choice((
32                function_parser(stmt_parser.clone(), expr_parser.clone())
33                    .map(DeclarationKind::Function),
34                enum_entry_parser(decl.clone(), expr_parser.clone())
35                    .map(DeclarationKind::EnumEntry),
36                init_block_parser(stmt_parser.clone())
37                    .map(DeclarationKind::InitBlock),
38                entity_parser(stmt_parser.clone(), expr_parser.clone())
39                    .map(DeclarationKind::Entity),
40                constructor_parser(stmt_parser.clone(), expr_parser.clone())
41                    .map(DeclarationKind::Constructor),
42                typealias_parser(expr_parser.clone())
43                    .map(DeclarationKind::TypeAlias),
44                property_parser(stmt_parser.clone(), expr_parser.clone())
45                    .map(DeclarationKind::Property),
46            )))
47            .map(|(annotations, kind)| Declaration {
48                annotations: annotations.unwrap_or_default(),
49                kind,
50            })
51    })
52}
53
54pub fn modifier_parser() -> impl Parser<char, Modifier, Error = Simple<char>> {
55    choice((
56        just("public").to(Modifier::Public),
57        just("internal").to(Modifier::Internal),
58        just("private").to(Modifier::Private),
59        just("protected").to(Modifier::Protected),
60    ))
61    .or(choice((
62        just("abstract").to(Modifier::Abstract),
63        just("final").to(Modifier::Final),
64        just("open").to(Modifier::Open),
65        just("annotation").to(Modifier::Annotation),
66        just("sealed").to(Modifier::Sealed),
67        just("data").to(Modifier::Data),
68        just("override").to(Modifier::Override),
69        just("lateinit").to(Modifier::Lateinit),
70        just("inner").to(Modifier::Inner),
71        just("in").to(Modifier::In),
72        just("out").to(Modifier::Out),
73        just("noinline").to(Modifier::NoInline),
74        just("crossinline").to(Modifier::CrossInline),
75        just("vararg").to(Modifier::Vararg),
76        just("reified").to(Modifier::Reified),
77        just("tailrec").to(Modifier::Tailrec),
78        just("operator").to(Modifier::Operator),
79        just("infix").to(Modifier::Infix),
80        just("inline").to(Modifier::Inline),
81        just("external").to(Modifier::External),
82        just("suspend").to(Modifier::Suspend),
83        just("const").to(Modifier::Const),
84        just("actual").to(Modifier::Actual),
85        just("expect").to(Modifier::Expect),
86    )))
87    .padded()
88}