rusty-javac 0.2.2

A Java compiler written in Rust.
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use crate::parser::{JavaSyntaxKind, Parser};

pub(crate) fn type_(p: &mut Parser) {
    use JavaSyntaxKind::*;
    let m = p.start();
    type_base(p);
    while p.at(LBrack) {
        p.bump();
        p.expect(RBrack);
    }
    m.complete(p, Type);
}

pub(crate) fn type_no_array(p: &mut Parser) {
    use JavaSyntaxKind::*;
    let m = p.start();
    type_base(p);
    m.complete(p, Type);
}

fn type_base(p: &mut Parser) {
    use JavaSyntaxKind::*;
    if p.at(VarKw) {
        p.bump();
    } else if p.at_any(&[
        IntKw, LongKw, ShortKw, ByteKw, CharKw, FloatKw, DoubleKw, BooleanKw, VoidKw,
    ]) {
        let pm = p.start();
        p.bump();
        pm.complete(p, PrimitiveType);
    } else {
        class_type(p);
    }
}

pub(crate) fn class_type(p: &mut Parser) {
    use JavaSyntaxKind::*;
    let m = p.start();
    p.expect(Ident);
    if p.at(Lt) {
        type_arg_list(p);
    }
    while p.eat(Dot) {
        let sm = p.start();
        p.expect(Ident);
        if p.at(Lt) {
            type_arg_list(p);
        }
        sm.complete(p, ClassTypeSegment);
    }
    m.complete(p, ClassType);
}

pub(crate) fn type_arg_list(p: &mut Parser) {
    use JavaSyntaxKind::*;
    let m = p.start();
    p.expect(Lt);
    while !p.at(Gt) && p.kind() != Error {
        if p.at(Question) {
            let wm = p.start();
            p.bump();
            if p.eat(ExtendsKw) || p.eat(SuperKw) {
                type_(p);
            }
            wm.complete(p, WildcardType);
        } else {
            type_(p);
        }
        if !p.eat(Comma) {
            break;
        }
    }
    p.expect(Gt);
    m.complete(p, TypeArgList);
}

pub(crate) fn type_param_list(p: &mut Parser) {
    use JavaSyntaxKind::*;
    let m = p.start();
    p.expect(Lt);
    while !p.at(Gt) && p.kind() != Error {
        let pm = p.start();
        p.expect(Ident);
        if p.eat(ExtendsKw) {
            let bm = p.start();
            type_list(p);
            bm.complete(p, TypeBound);
        }
        pm.complete(p, TypeParam);
        if !p.eat(Comma) {
            break;
        }
    }
    p.expect(Gt);
    m.complete(p, TypeParamList);
}

pub(crate) fn type_list(p: &mut Parser) {
    type_(p);
    while p.eat(JavaSyntaxKind::Comma) {
        type_(p);
    }
}