1daf23b129
This is broken b/c not type aware, but will do for now
565 lines
10 KiB
Rust
565 lines
10 KiB
Rust
#![cfg(test)]
|
|
use pretty_assertions::assert_eq;
|
|
use test_case::test_case;
|
|
|
|
use crate::{
|
|
symbol_table::SymbolTable,
|
|
tree_walk_eval::{evaluator::Evaluator, State},
|
|
type_inference::TypeContext,
|
|
};
|
|
|
|
fn evaluate_input(input: &str) -> Result<String, String> {
|
|
let ast = crate::util::quick_ast(input);
|
|
let mut symbol_table = SymbolTable::new();
|
|
let mut type_context = TypeContext::new();
|
|
|
|
symbol_table.process_ast(&ast, &mut type_context).unwrap();
|
|
|
|
let reduced_ir = crate::reduced_ir::reduce(&ast, &symbol_table, &type_context);
|
|
reduced_ir.debug(&symbol_table);
|
|
println!("========");
|
|
symbol_table.debug();
|
|
|
|
let mut state = State::new();
|
|
let mut evaluator = Evaluator::new(&mut state, &type_context);
|
|
let mut outputs = evaluator.evaluate(reduced_ir, true);
|
|
outputs.pop().unwrap()
|
|
}
|
|
|
|
fn eval_assert(input: &str, expected: &str) {
|
|
assert_eq!(evaluate_input(input), Ok(expected.to_string()));
|
|
}
|
|
|
|
fn eval_assert_failure(input: &str, expected: &str) {
|
|
assert_eq!(evaluate_input(input), Err(expected.to_string()));
|
|
}
|
|
|
|
#[test]
|
|
fn test_basic_eval() {
|
|
eval_assert("1 + 2", "3");
|
|
eval_assert("let mut a = 1; a = 2", "()");
|
|
eval_assert("let mut a = 1; a = a + 2; a", "3");
|
|
}
|
|
|
|
#[test]
|
|
fn op_eval() {
|
|
eval_assert("-13", "-13");
|
|
eval_assert("10 - 2", "8");
|
|
}
|
|
|
|
#[test]
|
|
fn function_eval() {
|
|
eval_assert("fn oi(x) { x + 1 }; oi(4)", "5");
|
|
eval_assert("fn oi(x) { x + 1 }; oi(1+2)", "4");
|
|
}
|
|
|
|
#[test]
|
|
fn scopes() {
|
|
let scope_ok = r#"
|
|
let a = 20
|
|
fn haha() {
|
|
let something = 38
|
|
let a = 10
|
|
a
|
|
}
|
|
haha()
|
|
"#;
|
|
|
|
eval_assert(scope_ok, "10");
|
|
|
|
let scope_ok = r#"
|
|
let a = 20
|
|
fn queque() {
|
|
let a = 10
|
|
a
|
|
}
|
|
a
|
|
"#;
|
|
eval_assert(scope_ok, "20");
|
|
}
|
|
|
|
#[test]
|
|
fn eval_scopes_2() {
|
|
eval_assert(
|
|
r#"
|
|
fn trad() {
|
|
let a = 10
|
|
fn jinner() {
|
|
let b = 20
|
|
b
|
|
}
|
|
|
|
a + jinner()
|
|
}
|
|
trad()"#,
|
|
"30",
|
|
);
|
|
|
|
let err = "No symbol found for name: `a`";
|
|
|
|
eval_assert_failure(
|
|
r#"
|
|
fn trad() {
|
|
let a = 10
|
|
fn inner() {
|
|
let b = 20
|
|
a + b
|
|
}
|
|
|
|
inner()
|
|
}
|
|
|
|
trad()
|
|
"#,
|
|
err,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn adt_output_1() {
|
|
let source = r#"
|
|
|
|
type Option<T> = Some(T) | None
|
|
let a = Option::None
|
|
let b = Option::Some(10)
|
|
(b, a)
|
|
"#;
|
|
eval_assert(source, "(Some(10), None)");
|
|
}
|
|
|
|
#[test]
|
|
fn adt_output_2() {
|
|
let source = r#"
|
|
type Gobble = Unknown | Rufus { a: Int, torrid: Nat }
|
|
let b = Gobble::Rufus { a: 3, torrid: 99 }
|
|
b
|
|
"#;
|
|
eval_assert(source, "Rufus { a: 3, torrid: 99 }");
|
|
|
|
let source = r#"
|
|
type Gobble = Unknown | Rufus { a: Int, torrid: Nat }
|
|
let b = Gobble::Rufus { torrid: 3, a: 84 }
|
|
b
|
|
"#;
|
|
eval_assert(source, "Rufus { a: 84, torrid: 3 }");
|
|
|
|
let source = r#"
|
|
type Gobble = Unknown | Rufus { a: Int, torrid: Nat }
|
|
let b = Gobble::Rufus { a: 84 }
|
|
b
|
|
"#;
|
|
eval_assert_failure(source, "Field torrid not specified for record Gobble::Rufus");
|
|
}
|
|
|
|
#[test]
|
|
fn basic_if_statement() {
|
|
let source = r#"
|
|
let a = 10
|
|
let b = 10
|
|
if a == b then { 69 } else { 420 }
|
|
"#;
|
|
eval_assert(source, "69");
|
|
}
|
|
|
|
#[test]
|
|
fn basic_patterns_1() {
|
|
let source = r#"
|
|
let x = 10
|
|
let a = if x is 10 then { 255 } else { 256 }
|
|
let b = if 23 is 99 then { 255 } else { 256 }
|
|
let c = if true is false then { 9 } else { 10 }
|
|
let d = if "xxx" is "yyy" then { 20 } else { 30 }
|
|
(a, b, c, d)
|
|
"#;
|
|
eval_assert(source, "(255, 256, 10, 30)");
|
|
}
|
|
|
|
#[test_case("sanchez", "1")]
|
|
#[test_case("mouri", "2")]
|
|
#[test_case("hella", "3")]
|
|
#[test_case("cyrus", "4")]
|
|
fn basic_patterns_2(input: &str, expected: &str) {
|
|
let mut source = format!(r#"let x = "{}""#, input);
|
|
source.push_str(
|
|
r#"
|
|
if x {
|
|
is "sanchez" then 1
|
|
is "mouri" then 2
|
|
is "hella" then 3
|
|
is _ then 4
|
|
}
|
|
"#,
|
|
);
|
|
eval_assert(&source, expected);
|
|
}
|
|
|
|
#[test_case(r#"(45, "panda", false, 2.2)"#, r#""yes""#)]
|
|
#[test_case(r#"(99, "panda", false, -2.45)"#, r#""maybe""#)]
|
|
fn tuple_patterns(input: &str, expected: &str) {
|
|
let mut source = format!("let x = {}", input);
|
|
source.push_str(
|
|
r#"
|
|
if x {
|
|
is (45, "pablo", _, 28.4) then "no"
|
|
is (_, "panda", _, 2.2) then "yes"
|
|
is _ then "maybe"
|
|
}"#,
|
|
);
|
|
|
|
eval_assert(&source, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn record_patterns_1() {
|
|
let source = r#"
|
|
type Ara = Kueh { a: Int, b: String } | Morbuk
|
|
|
|
let alpha = Ara::Kueh { a: 10, b: "sanchez" }
|
|
if alpha {
|
|
is Ara::Kueh { a, b } then (b, a)
|
|
is _ then ("nooo", 8888)
|
|
}"#;
|
|
eval_assert(source, r#"("sanchez", 10)"#);
|
|
}
|
|
|
|
#[test]
|
|
fn record_patterns_2() {
|
|
let source = r#"
|
|
type Ara = Kueh { a: Int, b: String } | Morbuk
|
|
|
|
let alpha = Ara::Kueh { a: 10, b: "sanchez" }
|
|
if alpha {
|
|
is Ara::Kueh { a, b: le_value } then (le_value, (a*2))
|
|
is _ then ("nooo", 8888)
|
|
}"#;
|
|
eval_assert(source, r#"("sanchez", 20)"#);
|
|
}
|
|
|
|
#[test]
|
|
fn record_patterns_3() {
|
|
let source = r#"
|
|
type Vstsavlobs = { tkveni: Int, b: Ia }
|
|
type Ia = { sitqva: Int, ghmerts: String }
|
|
let b = Vstsavlobs { tkveni: 3, b: Ia::Ia { sitqva: 5, ghmerts: "ooo" } }
|
|
if b {
|
|
is Vstsavlobs::Vstsavlobs { tkveni: _, b: Ia::Ia { sitqva, ghmerts } } then sitqva
|
|
is _ then 5000
|
|
}"#;
|
|
eval_assert(source, "5");
|
|
}
|
|
|
|
#[test]
|
|
fn if_is_patterns() {
|
|
let source = r#"
|
|
type Option<T> = Some(T) | None
|
|
let q = "a string"
|
|
let x = Option::Some(9); if x is Option::Some(q) then { q } else { 0 }"#;
|
|
|
|
eval_assert(source, "9");
|
|
|
|
let source = r#"
|
|
type Option<T> = Some(T) | None
|
|
let q = "a string"
|
|
let outer = 2
|
|
let x = Option::None; if x is Option::Some(q) then { q } else { -2 + outer }"#;
|
|
eval_assert(source, "0");
|
|
}
|
|
|
|
#[test]
|
|
fn full_if_matching() {
|
|
let source = r#"
|
|
type Option<T> = Some(T) | None
|
|
let a = Option::None
|
|
if a { is Option::None then 4; is Option::Some(x) then x }
|
|
"#;
|
|
eval_assert(source, "4");
|
|
|
|
let source = r#"
|
|
type Option<T> = Some(T) | None
|
|
let sara = Option::Some(99)
|
|
if sara { is Option::None then 1 + 3; is Option::Some(x) then x }
|
|
"#;
|
|
eval_assert(source, "99");
|
|
|
|
let source = r#"
|
|
let a = 10
|
|
if a { is 10 then "x"; is 4 then "y" }
|
|
"#;
|
|
eval_assert(source, "\"x\"");
|
|
|
|
let source = r#"
|
|
let a = 10
|
|
if a { is 15 then "x"; is 10 then "y" }
|
|
"#;
|
|
eval_assert(source, "\"y\"");
|
|
}
|
|
|
|
//TODO - I can probably cut down some of these
|
|
#[test]
|
|
fn string_pattern() {
|
|
let source = r#"
|
|
let a = "foo"
|
|
if a { is "foo" then "x"; is _ then "y" }
|
|
"#;
|
|
eval_assert(source, "\"x\"");
|
|
}
|
|
|
|
#[test]
|
|
fn boolean_pattern() {
|
|
let source = r#"
|
|
let a = true
|
|
if a {
|
|
is true then "x"
|
|
is false then "y"
|
|
}
|
|
"#;
|
|
eval_assert(source, "\"x\"");
|
|
}
|
|
|
|
#[test]
|
|
fn boolean_pattern_2() {
|
|
let source = r#"
|
|
let a = false
|
|
if a { is true then "x"; is false then "y" }
|
|
"#;
|
|
eval_assert(source, "\"y\"");
|
|
}
|
|
|
|
#[test]
|
|
fn ignore_pattern() {
|
|
let source = r#"
|
|
type Option<T> = Some(T) | None
|
|
if Option::Some(10) {
|
|
is _ then "hella"
|
|
}
|
|
"#;
|
|
eval_assert(source, "\"hella\"");
|
|
}
|
|
|
|
#[test]
|
|
fn tuple_pattern() {
|
|
let source = r#"
|
|
if (1, 2) {
|
|
is (1, x) then x;
|
|
is _ then 99
|
|
}
|
|
"#;
|
|
eval_assert(source, "2");
|
|
}
|
|
|
|
#[test]
|
|
fn tuple_pattern_2() {
|
|
let source = r#"
|
|
if (1, 2) {
|
|
is (10, x) then x
|
|
is (y, x) then x + y
|
|
}
|
|
"#;
|
|
eval_assert(source, "3");
|
|
}
|
|
|
|
#[test]
|
|
fn tuple_pattern_3() {
|
|
let source = r#"
|
|
if (1, 5) {
|
|
is (10, x) then x
|
|
is (1, x) then x
|
|
}
|
|
"#;
|
|
eval_assert(source, "5");
|
|
}
|
|
|
|
#[test]
|
|
fn tuple_pattern_4() {
|
|
let source = r#"
|
|
if (1, 5) {
|
|
is (10, x) then x
|
|
is (1, x) then x
|
|
}
|
|
"#;
|
|
eval_assert(source, "5");
|
|
}
|
|
|
|
#[test]
|
|
fn prim_obj_pattern() {
|
|
let source = r#"
|
|
type Stuff = Mulch(Nat) | Jugs(Nat, String) | Mardok
|
|
let a = Stuff::Mulch(20)
|
|
let b = Stuff::Jugs(1, "haha")
|
|
let c = Stuff::Mardok
|
|
|
|
let x = if a {
|
|
is Stuff::Mulch(20) then "x"
|
|
is _ then "ERR"
|
|
}
|
|
|
|
let y = if b {
|
|
is Stuff::Mulch(n) then "ERR"
|
|
is Stuff::Jugs(2, _) then "ERR"
|
|
is Stuff::Jugs(1, s) then s
|
|
is _ then "ERR"
|
|
}
|
|
|
|
let z = if c {
|
|
is Stuff::Jugs(_, _) then "ERR"
|
|
is Stuff::Mardok then "NIGH"
|
|
is _ then "ERR"
|
|
}
|
|
|
|
(x, y, z)
|
|
"#;
|
|
eval_assert(source, r#"("x", "haha", "NIGH")"#);
|
|
}
|
|
|
|
#[test]
|
|
fn basic_lambda_evaluation_1() {
|
|
let source = r#"
|
|
let q = \(x, y) { x * y }
|
|
let x = q(5, 2)
|
|
let y = \(m, n, o) { m + n + o }(1,2,3)
|
|
(x, y)
|
|
"#;
|
|
|
|
eval_assert(source, r"(10, 6)");
|
|
}
|
|
|
|
#[test]
|
|
fn basic_lambda_evaluation_2() {
|
|
let source = r#"
|
|
fn milta() {
|
|
\(x) { x + 33 }
|
|
}
|
|
milta()(10)
|
|
"#;
|
|
|
|
eval_assert(source, "43");
|
|
}
|
|
|
|
#[test]
|
|
fn import_all() {
|
|
let source = r#"
|
|
type Option<T> = Some(T) | None
|
|
import Option::*
|
|
let x = Some(9); if x is Some(q) then { q } else { 0 }"#;
|
|
eval_assert(source, "9");
|
|
}
|
|
|
|
#[test]
|
|
fn accessors() {
|
|
let source = r#"
|
|
type Klewos = { a: Int, b: String }
|
|
let value = Klewos::Klewos { a: 50, b: "nah" }
|
|
(value.a, value.b)
|
|
"#;
|
|
|
|
eval_assert(source, r#"(50, "nah")"#);
|
|
}
|
|
|
|
#[test]
|
|
fn early_return() {
|
|
let source = r#"
|
|
fn chnurmek(a: Int): Int {
|
|
if a == 5 then {
|
|
return 9999;
|
|
}
|
|
return (a + 2);
|
|
}
|
|
|
|
(chnurmek(5), chnurmek(0))
|
|
"#;
|
|
eval_assert(source, r#"(9999, 2)"#);
|
|
|
|
let source = r#"
|
|
fn marbuk(a: Int, b: Int): (Int, Int) {
|
|
if a == 5 then {
|
|
if b == 6 then {
|
|
return (50, 50);
|
|
}
|
|
|
|
return (a, b + 1)
|
|
}
|
|
(a * 100, b * 100)
|
|
}
|
|
|
|
let x = marbuk(1, 1)
|
|
let y = marbuk(5, 1)
|
|
let z = marbuk(5, 6)
|
|
|
|
(x, y, z)
|
|
"#;
|
|
eval_assert(source, "((100, 100), (5, 2), (50, 50))");
|
|
}
|
|
|
|
#[test]
|
|
fn loops() {
|
|
let source = r#"
|
|
let mut a = 0
|
|
let mut count = 0
|
|
while a != 5 {
|
|
a = a + 1
|
|
count = count + 100
|
|
}
|
|
|
|
count
|
|
"#;
|
|
eval_assert(source, "500");
|
|
}
|
|
|
|
#[test]
|
|
fn loops_2() {
|
|
let source = r#"
|
|
let mut a = 0
|
|
let mut acc = 0
|
|
while a < 10 {
|
|
acc = acc + 1
|
|
a = a + 1
|
|
|
|
// Without this continue, the output would be 20
|
|
if a == 5 then {
|
|
continue
|
|
}
|
|
|
|
acc = acc + 1
|
|
}
|
|
|
|
acc"#;
|
|
eval_assert(source, "19");
|
|
}
|
|
|
|
#[test]
|
|
fn list_literals() {
|
|
eval_assert(
|
|
r#"
|
|
let a = [7, 8, 9]
|
|
a
|
|
"#,
|
|
"[7, 8, 9]",
|
|
);
|
|
|
|
eval_assert(
|
|
r#"
|
|
let a = [7, 8, 9]
|
|
fn foo() { return 2 }
|
|
(a[0], a[foo()])
|
|
"#,
|
|
"(7, 9)",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_method() {
|
|
let src = r#"
|
|
type Thing = Thing
|
|
impl Thing {
|
|
fn a_method() {
|
|
20
|
|
}
|
|
|
|
}
|
|
|
|
let a = Thing::Thing
|
|
4 + a.a_method()
|
|
"#;
|
|
eval_assert(src, "24");
|
|
}
|