wip: add tests for Inferred unification

Author: andogq

src/passes/thir_gen/unification_table.rs

@@ -222,14 +222,18 @@ impl UnificationTable {
                     }
 
                     // Type mismatches.
-                    _ => todo!(),
+                    _ => panic!("cannot merge mismatched inferred types"),
                 };
 
                 // Used later for assertion.
                 let inferred_lhs = inferred_lhs.clone();
 
                 // Merge the fields together.
-                assert_eq!(lhs_fields.len(), rhs_fields.len());
+                assert_eq!(
+                    lhs_fields.len(),
+                    rhs_fields.len(),
+                    "cannot merge inferred types of different sizes"
+                );
                 for (lhs, rhs) in lhs_fields.into_iter().zip(rhs_fields.into_iter()) {
                     self.unify(types, lhs, rhs);
                 }
@@ -419,4 +423,75 @@ mod test {
             assert_eq!(table.get(result), &Solution::Concrete(ty));
         }
     }
+
+    mod inferred {
+        use super::*;
+
+        #[rstest]
+        #[case::reference(|solutions: [_; 1]| CompositeType::Ref(solutions[0]))]
+        #[case::function_no_parameters(|solutions: [_; 1]| CompositeType::Function { parameters: vec![], return_ty: solutions[0] })]
+        #[case::function_one_parameter(|solutions: [_; 2]| CompositeType::Function { parameters: vec![solutions[0]], return_ty: solutions[1] })]
+        #[case::function_many_parameters(|solutions: [_; 4]| CompositeType::Function { parameters: vec![solutions[0], solutions[1], solutions[2]], return_ty: solutions[3] })]
+        #[case::tuple_empty(|_: [_; 0]| CompositeType::Tuple(vec![]))]
+        #[case::tuple_one(|solutions: [_; 1]| CompositeType::Tuple(Vec::from_iter(solutions)))]
+        #[case::tuple_many(|solutions: [_; 4]| CompositeType::Tuple(Vec::from_iter(solutions)))]
+        fn matching<const N: usize>(
+            mut table: UnificationTable,
+            types: Types,
+            #[case] get_inferred: impl Fn([SolutionId; N]) -> CompositeType<SolutionId>,
+        ) {
+            let [lhs_unknowns, rhs_unknowns] = std::array::from_fn(|_| {
+                std::array::from_fn(|_| table.set.insert(Solution::Unknown))
+            });
+
+            let lhs = table
+                .set
+                .insert(Solution::Inferred(get_inferred(lhs_unknowns)));
+            let rhs = table
+                .set
+                .insert(Solution::Inferred(get_inferred(rhs_unknowns)));
+
+            let result = table.unify(&types, lhs, rhs);
+
+            // Unknowns should be merged.
+            for (lhs, rhs) in lhs_unknowns.iter().zip(rhs_unknowns.iter()) {
+                assert_eq!(table.set.find_root(*lhs), table.set.find_root(*rhs));
+            }
+
+            // Result should be inferred based on merged unknown components.
+            let expected = get_inferred(lhs_unknowns.map(|unknown| table.set.find_root(unknown)));
+            assert_eq!(table.get(result), &Solution::Inferred(expected));
+        }
+
+        #[rstest]
+        #[should_panic(expected = "cannot merge mismatched inferred types")]
+        #[case::reference_and_function(
+            |solutions: [_; 1]| CompositeType::Ref(solutions[0]),
+            |solutions: [_; 1]| CompositeType::Function { parameters: vec![], return_ty: solutions[0] },
+        )]
+        #[should_panic(expected = "cannot merge inferred types of different sizes")]
+        #[case::function_different_parameters(
+            |solutions: [_; 1]| CompositeType::Function { parameters: vec![], return_ty: solutions[0] },
+            |solutions: [_; 3]| CompositeType::Function { parameters: vec![solutions[0], solutions[1]], return_ty: solutions[2] },
+        )]
+        #[should_panic(expected = "cannot merge inferred types of different sizes")]
+        #[case::tuple_different_sizes(
+            |solutions: [_; 1]| CompositeType::Tuple(Vec::from_iter(solutions)),
+            |solutions: [_; 3]| CompositeType::Tuple(Vec::from_iter(solutions)),
+        )]
+        fn mismatched<const N: usize, const M: usize>(
+            mut table: UnificationTable,
+            types: Types,
+            #[case] get_lhs: impl Fn([SolutionId; N]) -> CompositeType<SolutionId>,
+            #[case] get_rhs: impl Fn([SolutionId; M]) -> CompositeType<SolutionId>,
+        ) {
+            let lhs_unknowns = std::array::from_fn(|_| table.set.insert(Solution::Unknown));
+            let rhs_unknowns = std::array::from_fn(|_| table.set.insert(Solution::Unknown));
+
+            let lhs = table.set.insert(Solution::Inferred(get_lhs(lhs_unknowns)));
+            let rhs = table.set.insert(Solution::Inferred(get_rhs(rhs_unknowns)));
+
+            table.unify(&types, lhs, rhs);
+        }
+    }
 }