Fix subtyping relations for union types

Author: alexisthedev

src/ir/typescript_types.py

@@ -160,11 +160,6 @@ def __init__(self, name="Number", primitive=False):
         super().__init__(name, primitive)
         self.supertypes.append(ObjectType())
 
-    def is_assignable(self, other):
-        if isinstance(other, NumberLiteralType):
-            return False
-        return isinstance(other, NumberType)
-
     def box_type(self):
         return NumberType(self.name, primitive=False)
 
@@ -214,11 +209,6 @@ def __init__(self, name="String", primitive=False):
     def box_type(self):
         return StringType(self.name, primitive=False)
 
-    def is_assignable(self, other):
-        if isinstance(other, StringLiteralType):
-            return False
-        return isinstance(other, StringType)
-
     def get_name(self):
         if self.is_primitive:
             return "string"
@@ -436,14 +426,22 @@ def __init__(self, types, name="UnionType", primitive=False):
     def get_types(self):
         return self.types
 
-    def is_assignable(self, other):
-        # TODO revisit this after implementing structural types
-        return (isinstance(other, UnionType) and
-                    set(other.types) == set(self.types))
+    def is_subtype(self, other):
+        if isinstance(other, UnionType):
+            return set(self.types).issubset(other.types)
+        return other.name == 'Object'
 
     def get_name(self):
         return self.name
 
+    def __eq__(self, other):
+        return (self.__class__ == other.__class__ and
+                self.name == other.name and
+                set(self.types) == set(other.types))
+
+    def __hash__(self):
+        return hash(str(self.name) + str(self.types))
+
 
 class UnionTypeFactory:
     def __init__(self, max_ut, max_in_union):
@@ -470,15 +468,11 @@ def gen_union_type(self, gen):
             Args:
                 num_of_types - Number of types to be unionized
                 gen - Instance of Hephaestus' generator
+
         """
         num_of_types = self.get_number_of_types()
         assert num_of_types < len(self.candidates)
         types = self.candidates.copy()
-        usr_types = [
-            c.get_type()
-            for c in gen.context.get_classes(gen.namespace).values()
-        ]
-        types.extend(usr_types)
         ut.random.shuffle(types)
         types = types[0:num_of_types]
         gen_union = UnionType(types)

src/utils.py

@@ -167,7 +167,6 @@ def caps(self, length=1, blacklist=None):
     def range(self, from_value, to_value):
         return range(0, self.integer(from_value, to_value))
 
-<<<<<<< HEAD
     def identifier(self, ident_type:str=None) -> str:
         """Generate an identifier name.
 
@@ -186,10 +185,9 @@ def identifier(self, ident_type:str=None) -> str:
         if ident_type == 'capitalize':
             return word.capitalize()
         raise AssertionError("ident_type should be 'capitalize' or 'lower'")
-=======
+
     def shuffle(self, ll):
         return self.r.shuffle(ll)
->>>>>>> d566664 (Add UnionType class and UnionTypeFactory)
 
 
 random = RandomUtils()

tests/test_typescript.py

@@ -34,19 +34,19 @@ def test_union_types_simple():
 
     union_3 = tst.UnionType([tst.BooleanType(), tst.NumberType()])
 
-    assert not union_1.is_assignable(union_2)
-    assert not union_2.is_assignable(union_1)
-    assert union_3.is_assignable(union_1)
-    assert union_1.is_assignable(union_3)
+    assert not union_1.is_subtype(union_2)
+    assert not union_2.is_subtype(union_1)
+    assert union_3.is_subtype(union_1)
+    assert union_1.is_subtype(union_3)
 
 
 def test_union_type_assign():
     union = tst.UnionType([tst.StringType(), tst.NumberType(), tst.BooleanType(), tst.ObjectType()])
     foo = tst.StringType()
 
     assert len(union.types) == 4
-    assert not union.is_assignable(foo)
-    assert foo.is_assignable(union)
+    assert not union.is_subtype(foo)
+    assert foo.is_subtype(union)
 
 
 def test_union_type_param():