add parser torture testing framework

Author: nikomatsakis

tests/parser-torture-tests/ambiguity.rs

@@ -0,0 +1,57 @@
+use formality_core::term;
+use std::sync::Arc;
+
+#[test]
+#[should_panic(expected = "ambiguous parse")] // FIXME: we want this example to work
+fn reduce_reduce_ok() {
+    #[term]
+    pub enum Root {
+        #[cast]
+        ClassTy(ClassTy),
+        #[cast]
+        Perm(Perm),
+    }
+
+    #[term($perm $class_id)]
+    pub struct ClassTy {
+        perm: Perm,
+        class_id: Id,
+    }
+
+    #[term]
+    pub enum Perm {
+        My,
+        Our,
+    }
+
+    formality_core::id!(Id);
+
+    let term: Root = crate::ptt::term("my String");
+    expect_test::expect![].assert_debug_eq(&term);
+}
+
+#[test]
+#[should_panic(expected = "ambiguous parse")]
+fn reduce_reduce_ambig() {
+    #[term]
+    pub enum Root {
+        #[grammar($v0)]
+        OneId(Id),
+        #[grammar($v0 $v1)]
+        TwoId(Id, Id),
+        #[grammar($v0 $v1)]
+        TwoRr(Arc<Root>, Arc<Root>),
+    }
+
+    formality_core::id!(Id);
+
+    // This will panic. It could be parsed in multiple ways
+    // (using a variant of Reverse Polish Notation) and none is obviously
+    // better than the other:
+    //
+    // Root = ((Id Root::OneId) (Id Id Root::TwoId) Root::TwoRr)
+    // Root = (Id Id Root::TwoId) (Id Root::OneId) Root::TwoRr)
+    // Root = ((Id Root::OneId) (Id Root::OneId) (Id Root::OneId) Root::TwoRr)
+    let term: Root = crate::ptt::term("a b c");
+    expect_test::expect![].assert_debug_eq(&term);
+}

tests/parser-torture-tests/grammar.rs

@@ -0,0 +1,42 @@
+use crate::ptt::{
+    grammar::{BoundVar, ExistentialVar, UniversalVar, Variable},
+    FormalityLang,
+};
+use formality_core::{language::HasKind, term};
+
+// Create a dummy kind/parameter -- we're not using these for the torture
+// tests, but we need them.
+
+#[term]
+#[derive(Copy)]
+pub enum DummyKind {
+    Ty,
+}
+
+#[term]
+pub enum DummyParameter {
+    #[cast]
+    Ty(DummyTy),
+}
+
+#[term]
+pub enum DummyTy {
+    #[variable]
+    Variable(Variable),
+}
+
+formality_core::cast_impl!((BoundVar) <: (Variable) <: (DummyTy));
+formality_core::cast_impl!((ExistentialVar) <: (Variable) <: (DummyTy));
+formality_core::cast_impl!((UniversalVar) <: (Variable) <: (DummyTy));
+formality_core::cast_impl!((Variable) <: (DummyTy) <: (DummyParameter));
+formality_core::cast_impl!((BoundVar) <: (DummyTy) <: (DummyParameter));
+formality_core::cast_impl!((ExistentialVar) <: (DummyTy) <: (DummyParameter));
+formality_core::cast_impl!((UniversalVar) <: (DummyTy) <: (DummyParameter));
+
+impl HasKind<FormalityLang> for DummyParameter {
+    fn kind(&self) -> formality_core::language::CoreKind<FormalityLang> {
+        match self {
+            DummyParameter::Ty(_) => DummyKind::Ty,
+        }
+    }
+}

tests/parser-torture-tests/main.rs

@@ -0,0 +1,28 @@
+mod ambiguity;
+mod grammar;
+mod precedence;
+
+formality_core::declare_language! {
+    mod ptt {
+        const NAME = "PTT";
+        type Kind = crate::grammar::DummyKind;
+        type Parameter = crate::grammar::DummyParameter;
+        const BINDING_OPEN = '<';
+        const BINDING_CLOSE = '>';
+        const KEYWORDS = [
+            "struct",
+            "fn",
+            "let",
+            "in",
+            "integer",
+        ];
+    }
+}
+
+// Default language for our crate
+use formality_core::Fallible;
+use ptt::FormalityLang;
+
+fn main() -> Fallible<()> {
+    Ok(())
+}

tests/parser-torture-tests/precedence.rs

@@ -0,0 +1,26 @@
+use formality_core::term;
+use std::sync::Arc;
+
+#[test]
+fn precedence() {
+    #[term]
+    pub enum Root {
+        #[cast]
+        Id(Id),
+
+        #[grammar($v0 + $v1)]
+        Add(Arc<Root>, Arc<Root>),
+
+        #[grammar($v0 * $v1)]
+        #[precedence(1)]
+        Mul(Arc<Root>, Arc<Root>),
+    }
+
+    formality_core::id!(Id);
+
+    let term: Root = crate::ptt::term("a + b * c");
+    expect_test::expect![[r#"
+        a + b * c
+    "#]]
+    .assert_debug_eq(&term);
+}