Add an extra subtyping check for when additional subtyping relations exist

Author: alexisthedev

src/generators/generator.py

@@ -1950,7 +1950,8 @@ def get_types(self,
                   exclude_covariants=False,
                   exclude_contravariants=False,
                   exclude_type_vars=False,
-                  exclude_function_types=False) -> List[tp.Type]:
+                  exclude_function_types=False,
+                  exclude_dynamic_types=False) -> List[tp.Type]:
         """Get all available types.
 
         Including user-defined types, built-ins, and function types.
@@ -1964,6 +1965,7 @@ def get_types(self,
             exclude_contravariants: exclude contravariant type parameters.
             exclude_type_vars: exclude type variables.
             exclude_function_types: exclude function types.
+            exclude_dynamic_types: exclude dynamic types.
 
         Returns:
             A list of available types.
@@ -1993,7 +1995,9 @@ def get_types(self,
                 if t.name != self.bt_factory.get_array_type().name
             ]
 
-        dynamic = self.bt_factory.get_dynamic_types(self)
+        dynamic = (self.bt_factory.get_dynamic_types(self)
+                   if not exclude_dynamic_types
+                   else [])
         if exclude_function_types:
             return usr_types + builtins + dynamic
         return usr_types + builtins + dynamic + self.function_types
@@ -2003,7 +2007,8 @@ def select_type(self,
                     exclude_arrays=False,
                     exclude_covariants=False,
                     exclude_contravariants=False,
-                    exclude_function_types=False) -> tp.Type:
+                    exclude_function_types=False,
+                    exclude_dynamic_types=False) -> tp.Type:
         """Select a type from the all available types.
 
         It will always instantiating type constructors to parameterized types.
@@ -2014,8 +2019,8 @@ def select_type(self,
             exclude_arrays: exclude array types.
             exclude_covariants: exclude covariant type parameters.
             exclude_contravariants: exclude contravariant type parameters.
-            exclude_type_vars: exclude type variables.
             exclude_function_types: exclude function types.
+            eclude_dynamic_types: exclude dynamic types.
 
         Returns:
             Returns a type.
@@ -2024,7 +2029,8 @@ def select_type(self,
                                exclude_arrays=exclude_arrays,
                                exclude_covariants=exclude_covariants,
                                exclude_contravariants=exclude_contravariants,
-                               exclude_function_types=exclude_function_types)
+                               exclude_function_types=exclude_function_types,
+                               exclude_dynamic_types=exclude_dynamic_types)
         stype = ut.random.choice(types)
         if stype.is_type_constructor():
             exclude_type_vars = stype.name == self.bt_factory.get_array_type().name
@@ -2033,7 +2039,8 @@ def select_type(self,
                                       exclude_covariants=True,
                                       exclude_contravariants=True,
                                       exclude_type_vars=exclude_type_vars,
-                                      exclude_function_types=exclude_function_types),
+                                      exclude_function_types=exclude_function_types,
+                                      exclude_dynamic_types=exclude_dynamic_types),
                 enable_pecs=self.enable_pecs,
                 disable_variance_functions=self.disable_variance_functions,
                 variance_choices={}

src/ir/decorators.py

@@ -0,0 +1,4 @@
+def two_way_subtyping(is_subtype):
+    def inner(self, other):
+        return is_subtype(self, other) or other.dynamic_subtyping(self)
+    return inner

src/ir/types.py

@@ -5,6 +5,7 @@
 from typing import List, Dict, Set
 
 from src.ir.node import Node
+from src.ir.decorators import two_way_subtyping
 
 
 class Variance(object):
@@ -66,6 +67,19 @@ def has_type_variables(self):
     def is_subtype(self, other: Type):
         raise NotImplementedError("You have to implement 'is_subtype()'")
 
+    def dynamic_subtyping(self, other: Type):
+        """
+        Overwritten when a certain type needs
+        two-way subtyping checks.
+
+        Eg. when checking if a string type is a subtype
+        of union type 'Foo | string' we call this method
+        as `union-type.dynamic_subtyping(string_type)`
+        to check from the union's side.
+
+        """
+        return False
+
     def is_assignable(self, other: Type):
         """
         Checks of a value of the current type is assignable to 'other' type.
@@ -153,6 +167,7 @@ def __hash__(self):
         """Hash based on the Type"""
         return hash(str(self.__class__))
 
+    @two_way_subtyping
     def is_subtype(self, other: Type) -> bool:
         return other == self or other in self.get_supertypes()
 
@@ -219,6 +234,7 @@ def _check_supertypes(self):
                     str(t_class[0].t_constructor) + " " + \
                     "do not have the same types"
 
+    @two_way_subtyping
     def is_subtype(self, other: Type) -> bool:
         supertypes = self.get_supertypes()
         # Since the subtyping relation is transitive, we must also check
@@ -273,6 +289,7 @@ def get_bound_rec(self, factory):
         # are out of scope in the context where we use this bound.
         return t.to_type_variable_free(factory)
 
+    @two_way_subtyping
     def is_subtype(self, other):
         if not self.bound:
             return False
@@ -302,6 +319,7 @@ def __init__(self, bound=None, variance=Invariant):
         self.bound = bound
         self.variance = variance
 
+    @two_way_subtyping
     def is_subtype(self, other):
         if isinstance(other, WildCardType):
             if other.bound is not None:
@@ -471,6 +489,7 @@ def __hash__(self):
     def is_type_constructor(self):
         return True
 
+    @two_way_subtyping
     def is_subtype(self, other: Type):
         supertypes = self.get_supertypes()
         matched_supertype = None
@@ -695,6 +714,7 @@ def get_name(self):
         return "{}<{}>".format(self.name, ", ".join([t.get_name()
                                                      for t in self.type_args]))
 
+    @two_way_subtyping
     def is_subtype(self, other: Type) -> bool:
         if super().is_subtype(other):
             return True

src/ir/typescript_types.py

@@ -4,6 +4,7 @@
 import src.ir.types as tp
 import src.ir.ast as ast
 import src.utils as ut
+from src.ir.decorators import two_way_subtyping
 
 class TypeScriptBuiltinFactory(bt.BuiltinFactory):
     def get_language(self):
@@ -263,6 +264,7 @@ def __init__(self, alias, name="AliasType", primitive=False):
     def get_type(self):
         return self.alias
 
+    @two_way_subtyping
     def is_subtype(self, other):
         if isinstance(other, AliasType):
             return self.alias.is_subtype(other.alias)
@@ -291,6 +293,7 @@ def __init__(self, literal, name="NumberLiteralType", primitive=False):
     def get_literal(self):
         return self.literal
 
+    @two_way_subtyping
     def is_subtype(self, other):
         """ A number literal type is assignable to any
             supertype of type 'number'.
@@ -338,6 +341,7 @@ def __init__(self, literal, name="StringLiteralType", primitive=False):
     def get_literal(self):
         return '"' + self.literal + '"'
 
+    @two_way_subtyping
     def is_subtype(self, other):
         """ A string literal type is assignable to any
             supertype of type 'string'.
@@ -426,11 +430,15 @@ def __init__(self, types, name="UnionType", primitive=False):
     def get_types(self):
         return self.types
 
+    @two_way_subtyping
     def is_subtype(self, other):
         if isinstance(other, UnionType):
             return set(self.types).issubset(other.types)
         return other.name == 'Object'
 
+    def dynamic_subtyping(self, other):
+        return other in set(self.types)
+
     def get_name(self):
         return self.name
 
@@ -448,7 +456,6 @@ def __init__(self, max_ut, max_in_union):
         self.max_ut = max_ut
         self.unions = []
         self.candidates = [
-            ObjectType(),
             NumberType(),
             BooleanType(),
             StringType(),
@@ -462,11 +469,10 @@ def get_number_of_types(self):
         return ut.random.integer(2, self.max_in_union)
 
     def gen_union_type(self, gen):
-        """ Generates a union type that consists of
-            N types (where N is num_of_types).
+        """ Generates a union type that consists of N types
+            where N is a number in [2, self.max_in_union].
 
             Args:
-                num_of_types - Number of types to be unionized
                 gen - Instance of Hephaestus' generator
 
         """