Refactoring of Type Substitution Mechanism

Author: alexisthedev

src/ir/types.py

@@ -121,6 +121,19 @@ def get_supertypes(self):
                     stack.append(supertype)
         return visited
 
+    def substitute_type_args(self, type_map,
+                             cond=lambda t: t.has_type_variables()):
+        t = type_map.get(self)
+        if t is None or cond(t):
+            # Perform type substitution on the bound of the current type variable.
+            if self.is_type_var() and self.bound is not None:
+                new_bound = self.bound.substitute_type_args(type_map, cond)
+                return TypeParameter(self.name, self.variance, new_bound)
+            # The type parameter does not correspond to an abstract type
+            # so, there is nothing to substitute.
+            return self
+        return t
+
     def not_related(self, other: Type):
         return not(self.is_subtype(other) or other.is_subtype(self))
 
@@ -343,6 +356,18 @@ def get_type_variables(self, factory):
         else:
             return {}
 
+    def substitute_type_args(self, type_map,
+                             cond=lambda t: t.has_type_variables()):
+        if self.bound is not None:
+            new_bound = self.bound.substitute_type_args(type_map, cond)
+            return WildCardType(new_bound, variance=self.variance)
+        t = type_map.get(self)
+        if t is None or cond(t):
+            # The bound does not correspond to abstract type
+            # so there is nothing to substitute
+            return self
+        return t
+
     def get_bound_rec(self):
         if not self.bound:
             return None
@@ -385,42 +410,8 @@ def is_primitive(self):
         return False
 
 
-def _get_type_substitution(etype, type_map,
-                           cond=lambda t: t.has_type_variables()):
-    if etype.is_parameterized():
-        return substitute_type_args(etype, type_map, cond)
-    if etype.is_wildcard() and etype.bound is not None:
-        new_bound = _get_type_substitution(etype.bound, type_map, cond)
-        return WildCardType(new_bound, variance=etype.variance)
-    t = type_map.get(etype)
-    if t is None or cond(t):
-        # Perform type substitution on the bound of the current type variable.
-        if etype.is_type_var() and etype.bound is not None:
-            new_bound = _get_type_substitution(etype.bound, type_map, cond)
-            return TypeParameter(etype.name, etype.variance, new_bound)
-        # The type parameter does not correspond to an abstract type
-        # so, there is nothing to substitute.
-        return etype
-    return t
-
-
-def substitute_type_args(etype, type_map,
-                         cond=lambda t: t.has_type_variables()):
-    assert etype.is_parameterized()
-    type_args = []
-    for t_arg in etype.type_args:
-        type_args.append(_get_type_substitution(t_arg, type_map, cond))
-    new_type_map = {
-        tp: type_args[i]
-        for i, tp in enumerate(etype.t_constructor.type_parameters)
-    }
-    type_con = perform_type_substitution(
-        etype.t_constructor, new_type_map, cond)
-    return ParameterizedType(type_con, type_args)
-
-
 def substitute_type(t, type_map):
-    return _get_type_substitution(t, type_map, lambda t: False)
+    return t.substitute_type_args(type_map, lambda t: False)
 
 
 def perform_type_substitution(etype, type_map,
@@ -443,7 +434,7 @@ class X<T> : Y<Z<T>>()
     supertypes = []
     for t in etype.supertypes:
         if t.is_parameterized():
-            supertypes.append(substitute_type_args(t, type_map))
+            supertypes.append(t.substitute_type_args(type_map))
         else:
             supertypes.append(t)
     type_params = []
@@ -682,6 +673,18 @@ def get_type_variables(self, factory) -> Dict[TypeParameter, Set[Type]]:
                 continue
         return type_vars
 
+    def substitute_type_args(self, type_map, cond=lambda t: t.has_type_variables()):
+        type_args = []
+        for t_arg in self.type_args:
+            type_args.append(t_arg.substitute_type_args(type_map, cond))
+        new_type_map = {
+            tp: type_args[i]
+            for i, tp in enumerate(self.t_constructor.type_parameters)
+        }
+        type_con = perform_type_substitution(
+            self.t_constructor, new_type_map, cond)
+        return ParameterizedType(type_con, type_args)
+
     @property
     def can_infer_type_args(self):
         return self._can_infer_type_args

src/ir/typescript_types.py

@@ -96,7 +96,7 @@ def update_add_node_to_parent(self):
 
     def get_dynamic_types(self, gen_object):
         return [
-            union_types.get_union_type(gen_object),
+            #union_types.get_union_type(gen_object),
         ]
 
     def get_constant_candidates(self, constants):
@@ -439,6 +439,9 @@ def is_subtype(self, other):
     def dynamic_subtyping(self, other):
         return other in set(self.types)
 
+    def has_type_variables(self):
+        return any(t.has_type_variables() for t in self.types)
+
     def get_name(self):
         return self.name
 
@@ -455,19 +458,19 @@ class UnionTypeFactory:
     def __init__(self, max_ut, max_in_union):
         self.max_ut = max_ut
         self.unions = []
-        self.candidates = [
-            NumberType(),
-            BooleanType(),
-            StringType(),
-            NullType(),
-            UndefinedType(primitive=False),
-        ] + literal_types.get_literal_types()
-        self.max_in_union = (max_in_union if max_in_union <= len(self.candidates)
-                                else len(self.candidates))
+        self.max_in_union = max_in_union
 
     def get_number_of_types(self):
         return ut.random.integer(2, self.max_in_union)
 
+    def get_types_for_union(self, gen):
+        num_of_types = self.get_number_of_types()
+        types = set()
+        while len(types) < num_of_types:
+            t = gen.select_type(exclude_dynamic_types=True)
+            types.add(t)
+        return list(types)
+
     def gen_union_type(self, gen):
         """ Generates a union type that consists of N types
             where N is a number in [2, self.max_in_union].
@@ -476,11 +479,7 @@ def gen_union_type(self, gen):
                 gen - Instance of Hephaestus' generator
 
         """
-        num_of_types = self.get_number_of_types()
-        assert num_of_types < len(self.candidates)
-        types = self.candidates.copy()
-        ut.random.shuffle(types)
-        types = types[0:num_of_types]
+        types = self.get_types_for_union(gen)
         gen_union = UnionType(types)
         self.unions.append(gen_union)
         return gen_union
@@ -495,6 +494,7 @@ def get_union_type(self, gen_object):
             the already generated types or create a new one.
 
         """
+        return self.gen_union_type(gen_object)
         generated = len(self.unions)
         if generated == 0:
             return self.gen_union_type(gen_object)
@@ -574,7 +574,7 @@ def gen_type_alias_decl(gen,
     gen.depth += 1
     gen.depth = initial_depth
     type_alias_decl = ts_ast.TypeAliasDeclaration(
-        name=ut.random.identifier('capitalize'),
+        name=ut.random.identifier('lower'),
         alias=alias_type
     )
     gen._add_node_to_parent(gen.namespace, type_alias_decl)

src/translators/typescript.py

@@ -78,15 +78,15 @@ def get_incorrect_filename():
         return TypeScriptTranslator.incorrect_filename
 
     def get_union(self, utype):
-        return " | ".join([self.type_arg2str(t) for t in utype.types])
+        return " | ".join([self.type_arg2str(t, True) for t in utype.types])
 
-    def type_arg2str(self, t_arg):
+    def type_arg2str(self, t_arg, from_union=False):
         # TypeScript does not have a Wildcard type
         if not t_arg.is_wildcard():
-            return self.get_type_name(t_arg)
+            return self.get_type_name(t_arg, from_union)
         return "unknown"
 
-    def get_type_name(self, t):
+    def get_type_name(self, t, from_union=False):
         t_constructor = getattr(t, 't_constructor', None)
         if (isinstance(t, tst.NumberLiteralType) or
             isinstance(t, tst.StringLiteralType)):
@@ -107,6 +107,8 @@ def get_type_name(self, t):
                 ]),
                 self.type_arg2str(ret_type)
             )
+            if from_union:
+                return "("+res+")"
             return res
 
         return "{}<{}>".format(t.name, ", ".join([self.type_arg2str(ta)