wip: add tests for Integer unification

Author: andogq

src/passes/thir_gen/unification_table.rs

@@ -28,7 +28,10 @@ pub enum Solution {
     )]
     SignedInteger,
     /// An error.
-    #[expect(dead_code, reason = "error may be used in the future")]
+    #[cfg_attr(
+        not(test),
+        expect(dead_code, reason = "error may be used in the future")
+    )]
     Error,
 }
 
@@ -244,12 +247,51 @@ impl UnificationTable {
                 );
                 rhs
             }
-            // Both sides are some kind of integer.
-            ((lhs, kind @ Solution::AnyInteger), (rhs, Solution::AnyInteger))
-            | ((lhs, kind @ Solution::UnsignedInteger), (rhs, Solution::UnsignedInteger)) => {
-                let kind = kind.clone();
-                assert_eq!(self.set.redirect(lhs, rhs).expect("different nodes"), kind);
-                rhs
+
+            (
+                (
+                    integer,
+                    kind @ (Solution::AnyInteger
+                    | Solution::SignedInteger
+                    | Solution::UnsignedInteger),
+                ),
+                (other, solution),
+            )
+            | (
+                (other, solution),
+                (
+                    integer,
+                    kind @ (Solution::AnyInteger
+                    | Solution::SignedInteger
+                    | Solution::UnsignedInteger),
+                ),
+            ) => {
+                assert!(
+                    matches!(
+                        solution,
+                        Solution::AnyInteger | Solution::UnsignedInteger | Solution::SignedInteger
+                    ),
+                    "cannot unify an integer with a non-integer"
+                );
+
+                match (kind, solution) {
+                    (Solution::AnyInteger, _) => {
+                        assert_eq!(
+                            self.set.redirect(integer, other).expect("different nodes"),
+                            Solution::AnyInteger,
+                        );
+                        other
+                    }
+                    (lhs, rhs) if lhs == rhs => {
+                        let lhs = lhs.clone();
+                        assert_eq!(
+                            self.set.redirect(integer, other).expect("different nodes"),
+                            lhs,
+                        );
+                        other
+                    }
+                    _ => panic!("cannot merge incompatible integers"),
+                }
             }
             _ => {
                 todo!()
@@ -494,4 +536,44 @@ mod test {
             table.unify(&types, lhs, rhs);
         }
     }
+
+    #[rstest]
+    #[case::both_any(Solution::AnyInteger, Solution::AnyInteger, Solution::AnyInteger)]
+    #[case::both_signed(
+        Solution::SignedInteger,
+        Solution::SignedInteger,
+        Solution::SignedInteger
+    )]
+    #[case::both_unsigned(
+        Solution::UnsignedInteger,
+        Solution::UnsignedInteger,
+        Solution::UnsignedInteger
+    )]
+    #[case::any_and_signed(Solution::AnyInteger, Solution::SignedInteger, Solution::SignedInteger)]
+    #[case::any_and_unsigned(
+        Solution::AnyInteger,
+        Solution::UnsignedInteger,
+        Solution::UnsignedInteger
+    )]
+    #[should_panic(expected = "cannot merge incompatible integers")]
+    #[case::signed_and_unsigned(
+        Solution::SignedInteger,
+        Solution::UnsignedInteger,
+        // NOTE: Outcome doesn't matter as it will panic.
+        Solution::Error
+    )]
+    fn integer(
+        mut table: UnificationTable,
+        types: Types,
+        #[case] lhs: Solution,
+        #[case] rhs: Solution,
+        #[case] outcome: Solution,
+    ) {
+        let lhs = table.set.insert(lhs);
+        let rhs = table.set.insert(rhs);
+
+        let result = table.unify(&types, lhs, rhs);
+
+        assert_eq!(table.get(result), &outcome);
+    }
 }