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
104
105

use crate::ty::Ty;
use ustr::Ustr;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TypeError {
    IncompatibleTypes { expected: Ty, found: Ty },
    NotAccessible { name: Ustr },
    NotAssignable { from: Ty, to: Ty },
    Ambiguous { name: Ustr },
    NotFound { name: Ustr },
}

pub fn is_assignable(from: &Ty, to: &Ty) -> bool {
    if from == to {
        return true;
    }
    let from_erased = from.erasure();
    let to_erased = to.erasure();
    if from_erased == to_erased {
        return true;
    }
    if is_widening_primitive(&from_erased, &to_erased) {
        return true;
    }
    false
}

fn is_widening_primitive(from: &Ty, to: &Ty) -> bool {
    matches!(
        (from, to),
        (
            Ty::Byte,
            Ty::Short | Ty::Int | Ty::Long | Ty::Float | Ty::Double
        ) | (Ty::Short, Ty::Int | Ty::Long | Ty::Float | Ty::Double)
            | (Ty::Char, Ty::Int | Ty::Long | Ty::Float | Ty::Double)
            | (Ty::Int, Ty::Long | Ty::Float | Ty::Double)
            | (Ty::Long, Ty::Float | Ty::Double)
            | (Ty::Float, Ty::Double)
    )
}

pub fn is_narrowing_primitive(from: &Ty, to: &Ty) -> bool {
    matches!(
        (from, to),
        (Ty::Short, Ty::Byte | Ty::Char)
            | (Ty::Char, Ty::Byte | Ty::Short)
            | (Ty::Int, Ty::Byte | Ty::Short | Ty::Char)
            | (Ty::Long, Ty::Byte | Ty::Short | Ty::Char | Ty::Int)
            | (
                Ty::Float,
                Ty::Byte | Ty::Short | Ty::Char | Ty::Int | Ty::Long
            )
            | (
                Ty::Double,
                Ty::Byte | Ty::Short | Ty::Char | Ty::Int | Ty::Long | Ty::Float
            )
    )
}

pub fn unboxing_type(ty: &Ty) -> Option<Ty> {
    match ty {
        Ty::Class(name) => match name.as_str() {
            "java/lang/Boolean" => Some(Ty::Boolean),
            "java/lang/Byte" => Some(Ty::Byte),
            "java/lang/Character" => Some(Ty::Char),
            "java/lang/Short" => Some(Ty::Short),
            "java/lang/Integer" => Some(Ty::Int),
            "java/lang/Long" => Some(Ty::Long),
            "java/lang/Float" => Some(Ty::Float),
            "java/lang/Double" => Some(Ty::Double),
            _ => None,
        },
        _ => None,
    }
}

pub fn boxing_type(ty: &Ty) -> Option<Ty> {
    match ty {
        Ty::Boolean => Some(Ty::Class(Ustr::from("java/lang/Boolean"))),
        Ty::Byte => Some(Ty::Class(Ustr::from("java/lang/Byte"))),
        Ty::Char => Some(Ty::Class(Ustr::from("java/lang/Character"))),
        Ty::Short => Some(Ty::Class(Ustr::from("java/lang/Short"))),
        Ty::Int => Some(Ty::Class(Ustr::from("java/lang/Integer"))),
        Ty::Long => Some(Ty::Class(Ustr::from("java/lang/Long"))),
        Ty::Float => Some(Ty::Class(Ustr::from("java/lang/Float"))),
        Ty::Double => Some(Ty::Class(Ustr::from("java/lang/Double"))),
        _ => None,
    }
}

pub fn numeric_promotion(left: &Ty, right: &Ty) -> Option<Ty> {
    if !left.is_numeric() || !right.is_numeric() {
        return None;
    }
    if left == &Ty::Double || right == &Ty::Double {
        return Some(Ty::Double);
    }
    if left == &Ty::Float || right == &Ty::Float {
        return Some(Ty::Float);
    }
    if left == &Ty::Long || right == &Ty::Long {
        return Some(Ty::Long);
    }
    Some(Ty::Int)
}