Fix subtyping checks for type constructors

Author: theosotr

src/ir/types.py

@@ -472,7 +472,31 @@ def is_type_constructor(self):
         return True
 
     def is_subtype(self, other: Type):
-        return other in self.get_supertypes()
+        supertypes = self.get_supertypes()
+        matched_supertype = None
+        for supertype in supertypes:
+            if other == supertype:
+                matched_supertype = supertype
+                break
+        if matched_supertype is None:
+            # This type constructor is not subtype of other
+            return False
+        if not other.is_parameterized():
+            return True
+
+        # The rationale here is the following: there might be collision
+        # in the type variables introduced by the type constructor and
+        # the type variables that appear in the type arguments of the given
+        # parameterized type. See the following example:
+        #
+        # class Bar<T> extends Foo<Float, T> {}
+        # fun <T> foo(Foo<Float, T> x) {
+        #    In this context, the type constructor Bar<T> is not a subtype
+        #    of Foo<Float, T>.
+        # }
+        type_vars = set(
+            matched_supertype.get_type_variable_assignments().values())
+        return not bool(type_vars.intersection(self.type_parameters))
 
     def new(self, type_args: List[Type]):
         type_map = {tp: type_args[i]

tests/test_types.py

@@ -142,6 +142,29 @@ def test_parameterized_with_bound_abstract():
         [type_param, tp.TypeParameter("K", bound=type_param)]
 
 
+def test_subtype_type_constructor_regular():
+    type_param = tp.TypeParameter("T1")
+    bar = tp.Classifier("Bar")
+    foo = tp.TypeConstructor("Foo", [type_param], [bar])
+    assert foo.is_subtype(bar)
+
+
+def test_subtype_type_constructor_paramerized():
+    type_param1 = tp.TypeParameter("T1")
+    type_param2 = tp.TypeParameter("T2")
+    foo = tp.TypeConstructor("Foo", [type_param1, type_param2])
+    bar = tp.TypeConstructor("Bar", [type_param1],
+                             [foo.new([kt.String, type_param1])])
+
+    foo_type = foo.new([kt.String, type_param1])
+    assert not bar.is_subtype(foo_type)
+
+    bar = tp.TypeConstructor("Bar", [type_param1],
+                             [foo.new([kt.String, kt.Integer])])
+    foo_type = foo.new([kt.String, kt.Integer])
+    assert bar.is_subtype(foo_type)
+
+
 def test_subtype_covariant_parameterized():
     type_param = tp.TypeParameter("T", tp.Covariant)
     type_param2 = tp.TypeParameter("K", tp.Covariant)