ergoscript-compiler 0.24.0

Compiler for ErgoScript
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
106
107

use rowan::TextRange;

use crate::error::pretty_error_desc;
use crate::hir;
use crate::hir::Binary;
use crate::hir::Expr;
use crate::hir::ExprKind;

#[derive(Debug, PartialEq, Eq)]
pub struct TypeInferenceError {
    msg: String,
    span: TextRange,
}

impl TypeInferenceError {
    pub fn new(msg: String, span: TextRange) -> Self {
        Self { msg, span }
    }

    pub fn pretty_desc(&self, source: &str) -> String {
        pretty_error_desc(source, self.span, &self.msg)
    }
}

pub fn assign_type(expr: Expr) -> Result<Expr, TypeInferenceError> {
    hir::rewrite(expr, |e| {
        Ok(match &e.kind {
            ExprKind::Binary(Binary { op, lhs, rhs }) => match op.node {
                hir::BinaryOp::Plus => {
                    let l = assign_type(*lhs.clone())?;
                    let r = assign_type(*rhs.clone())?;
                    let tpe = l.tpe.clone();
                    Some(Expr {
                        kind: Binary {
                            op: op.clone(),
                            lhs: l.into(),
                            rhs: r.into(),
                        }
                        .into(),
                        span: e.span,
                        tpe,
                    })
                }
                _ => todo!(),
            },
            _ => None,
        })
    })
}

#[cfg(test)]
pub fn check(input: &str, expected_tree: expect_test::Expect) {
    let parse = super::parser::parse(input);
    let syntax = parse.syntax();
    let root = crate::ast::Root::cast(syntax).unwrap();
    let hir = hir::lower(root).unwrap();
    let binder = crate::binder::Binder::new(crate::script_env::ScriptEnv::new());
    let bind = binder.bind(hir).unwrap();
    let res = assign_type(bind).unwrap();
    expected_tree.assert_eq(&res.debug_tree());
}

#[cfg(test)]
mod tests {
    use super::*;
    use expect_test::expect;

    #[test]
    fn bin_smoke() {
        check(
            "HEIGHT + HEIGHT",
            expect![[r#"
            Expr {
                kind: Binary(
                    Binary {
                        op: Spanned {
                            node: Plus,
                            span: 7..8,
                        },
                        lhs: Expr {
                            kind: GlobalVars(
                                Height,
                            ),
                            span: 0..7,
                            tpe: Some(
                                SInt,
                            ),
                        },
                        rhs: Expr {
                            kind: GlobalVars(
                                Height,
                            ),
                            span: 9..15,
                            tpe: Some(
                                SInt,
                            ),
                        },
                    },
                ),
                span: 0..15,
                tpe: Some(
                    SInt,
                ),
            }"#]],
        );
    }
}