1355 lines
41 KiB
Rust
1355 lines
41 KiB
Rust
#![cfg(test)]
|
|
#![allow(clippy::upper_case_acronyms)]
|
|
#![allow(clippy::vec_init_then_push)]
|
|
//use test_case::test_case;
|
|
use std::{fmt::Write, rc::Rc};
|
|
|
|
use pretty_assertions::assert_eq;
|
|
|
|
use super::new::{schala_parser, Parser};
|
|
use crate::{ast::*, parsing::Location};
|
|
|
|
fn rc(s: &str) -> Rc<String> {
|
|
Rc::new(s.to_owned())
|
|
}
|
|
|
|
fn bx<T>(item: T) -> Box<T> {
|
|
Box::new(item)
|
|
}
|
|
|
|
fn stmt(kind: StatementKind) -> Statement {
|
|
Statement { location: Location::default(), id: ItemId::default(), kind }
|
|
}
|
|
|
|
fn exst(kind: ExpressionKind) -> Statement {
|
|
Statement {
|
|
location: Location::default(),
|
|
id: ItemId::default(),
|
|
kind: StatementKind::Expression(expr(kind)),
|
|
}
|
|
}
|
|
|
|
fn decl(declaration: Declaration) -> Statement {
|
|
Statement {
|
|
location: Location::default(),
|
|
id: ItemId::default(),
|
|
kind: StatementKind::Declaration(declaration),
|
|
}
|
|
}
|
|
|
|
fn fn_decl(sig: Signature, stmts: Block) -> Statement {
|
|
Statement {
|
|
kind: StatementKind::Declaration(Declaration::FuncDecl(sig, stmts)),
|
|
location: Default::default(),
|
|
id: Default::default(),
|
|
}
|
|
}
|
|
|
|
fn expr_anno(kind: ExpressionKind, anno: TypeIdentifier) -> Expression {
|
|
Expression { id: ItemId::default(), kind, type_anno: Some(anno) }
|
|
}
|
|
|
|
fn expr(kind: ExpressionKind) -> Expression {
|
|
Expression { id: ItemId::default(), kind, type_anno: None }
|
|
}
|
|
|
|
fn binop(sigil: &str, lhs: Expression, rhs: Expression) -> Expression {
|
|
Expression {
|
|
id: Default::default(),
|
|
type_anno: None,
|
|
kind: ExpressionKind::BinExp(BinOp::from_sigil(sigil), Box::new(lhs), Box::new(rhs)),
|
|
}
|
|
}
|
|
|
|
fn prefixop(sigil: &str, exp: Expression) -> Expression {
|
|
Expression {
|
|
id: Default::default(),
|
|
type_anno: None,
|
|
kind: ExpressionKind::PrefixExp(PrefixOp::from_sigil(sigil), Box::new(exp)),
|
|
}
|
|
}
|
|
|
|
macro_rules! qn {
|
|
( $( $component:ident),* ) => {
|
|
{
|
|
let mut components = vec![];
|
|
$(
|
|
components.push(rc(stringify!($component)));
|
|
)*
|
|
QualifiedName { components, id: Default::default() }
|
|
}
|
|
};
|
|
}
|
|
|
|
fn ty_simple(name: &str) -> TypeIdentifier {
|
|
TypeIdentifier::Singleton(TypeSingletonName { name: rc(name), params: vec![] })
|
|
}
|
|
|
|
macro_rules! assert_ast {
|
|
($input:expr, $statements:expr) => {
|
|
let mut parser = Parser::new();
|
|
let ast = schala_parser::program($input, &mut parser);
|
|
let expected = AST { id: Default::default(), statements: $statements.into() };
|
|
if ast.is_err() {
|
|
println!("Parse error: {}", ast.unwrap_err());
|
|
panic!();
|
|
}
|
|
assert_eq!(ast.unwrap(), expected);
|
|
};
|
|
}
|
|
|
|
macro_rules! assert_fail {
|
|
($input:expr, $failure:expr) => {
|
|
let mut parser = Parser::new();
|
|
let err = schala_parser::program($input, &mut parser).unwrap_err();
|
|
assert_eq!(err.to_string(), $failure);
|
|
};
|
|
}
|
|
|
|
macro_rules! assert_expr {
|
|
($input:expr, $correct:expr) => {
|
|
let mut parser = Parser::new();
|
|
let expr = schala_parser::expression($input, &mut parser);
|
|
if expr.is_err() {
|
|
println!("Expression parse error: {}", expr.unwrap_err());
|
|
panic!();
|
|
}
|
|
assert_eq!(expr.unwrap(), $correct);
|
|
};
|
|
}
|
|
|
|
macro_rules! assert_fail_expr {
|
|
($input:expr, $failure:expr) => {
|
|
let mut parser = Parser::new();
|
|
let _err = schala_parser::expression($input, &mut parser).unwrap_err();
|
|
//TODO make real tests for failures
|
|
//assert_eq!(err.to_string(), $failure);
|
|
};
|
|
}
|
|
#[test]
|
|
fn basic_literals() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_expr!(".2", expr(FloatLiteral(0.2)));
|
|
assert_expr!("8.1", expr(FloatLiteral(8.1)));
|
|
assert_expr!("0b010", expr(NatLiteral(2)));
|
|
assert_expr!("0b0_1_0", expr(NatLiteral(2)));
|
|
assert_expr!("0xff", expr(NatLiteral(255)));
|
|
assert_expr!("0x032f", expr(NatLiteral(815)));
|
|
assert_expr!("0xf_f_", expr(NatLiteral(255)));
|
|
assert_expr!("false", expr(BoolLiteral(false)));
|
|
assert_expr!("true", expr(BoolLiteral(true)));
|
|
}
|
|
|
|
#[test]
|
|
fn string_literals() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_expr!(r#""""#, expr(StringLiteral(rc(""))));
|
|
assert_expr!(r#""hello""#, expr(StringLiteral(rc("hello"))));
|
|
assert_expr!(r#"b"some bytestring""#, expr(StringLiteral(rc("some bytestring"))));
|
|
//NOTE I'm not 100% sure this case is correct, but I'll deal with it later
|
|
assert_expr!(r#""Do \n \" escapes work\t""#, expr(StringLiteral(rc(r#"Do \n \" escapes work\t"#))));
|
|
}
|
|
|
|
#[test]
|
|
fn list_literals() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_expr!("[]", expr(ListLiteral(vec![])));
|
|
assert_expr!("[1,2]", expr(ListLiteral(vec![expr(NatLiteral(1)), expr(NatLiteral(2)),])));
|
|
assert_fail_expr!("[1,,2]", "some failure");
|
|
}
|
|
|
|
#[test]
|
|
fn binexps() {
|
|
use ExpressionKind::*;
|
|
use StatementKind::Expression;
|
|
|
|
assert_expr!("0xf_f_+1", binop("+", expr(NatLiteral(255)), expr(NatLiteral(1))));
|
|
assert_ast!(
|
|
"3; 4; 4.3",
|
|
vec![
|
|
stmt(Expression(expr(NatLiteral(3)))),
|
|
stmt(Expression(expr(NatLiteral(4)))),
|
|
stmt(Expression(expr(FloatLiteral(4.3)))),
|
|
]
|
|
);
|
|
|
|
assert_expr!(
|
|
"1 + 2 * 3",
|
|
binop("+", expr(NatLiteral(1)), binop("*", expr(NatLiteral(2)), expr(NatLiteral(3))))
|
|
);
|
|
assert_expr!(
|
|
"1 * 2 + 3",
|
|
binop("+", binop("*", expr(NatLiteral(1)), expr(NatLiteral(2))), expr(NatLiteral(3)))
|
|
);
|
|
assert_expr!("1 && 2", binop("&&", expr(NatLiteral(1)), expr(NatLiteral(2))));
|
|
assert_expr!(
|
|
"1 + 2 * 3 + 4",
|
|
binop(
|
|
"+",
|
|
binop("+", expr(NatLiteral(1)), binop("*", expr(NatLiteral(2)), expr(NatLiteral(3)))),
|
|
expr(NatLiteral(4))
|
|
)
|
|
);
|
|
assert_expr!(
|
|
"(1 + 2) * 3",
|
|
binop("*", binop("+", expr(NatLiteral(1)), expr(NatLiteral(2))), expr(NatLiteral(3)))
|
|
);
|
|
assert_expr!(".1 + .2", binop("+", expr(FloatLiteral(0.1)), expr(FloatLiteral(0.2))));
|
|
assert_expr!("1 / 2.", binop("/", expr(NatLiteral(1)), expr(FloatLiteral(2.))));
|
|
}
|
|
|
|
#[test]
|
|
fn prefix_exps() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_expr!("-3", prefixop("-", expr(NatLiteral(3))));
|
|
assert_expr!("-0.2", prefixop("-", expr(FloatLiteral(0.2))));
|
|
assert_expr!("!3", prefixop("!", expr(NatLiteral(3))));
|
|
assert_expr!("!t", prefixop("!", expr(Value(qn!(t)))));
|
|
assert_expr!("a <- -b", binop("<-", expr(Value(qn!(a))), prefixop("-", expr(Value(qn!(b))))));
|
|
assert_expr!("a <--b", binop("<--", expr(Value(qn!(a))), expr(Value(qn!(b)))));
|
|
}
|
|
|
|
#[test]
|
|
fn operators() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_expr!("a <- 1", binop("<-", expr(Value(qn!(a))), expr(NatLiteral(1))));
|
|
assert_expr!("a || 1", binop("||", expr(Value(qn!(a))), expr(NatLiteral(1))));
|
|
assert_expr!("a <> 1", binop("<>", expr(Value(qn!(a))), expr(NatLiteral(1))));
|
|
}
|
|
|
|
#[test]
|
|
fn accessors() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_expr!("a.b", expr(Access { name: rc("b"), expr: bx(expr(Value(qn!(a)))) }));
|
|
assert_expr!(
|
|
"a.b.c",
|
|
expr(Access {
|
|
name: rc("c"),
|
|
expr: bx(expr(Access { name: rc("b"), expr: bx(expr(Value(qn!(a)))) }))
|
|
})
|
|
);
|
|
assert_expr!(
|
|
"a.b.c(3)",
|
|
expr(Call {
|
|
f: bx(expr(Access {
|
|
name: rc("c"),
|
|
expr: bx(expr(Access { name: rc("b"), expr: bx(expr(Value(qn!(a)))) }))
|
|
})),
|
|
arguments: vec![InvocationArgument::Positional(expr(NatLiteral(3)))],
|
|
})
|
|
);
|
|
assert_expr!(
|
|
"a.b().c",
|
|
expr(Access {
|
|
name: rc("c"),
|
|
expr: bx(expr(Call {
|
|
f: bx(expr(Access { name: rc("b"), expr: bx(expr(Value(qn!(a)))) })),
|
|
arguments: vec![]
|
|
}))
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn tuples() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_expr!("()", expr(TupleLiteral(vec![])));
|
|
assert_expr!(
|
|
r#"("hella", 34)"#,
|
|
expr(TupleLiteral(vec![expr(StringLiteral(rc("hella"))), expr(NatLiteral(34))]))
|
|
);
|
|
assert_expr!(
|
|
r#"(1+2, "slough")"#,
|
|
expr(TupleLiteral(vec![
|
|
binop("+", expr(NatLiteral(1)), expr(NatLiteral(2))),
|
|
expr(StringLiteral(rc("slough"))),
|
|
]))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn identifiers() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_expr!("a", expr(Value(qn!(a))));
|
|
assert_expr!("some_value", expr(Value(qn!(some_value))));
|
|
assert_expr!("alpha::beta::gamma", expr(Value(qn!(alpha, beta, gamma))));
|
|
assert_expr!("a + b", binop("+", expr(Value(qn!(a))), expr(Value(qn!(b)))));
|
|
assert_expr!("None", expr(Value(qn!(None))));
|
|
assert_expr!(
|
|
"thing::item::call()",
|
|
expr(Call { f: bx(expr(Value(qn!(thing, item, call)))), arguments: vec![] })
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn named_struct() {
|
|
use ExpressionKind::*;
|
|
assert_expr!(
|
|
"Pandas { a: x + y }",
|
|
expr(NamedStruct {
|
|
name: qn!(Pandas),
|
|
fields: vec![(rc("a"), binop("+", expr(Value(qn!(x))), expr(Value(qn!(y)))))]
|
|
})
|
|
);
|
|
assert_expr!(
|
|
"Trousers { a:1, b:800 }",
|
|
expr(NamedStruct {
|
|
name: qn!(Trousers),
|
|
fields: vec![(rc("a"), expr(NatLiteral(1))), (rc("b"), expr(NatLiteral(800)))]
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn index() {
|
|
use ExpressionKind::*;
|
|
assert_expr!(
|
|
"armok[b,c]",
|
|
expr(Index {
|
|
indexee: bx(expr(Value(qn!(armok)))),
|
|
indexers: vec![expr(Value(qn!(b))), expr(Value(qn!(c)))]
|
|
})
|
|
);
|
|
assert_expr!(
|
|
"a[b,c][1]",
|
|
expr(Index {
|
|
indexee: bx(expr(Index {
|
|
indexee: bx(expr(Value(qn!(a)))),
|
|
indexers: vec![expr(Value(qn!(b))), expr(Value(qn!(c)))]
|
|
})),
|
|
indexers: vec![expr(NatLiteral(1))]
|
|
})
|
|
);
|
|
assert_expr!(
|
|
"perspicacity()[a]",
|
|
expr(Index {
|
|
indexee: bx(expr(Call { f: bx(expr(Value(qn!(perspicacity)))), arguments: vec![] })),
|
|
indexers: vec![expr(Value(qn!(a)))]
|
|
})
|
|
);
|
|
|
|
let a = expr(Call { f: bx(expr(Value(qn!(a)))), arguments: vec![] });
|
|
let b = expr(Index { indexee: bx(a), indexers: vec![expr(Value(qn!(b)))] });
|
|
let c = expr(Call { f: bx(b), arguments: vec![] });
|
|
let d = expr(Index { indexee: bx(c), indexers: vec![expr(Value(qn!(d)))] });
|
|
assert_expr!("a()[b]()[d]", d);
|
|
|
|
assert_fail_expr!("a[]", "Empty index expressions are not allowed");
|
|
}
|
|
|
|
#[test]
|
|
fn while_expression() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_expr!("while { }", expr(WhileExpression { condition: None, body: Block::default() }));
|
|
assert_expr!(
|
|
"while a == b { }",
|
|
expr(WhileExpression {
|
|
condition: Some(bx(binop("==", expr(Value(qn!(a))), expr(Value(qn!(b)))))),
|
|
body: Block::default()
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn for_expression() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_expr!(
|
|
"for { a <- garodzny::maybeValue } return 1",
|
|
expr(ForExpression {
|
|
enumerators: vec![Enumerator { id: rc("a"), generator: expr(Value(qn!(garodzny, maybeValue))) }],
|
|
body: bx(ForBody::MonadicReturn(expr(NatLiteral(1))))
|
|
})
|
|
);
|
|
|
|
assert_expr!(
|
|
"for n <- someRange { f(n) ; }",
|
|
expr(ForExpression {
|
|
enumerators: vec![Enumerator { id: rc("n"), generator: expr(Value(qn!(someRange))) }],
|
|
body: bx(ForBody::StatementBlock(
|
|
vec![stmt(StatementKind::Expression(expr(Call {
|
|
f: bx(expr(Value(qn!(f)))),
|
|
arguments: vec![InvocationArgument::Positional(expr(Value(qn!(n))))],
|
|
}))),]
|
|
.into()
|
|
)),
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn lambda_expressions() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_expr!(
|
|
r#"\(x) { x + 1}"#,
|
|
expr(Lambda {
|
|
params: vec![FormalParam { name: rc!(x), anno: None, default: None }],
|
|
type_anno: None,
|
|
body:
|
|
vec![stmt(StatementKind::Expression(binop("+", expr(Value(qn!(x))), expr(NatLiteral(1))))),]
|
|
.into()
|
|
})
|
|
);
|
|
|
|
assert_expr!(
|
|
r#"\ (x: Int, y) { a;b;c;}"#,
|
|
expr(Lambda {
|
|
params: vec![
|
|
FormalParam { name: rc!(x), anno: Some(ty_simple("Int")), default: None },
|
|
FormalParam { name: rc!(y), anno: None, default: None },
|
|
],
|
|
type_anno: None,
|
|
body: vec![
|
|
stmt(StatementKind::Expression(expr(Value(qn!(a))))),
|
|
stmt(StatementKind::Expression(expr(Value(qn!(b))))),
|
|
stmt(StatementKind::Expression(expr(Value(qn!(c))))),
|
|
]
|
|
.into()
|
|
})
|
|
);
|
|
|
|
assert_expr!(
|
|
r#"\(x){y}(1)"#,
|
|
expr(Call {
|
|
f: bx(expr(Lambda {
|
|
params: vec![FormalParam { name: rc!(x), anno: None, default: None },],
|
|
type_anno: None,
|
|
body: vec![stmt(StatementKind::Expression(expr(Value(qn!(y))))),].into()
|
|
})),
|
|
arguments: vec![InvocationArgument::Positional(expr(NatLiteral(1)))],
|
|
})
|
|
);
|
|
|
|
assert_expr!(
|
|
r#"\(x: Int): String { "q" }"#,
|
|
expr(Lambda {
|
|
params: vec![FormalParam { name: rc!(x), anno: Some(ty_simple("Int")), default: None },],
|
|
type_anno: Some(TypeIdentifier::Singleton(TypeSingletonName {
|
|
name: rc("String"),
|
|
params: vec![]
|
|
})),
|
|
body: vec![stmt(StatementKind::Expression(expr(StringLiteral(rc("q"))))),].into()
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn single_param_lambda() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_expr!(
|
|
r#"\x { x + 10 }"#,
|
|
expr(Lambda {
|
|
params: vec![FormalParam { name: rc!(x), anno: None, default: None },],
|
|
type_anno: None,
|
|
body: vec![stmt(StatementKind::Expression(binop(
|
|
"+",
|
|
expr(Value(qn!(x))),
|
|
expr(NatLiteral(10))
|
|
)))]
|
|
.into()
|
|
})
|
|
);
|
|
|
|
assert_expr!(
|
|
r#"\x: Int { x + 10 }"#,
|
|
expr(Lambda {
|
|
params: vec![FormalParam { name: rc!(x), anno: Some(ty_simple("Int")), default: None },],
|
|
type_anno: None,
|
|
body: vec![stmt(StatementKind::Expression(binop(
|
|
"+",
|
|
expr(Value(qn!(x))),
|
|
expr(NatLiteral(10))
|
|
)))]
|
|
.into()
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn complex_lambdas() {
|
|
use ExpressionKind::*;
|
|
|
|
//TODO support this without the semicolon after the lambda
|
|
assert_ast! {
|
|
r#"fn wahoo() { let a = 10; \(x) { x + a }; }
|
|
wahoo()(3) "#,
|
|
vec![
|
|
fn_decl(Signature { name: rc("wahoo"), operator: false, type_anno: None, params: vec![] },
|
|
vec![
|
|
decl(Declaration::Binding {
|
|
name: rc("a"),
|
|
constant: true,
|
|
type_anno: None,
|
|
expr: expr(NatLiteral(10))
|
|
}),
|
|
stmt(StatementKind::Expression(expr(Lambda {
|
|
params: vec![
|
|
FormalParam { name: rc("x"), default: None, anno: None }
|
|
],
|
|
type_anno: None,
|
|
body: vec![
|
|
stmt(StatementKind::Expression(binop("+", expr(Value(qn!(x))), expr(Value(qn!(a)))))),
|
|
].into()
|
|
}))),
|
|
].into()),
|
|
stmt(StatementKind::Expression(expr(Call {
|
|
f: bx(expr(Call {
|
|
f: bx(expr(Value(qn!(wahoo)))),
|
|
arguments: vec![] })),
|
|
arguments: vec![
|
|
InvocationArgument::Positional(expr(NatLiteral(3)))
|
|
]
|
|
})))
|
|
]
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn reserved_words() {
|
|
assert_fail!("module::item::call()", "error at 1:7: expected ['a' ..= 'z' | 'A' ..= 'Z' | '_']");
|
|
}
|
|
|
|
#[test]
|
|
fn type_annotations() {
|
|
use ExpressionKind::*;
|
|
use TypeIdentifier::*;
|
|
|
|
assert_ast!(
|
|
"let a = b : Int",
|
|
vec![decl(Declaration::Binding {
|
|
name: rc("a"),
|
|
constant: true,
|
|
type_anno: None,
|
|
expr: expr_anno(Value(qn!(b)), Singleton(TypeSingletonName { name: rc("Int"), params: vec![] })),
|
|
})]
|
|
);
|
|
|
|
assert_expr!(
|
|
"a: Int",
|
|
expr_anno(Value(qn!(a)), Singleton(TypeSingletonName { name: rc("Int"), params: vec![] }))
|
|
);
|
|
assert_expr!(
|
|
"a: Option<Int>",
|
|
expr_anno(
|
|
Value(qn!(a)),
|
|
Singleton(TypeSingletonName {
|
|
name: rc("Option"),
|
|
params: vec![Singleton(TypeSingletonName { name: rc("Int"), params: vec![] })]
|
|
})
|
|
)
|
|
);
|
|
assert_expr!(
|
|
"a: KoreanBBQSpecifier<Kimchi, Option<Bulgogi> >",
|
|
expr_anno(
|
|
Value(qn!(a)),
|
|
Singleton(TypeSingletonName {
|
|
name: rc("KoreanBBQSpecifier"),
|
|
params: vec![
|
|
Singleton(TypeSingletonName { name: rc("Kimchi"), params: vec![] }),
|
|
Singleton(TypeSingletonName {
|
|
name: rc("Option"),
|
|
params: vec![Singleton(TypeSingletonName { name: rc("Bulgogi"), params: vec![] })]
|
|
})
|
|
]
|
|
})
|
|
)
|
|
);
|
|
assert_expr!(
|
|
"a: (Int, Yolo<a>)",
|
|
expr_anno(
|
|
Value(qn!(a)),
|
|
Tuple(vec![
|
|
Singleton(TypeSingletonName { name: rc("Int"), params: vec![] }),
|
|
Singleton(TypeSingletonName {
|
|
name: rc("Yolo"),
|
|
params: vec![Singleton(TypeSingletonName { name: rc("a"), params: vec![] })]
|
|
}),
|
|
]),
|
|
)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn type_declarations() {
|
|
use Declaration::TypeDecl;
|
|
assert_ast! {
|
|
"type Alpha = Alpha", vec![
|
|
decl(TypeDecl {
|
|
name: TypeSingletonName { name: rc("Alpha"), params: vec![] },
|
|
mutable: false,
|
|
body: TypeBody::Variants(vec![
|
|
Variant {
|
|
id: Default::default(),
|
|
name: rc("Alpha"),
|
|
kind: VariantKind::UnitStruct
|
|
}
|
|
])
|
|
})
|
|
]
|
|
};
|
|
|
|
assert_ast!(
|
|
"type mut Kuah = Kuah",
|
|
decl(TypeDecl {
|
|
name: TypeSingletonName { name: rc("Kuah"), params: vec![] },
|
|
mutable: true,
|
|
body: TypeBody::Variants(vec![Variant {
|
|
id: Default::default(),
|
|
name: rc("Kuah"),
|
|
kind: VariantKind::UnitStruct
|
|
}])
|
|
})
|
|
);
|
|
|
|
assert_ast! {
|
|
"type Alpha = Alpha { a: Int, b: Int }",
|
|
vec![decl(TypeDecl {
|
|
name: TypeSingletonName { name: rc("Alpha"), params: vec![] },
|
|
mutable: false,
|
|
body: TypeBody::Variants(vec![
|
|
Variant {
|
|
id: Default::default(),
|
|
name: rc("Alpha"),
|
|
kind: VariantKind::Record(vec![
|
|
(rc("a"), ty_simple("Int")),
|
|
(rc("b"), ty_simple("Int"))
|
|
])
|
|
}
|
|
])
|
|
})]
|
|
};
|
|
|
|
assert_ast! {
|
|
"type Alpha = { a: Int, b: Int }",
|
|
vec![decl(TypeDecl {
|
|
name: TypeSingletonName { name: rc("Alpha"), params: vec![] },
|
|
mutable: false,
|
|
body: TypeBody::ImmediateRecord(Default::default(), vec![
|
|
(rc("a"), ty_simple("Int")),
|
|
(rc("b"), ty_simple("Int"))
|
|
])
|
|
|
|
})]
|
|
};
|
|
|
|
assert_ast!(
|
|
"type Option<T> = None | Some(T)",
|
|
vec![decl(TypeDecl {
|
|
name: TypeSingletonName {
|
|
name: rc("Option"),
|
|
params: vec![TypeIdentifier::Singleton(TypeSingletonName { name: rc("T"), params: vec![] })]
|
|
},
|
|
mutable: false,
|
|
body: TypeBody::Variants(vec![
|
|
Variant { id: Default::default(), name: rc("None"), kind: VariantKind::UnitStruct },
|
|
Variant {
|
|
id: Default::default(),
|
|
name: rc("Some"),
|
|
kind: VariantKind::TupleStruct(vec![TypeIdentifier::Singleton(TypeSingletonName {
|
|
name: rc("T"),
|
|
params: vec![]
|
|
})])
|
|
},
|
|
])
|
|
})]
|
|
);
|
|
|
|
assert_ast!(
|
|
"type alias Alpha = Beta",
|
|
decl(Declaration::TypeAlias { alias: rc("Alpha"), original: rc("Beta") })
|
|
);
|
|
|
|
assert_ast!("type Complex<T, U> = Unit | Record { field: AnotherType<Bool>, field2: (Nat, Int), field3: T } | Tuple(Int, (String, T))",
|
|
decl(TypeDecl {
|
|
name: TypeSingletonName { name: rc("Complex"), params: vec![
|
|
TypeIdentifier::Singleton(TypeSingletonName { name: rc("T"), params: vec![] }),
|
|
TypeIdentifier::Singleton(TypeSingletonName { name: rc("U"), params: vec![] }),
|
|
] },
|
|
mutable: false,
|
|
body: TypeBody::Variants(vec![
|
|
Variant { id: Default::default(), name: rc("Unit"), kind: VariantKind::UnitStruct },
|
|
Variant { id: Default::default(), name: rc("Record"), kind: VariantKind::Record(
|
|
vec![
|
|
(rc("field"), TypeIdentifier::Singleton(TypeSingletonName { name: rc("AnotherType"), params: vec![TypeIdentifier::Singleton(TypeSingletonName { name: rc("Bool"), params: vec![] })] })),
|
|
(rc("field2"), TypeIdentifier::Tuple(vec![
|
|
TypeIdentifier::Singleton(TypeSingletonName { name: rc("Nat"), params: vec![] }),
|
|
TypeIdentifier::Singleton(TypeSingletonName { name: rc("Int"), params: vec![] }),
|
|
]
|
|
)),
|
|
(rc("field3"), TypeIdentifier::Singleton(TypeSingletonName { name: rc("T"), params: vec![] })),
|
|
]
|
|
)},
|
|
Variant { id: Default::default(), name: rc("Tuple"), kind: VariantKind::TupleStruct(
|
|
vec![
|
|
TypeIdentifier::Singleton(TypeSingletonName { name: rc("Int"), params: vec![] }),
|
|
TypeIdentifier::Tuple(vec![
|
|
TypeIdentifier::Singleton(TypeSingletonName { name: rc("String"), params: vec![] }),
|
|
TypeIdentifier::Singleton(TypeSingletonName { name: rc("T"), params: vec![] }),
|
|
])
|
|
]
|
|
)},
|
|
]),
|
|
}));
|
|
}
|
|
|
|
#[test]
|
|
fn declarations() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_ast!(
|
|
"let q_q = Yolo::Swaggins",
|
|
vec![decl(Declaration::Binding {
|
|
name: rc("q_q"),
|
|
constant: true,
|
|
type_anno: None,
|
|
expr: expr(Value(qn!(Yolo, Swaggins)))
|
|
})]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn bindings() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_ast!(
|
|
"let mut a = 10",
|
|
vec![decl(Declaration::Binding {
|
|
name: rc("a"),
|
|
constant: false,
|
|
type_anno: None,
|
|
expr: expr(NatLiteral(10)),
|
|
})]
|
|
);
|
|
|
|
assert_ast!(
|
|
"let a = 2 + a",
|
|
vec![stmt(StatementKind::Declaration(Declaration::Binding {
|
|
name: rc("a"),
|
|
constant: true,
|
|
type_anno: None,
|
|
expr: binop("+", expr(NatLiteral(2)), expr(Value(qn!(a)))),
|
|
}))]
|
|
);
|
|
|
|
assert_ast!(
|
|
"let a: Nat = 2",
|
|
vec![stmt(StatementKind::Declaration(Declaration::Binding {
|
|
name: rc("a"),
|
|
constant: true,
|
|
type_anno: Some(TypeIdentifier::Singleton(TypeSingletonName { name: rc("Nat"), params: vec![] })),
|
|
expr: expr(NatLiteral(2)),
|
|
}))]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn functions() {
|
|
use ExpressionKind::*;
|
|
assert_ast!(
|
|
"fn oi()",
|
|
vec![stmt(StatementKind::Declaration(Declaration::FuncSig(Signature {
|
|
name: rc("oi"),
|
|
operator: false,
|
|
params: vec![],
|
|
type_anno: None
|
|
})))]
|
|
);
|
|
|
|
assert_ast!(
|
|
"oi()",
|
|
vec![stmt(StatementKind::Expression(expr(Call { f: bx(expr(Value(qn!(oi)))), arguments: vec![] })))]
|
|
);
|
|
|
|
assert_expr!(
|
|
"oi(a, 2+2)",
|
|
expr(Call {
|
|
f: bx(expr(Value(qn!(oi)))),
|
|
arguments: vec![
|
|
InvocationArgument::Positional(expr(Value(qn!(a)))),
|
|
InvocationArgument::Positional(binop("+", expr(NatLiteral(2)), expr(NatLiteral(2)))),
|
|
]
|
|
})
|
|
);
|
|
assert_fail!("a(b,,c)","error at 1:5: expected one of \"(\", \".\", \"0b\", \"0x\", \"[\", \"\\\"\", \"_\", \"false\", \"for\", \"if\", \"true\", \"while\", ['+' | '-' | '!'], ['0' ..= '9'], ['a' ..= 'z' | 'A' ..= 'Z' | '_'], r#\"\\\"#");
|
|
|
|
assert_ast!(
|
|
"fn a(b, c: Int): Int",
|
|
vec![stmt(StatementKind::Declaration(Declaration::FuncSig(Signature {
|
|
name: rc("a"),
|
|
operator: false,
|
|
params: vec![
|
|
FormalParam { name: rc("b"), default: None, anno: None },
|
|
FormalParam {
|
|
name: rc("c"),
|
|
default: None,
|
|
anno: Some(TypeIdentifier::Singleton(TypeSingletonName {
|
|
name: rc("Int"),
|
|
params: vec![]
|
|
})),
|
|
},
|
|
],
|
|
type_anno: Some(TypeIdentifier::Singleton(TypeSingletonName { name: rc("Int"), params: vec![] })),
|
|
})))]
|
|
);
|
|
|
|
let source = r#"
|
|
fn some_function() {
|
|
|
|
}"#;
|
|
|
|
assert_ast!(
|
|
source,
|
|
vec![fn_decl(
|
|
Signature { name: rc("some_function"), operator: false, type_anno: None, params: vec![] },
|
|
vec![].into()
|
|
)]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn max_function_params() {
|
|
let mut buf = "fn longfunc(".to_string();
|
|
for n in 0..256 {
|
|
write!(buf, "a{}, ", n).unwrap();
|
|
}
|
|
write!(buf, ") {{ return 20 }}").unwrap();
|
|
//assert_fail!(&buf, "A function cannot have more than 255 arguments");
|
|
//TODO better errors again
|
|
assert_fail!(&buf, "error at 1:1439: expected ['a' ..= 'z' | 'A' ..= 'Z' | '_']");
|
|
}
|
|
|
|
#[test]
|
|
fn functions_with_different_whitespace() {
|
|
use ExpressionKind::*;
|
|
|
|
let a = "fn a(x) { x() }";
|
|
let b = "fn a(x) {\n x() }";
|
|
let c = r#"
|
|
|
|
fn a(x) {
|
|
|
|
|
|
x()
|
|
|
|
|
|
}
|
|
|
|
"#;
|
|
|
|
for item in [a, b, c].iter() {
|
|
assert_ast!(
|
|
item,
|
|
vec![fn_decl(
|
|
Signature {
|
|
name: rc("a"),
|
|
operator: false,
|
|
type_anno: None,
|
|
params: vec![FormalParam { name: rc("x"), default: None, anno: None }]
|
|
},
|
|
vec![stmt(StatementKind::Expression(expr(Call {
|
|
f: bx(expr(Value(qn!(x)))),
|
|
arguments: vec![],
|
|
})))]
|
|
.into()
|
|
)]
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn functions_with_default_args() {
|
|
use ExpressionKind::*;
|
|
|
|
assert_ast!(
|
|
"fn func(x: Int, y: Int = 4) { }",
|
|
vec![fn_decl(
|
|
Signature {
|
|
name: rc("func"),
|
|
operator: false,
|
|
type_anno: None,
|
|
params: vec![
|
|
FormalParam { name: rc("x"), anno: Some(ty_simple("Int")), default: None },
|
|
FormalParam {
|
|
name: rc("y"),
|
|
anno: Some(ty_simple("Int")),
|
|
default: Some(expr(NatLiteral(4)))
|
|
},
|
|
],
|
|
},
|
|
vec![].into()
|
|
)]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn interface() {
|
|
let glue = TypeIdentifier::Singleton(TypeSingletonName { name: rc("Glue"), params: vec![] });
|
|
assert_ast!(
|
|
"interface Unglueable { fn unglue(a: Glue); fn mar(): Glue }",
|
|
vec![decl(Declaration::Interface {
|
|
name: rc("Unglueable"),
|
|
signatures: vec![
|
|
Signature {
|
|
name: rc("unglue"),
|
|
operator: false,
|
|
params: vec![FormalParam { name: rc("a"), default: None, anno: Some(glue.clone()) },],
|
|
type_anno: None,
|
|
},
|
|
Signature { name: rc("mar"), operator: false, params: vec![], type_anno: Some(glue) },
|
|
],
|
|
})]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn impls() {
|
|
use Declaration::{FuncDecl, Impl};
|
|
|
|
let block = vec![
|
|
FuncDecl(
|
|
Signature { name: rc("yolo"), operator: false, params: vec![], type_anno: None },
|
|
vec![].into(),
|
|
),
|
|
FuncDecl(
|
|
Signature { name: rc("swagg"), operator: false, params: vec![], type_anno: None },
|
|
vec![].into(),
|
|
),
|
|
];
|
|
|
|
assert_ast!(
|
|
"impl Heh { fn yolo() { }; fn swagg() { } }",
|
|
vec![decl(Impl { type_name: ty_simple("Heh"), interface_name: None, block: block.clone() })]
|
|
);
|
|
|
|
//TODO `"impl Heh<X> { fn yolo() { }; fn swagg() { }; }"` ought to work
|
|
assert_ast!(
|
|
"impl Heh<X> { fn yolo() { }; fn swagg() { } }",
|
|
vec![decl(Impl {
|
|
type_name: TypeIdentifier::Singleton(TypeSingletonName {
|
|
name: rc("Heh"),
|
|
params: vec![ty_simple("X")]
|
|
}),
|
|
interface_name: None,
|
|
block: block.clone(),
|
|
})]
|
|
);
|
|
|
|
assert_ast!(
|
|
"impl Heh for Saraz { fn yolo() {}; fn swagg() {} }",
|
|
vec![decl(Impl {
|
|
type_name: ty_simple("Saraz"),
|
|
interface_name: Some(TypeSingletonName { name: rc("Heh"), params: vec![] }),
|
|
block: block.clone(),
|
|
})]
|
|
);
|
|
|
|
assert_ast!(
|
|
"impl Heh<T> for (Int, Codepoint) {}",
|
|
vec![decl(Impl {
|
|
type_name: TypeIdentifier::Tuple(vec![ty_simple("Int"), ty_simple("Codepoint")]),
|
|
interface_name: Some(TypeSingletonName { name: rc("Heh"), params: vec![ty_simple("T")] }),
|
|
block: vec![]
|
|
})]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn annotations() {
|
|
use ExpressionKind::*;
|
|
|
|
let func = decl(Declaration::FuncDecl(
|
|
Signature { name: rc("some_function"), operator: false, params: vec![], type_anno: None },
|
|
vec![].into(),
|
|
));
|
|
|
|
assert_ast! {
|
|
r#"
|
|
@test_annotation
|
|
fn some_function() {
|
|
|
|
}"#,
|
|
vec![decl(Declaration::Annotation {
|
|
name: rc("test_annotation"),
|
|
arguments: vec![],
|
|
inner: bx(func.clone()),
|
|
}),
|
|
]
|
|
};
|
|
|
|
assert_ast! {
|
|
r#"
|
|
@test_annotation(some,value)
|
|
@another_annotation
|
|
fn some_function() {
|
|
|
|
}"#,
|
|
vec![decl(Declaration::Annotation {
|
|
name: rc("test_annotation"),
|
|
arguments: vec![expr(Value(qn!(some))), expr(Value(qn!(value)))],
|
|
inner: bx(decl(Declaration::Annotation {
|
|
name: rc("another_annotation"), arguments: vec![], inner: bx(func)
|
|
}))
|
|
}),
|
|
]
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn modules() {
|
|
assert_ast! {
|
|
r#"
|
|
module ephraim {
|
|
let mut a = 10
|
|
fn nah() { 33 }
|
|
}
|
|
"#,
|
|
vec![stmt(StatementKind::Declaration(Declaration::Module {
|
|
name: rc("ephraim"),
|
|
items: vec![
|
|
decl(Declaration::Binding {
|
|
name: rc("a"), constant: false, type_anno: None,
|
|
expr: expr(ExpressionKind::NatLiteral(10))
|
|
}),
|
|
fn_decl(Signature { name: rc("nah"), operator: false, params: vec![], type_anno: None },
|
|
vec![stmt(StatementKind::Expression(expr(ExpressionKind::NatLiteral(33))))].into()),
|
|
].into()
|
|
}))]
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn imports() {
|
|
assert_ast! {
|
|
"import harbinger::draughts::Norgleheim",
|
|
vec![stmt(StatementKind::Import(ImportSpecifier {
|
|
id: ItemId::default(),
|
|
path_components: vec![rc("harbinger"), rc("draughts"), rc("Norgleheim")],
|
|
imported_names: ImportedNames::LastOfPath
|
|
}))]
|
|
};
|
|
|
|
assert_ast! {
|
|
"import harbinger::draughts::{Norgleheim, Xraksenlaigar}",
|
|
vec![stmt(StatementKind::Import(ImportSpecifier {
|
|
id: ItemId::default(),
|
|
path_components: vec![rc("harbinger"), rc("draughts")],
|
|
imported_names: ImportedNames::List(vec![
|
|
rc("Norgleheim"), rc("Xraksenlaigar")])
|
|
}))]
|
|
};
|
|
|
|
assert_ast! {
|
|
"import bespouri::{}",
|
|
vec![stmt(StatementKind::Import(ImportSpecifier {
|
|
id: Default::default(),
|
|
path_components: vec![rc("bespouri")],
|
|
imported_names: ImportedNames::List(vec![]),
|
|
}))]
|
|
};
|
|
|
|
assert_ast! {
|
|
"import bespouri::*",
|
|
vec![stmt(StatementKind::Import(ImportSpecifier {
|
|
id: Default::default(),
|
|
path_components: vec![rc("bespouri")],
|
|
imported_names: ImportedNames::All,
|
|
}))]
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn if_exprs() {
|
|
use ExpressionKind::*;
|
|
assert_expr!(
|
|
"if a() then { tuah(); }",
|
|
expr(IfExpression {
|
|
discriminator: Some(bx(expr(Call { f: bx(expr(Value(qn!(a)))), arguments: vec![] }))),
|
|
body: bx(IfExpressionBody::SimpleConditional {
|
|
then_case: vec![exst(Call { f: bx(expr(Value(qn!(tuah)))), arguments: vec![] })].into(),
|
|
else_case: None,
|
|
})
|
|
})
|
|
);
|
|
|
|
assert_expr!(
|
|
"if a then b else c",
|
|
expr(IfExpression {
|
|
discriminator: Some(bx(expr(Value(qn!(a))))),
|
|
body: bx(IfExpressionBody::SimpleConditional {
|
|
then_case: vec![exst(Value(qn!(b)))].into(),
|
|
else_case: Some(vec![exst(Value(qn!(c)))].into()),
|
|
})
|
|
})
|
|
);
|
|
|
|
assert_expr!(
|
|
r#"
|
|
if true then {
|
|
let a = 10
|
|
b
|
|
} else {
|
|
c
|
|
}"#,
|
|
expr(IfExpression {
|
|
discriminator: Some(bx(expr(BoolLiteral(true)))),
|
|
body: bx(IfExpressionBody::SimpleConditional {
|
|
then_case: vec![
|
|
decl(Declaration::Binding {
|
|
name: rc("a"),
|
|
constant: true,
|
|
type_anno: None,
|
|
expr: expr(NatLiteral(10))
|
|
}),
|
|
exst(Value(qn!(b))),
|
|
]
|
|
.into(),
|
|
else_case: Some(vec![exst(Value(qn!(c))),].into())
|
|
})
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn pattern_matching() {
|
|
use ExpressionKind::*;
|
|
|
|
for item in ["if x is Some(a) then { 4 } else { 9 }", "if x is Some(a) then 4 else 9"] {
|
|
assert_expr!(
|
|
item,
|
|
expr(IfExpression {
|
|
discriminator: Some(bx(expr(Value(qn!(x))))),
|
|
body: bx(IfExpressionBody::SimplePatternMatch {
|
|
pattern: Pattern::TupleStruct(qn!(Some), vec![Pattern::VarOrName(qn!(a))]),
|
|
then_case: vec![exst(NatLiteral(4))].into(),
|
|
else_case: Some(vec![exst(NatLiteral(9))].into()),
|
|
})
|
|
})
|
|
);
|
|
}
|
|
|
|
assert_expr!(
|
|
"if x is Something { a, b: x } then { 4 } else { 9 }",
|
|
expr(IfExpression {
|
|
discriminator: Some(bx(expr(Value(qn!(x))))),
|
|
body: bx(IfExpressionBody::SimplePatternMatch {
|
|
pattern: Pattern::Record(
|
|
qn!(Something),
|
|
vec![(rc("a"), Pattern::VarOrName(qn!(a))), (rc("b"), Pattern::VarOrName(qn!(x)))]
|
|
),
|
|
then_case: vec![exst(NatLiteral(4))].into(),
|
|
else_case: Some(vec![exst(NatLiteral(9))].into()),
|
|
})
|
|
})
|
|
);
|
|
|
|
assert_expr!(
|
|
"if x is -1 then 1 else 2",
|
|
expr(IfExpression {
|
|
discriminator: Some(bx(expr(Value(qn!(x))))),
|
|
body: bx(IfExpressionBody::SimplePatternMatch {
|
|
pattern: Pattern::Literal(PatternLiteral::NumPattern { neg: true, num: NatLiteral(1) }),
|
|
then_case: vec![exst(NatLiteral(1))].into(),
|
|
else_case: Some(vec![exst(NatLiteral(2))].into()),
|
|
})
|
|
})
|
|
);
|
|
|
|
assert_expr!(
|
|
"if x is true then 1 else 2",
|
|
expr(IfExpression {
|
|
discriminator: Some(bx(expr(Value(qn!(x))))),
|
|
body: bx(IfExpressionBody::SimplePatternMatch {
|
|
pattern: Pattern::Literal(PatternLiteral::BoolPattern(true)),
|
|
then_case: vec![exst(NatLiteral(1))].into(),
|
|
else_case: Some(vec![exst(NatLiteral(2))].into()),
|
|
})
|
|
})
|
|
);
|
|
|
|
assert_expr!(
|
|
"if x { is 1 then 5; else 20 }",
|
|
expr(IfExpression {
|
|
discriminator: Some(bx(expr(Value(qn!(x))))),
|
|
body: bx(IfExpressionBody::CondList(vec![
|
|
ConditionArm {
|
|
condition: Condition::Pattern(Pattern::Literal(PatternLiteral::NumPattern {
|
|
neg: false,
|
|
num: NatLiteral(1)
|
|
})),
|
|
guard: None,
|
|
body: vec![exst(NatLiteral(5))].into(),
|
|
},
|
|
ConditionArm {
|
|
condition: Condition::Else,
|
|
guard: None,
|
|
body: vec![exst(NatLiteral(20))].into(),
|
|
},
|
|
]))
|
|
})
|
|
);
|
|
|
|
assert_expr!(
|
|
r#"if x is "gnosticism" then 1 else 2"#,
|
|
expr(IfExpression {
|
|
discriminator: Some(bx(expr(Value(qn!(x))))),
|
|
body: bx(IfExpressionBody::SimplePatternMatch {
|
|
pattern: Pattern::Literal(PatternLiteral::StringPattern(rc("gnosticism"))),
|
|
then_case: vec![exst(NatLiteral(1))].into(),
|
|
else_case: Some(vec![exst(NatLiteral(2))].into()),
|
|
})
|
|
})
|
|
);
|
|
|
|
assert_expr! {
|
|
r#"
|
|
if (45, "panda", false, 2.2) {
|
|
is (49, "pablo", _, 28.4) then "no"
|
|
is (_, "panda", _, -2.2) then "yes"
|
|
is _ then "maybe"
|
|
}"#,
|
|
expr(
|
|
IfExpression {
|
|
discriminator: Some(bx(expr(TupleLiteral(vec![
|
|
expr(NatLiteral(45)), expr(StringLiteral(rc("panda"))), expr(BoolLiteral(false)), expr(FloatLiteral(2.2))
|
|
])))),
|
|
body: bx(IfExpressionBody::CondList(vec![
|
|
ConditionArm {
|
|
condition: Condition::Pattern(Pattern::TuplePattern(
|
|
vec![
|
|
Pattern::Literal(PatternLiteral::NumPattern { neg: false, num: NatLiteral(49) }),
|
|
Pattern::Literal(PatternLiteral::StringPattern(rc("pablo"))),
|
|
Pattern::Ignored,
|
|
Pattern::Literal(PatternLiteral::NumPattern { neg: false, num: FloatLiteral(28.4) }),
|
|
]
|
|
)),
|
|
guard: None,
|
|
body: vec![stmt(StatementKind::Expression(expr(StringLiteral(rc("no")))))].into(),
|
|
},
|
|
ConditionArm {
|
|
condition: Condition::Pattern(Pattern::TuplePattern(
|
|
vec![
|
|
Pattern::Ignored,
|
|
Pattern::Literal(PatternLiteral::StringPattern(rc!(panda))),
|
|
Pattern::Ignored,
|
|
Pattern::Literal(PatternLiteral::NumPattern { neg: true, num: FloatLiteral(2.2) }),
|
|
]
|
|
)),
|
|
guard: None,
|
|
body: vec![stmt(StatementKind::Expression(expr(StringLiteral(rc("yes")))))].into(),
|
|
},
|
|
ConditionArm {
|
|
condition: Condition::Pattern(Pattern::Ignored),
|
|
guard: None,
|
|
body: vec![exst(StringLiteral(rc("maybe")))].into(),
|
|
},
|
|
]))
|
|
}
|
|
)
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn flow_control() {
|
|
use ExpressionKind::*;
|
|
|
|
// This is an incorrect program, but shoudl parse correctly.
|
|
let source = r#"
|
|
fn test() {
|
|
let a = 10;
|
|
break;
|
|
continue;
|
|
return;
|
|
return 10;
|
|
}"#;
|
|
|
|
assert_ast!(
|
|
source,
|
|
vec![fn_decl(
|
|
Signature { name: rc("test"), operator: false, type_anno: None, params: vec![] },
|
|
vec![
|
|
decl(Declaration::Binding {
|
|
name: rc("a"),
|
|
constant: true,
|
|
type_anno: None,
|
|
expr: expr(NatLiteral(10))
|
|
}),
|
|
stmt(StatementKind::Flow(FlowControl::Break)),
|
|
stmt(StatementKind::Flow(FlowControl::Continue)),
|
|
stmt(StatementKind::Flow(FlowControl::Return(None))),
|
|
stmt(StatementKind::Flow(FlowControl::Return(Some(expr(NatLiteral(10)))))),
|
|
]
|
|
.into()
|
|
)]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn blocks() {
|
|
use ExpressionKind::*;
|
|
|
|
let cases = ["{ a }", "{ a; }", "{a}", "{ a\n }", "{ a\n\n }", "{ a;\n\n; }"];
|
|
|
|
let mut parser = Parser::new();
|
|
for case in cases.iter() {
|
|
let block = schala_parser::block(case, &mut parser);
|
|
assert_eq!(block.unwrap(), vec![exst(Value(qn!(a)))].into());
|
|
}
|
|
|
|
let source = r#"{
|
|
fn quah() {
|
|
fn foo() { }
|
|
}
|
|
}"#;
|
|
let block = schala_parser::block(source, &mut parser);
|
|
assert_eq!(
|
|
block.unwrap(),
|
|
vec![decl(Declaration::FuncDecl(
|
|
Signature { name: rc("quah"), operator: false, params: vec![], type_anno: None },
|
|
vec![decl(Declaration::FuncDecl(
|
|
Signature { name: rc("foo"), operator: false, params: vec![], type_anno: None },
|
|
vec![].into(),
|
|
))]
|
|
.into()
|
|
))]
|
|
.into()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn comments() {
|
|
use ExpressionKind::*;
|
|
|
|
let source = "1 + /* hella /* bro */ */ 2";
|
|
assert_expr!(source, binop("+", expr(NatLiteral(1)), expr(NatLiteral(2))));
|
|
|
|
//TODO make sure this error message makes sense
|
|
let source = "1 + /* hella /* bro */ 2";
|
|
assert_fail_expr!(source, "foo");
|
|
|
|
let source = "1 + /* hella */ bro */ 2";
|
|
assert_fail_expr!(source, binop("+", expr(NatLiteral(1)), expr(NatLiteral(2))));
|
|
|
|
let source = "5//no man\n";
|
|
assert_ast!(source, vec![exst(NatLiteral(5))]);
|
|
}
|
|
|
|
//TODO support backtick operators like this
|
|
/*
|
|
#[test]
|
|
fn backtick_operators() {
|
|
let output = token_kinds("1 `plus` 2");
|
|
assert_eq!(output, vec![digit!("1"), op!("plus"), digit!("2")]);
|
|
}
|
|
*/
|