wip: add tests for Concrete unification

Author: andogq

src/passes/thir_gen/unification_table.rs

@@ -16,10 +16,16 @@ pub enum Solution {
     /// Some integer.
     AnyInteger,
     /// Some unsigned integer.
-    #[expect(dead_code, reason = "unsigned integer may be used in the future")]
+    #[cfg_attr(
+        not(test),
+        expect(dead_code, reason = "unsigned integer may be used in the future")
+    )]
     UnsignedInteger,
     /// Some signed integer.
-    #[expect(dead_code, reason = "signed integer may be used in the future")]
+    #[cfg_attr(
+        not(test),
+        expect(dead_code, reason = "signed integer may be used in the future")
+    )]
     SignedInteger,
     /// An error.
     #[expect(dead_code, reason = "error may be used in the future")]
@@ -247,3 +253,170 @@ impl UnificationTable {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[fixture]
+    fn table() -> UnificationTable {
+        UnificationTable::new()
+    }
+
+    #[fixture]
+    fn types() -> Types {
+        Types::new()
+    }
+
+    #[rstest]
+    #[case::unknown(
+            |_, _| Solution::Unknown
+        )]
+    #[case::concrete(
+            |_, u8| Solution::Concrete(u8)
+        )]
+    #[case::inferred(
+            |unknown, _| Solution::Inferred(
+                CompositeType::Ref(unknown)
+            )
+        )]
+    #[case::any_integer(
+            |_, _| Solution::AnyInteger
+        )]
+    #[case::unsigned_integer(
+            |_, _| Solution::UnsignedInteger
+        )]
+    #[case::signed_integer(
+            |_, _| Solution::SignedInteger
+        )]
+    fn unknown(
+        mut table: UnificationTable,
+        types: Types,
+        #[case] solution: impl FnOnce(SolutionId, TypeId) -> Solution,
+    ) {
+        let solution = solution(table.set.insert(Solution::Unknown), types.u8());
+
+        let unknown = table.set.insert(Solution::Unknown);
+        let other = table.set.insert(solution.clone());
+
+        let result = table.unify(&types, unknown, other);
+        assert_eq!(
+            table.get(result),
+            &solution,
+            "unifying with `Unknown` should always result in the other solution"
+        );
+    }
+
+    mod concrete {
+        use super::*;
+
+        #[rstest]
+        fn concrete_match(mut table: UnificationTable, types: Types) {
+            let lhs = table.set.insert(Solution::Concrete(types.u8()));
+            let rhs = table.set.insert(Solution::Concrete(types.u8()));
+
+            let result = table.unify(&types, lhs, rhs);
+            assert_eq!(table.get(result), &Solution::Concrete(types.u8()));
+        }
+
+        #[rstest]
+        #[should_panic(expected = "cannot unify different concrete types")]
+        fn concrete_mismatch(mut table: UnificationTable, types: Types) {
+            let lhs = table.set.insert(Solution::Concrete(types.u8()));
+            let rhs = table.set.insert(Solution::Concrete(types.i8()));
+
+            table.unify(&types, lhs, rhs);
+        }
+
+        #[rstest]
+        fn propagate_non_never_type(mut table: UnificationTable, types: Types) {
+            let lhs = table.set.insert(Solution::Concrete(types.u8()));
+            let rhs = table.set.insert(Solution::Concrete(types.never()));
+
+            let result = table.unify(&types, lhs, rhs);
+            assert_eq!(table.get(result), &Solution::Concrete(types.u8()));
+        }
+
+        #[rstest]
+        #[should_panic(expected = "cannot infer with primitive")]
+        fn primitive_with_inferred(mut table: UnificationTable, types: Types) {
+            let lhs = table.set.insert(Solution::Concrete(types.u8()));
+            let unknown = table.set.insert(Solution::Unknown);
+            let rhs = table
+                .set
+                .insert(Solution::Inferred(CompositeType::Ref(unknown)));
+
+            table.unify(&types, lhs, rhs);
+        }
+
+        #[rstest]
+        #[case::reference(
+                |types: &mut Types, ids: [_; 1]| types.ref_of(ids[0]),
+                |solutions: [_; 1]| CompositeType::Ref(solutions[0])
+            )]
+        #[case::tuple(
+                |types: &mut Types, ids: [_; 2]| types.tuple(ids),
+                |solutions: [_; 2]| CompositeType::Tuple(vec![solutions[0], solutions[1]])
+            )]
+        #[case::function(
+                |types: &mut Types, ids: [_; 3]| types.function([ids[0], ids[1]], ids[2]),
+                |solutions: [_; 3]| CompositeType::Function{ parameters: vec![solutions[0], solutions[1]], return_ty: solutions[2] }
+            )]
+        fn composite_with_inferred<const N: usize>(
+            mut table: UnificationTable,
+            mut types: Types,
+            #[case] composite: impl FnOnce(&mut Types, [TypeId; N]) -> TypeId,
+            #[case] inferred: impl FnOnce([SolutionId; N]) -> CompositeType<SolutionId>,
+        ) {
+            let type_selection = [types.u8(), types.i8(), types.boolean()];
+            let unknowns = std::array::from_fn(|_| table.unknown());
+
+            let composite_ty = composite(&mut types, *type_selection[0..N].as_array().unwrap());
+            let inferred = inferred(unknowns);
+
+            let composite = table.set.insert(Solution::Concrete(composite_ty));
+            let inferred = table.set.insert(Solution::Inferred(inferred));
+
+            let result = table.unify(&types, composite, inferred);
+
+            // Must result in concrete type.
+            assert_eq!(table.get(result), &Solution::Concrete(composite_ty));
+
+            // Unknowns should be merged.
+            for (ty, unknown) in type_selection.into_iter().zip(unknowns) {
+                assert_eq!(table.get(unknown), &Solution::Concrete(ty));
+            }
+        }
+
+        #[rstest]
+        #[case::any_u8(Solution::AnyInteger, |types: &mut Types| types.u8())]
+        #[case::any_i8(Solution::AnyInteger, |types: &mut Types| types.i8())]
+        #[should_panic(expected = "type is not any integer")]
+        #[case::any_boolean(Solution::AnyInteger, |types: &mut Types| types.boolean())]
+        #[case::unsigned_u8(Solution::UnsignedInteger, |types: &mut Types| types.u8())]
+        #[should_panic(expected = "type is not unsigned integer")]
+        #[case::unsigned_i8(Solution::UnsignedInteger, |types: &mut Types| types.i8())]
+        #[should_panic(expected = "type is not unsigned integer")]
+        #[case::unsigned_boolean(Solution::UnsignedInteger, |types: &mut Types| types.boolean())]
+        #[should_panic(expected = "type is not signed integer")]
+        #[case::signed_u8(Solution::SignedInteger, |types: &mut Types| types.u8())]
+        #[case::signed_i8(Solution::SignedInteger, |types: &mut Types| types.i8())]
+        #[should_panic(expected = "type is not signed integer")]
+        #[case::signed_boolean(Solution::SignedInteger, |types: &mut Types| types.boolean())]
+        fn integer_solutions(
+            mut table: UnificationTable,
+            mut types: Types,
+            #[case] solution: Solution,
+            #[case] concrete: impl FnOnce(&mut Types) -> TypeId,
+        ) {
+            let ty = concrete(&mut types);
+
+            let concrete = table.set.insert(Solution::Concrete(ty));
+            let integer_solution = table.set.insert(solution);
+
+            let result = table.unify(&types, concrete, integer_solution);
+
+            assert_eq!(table.get(result), &Solution::Concrete(ty));
+        }
+    }
+}