Rewrite many parser tests

Also introduces pretty print crate for parsing tests.

Cargo.lock

@@ -20,6 +20,15 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "ansi_term"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
+dependencies = [
+ "winapi 0.3.8",
+]
+
 [[package]]
 name = "approx"
 version = "0.1.1"
@@ -171,6 +180,16 @@ dependencies = [
  "lazy_static 1.4.0",
 ]
 
+[[package]]
+name = "ctor"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccc0a48a9b826acdf4028595adc9db92caea352f7af011a3034acd172a52a0aa"
+dependencies = [
+ "quote 1.0.10",
+ "syn 1.0.80",
+]
+
 [[package]]
 name = "derivative"
 version = "1.0.3"
@@ -182,6 +201,12 @@ dependencies = [
  "syn 0.15.44",
 ]
 
+[[package]]
+name = "diff"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499"
+
 [[package]]
 name = "dirs"
 version = "1.0.5"
@@ -524,6 +549,15 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "output_vt100"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53cdc5b785b7a58c5aad8216b3dfa114df64b0b06ae6e1501cef91df2fbdf8f9"
+dependencies = [
+ "winapi 0.3.8",
+]
+
 [[package]]
 name = "phf"
 version = "0.7.24"
@@ -562,6 +596,18 @@ dependencies = [
  "siphasher",
 ]
 
+[[package]]
+name = "pretty_assertions"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0cfe1b2403f172ba0f234e500906ee0a3e493fb81092dac23ebefe129301cc"
+dependencies = [
+ "ansi_term",
+ "ctor",
+ "diff",
+ "output_vt100",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "0.4.30"
@@ -849,6 +895,7 @@ dependencies = [
  "ena",
  "failure",
  "itertools",
+ "pretty_assertions",
  "radix_trie",
  "schala-lang-codegen",
  "schala-repl",

schala-lang/language/Cargo.toml

@@ -20,3 +20,4 @@ schala-repl = { path = "../../schala-repl" }
 
 [dev-dependencies]
 test-case = "1.2.0"
+pretty_assertions = "1.0.0"

schala-lang/language/src/ast/mod.rs

@@ -165,11 +165,6 @@ impl Expression {
     pub fn new(id: ItemId, kind: ExpressionKind) -> Expression {
         Expression { id, kind, type_anno: None }
     }
-
-    #[cfg(test)]
-    pub fn with_anno(id: ItemId, kind: ExpressionKind, type_anno: TypeIdentifier) -> Expression {
-        Expression { id, kind, type_anno: Some(type_anno) }
-    }
 }
 
 #[derive(Debug, PartialEq, Clone)]

schala-lang/language/src/parsing/mod.rs

@@ -67,7 +67,7 @@
 //!
 //! ## Expressions
 //! ```text
-//! expression := precedence_expr type_anno+
+//! expression := precedence_expr type_anno?
 //! precedence_expr := prefix_expr
 //! prefix_expr := prefix_op call_expr
 //! prefix_op := "+" | "-" | "!" | "~"
@@ -83,7 +83,7 @@
 //!
 //! ```text
 //! list_expr := "[" (expression, ",")* "]"
-//! lambda_expr := "\\" lambda_param_list type_anno+ nonempty_func_body
+//! lambda_expr := "\\" lambda_param_list type_anno? nonempty_func_body
 //! lambda_param_list := formal_param_list |  formal_param
 //! paren_expr := "(" paren_inner ")"
 //! paren_inner := (expression ",")*
@@ -161,6 +161,7 @@
 //! module := 'module' IDENTIFIER '{' statement* '}'
 //! ```
 mod test;
+mod new_tests;
 
 use std::rc::Rc;
 
@@ -729,6 +730,9 @@ impl Parser {
     let primary = self.primary()?;
     Ok(if let LSquareBracket = self.token_handler.peek_kind() {
       let indexers = delimited!(self, LSquareBracket, expression, Comma, RSquareBracket);
+      if indexers.is_empty() {
+        return ParseError::new_with_token("Empty index expressions are not allowed", self.token_handler.peek());
+      }
       Expression::new(self.id_store.fresh(), ExpressionKind::Index {
         indexee: Box::new(Expression::new(self.id_store.fresh(), primary.kind)),
         indexers,

schala-lang/language/src/parsing/new_tests.rs

@@ -0,0 +1,670 @@
+#![cfg(test)]
+#![allow(clippy::upper_case_acronyms)]
+#![allow(clippy::vec_init_then_push)]
+//use test_case::test_case;
+use std::rc::Rc;
+
+use pretty_assertions::assert_eq;
+
+use super::{tokenize, ParseResult, Parser};
+use crate::{ast::*, tokenizing::Location};
+
+fn rc(s: &str) -> Rc<String> {
+    Rc::new(s.to_owned())
+}
+
+fn bx<T>(item: T) -> Box<T> {
+    Box::new(item)
+}
+
+fn make_parser(input: &str) -> Parser {
+    let tokens: Vec<crate::tokenizing::Token> = tokenize(input);
+    let mut parser = super::Parser::new();
+    parser.add_new_tokens(tokens);
+    parser
+}
+
+fn parse(input: &str) -> ParseResult<AST> {
+    let mut parser = make_parser(input);
+    parser.parse()
+}
+
+fn stmt(kind: StatementKind) -> Statement {
+    Statement { location: Location::default(), id: ItemId::default(), 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() }
+    }
+  };
+}
+
+macro_rules! assert_ast {
+    ($input:expr, $statements:expr) => {
+        let ast = parse($input).unwrap();
+        let expected = AST { id: Default::default(), statements: $statements.into() };
+        println!("Expected: {}", expected);
+        println!("Actual: {}", ast);
+        assert_eq!(ast, expected);
+    };
+}
+
+macro_rules! assert_fail {
+    ($input:expr, $failure:expr) => {
+        let err = parse($input).unwrap_err();
+        assert_eq!(err.msg, $failure);
+    };
+}
+
+macro_rules! assert_expr {
+    ($input:expr, $correct:expr) => {
+        let mut parser = make_parser($input);
+        assert_eq!(parser.expression().unwrap(), $correct);
+    };
+}
+
+macro_rules! assert_fail_expr {
+    ($input:expr, $failure:expr) => {
+        let mut parser = make_parser($input);
+        let err = parser.expression().unwrap_err();
+        assert_eq!(err.msg, $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)));
+    assert_expr!(r#""hello""#, expr(StringLiteral(rc("hello"))));
+}
+
+#[test]
+fn binexps() {
+    use ExpressionKind::*;
+    use StatementKind::Expression;
+
+    assert_expr!("0xf_f_+1", binop("+", expr(NatLiteral(255)), expr(NatLiteral(1))));
+    assert_eq!(
+        parse("3; 4; 4.3").unwrap(),
+        AST {
+            id: Default::default(),
+            statements: vec![
+                stmt(Expression(expr(NatLiteral(3)))),
+                stmt(Expression(expr(NatLiteral(4)))),
+                stmt(Expression(expr(FloatLiteral(4.3)))),
+            ]
+            .into()
+        }
+    );
+
+    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))));
+}
+
+//TODO have a test for dot accessors
+/*
+  assert_expr!("a.b.c.d", exst!(binexp!(".",
+                                              binexp!(".",
+                                                binexp!(".", val!("a"), val!("b")),
+                                              val!("c")),
+                                              val!("d"))));
+*/
+
+#[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!(
+        "a[b,c]",
+        expr(Index {
+            indexee: bx(expr(Value(qn!(a)))),
+            indexers: vec![expr(Value(qn!(b))), expr(Value(qn!(c)))]
+        })
+    );
+    //TODO this is a parser bug
+    /*
+    assert_expr!("perspicacity()[a]", expr(Index{
+        indexee: bx(expr(Call {
+            f: bx(expr(Value(qn!(perspicacity)))),
+            arguments: vec![]
+        })),
+        indexers: vec![expr(Value(qn!(a)))]
+    }));
+    */
+    //TODO parse_test("a()[b]()[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 reserved_words() {
+    assert_fail!("module::item::call()", "Expected an identifier, got Colon");
+}
+
+#[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 declarations() {
+    use ExpressionKind::*;
+
+    assert_ast!(
+        "let q_q = Yolo::Swaggins",
+        vec![stmt(StatementKind::Declaration(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)", "Expected a literal expression, got Comma");
+
+    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![] })),
+        })))]
+    );
+}
+
+#[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::*;
+    let int_anno = TypeIdentifier::Singleton(TypeSingletonName { name: rc("Int"), params: vec![] });
+
+    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(int_anno.clone()), default: None },
+                    FormalParam { name: rc("y"), anno: Some(int_anno), 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 annotations() {
+    use ExpressionKind::*;
+
+    assert_ast! {
+        r#"
+        @test_annotation
+        fn some_function() {
+
+        }"#,
+        vec![decl(Declaration::Annotation {
+            name: rc("test_annotation"),
+            arguments: vec![]
+        }),
+        fn_decl(Signature { name: rc("some_function"), operator: false, params: vec![], type_anno: None },
+        vec![].into())
+        ]
+    };
+
+    assert_ast! {
+        r#"
+        @test_annotation(some,value)
+        fn some_function() {
+
+        }"#,
+        vec![decl(Declaration::Annotation {
+            name: rc("test_annotation"),
+            arguments: vec![expr(Value(qn!(some))), expr(Value(qn!(value)))]
+        }),
+        fn_decl(Signature { name: rc("some_function"), operator: false, params: vec![], type_anno: None },
+        vec![].into())
+        ]
+    };
+}
+
+#[test]
+fn modules() {
+    assert_ast! {
+        r#"
+    module ephraim {
+        let mut a = 10
+        fn nah() { 33 }
+    }
+    "#,
+    vec![stmt(StatementKind::Module(ModuleSpecifier {
+        name: rc("ephraim"),
+        contents: 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,
+        }))]
+    };
+}

schala-lang/language/src/parsing/test.rs

@@ -13,7 +13,6 @@ use super::TypeIdentifier::*;
 use super::TypeSingletonName;
 use super::ExpressionKind::*;
 use super::VariantKind::*;
-use super::ForBody::*;
 
 fn make_parser(input: &str) -> Parser {
   let tokens: Vec<crate::tokenizing::Token> = tokenize(input);
@@ -50,9 +49,6 @@ macro_rules! parse_test {
 macro_rules! parse_test_wrap_ast {
   ($string:expr, $correct:expr) => { parse_test!($string, AST { id: Default::default(), statements: vec![$correct].into() }) }
 }
-macro_rules! parse_error {
-  ($string:expr) => { assert!(parse($string).is_err()) }
-}
 macro_rules! qname {
   (  $( $component:expr),* ) => {
     {
@@ -80,18 +76,6 @@ macro_rules! decl {
   };
 }
 
-macro_rules! import {
-  ($import_spec:expr) => {
-    make_statement(StatementKind::Import($import_spec))
-  }
-}
-
-macro_rules! module {
-  ($module_spec:expr) => {
-    make_statement(StatementKind::Module($module_spec))
-  }
-}
-
 macro_rules! ex {
   ($expr_type:expr) => { Expression::new(Default::default(), $expr_type) };
   ($expr_type:expr, $type_anno:expr) => { Expression::with_anno(Default::default(), $expr_type, $type_anno) };
@@ -107,12 +91,6 @@ macro_rules! inv {
   ($expr_type:expr) => { InvocationArgument::Positional($expr_type) }
 }
 
-macro_rules! binexp {
-  ($op:expr, $lhs:expr, $rhs:expr) => { BinExp(BinOp::from_sigil($op), bx!(Expression::new(Default::default(), $lhs).into()), bx!(Expression::new(Default::default(), $rhs).into())) }
-}
-macro_rules! prefexp {
-  ($op:expr, $lhs:expr) => { PrefixExp(PrefixOp::from_sigil($op), bx!(Expression::new(Default::default(), $lhs).into())) }
-}
 macro_rules! exst {
   ($expr_type:expr) => { make_statement(StatementKind::Expression(Expression::new(Default::default(), $expr_type).into())) };
   ($expr_type:expr, $type_anno:expr) => { make_statement(StatementKind::Expression(Expression::with_anno(Default::default(), $expr_type, $type_anno).into())) };
@@ -125,201 +103,6 @@ macro_rules! exst {
   }
 }
 
-#[test]
-fn parsing_number_literals_and_binexps() {
-  parse_test_wrap_ast! { ".2", exst!(FloatLiteral(0.2)) };
-  parse_test_wrap_ast! { "8.1", exst!(FloatLiteral(8.1)) };
-
-  parse_test_wrap_ast! { "0b010", exst!(NatLiteral(2)) };
-  parse_test_wrap_ast! { "0b0_1_0_", exst!(NatLiteral(2)) }
-
-  parse_test_wrap_ast! {"0xff", exst!(NatLiteral(255)) };
-  parse_test_wrap_ast! {"0xf_f_", exst!(NatLiteral(255)) };
-
-  parse_test_wrap_ast! {"0xf_f_+1", exst!(binexp!("+", NatLiteral(255), NatLiteral(1))) };
-
-  parse_test! {"3; 4; 4.3",
-    AST {
-      id: Default::default(),
-      statements: vec![exst!(NatLiteral(3)), exst!(NatLiteral(4)),
-      exst!(FloatLiteral(4.3))].into()
-    }
-  };
-
-  parse_test_wrap_ast!("1 + 2 * 3",
-    exst!(binexp!("+", NatLiteral(1), binexp!("*", NatLiteral(2), NatLiteral(3))))
-  );
-
-  parse_test_wrap_ast!("1 * 2 + 3",
-    exst!(binexp!("+", binexp!("*", NatLiteral(1), NatLiteral(2)), NatLiteral(3)))
-    ) ;
-
-  parse_test_wrap_ast!("1 && 2", exst!(binexp!("&&", NatLiteral(1), NatLiteral(2))));
-
-  parse_test_wrap_ast!("1 + 2 * 3 + 4", exst!(
-    binexp!("+",
-      binexp!("+", NatLiteral(1), binexp!("*", NatLiteral(2), NatLiteral(3))),
-      NatLiteral(4))));
-
-  parse_test_wrap_ast!("(1 + 2) * 3",
-    exst!(binexp!("*", binexp!("+", NatLiteral(1), NatLiteral(2)), NatLiteral(3))));
-
-  parse_test_wrap_ast!(".1 + .2", exst!(binexp!("+", FloatLiteral(0.1), FloatLiteral(0.2))));
-  parse_test_wrap_ast!("1 / 2", exst!(binexp!("/", NatLiteral(1), NatLiteral(2))));
-}
-
-#[test]
-fn parsing_tuples() {
-  parse_test_wrap_ast!("()", exst!(TupleLiteral(vec![])));
-  parse_test_wrap_ast!("(\"hella\", 34)", exst!(
-    TupleLiteral(
-      vec![ex!(s r#""hella""#), ex!(s "34")]
-    )
-  ));
-  parse_test_wrap_ast!("((1+2), \"slough\")", exst!(TupleLiteral(vec![
-    ex!(binexp!("+", NatLiteral(1), NatLiteral(2))),
-    ex!(StringLiteral(rc!(slough))),
-  ])))
-}
-
-#[test]
-fn parsing_identifiers() {
-  parse_test_wrap_ast!("a", exst!(val!("a")));
-  parse_test_wrap_ast!("some_value", exst!(val!("some_value")));
-  parse_test_wrap_ast!("a + b", exst!(binexp!("+", val!("a"), val!("b"))));
-  //parse_test!("a[b]", AST(vec![Expression(
-  //parse_test!("a[]", <- TODO THIS NEEDS TO FAIL
-  //parse_test("a()[b]()[d]")
-  //TODO fix this parsing stuff
-  /*
-  parse_test! { "perspicacity()[a]", AST(vec![
-    exst!(Index {
-      indexee: bx!(ex!(Call { f: bx!(ex!(val!("perspicacity"))), arguments: vec![] })),
-      indexers: vec![ex!(val!("a"))]
-    })
-  ])
-  }
-  */
-  parse_test_wrap_ast!("a[b,c]", exst!(Index { indexee: bx!(ex!(val!("a"))), indexers: vec![ex!(val!("b")), ex!(val!("c"))]} ));
-
-  parse_test_wrap_ast!("None", exst!(val!("None")));
-  parse_test_wrap_ast!("Pandas {  a: x + y }",
-    exst!(NamedStruct { name: qname!(Pandas), fields: vec![(rc!(a), ex!(binexp!("+", val!("x"), val!("y"))))]})
-  );
-  parse_test_wrap_ast! { "Pandas { a: n, b: q, }",
-    exst!(NamedStruct { name: qname!(Pandas), fields:
-    vec![(rc!(a), ex!(val!("n"))), (rc!(b), ex!(val!("q")))]
-    }
-    )
-  };
-}
-
-
-#[test]
-fn qualified_identifiers() {
-  parse_test_wrap_ast! {
-    "let q_q = Yolo::Swaggins",
-    decl!(Binding { name: rc!(q_q), constant: true, type_anno: None,
-    expr: Expression::new(Default::default(), Value(qname!(Yolo, Swaggins))),
-    })
-  }
-
-  parse_test_wrap_ast! {
-    "thing::item::call()",
-    exst!(Call { f: bx![ex!(Value(qname!(thing, item, call)))], arguments: vec![] })
-  }
-}
-
-#[test]
-fn reserved_words() {
-  parse_error!("module::item::call()");
-}
-
-#[test]
-fn parsing_complicated_operators() {
-  parse_test_wrap_ast!("a <- b", exst!(binexp!("<-", val!("a"), val!("b"))));
-  parse_test_wrap_ast!("a || b", exst!(binexp!("||", val!("a"), val!("b"))));
-  parse_test_wrap_ast!("a<>b", exst!(binexp!("<>", val!("a"), val!("b"))));
-  parse_test_wrap_ast!("a.b.c.d", exst!(binexp!(".",
-                                              binexp!(".",
-                                                binexp!(".", val!("a"), val!("b")),
-                                              val!("c")),
-                                              val!("d"))));
-  parse_test_wrap_ast!("-3", exst!(prefexp!("-", NatLiteral(3))));
-  parse_test_wrap_ast!("-0.2", exst!(prefexp!("-", FloatLiteral(0.2))));
-  parse_test_wrap_ast!("!3", exst!(prefexp!("!", NatLiteral(3))));
-  parse_test_wrap_ast!("a <- -b", exst!(binexp!("<-", val!("a"), prefexp!("-", val!("b")))));
-  parse_test_wrap_ast!("a <--b", exst!(binexp!("<--", val!("a"), val!("b"))));
-}
-
-#[test]
-fn parsing_functions() {
-  parse_test_wrap_ast!("fn oi()",  decl!(FuncSig(Signature { name: rc!(oi), operator: false, params: vec![], type_anno: None })));
-  parse_test_wrap_ast!("oi()", exst!(Call { f: bx!(ex!(val!("oi"))), arguments: vec![] }));
-  parse_test_wrap_ast!("oi(a, 2 + 2)", exst!(Call
-  { f: bx!(ex!(val!("oi"))),
-    arguments: vec![inv!(ex!(val!("a"))), inv!(ex!(binexp!("+", NatLiteral(2), NatLiteral(2))))]
-  }));
-  parse_error!("a(b,,c)");
-
-  parse_test_wrap_ast!("fn a(b, c: Int): Int", decl!(
-      FuncSig(Signature { name: rc!(a), operator: false, params: vec![
-        FormalParam { name: rc!(b), anno: None, default: None },
-        FormalParam { name: rc!(c), anno: Some(ty!("Int")), default: None }
-      ], type_anno: Some(ty!("Int")) })));
-
-
-  parse_test_wrap_ast!("fn a(x) { x() }", decl!(
-      FuncDecl(Signature { name: rc!(a), operator: false, params: vec![FormalParam { name: rc!(x), anno: None, default: None }], type_anno: None },
-      vec![exst!(Call { f: bx!(ex!(val!("x"))), arguments: vec![] })].into())));
-  parse_test_wrap_ast!("fn a(x) {\n x() }", decl!(
-      FuncDecl(Signature { name: rc!(a), operator: false, params: vec![FormalParam { name: rc!(x), anno: None, default: None }], type_anno: None },
-      vec![exst!(Call { f: bx!(ex!(val!("x"))), arguments: vec![] })].into())));
-
-  let multiline = r#"
-fn a(x) {
-x()
-}
-"#;
-parse_test_wrap_ast!(multiline, decl!(
-    FuncDecl(Signature { name: rc!(a), operator: false, params: vec![FormalParam { name: rc!(x), default: None, anno: None }], type_anno: None },
-    vec![exst!(Call { f: bx!(ex!(val!("x"))), arguments: vec![] })].into())));
-  let multiline2 = r#"
-fn a(x) {
-
-x()
-
-}
-"#;
-parse_test_wrap_ast!(multiline2, decl!(
-    FuncDecl(Signature { name: rc!(a), operator: false, params: vec![FormalParam { name: rc!(x), default: None, anno: None }], type_anno: None },
-    exst!(s "x()").into())));
-}
-
-#[test]
-fn functions_with_default_args() {
-  parse_test_wrap_ast! {
-    "fn func(x: Int, y: Int = 4) { }",
-    decl!(
-      FuncDecl(Signature { name: rc!(func), operator: false, type_anno: None, params: vec![
-        FormalParam { name: rc!(x), default: None, anno: Some(ty!("Int")) },
-        FormalParam { name: rc!(y), default: Some(ex!(s "4")), anno: Some(ty!("Int")) }
-      ]}, vec![].into())
-    )
-  };
-}
-
-#[test]
-fn parsing_bools() {
-  parse_test_wrap_ast!("false", exst!(BoolLiteral(false)));
-  parse_test_wrap_ast!("true", exst!(BoolLiteral(true)));
-}
-
-#[test]
-fn parsing_strings() {
-  parse_test_wrap_ast!(r#""hello""#, exst!(StringLiteral(rc!(hello))));
-}
-
 #[test]
 fn parsing_types() {
   parse_test_wrap_ast!("type Yolo = Yolo", decl!(TypeDecl { name: tys!("Yolo"), body: TypeBody(vec![Variant { id: ItemId::default(), kind: UnitStruct, name: rc!(Yolo) }]), mutable: false} ));
@@ -363,16 +146,6 @@ fn parsing_types() {
   };
 }
 
-#[test]
-fn parsing_bindings() {
-  parse_test_wrap_ast!("let mut a = 10", decl!(Binding { name: rc!(a), constant: false, type_anno: None, expr: ex!(NatLiteral(10)) } ));
-  parse_test_wrap_ast!("let a = 2 + 2", decl!(Binding { name: rc!(a), constant: true, type_anno: None, expr: ex!(binexp!("+", NatLiteral(2), NatLiteral(2))) }));
-  parse_test_wrap_ast!("let a: Nat = 2 + 2", decl!(
-      Binding { name: rc!(a), constant: true, type_anno: Some(Singleton(TypeSingletonName { name: rc!(Nat), params: vec![] })),
-      expr: ex!(binexp!("+", NatLiteral(2), NatLiteral(2))) }
-  ));
-}
-
 #[test]
 fn parsing_block_expressions() {
   parse_test_wrap_ast! {
@@ -439,25 +212,6 @@ fn parsing_block_expressions() {
   parse_error!("if A {a: 1} { b } else { c }");
   */
 }
-#[test]
-fn parsing_interfaces() {
-  parse_test_wrap_ast!("interface Unglueable { fn unglue(a: Glue); fn mar(): Glue }",
-  decl!(Interface {
-    name: rc!(Unglueable),
-    signatures: vec![
-      Signature {
-        name: rc!(unglue),
-        operator: false,
-        params: vec![
-          FormalParam { name: rc!(a), anno: Some(Singleton(TypeSingletonName { name: rc!(Glue), params: vec![] })), default: None }
-        ],
-        type_anno: None
-      },
-      Signature { name: rc!(mar), operator: false, params: vec![], type_anno: Some(Singleton(TypeSingletonName { name: rc!(Glue), params: vec![] })) },
-    ]
-  })
-  );
-}
 
 #[test]
 fn parsing_impls() {
@@ -497,33 +251,6 @@ fn parsing_impls() {
   }));
 }
 
-#[test]
-fn parsing_type_annotations() {
-  parse_test_wrap_ast!("let a = b : Int",
-    decl!(Binding { name: rc!(a), constant: true, type_anno: None, expr:
-      ex!(val!("b"), ty!("Int")) }));
-
-  parse_test_wrap_ast!("a : Int",
-    exst!(val!("a"), ty!("Int"))
-  );
-
-  parse_test_wrap_ast!("a : Option<Int>",
-    exst!(val!("a"), Singleton(TypeSingletonName { name: rc!(Option), params: vec![ty!("Int")] }))
-  );
-
-  parse_test_wrap_ast!("a : KoreanBBQSpecifier<Kimchi, Option<Bulgogi> >",
-    exst!(val!("a"), Singleton(TypeSingletonName { name: rc!(KoreanBBQSpecifier), params: vec![
-      ty!("Kimchi"), Singleton(TypeSingletonName { name: rc!(Option), params: vec![ty!("Bulgogi")] })
-    ] }))
-  );
-
-  parse_test_wrap_ast!("a : (Int, Yolo<a>)",
-    exst!(val!("a"), Tuple(
-      vec![ty!("Int"), Singleton(TypeSingletonName {
-        name: rc!(Yolo), params: vec![ty!("a")]
-      })])));
-}
-
 #[test]
 fn parsing_lambdas() {
   parse_test_wrap_ast! { r#"\(x) { x + 1}"#, exst!(
@@ -615,37 +342,6 @@ fn more_advanced_lambdas() {
     };
   }
 
-#[test]
-fn while_expr() {
-  parse_test_wrap_ast! {
-    "while { }",
-    exst!(WhileExpression { condition: None, body: Block::default() })
-  }
-
-  parse_test_wrap_ast! {
-    "while a == b { }",
-    exst!(WhileExpression { condition: Some(bx![ex![binexp!("==", val!("a"), val!("b"))]]), body: Block::default() })
-  }
-}
-
-#[test]
-fn for_expr() {
-  parse_test_wrap_ast! {
-    "for { a <- maybeValue } return 1",
-    exst!(ForExpression {
-      enumerators: vec![Enumerator { id: rc!(a), generator: ex!(val!("maybeValue")) }],
-      body: bx!(MonadicReturn(ex!(s "1")))
-    })
-  }
-
-  parse_test_wrap_ast! {
-    "for n <- someRange { f(n); }",
-    exst!(ForExpression { enumerators: vec![Enumerator { id: rc!(n), generator: ex!(val!("someRange"))}],
-      body: bx!(ForBody::StatementBlock(vec![exst!(s "f(n)")].into()))
-    })
-  }
-}
-
 #[test]
 fn patterns() {
   parse_test_wrap_ast! {
@@ -751,58 +447,6 @@ fn pattern_literals() {
   }
 }
 
-#[test]
-fn imports() {
-  parse_test_wrap_ast! {
-    "import harbinger::draughts::Norgleheim",
-    import!(ImportSpecifier { 
-      id: Default::default(),
-      path_components: vec![rc!(harbinger), rc!(draughts), rc!(Norgleheim)],
-      imported_names: ImportedNames::LastOfPath
-    })
-  }
-}
-
-#[test]
-fn imports_2() {
-  parse_test_wrap_ast! {
-    "import harbinger::draughts::{Norgleheim, Xraksenlaigar}",
-    import!(ImportSpecifier { 
-      id: Default::default(),
-      path_components: vec![rc!(harbinger), rc!(draughts)],
-      imported_names: ImportedNames::List(vec![
-        rc!(Norgleheim),
-        rc!(Xraksenlaigar)
-      ])
-    })
-  }
-}
-
-#[test]
-fn imports_3() {
-  parse_test_wrap_ast! {
-    "import bespouri::{}",
-    import!(ImportSpecifier { 
-      id: Default::default(),
-      path_components: vec![rc!(bespouri)],
-      imported_names: ImportedNames::List(vec![])
-    })
-  }
-}
-
-
-#[test]
-fn imports_4() {
-  parse_test_wrap_ast! {
-    "import bespouri::*",
-    import!(ImportSpecifier {
-      id: Default::default(),
-      path_components: vec![rc!(bespouri)],
-      imported_names: ImportedNames::All
-    })
-  }
-}
-
 
 #[test]
 fn if_expr() {
@@ -878,64 +522,3 @@ if (45, "panda", false, 2.2) {
       )
     }
 }
-
-#[test]
-fn modules() {
-  parse_test_wrap_ast! {
-r#"
-  module ephraim {
-    let a = 10
-    fn nah() { 33 }
-  }
-"#,
-module!(
-  ModuleSpecifier { name: rc!(ephraim), contents: vec![
-    decl!(Binding { name: rc!(a), constant: true, type_anno: None, expr: ex!(s "10") }),
-    decl!(FuncDecl(Signature { name: rc!(nah), operator: false, params: vec![], type_anno: None }, vec![exst!(NatLiteral(33))].into())),
-  ].into() }
-)
-  }
-}
-
-#[test]
-fn annotations() {
-    parse_test! {
-        r#"
-        @test_annotation
-        fn some_function() {
-
-        }"#,
-        AST {
-            id: Default::default(),
-            statements: vec![
-                decl!(Annotation { name: rc!(test_annotation), arguments: vec![] }),
-                decl!(FuncDecl(
-                        Signature { name: rc!(some_function), operator: false, params: vec![], type_anno: None }
-                        , vec![].into()
-                      )
-                )
-            ].into()
-        }
-    };
-    parse_test! {
-        r#"
-        @test_annotation(some, value)
-        fn some_function() {
-
-        }"#,
-        AST {
-            id: Default::default(),
-            statements: vec![
-                decl!(Annotation { name: rc!(test_annotation), arguments: vec![
-                    ex!(val!("some")),
-                    ex!(val!("value"))
-                ] }),
-                decl!(FuncDecl(
-                        Signature { name: rc!(some_function), operator: false, params: vec![], type_anno: None }
-                        , vec![].into()
-                      )
-                )
-            ].into()
-        }
-    };
-}