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

#![cfg(test)]
#![allow(clippy::upper_case_acronyms)]
#![allow(clippy::vec_init_then_push)]

use std::rc::Rc;

use crate::tokenizing::Location;
use super::{Parser, ParseResult, tokenize};
use crate::ast::*;
use super::Declaration::*;
use super::Signature;
use super::TypeIdentifier::*;
use super::TypeSingletonName;
use super::ExpressionKind::*;
use super::VariantKind::*;

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()
}

//TODO maybe can be const?
fn make_statement(kind: StatementKind) -> Statement {
  Statement {
    location: Location::default(),
    id: ItemId::default(),
    kind,
  }
}

macro_rules! bx {
    ($e:expr) => {
        Box::new($e)
    };
}

macro_rules! parse_test {
  ($string:expr, $correct:expr) => {
    assert_eq!(parse($string).unwrap(), $correct)
  };
}
macro_rules! parse_test_wrap_ast {
  ($string:expr, $correct:expr) => { parse_test!($string, AST { id: Default::default(), statements: vec![$correct].into() }) }
}
macro_rules! qname {
  (  $( $component:expr),* ) => {
    {
    let mut components = vec![];
    $(
      components.push(rc!($component));
    )*
    QualifiedName { components, id: Default::default() }
    }
  };
}
macro_rules! val {
  ($var:expr) => { Value(QualifiedName { components: vec![Rc::new($var.to_string())], id: Default::default() }) };
}
macro_rules! ty {
  ($name:expr) => { Singleton(tys!($name)) }
}
macro_rules! tys {
  ($name:expr) => { TypeSingletonName { name: Rc::new($name.to_string()), params: vec![] } };
}

macro_rules! decl {
  ($expr_type:expr) => {
    make_statement(StatementKind::Declaration($expr_type))
  };
}

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) };
  (s $expr_text:expr) => {
    {
      let mut parser = make_parser($expr_text);
      parser.expression().unwrap()
    }
  };
}

macro_rules! inv {
  ($expr_type:expr) => { InvocationArgument::Positional($expr_type) }
}

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())) };
  ($op:expr, $lhs:expr, $rhs:expr) => { make_statement(StatementKind::Expression(ex!(binexp!($op, $lhs, $rhs)))) };
  (s $statement_text:expr) => {
    {
      let mut parser = make_parser($statement_text);
      parser.statement().unwrap()
    }
  }
}

#[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} ));
  parse_test_wrap_ast!("type mut Yolo = Yolo", decl!(TypeDecl { name: tys!("Yolo"), body: TypeBody(vec![Variant { id: ItemId::default(), kind: UnitStruct, name: rc!(Yolo) }]), mutable: true} ));
  parse_test_wrap_ast!("type alias Sex = Drugs", decl!(TypeAlias { alias: rc!(Sex), original: rc!(Drugs) }));
  parse_test_wrap_ast!("type Sanchez = Miguel | Alejandro(Int, Option<a>) | Esperanza { a: Int, b: String }",
  decl!(TypeDecl {
    name: tys!("Sanchez"),
    body: TypeBody(vec![
      Variant {
          id: ItemId::default(),
          kind: UnitStruct, name: rc!(Miguel) },
      Variant {
          id: ItemId::default(),
          name: rc!(Alejandro),
          kind: TupleStruct(vec![
        Singleton(TypeSingletonName { name: rc!(Int), params: vec![] }),
        Singleton(TypeSingletonName { name: rc!(Option), params: vec![Singleton(TypeSingletonName { name: rc!(a), params: vec![] })] }),
      ])
      },
      Variant {
          id: ItemId::default(),
          name: rc!(Esperanza),
          kind: Record(vec![
          (rc!(a), Singleton(TypeSingletonName { name: rc!(Int), params: vec![] })),
          (rc!(b), Singleton(TypeSingletonName { name: rc!(String), params: vec![] })),
        ])
      }
    ]),
    mutable: false
  }));

  parse_test_wrap_ast! {
    "type Jorge<a> = Diego | Kike(a)",
    decl!(TypeDecl{
      name: TypeSingletonName { name: rc!(Jorge), params: vec![Singleton(TypeSingletonName { name: rc!(a), params: vec![] })] },
      body: TypeBody(vec![Variant{ id: ItemId::default(), kind: UnitStruct, name: rc!(Diego) }, Variant { id: ItemId::default(), name: rc!(Kike), kind: TupleStruct( vec![Singleton(TypeSingletonName { name: rc!(a), params: vec![] })]) }]),
      mutable: false
    }
    )
  };
}

#[test]
fn parsing_block_expressions() {
  parse_test_wrap_ast! {
    "if a() then { b(); c() }", exst!(
      IfExpression {
        discriminator: Some(bx! {
          ex!(Call { f: bx!(ex!(val!("a"))), arguments: vec![]})
        }),
        body: bx! {
          IfExpressionBody::SimpleConditional {
            then_case: vec![exst!(Call { f: bx!(ex!(val!("b"))), arguments: vec![]}), exst!(Call { f: bx!(ex!(val!("c"))), arguments: vec![] })].into(),
            else_case: None,
          }
        }
      }
    )
  };

  parse_test_wrap_ast! {
    "if a() then { b(); c() } else { q }", exst!(
      IfExpression {
        discriminator: Some(bx! {
          ex!(Call { f: bx!(ex!(val!("a"))), arguments: vec![]})
        }),
        body: bx! {
          IfExpressionBody::SimpleConditional {
            then_case: vec![exst!(Call { f: bx!(ex!(val!("b"))), arguments: vec![]}), exst!(Call { f: bx!(ex!(val!("c"))), arguments: vec![] })].into(),
            else_case: Some(vec![exst!(val!("q"))].into()),
          }
        }
      }
    )
  };

  /*
  parse_test!("if a() then { b(); c() }", AST(vec![exst!(
      IfExpression(bx!(ex!(Call { f: bx!(ex!(val!("a"))), arguments: vec![]})),
        vec![exst!(Call { f: bx!(ex!(val!("b"))), arguments: vec![]}), exst!(Call { f: bx!(ex!(val!("c"))), arguments: vec![] })],
        None)
      )]));
  parse_test!(r#"
  if true then {
    const a = 10
    b
  } else {
    c
  }"#,
  AST(vec![exst!(IfExpression(bx!(ex!(BoolLiteral(true))),
    vec![decl!(Binding { name: rc!(a), constant: true, expr: ex!(NatLiteral(10)) }),
          exst!(val!(rc!(b)))],
    Some(vec![exst!(val!(rc!(c)))])))])
  );

  parse_test!("if a { b } else { c }", AST(vec![exst!(
        IfExpression(bx!(ex!(val!("a"))),
          vec![exst!(val!("b"))],
          Some(vec![exst!(val!("c"))])))]));

  parse_test!("if (A {a: 1}) { b } else { c }", AST(vec![exst!(
        IfExpression(bx!(ex!(NamedStruct { name: rc!(A), fields: vec![(rc!(a), ex!(NatLiteral(1)))]})),
          vec![exst!(val!("b"))],
          Some(vec![exst!(val!("c"))])))]));

  parse_error!("if A {a: 1} { b } else { c }");
  */
}

#[test]
fn parsing_impls() {
  parse_test_wrap_ast!("impl Heh { fn yolo(); fn swagg(); }",
  decl!(Impl {
    type_name: ty!("Heh"),
    interface_name: None,
    block: vec![
      FuncSig(Signature { name: rc!(yolo), operator: false, params: vec![], type_anno: None }),
      FuncSig(Signature { name: rc!(swagg), operator: false, params: vec![], type_anno: None })
    ] }));

  parse_test_wrap_ast!("impl Mondai for Lollerino { fn yolo(); fn swagg(); }",
  decl!(Impl {
    type_name: ty!("Lollerino"),
    interface_name: Some(TypeSingletonName { name: rc!(Mondai), params: vec![] }),
    block: vec![
      FuncSig(Signature { name: rc!(yolo), operator: false, params: vec![], type_anno: None}),
      FuncSig(Signature { name: rc!(swagg), operator: false, params: vec![], type_anno: None })
    ] }));

  parse_test_wrap_ast!("impl Hella<T> for (Alpha, Omega) { }",
  decl!(Impl {
    type_name: Tuple(vec![ty!("Alpha"), ty!("Omega")]),
    interface_name: Some(TypeSingletonName { name: rc!(Hella), params: vec![ty!("T")] }),
    block: vec![]
  })
  );

  parse_test_wrap_ast!("impl Option<WTFMate> { fn oi() }",
  decl!(Impl {
    type_name: Singleton(TypeSingletonName { name: rc!(Option), params: vec![ty!("WTFMate")]}),
    interface_name: None,
    block: vec![
      FuncSig(Signature { name: rc!(oi), operator: false, params: vec![], type_anno: None }),
    ]
  }));
}

#[test]
fn parsing_lambdas() {
  parse_test_wrap_ast! { r#"\(x) { x + 1}"#, exst!(
      Lambda { params: vec![FormalParam { name: rc!(x), anno: None, default: None } ], type_anno: None, body: exst!(s "x + 1").into() }
    )
  }

  parse_test_wrap_ast!(r#"\  (x: Int, y) { a;b;c;}"#,
    exst!(Lambda {
      params: vec![
        FormalParam { name: rc!(x), anno: Some(ty!("Int")), default: None },
        FormalParam { name: rc!(y), anno: None, default: None }
      ],
      type_anno: None,
      body: vec![exst!(s "a"), exst!(s "b"), exst!(s "c")].into()
    })
  );

  parse_test_wrap_ast! { r#"\(x){y}(1)"#,
    exst!(Call { f: bx!(ex!(
      Lambda {
        params: vec![
          FormalParam { name: rc!(x), anno: None, default: None }
        ],
        type_anno: None,
        body: exst!(s "y").into() }
      )),
      arguments: vec![inv!(ex!(NatLiteral(1)))] })
  };

  parse_test_wrap_ast! {
    r#"\(x: Int): String { "q" }"#,
    exst!(Lambda {
      params: vec![
        FormalParam { name: rc!(x), anno: Some(ty!("Int")), default: None },
      ],
      type_anno: Some(ty!("String")),
      body: exst!(s r#""q""#).into()
    })
  }
}

#[test]
fn single_param_lambda() {
  parse_test_wrap_ast! {
    r"\x { x + 10 }",
    exst!(Lambda {
      params: vec![FormalParam { name: rc!(x), anno: None, default: None }],
      type_anno: None,
      body: exst!(s r"x + 10").into()
    })
  }

  parse_test_wrap_ast! {
    r"\x: Nat { x + 10 }",
    exst!(Lambda {
      params: vec![FormalParam { name: rc!(x), anno: Some(ty!("Nat")), default: None }],
      type_anno: None,
      body: exst!(s r"x + 10").into()
    })
  }
}

#[test]
fn more_advanced_lambdas() {
  parse_test! {
    r#"fn wahoo() { let a = 10; \(x) { x + a } };
    wahoo()(3) "#,
    AST {
      id: Default::default(),
      statements: vec![
        exst!(s r"fn wahoo() { let a = 10; \(x) { x + a } }"),
        exst! {
        Call {
          f: bx!(ex!(Call { f: bx!(ex!(val!("wahoo"))), arguments: vec![] })),
          arguments: vec![inv!(ex!(NatLiteral(3)))],
        }
      }
    ].into()
  }
  }
}

#[test]
  fn list_literals() {
    parse_test_wrap_ast! {
      "[1,2]",
        exst!(ListLiteral(vec![ex!(NatLiteral(1)), ex!(NatLiteral(2))]))
    };
  }

#[test]
fn patterns() {
  parse_test_wrap_ast! {
    "if x is Some(a) then { 4 } else { 9 }", exst!(
      IfExpression {
        discriminator: Some(bx!(ex!(s "x"))),
        body: bx!(IfExpressionBody::SimplePatternMatch {
          pattern: Pattern::TupleStruct(qname!(Some), vec![Pattern::VarOrName(qname!(a))]),
          then_case: vec![exst!(s "4")].into(),
          else_case: Some(vec![exst!(s "9")].into()) })
        }
      )
  }

  parse_test_wrap_ast! {
    "if x is Some(a) then 4 else 9", exst!(
      IfExpression {
        discriminator: Some(bx!(ex!(s "x"))),
        body: bx!(IfExpressionBody::SimplePatternMatch {
            pattern: Pattern::TupleStruct(qname!(Some), vec![Pattern::VarOrName(qname!(a))]),
            then_case: vec![exst!(s "4")].into(),
            else_case: Some(vec![exst!(s "9")].into()) }
          )
        }
    )
  }

  parse_test_wrap_ast! {
    "if x is Something { a, b: x } then { 4 } else { 9 }", exst!(
      IfExpression {
        discriminator: Some(bx!(ex!(s "x"))),
        body: bx!(IfExpressionBody::SimplePatternMatch {
          pattern: Pattern::Record(qname!(Something), vec![
                (rc!(a),Pattern::Literal(PatternLiteral::StringPattern(rc!(a)))),
                (rc!(b),Pattern::VarOrName(qname!(x)))
            ]),
          then_case: vec![exst!(s "4")].into(),
          else_case: Some(vec![exst!(s "9")].into())
          }
        )
      }
    )
  }
}

#[test]
fn pattern_literals() {
  parse_test_wrap_ast! {
    "if x is -1 then 1 else 2",
    exst!(
      IfExpression {
        discriminator: Some(bx!(ex!(s "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()),
        })
      }
    )
  }

  parse_test_wrap_ast! {
    "if x is 1 then 1 else 2",
    exst!(
      IfExpression {
        discriminator: Some(bx!(ex!(s "x"))),
        body: bx!(IfExpressionBody::SimplePatternMatch {
          pattern: Pattern::Literal(PatternLiteral::NumPattern { neg: false, num: NatLiteral(1) }),
          then_case: vec![exst!(s "1")].into(),
          else_case: Some(vec![exst!(s "2")].into()),
        })
      }
    )
  }

  parse_test_wrap_ast! {
    "if x is true then 1 else 2",
    exst!(
    IfExpression {
        discriminator: Some(bx!(ex!(s "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()),
          })
      }
    )
  }

  parse_test_wrap_ast! {
    "if x is \"gnosticism\" then 1 else 2",
      exst!(
        IfExpression {
          discriminator: Some(bx!(ex!(s "x"))),
          body: bx!(IfExpressionBody::SimplePatternMatch {
              pattern: Pattern::Literal(PatternLiteral::StringPattern(rc!(gnosticism))),
              then_case: vec![exst!(s "1")].into(),
              else_case: Some(vec![exst!(s "2")].into()),
          })
        }
      )
  }
}


#[test]
fn if_expr() {
  parse_test_wrap_ast! {
    "if x { is 1 then 5, else 20 }",
    exst! {
      IfExpression {
        discriminator: Some(bx!(ex!(s "x"))),
        body: bx!(IfExpressionBody::CondList(
          vec![
            ConditionArm {
              condition: Condition::Pattern(Pattern::Literal(PatternLiteral::NumPattern { neg: false, num: NatLiteral(1)})),
              guard: None,
              body: vec![exst!(s "5")].into(),
            },
            ConditionArm {
              condition: Condition::Else,
              guard: None,
              body: vec![exst!(s "20")].into(),
            },
          ]
        ))
      }
    }
  }
}

#[test]
fn advanced_if_expr() {

    parse_test_wrap_ast! {
        r#"
if (45, "panda", false, 2.2) {
    is (49, "pablo", _, 28.4) then "no"
    is (_, "panda", _, -2.2) then "yes"
    is _ then "maybe"
}"#,
      exst!(
        IfExpression {
          discriminator: Some(bx!(ex!(s r#"(45, "panda", false, 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![exst!(s r#""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![exst!(s r#""yes""#)].into(),
            },
            ConditionArm {
              condition: Condition::Pattern(Pattern::Ignored),
              guard: None,
              body: vec![exst!(s r#""maybe""#)].into(),
            },
          ]))
        }
      )
    }
}