Add more unit tests for type unification, solve bugs in the type unification algorithm

Author: alexisthedev

src/ir/typescript_types.py

@@ -532,7 +532,7 @@ def unify_types(self, t1, factory, same_type=True):
             # Hence, we only substitute necessary types in T2
             # by ensuring that the T1 type we will subtitute
             # is NOT a subtype of any other types in the T1 union type.
-            for t1_t in t1_types:
+            for t1_t in list(add_to_t2):
                 if any(t1_t.is_subtype(other_t1_t)
                         and t1_t is not other_t1_t
                         for other_t1_t in t1_types):
@@ -665,7 +665,7 @@ def assign_types_to_type_vars(self, possible_subs):
         while possible_subs:
             # Sort the possible_subs dict, in order to first find a substitution for the T1
             # type with the fewest compatible T2 type variables.
-            sorted_type_subs = sorted(possible_subs.items(), key=lambda x: len(x), reverse=True)
+            sorted_type_subs = sorted(list(possible_subs.items()), key=lambda x: len(x[1]), reverse=False)
 
             # Get the first (T1 type, T2 type variable) pair (sorted_type_subs is a tuples list)
             type_to_substitute, compatible_tvars = sorted_type_subs[0]
@@ -686,7 +686,7 @@ def assign_types_to_type_vars(self, possible_subs):
             # of all other T1 types.
             for k in list(possible_subs.keys()):
                 if chosen_tvar in possible_subs[k]:
-                    possible_subs.remove(chosen_tvar)
+                    possible_subs[k].remove(chosen_tvar)
 
             # Delete the possible substitutions of the T1 type we just substituted in T2
             del possible_subs[type_to_substitute]
@@ -698,6 +698,9 @@ def assign_types_to_type_vars(self, possible_subs):
     def get_name(self):
         return self.name
 
+    def __str__(self):
+        return f'UnionType(TS)({" | ".join([str(t) for t in self.types])})'
+
     def __eq__(self, other):
         return (self.__class__ == other.__class__ and
                 self.name == other.name and

src/resources/typescript_keywords

@@ -6,4 +6,5 @@ Delete
 debugger
 arguments
 let
-export
+export
+symbol

tests/test_typescript.py

@@ -1,3 +1,4 @@
+from src.ir.builtins import NumberType
 import src.ir.typescript_types as tst
 import src.ir.typescript_ast as ts_ast
 import src.ir.types as tp
@@ -130,7 +131,7 @@ def test_union_type_unification_type_var():
     assert type_var_map == {type_param: union}
 
 
-def test_unify_two_union_types():
+def test_union_type_unification():
     type_param = tp.TypeParameter("T")
     union1 = tst.UnionType([tst.NumberLiteralType(1410), tst.NumberType(), tst.StringType()])
     union2 = tst.UnionType([type_param, tst.NumberType(), tst.StringType()])
@@ -147,3 +148,35 @@ def test_unify_two_union_types():
     assert len(type_var_map) == 2
     assert type_param, type_param2 in type_var_map
     assert union1.types[1], union1.types[2] in type_var_map.values()
+
+def test_union_type_unification2():
+    union = tst.UnionType([tst.NumberType(), tst.StringType()])
+    assert tu.unify_types(tst.BooleanType(), union, tst.TypeScriptBuiltinFactory()) == {}
+
+    t1 = tst.NumberType()
+    t2 = tst.UnionType([tst.NumberType(), tp.TypeParameter("T")])
+    res = tu.unify_types(t1, t2, tst.TypeScriptBuiltinFactory())
+    assert len(res) == 1 and res[t2.types[1]] == t1
+
+    t1 = tst.UnionType([tst.NumberType(), tst.StringType()])
+    res = tu.unify_types(t1, t2, tst.TypeScriptBuiltinFactory())
+    assert len(res) == 1 and res[t2.types[1]] == t1.types[1]
+
+    t1 = tst.UnionType([tst.NumberType(), tst.StringLiteralType("foo"), tst.StringType()])
+    res = tu.unify_types(t1, t2, tst.TypeScriptBuiltinFactory())
+    assert len(res) == 1 and res[t2.types[1]] == t1.types[2]
+
+    t1 = tst.UnionType([tst.NumberType(), tst.NumberLiteralType(100), tst.BooleanType(), tst.StringLiteralType("foo"), tst.StringType()])
+
+    t_param1 = tp.TypeParameter("T", bound=tst.StringType())
+    helper_union = tst.UnionType([tst.BooleanType(), tst.StringType()])
+    t_param2 = tp.TypeParameter("G", bound=helper_union)
+    t2 = tst.UnionType([tst.NumberType(), t_param1, t_param2])
+
+    # Unify t1: number | 100 | boolean | "foo" | string
+    # with t2: number | T extends string | G extends (boolean | string)
+    # Result should be {T: StringType, G: BooleanType}
+    res = tu.unify_types(t1, t2, tst.TypeScriptBuiltinFactory())
+    assert (len(res) == 2 and
+            res[t2.types[1]] == t1.types[4] and
+            res[t2.types[2]] == t1.types[2])