enso/app/gui/language/parser/tests/macros.rs

// === Standard Linter Configuration ===
#![deny(non_ascii_idents)]
#![warn(unsafe_code)]

use parser::prelude::*;

use parser::Parser;
use wasm_bindgen_test::wasm_bindgen_test;
use wasm_bindgen_test::wasm_bindgen_test_configure;



wasm_bindgen_test_configure!(run_in_browser);

#[wasm_bindgen_test]
fn import_utilities() {
    use ast::macros::ast_as_import_match;
    use ast::macros::is_ast_import;
    use ast::macros::is_match_import;

    let parser = Parser::new_or_panic();
    let expect_import = |code: &str| {
        let ast = parser.parse_line_ast(code).unwrap();
        assert!(is_ast_import(&ast), "Not Ast import: {:?}", ast);
        let ast_match = ast_as_import_match(&ast).unwrap();
        assert_eq!(&ast, ast_match.ast());
        assert!(is_match_import(&ast_match));
    };

    let expect_not_import = |code: &str| {
        let ast = parser.parse_line_ast(code).unwrap();
        assert!(!is_ast_import(&ast));
        assert!(ast_as_import_match(&ast).is_none());
    };

    expect_import("import");
    expect_import("import Foo");
    expect_import("import foo.Foo.Bar");
    expect_import("import foo.Foo.Bar");
    expect_import("import Foo.Bar");
    expect_import("import Foo.Bar.Baz");
    expect_import("from Foo import Bar");
    expect_import("from foo.Foo import all hiding Bar");
    expect_import("from Base.Data.List import all hiding Cons, Nil");

    expect_not_import("type Foo");
    expect_not_import("type Foo as Bar");
    expect_not_import("if Foo then Bar else Baz");
    expect_not_import("Foo.Bar.Baz");
    expect_not_import("->");
    expect_not_import("export");
    expect_not_import("export Foo");
    expect_not_import("from Foo export all hiding Bar");
}

#[wasm_bindgen_test]
fn recognizing_lambdas() {
    let parser = Parser::new_or_panic();

    let expect_lambda = |code: &str, arg: &str, body: &str| {
        let ast = parser.parse_line_ast(code).unwrap();
        let lambda = ast::macros::as_lambda(&ast).expect("failed to recognize lambda");
        assert_eq!(lambda.arg.repr(), arg);
        assert_eq!(lambda.body.repr(), body);
        assert_eq!(*lambda.arg, ast.get_traversing(&lambda.arg.crumbs).unwrap());
        assert_eq!(*lambda.body, ast.get_traversing(&lambda.body.crumbs).unwrap());
    };
    let expect_not_lambda = |code: &str| {
        let ast = parser.parse_line_ast(code).unwrap();
        assert!(ast::macros::as_lambda_match(&ast).is_none(), "wrongly recognized a lambda");
    };

    expect_lambda("a->b", "a", "b");
    expect_lambda("foo->4+(4)", "foo", "4+(4)");
    expect_lambda("a->b->c", "a", "b->c");
    expect_lambda("(a->b)->c", "(a->b)", "c");

    expect_not_lambda("(a->b)");
    expect_not_lambda("a+b");
    expect_not_lambda("'a+b'");
    expect_not_lambda("497");
}