geam 0.1.1

Experimental Rust-embedded execution runtime for typed Gleam programs
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
108
109
110
111
112
113

use crate::plan::{BoolExpr, Expr};
use crate::planner::context::PlanContext;
use crate::planner::error::PlanError;
use gleam_core::ast::TypedExpr;

pub(super) fn equal(
    left: TypedExpr,
    right: TypedExpr,
    context: &mut PlanContext<'_>,
) -> Result<Expr, PlanError> {
    let left = super::super::plan_expr(left, context)?;
    let right = super::super::plan_expr(right, context)?;
    Ok(Expr::bool(BoolExpr::equal(left, right)))
}

pub(super) fn not_equal(
    left: TypedExpr,
    right: TypedExpr,
    context: &mut PlanContext<'_>,
) -> Result<Expr, PlanError> {
    let left = super::super::plan_expr(left, context)?;
    let right = super::super::plan_expr(right, context)?;
    Ok(Expr::bool(BoolExpr::not_equal(left, right)))
}

#[cfg(test)]
mod tests {
    use crate::planner::dsl::{bool_, equal, function, int, module, not_equal};
    use crate::planner::plan_module;
    use crate::planner::support::{compile, expect_plan_error};
    use crate::planner::{PlanError, UnsupportedBitArraySegmentReason};

    #[test]
    fn plan_equality_operators() {
        let actual = plan_module(compile(
            r#"
pub fn main() {
  1 == 1
}

pub fn not_equal() {
  True != False
}
"#,
        ))
        .expect("source should plan");
        let expected = module(
            "main",
            function("main", equal(int(1), int(1))),
            [function("not_equal", not_equal(bool_(true), bool_(false)))],
        );

        assert_eq!(actual, expected);
    }

    #[test]
    fn equality_operand_expression_errors_propagate() {
        for (name, src) in [
            (
                "equal left",
                r#"
pub fn main() {
  {
    <<1:native>>
    1
  } == 1
}
"#,
            ),
            (
                "equal right",
                r#"
pub fn main() {
  1 == {
    <<1:native>>
    1
  }
}
"#,
            ),
            (
                "not equal left",
                r#"
pub fn main() {
  {
    <<1:native>>
    1
  } != 1
}
"#,
            ),
            (
                "not equal right",
                r#"
pub fn main() {
  1 != {
    <<1:native>>
    1
  }
}
"#,
            ),
        ] {
            assert_eq!(
                expect_plan_error(src),
                PlanError::UnsupportedBitArraySegment {
                    reason: UnsupportedBitArraySegmentReason::NativeEndianness,
                },
                "{name}",
            );
        }
    }
}