blr-lang 0.1.0

use expect_test::{Expect, expect};

use crate::compiler::parse;

fn test_parse(src: &str, expect: Expect) {
    let expr = parse(src);
    match expr {
        Ok(expr) => expect.assert_debug_eq(&expr),
        Err(err) => expect.assert_eq(&err.to_string()),
    }
}

#[test]
fn precedence_1() {
    test_parse(
        "1 + 2 * 3",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (bin (int 1) + (bin (int 2) * (int 3))))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_3() {
    test_parse(
        "r.a + r.b",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (bin (record-select (var r) a) + (record-select (var r) b)))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_5() {
    test_parse(
        "1 + a()",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (bin (int 1) + (app (var a))))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_7() {
    test_parse(
        "1 * r.a",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (bin (int 1) * (record-select (var r) a)))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_9() {
    test_parse(
        "r.a()",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (app (record-select (var r) a)))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_11() {
    test_parse(
        "r.a >> b()",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (forward (record-select (var r) a) (app (var b))))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_13() {
    test_parse(
        "a >> b() >> c()",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (forward (forward (var a) (app (var b))) (app (var c))))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_15() {
    test_parse(
        "let id = fn (x) => x; 1",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (let id (function (x) (var x)) (int 1)))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_18() {
    test_parse(
        "
        let a = 1;
        let b = 2;
        a + b",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (let a (int 1) (let b (int 2) (bin (var a) + (var b)))))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_20() {
    test_parse(
        "
        let a = fn (x) => x + 1;
        a(2)
        ",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function
                  (_)
                  (let a (function (x) (bin (var x) + (int 1))) (app (var a) (int 2))))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_22() {
    test_parse(
        "
        let a = fn (x) => let b = 1; x + b;
        a(2)
        ",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function
                  (_)
                  (let
                    a
                    (function (x) (let b (int 1) (bin (var x) + (var b))))
                    (app (var a) (int 2))))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_26() {
    test_parse(
        "(1 + 2) * 3",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (bin (parenthesized (bin (int 1) + (int 2))) * (int 3)))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_27() {
    test_parse(
        "a .. b",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (bin (var a) .. (var b)))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_28() {
    test_parse(
        "a + b >> c()",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (forward (bin (var a) + (var b)) (app (var c))))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_29() {
    test_parse(
        "a * b >> c()",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (forward (bin (var a) * (var b)) (app (var c))))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_30() {
    test_parse(
        "a .. b >> c()",
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (forward (bin (var a) .. (var b)) (app (var c))))
                (type (_ (unit)) (var _))))
        "#]],
    );
}

#[test]
fn precedence_31() {
    test_parse(
        r#""this is a string""#,
        expect![[r#"
            (module
              (native
                (symbol "" main)
                (function (_) (str "this is a string"))
                (type (_ (unit)) (var _))))
        "#]],
    );
}