Add tests for well-formedness

Author: purefunctor

Cargo.lock

@@ -7,6 +7,7 @@ edition = "2021"
 fxhash = "0.2.1"
 hashbrown = "0.15.2"
 indexmap = "2.7.0"
+insta = "1.42.0"
 itertools = "0.14.0"
 la-arena = "0.3.1"
 petgraph = "0.7.0"

crates/indexing/Cargo.toml

@@ -13,7 +13,8 @@ pub enum IndexingError {
     DuplicateSignature { signature: DeclarationId, duplicate: DeclarationId },
 
     InvalidRole { role: DeclarationId },
-    NonConsecutive { before: DeclarationId, after: DeclarationId },
+    InvalidOrder { early: DeclarationId, late: DeclarationId },
+    NonConsecutive { first: DeclarationId, second: DeclarationId },
 }
 
 /// The kind of a duplicate item.

crates/indexing/src/error.rs

@@ -36,24 +36,36 @@ fn check_type_item(errors: &mut Vec<IndexingError>, item: &TypeItem) {
 
 fn check_value_group_id(errors: &mut Vec<IndexingError>, group: &ValueGroupId) {
     let ValueGroupId { signature, equations } = group;
-    let signature = signature.iter().copied();
+    if let Some(signature) = signature {
+        if let [equation, ..] = &equations[..] {
+            if signature > equation {
+                errors.push(IndexingError::InvalidOrder { early: *equation, late: *signature });
+            } else if !equation.consecutive_of(signature) {
+                errors.push(IndexingError::NonConsecutive { first: *signature, second: *equation });
+            }
+        }
+    }
     let equations = equations.iter().copied();
-    for (zero, one) in signature.chain(equations).tuple_windows() {
-        if !one.consecutive_of(zero) {
-            errors.push(IndexingError::NonConsecutive { before: zero, after: one });
+    for (first, second) in equations.tuple_windows() {
+        if !second.consecutive_of(first) {
+            errors.push(IndexingError::NonConsecutive { first, second });
         }
     }
 }
 
 fn check_type_group_id(errors: &mut Vec<IndexingError>, group: &TypeGroupId) {
     if let TypeGroupId { signature: Some(signature), declaration: Some(declaration), .. } = group {
-        if !declaration.consecutive_of(signature) {
-            errors.push(IndexingError::NonConsecutive { before: *signature, after: *declaration });
+        if signature > declaration {
+            errors.push(IndexingError::InvalidOrder { early: *declaration, late: *signature });
+        } else if !declaration.consecutive_of(signature) {
+            errors.push(IndexingError::NonConsecutive { first: *signature, second: *declaration });
         }
     }
     if let TypeGroupId { declaration: Some(declaration), role: Some(role), .. } = group {
-        if !role.consecutive_of(declaration) {
-            errors.push(IndexingError::NonConsecutive { before: *declaration, after: *role });
+        if declaration > role {
+            errors.push(IndexingError::InvalidOrder { early: *role, late: *declaration });
+        } else if !role.consecutive_of(declaration) {
+            errors.push(IndexingError::NonConsecutive { first: *declaration, second: *role });
         }
     }
 }

crates/indexing/src/wellformed.rs

@@ -1 +1,57 @@
+use indexing::{IndexingErrors, IndexingResult};
+use rowan::ast::AstNode;
+use syntax::cst;
 
+fn index<'s>(lines: impl AsRef<[&'s str]>) -> (cst::Module, IndexingResult, IndexingErrors) {
+    let source = format!("module Main where\n{}", lines.as_ref().join("\n"));
+
+    let lexed = lexing::lex(&source);
+    let tokens = lexing::layout(&lexed);
+
+    let (module, _) = parsing::parse(&lexed, &tokens);
+    let module = cst::Module::cast(module).unwrap();
+
+    let (index, errors) = indexing::index(&module);
+    (module, index, errors)
+}
+
+#[test]
+fn value_non_consecutive() {
+    let (_, _, errors) = index([
+        "isJust :: forall a. Maybe a -> Bool",
+        "isJust (Just _) = true",
+        "life = 42",
+        "isJust Nothing = false",
+    ]);
+    insta::assert_debug_snapshot!(errors);
+}
+
+#[test]
+fn value_late_signature() {
+    let (_, _, errors) = index([
+        "isJust (Just _) = true",
+        "isJust Nothing = false",
+        "isJust :: forall a. Maybe a -> Bool",
+    ]);
+    insta::assert_debug_snapshot!(errors);
+}
+
+#[test]
+fn type_non_consecutive() {
+    let (_, _, errors) = index([
+        "data Maybe :: Type -> Type",
+        "life :: Int",
+        "life = 42",
+        "data Maybe a = Just a | Nothing",
+    ]);
+    insta::assert_debug_snapshot!(errors);
+}
+
+#[test]
+fn type_late_signature() {
+    let (_, _, errors) = index([
+        "data Maybe a = Just a | Nothing",
+        "data Maybe :: Type -> Type",
+    ]);
+    insta::assert_debug_snapshot!(errors);
+}

crates/indexing/tests/indexing.rs

@@ -0,0 +1,15 @@
+---
+source: crates/indexing/tests/indexing.rs
+expression: errors
+snapshot_kind: text
+---
+[
+    InvalidOrder {
+        early: Id(
+            0,
+        ),
+        late: Id(
+            1,
+        ),
+    },
+]

crates/indexing/tests/snapshots/indexing__type_late_signature.snap

@@ -0,0 +1,15 @@
+---
+source: crates/indexing/tests/indexing.rs
+expression: errors
+snapshot_kind: text
+---
+[
+    NonConsecutive {
+        first: Id(
+            0,
+        ),
+        second: Id(
+            3,
+        ),
+    },
+]

crates/indexing/tests/snapshots/indexing__type_non_consecutive.snap

@@ -0,0 +1,15 @@
+---
+source: crates/indexing/tests/indexing.rs
+expression: errors
+snapshot_kind: text
+---
+[
+    InvalidOrder {
+        early: Id(
+            0,
+        ),
+        late: Id(
+            2,
+        ),
+    },
+]

crates/indexing/tests/snapshots/indexing__value_late_signature.snap

@@ -0,0 +1,15 @@
+---
+source: crates/indexing/tests/indexing.rs
+expression: errors
+snapshot_kind: text
+---
+[
+    NonConsecutive {
+        first: Id(
+            1,
+        ),
+        second: Id(
+            3,
+        ),
+    },
+]