Fix type unification for type params and combound types

Author: theosotr

src/ir/type_utils.py

@@ -1042,8 +1042,12 @@ class B : A<String>()
     """
     if t2.is_combound() and not t2.is_parameterized():
         return t2.unify_types(t1, factory, same_type)
-    elif t1.is_combound() and not t1.is_parameterized() and t2.is_type_var():
-        return {t2: t1}
+    elif t1.is_combound() and t2.is_type_var():
+        bound = t2.get_bound_rec(factory)
+        if bound is None or t1.is_subtype(bound):
+            return {t2: t1}
+        else:
+            return {}
 
     if same_type and type(t1) != type(t2):
         return {}

tests/test_typescript.py

@@ -4,6 +4,7 @@
 import src.ir.types as tp
 import src.ir.type_utils as tu
 
+
 def test_type_alias_with_literals():
     string_alias = ts_ast.TypeAliasDeclaration("Foo", tst.StringType()).get_type()
     number_alias = ts_ast.TypeAliasDeclaration("Bar", tst.NumberType()).get_type()
@@ -16,6 +17,7 @@ def test_type_alias_with_literals():
     assert number_lit.is_subtype(number_alias)
     assert not number_alias.is_subtype(number_lit)
 
+
 def test_type_alias_with_literals2():
     string_alias = ts_ast.TypeAliasDeclaration("Foo", tst.StringLiteralType("foo")).get_type()
     number_alias = ts_ast.TypeAliasDeclaration("Bar", tst.NumberLiteralType(5)).get_type()
@@ -28,6 +30,7 @@ def test_type_alias_with_literals2():
     assert string_alias.is_subtype(string_lit)
     assert number_alias.is_subtype(number_lit)
 
+
 def test_union_types_simple():
     union_1 = tst.UnionType([tst.NumberType(), tst.BooleanType()])
 
@@ -42,6 +45,11 @@ def test_union_types_simple():
     assert union_1.is_subtype(union_3)
 
 
+def test_union_types_other_types():
+    union = tst.UnionType([tst.NumberType(), tst.BooleanType()])
+    assert tst.NumberType().is_subtype(union)
+
+
 def test_union_type_assign():
     union = tst.UnionType([tst.StringType(), tst.NumberType(), tst.BooleanType(), tst.ObjectType()])
     foo = tst.StringType()
@@ -130,6 +138,22 @@ def test_union_type_unification_type_var():
     assert len(type_var_map) == 1
     assert type_var_map == {type_param: union}
 
+    # Case 2: unify a union with a bounded type param, which has an
+    # incompatible bound with the given union.
+    union = tst.UnionType([tst.NumberType(), tst.StringType()])
+    type_param = tp.TypeParameter("T", bound=tst.NumberType())
+
+    type_var_map = tu.unify_types(union, type_param,
+                                  tst.TypeScriptBuiltinFactory())
+    assert type_var_map == {}
+
+
+    # Case 3: unify a union with a bounded type param, which has a compatible
+    # bound with the given union.
+    type_param = tp.TypeParameter("T", bound=union)
+    type_var_map = tu.unify_types(union, type_param,
+                                  tst.TypeScriptBuiltinFactory())
+    assert type_var_map == {type_param: union}
 
 def test_union_type_unification():
     type_param = tp.TypeParameter("T")
@@ -149,6 +173,7 @@ def test_union_type_unification():
     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()) == {}