Expand generator to generate union type constants

Author: alexisthedev

src/generators/generator.py

@@ -1895,7 +1895,7 @@ def gen_fun_call(etype):
             ),
             self.bt_factory.get_null_type().name: lambda x: ast.Null
         }
-        constant_candidates.update(self.bt_factory.get_constant_candidates())
+        constant_candidates.update(self.bt_factory.get_constant_candidates(self, constant_candidates))
         binary_ops = {
             self.bt_factory.get_boolean_type(): [
                 lambda x: self.gen_logical_expr(x, only_leaves),

src/ir/typescript_types.py

@@ -94,10 +94,29 @@ def update_add_node_to_parent(self):
             ts_ast.TypeAliasDeclaration: add_type_alias,
         }
 
-    def get_constant_candidates(self):
+    def get_constant_candidates(self, gen_object, constants):
+        """ Updates the constant candidates of the generator
+        with the type-constant pairs for language-specific features.
+
+        Args:
+            gen_object: The generator instance
+            constants: The dictionary of constant candidates
+                       at the time of the method call
+        Returns:
+            A dictionary where the keys are strings of type names and
+            values are functions that return the appropriate constant
+            node for the type.
+
+            The constants dictionary is updated at the generator-side
+            with the method's returned key-value pairs.
+
+            This method is called at src.ir.generator.get_generators()
+
+        """
         return {
             "NumberLiteralType": lambda etype: ast.IntegerConstant(etype.literal, NumberLiteralType),
             "StringLiteralType": lambda etype: ast.StringConstant(etype.literal),
+            "UnionType": lambda etype: union_types.get_union_constant(etype, constants),
         }
 
 
@@ -471,6 +490,21 @@ def get_union_type(self, gen_object):
             return ut.random.choice(self.unions)
         return self.gen_union_type()
 
+    def get_union_constant(self, utype, constants):
+        type_candidates = [t for t in utype.types if t.name in constants]
+        """ A union type can have types like 'Object' or 'undefined'
+        as part of its union, which however do not have a respective
+        constant equivalent.
+
+        Hence, we only consider types that we can generate a constant
+        from. If there is none, we revert to a bottom constant.
+
+        """
+        if len(type_candidates) == 0:
+            return ast.BottomConstant(utype.types[0])
+        t = ut.random.choice(type_candidates)
+        return constants[t.name](t)
+
 
 class ArrayType(tp.TypeConstructor, ObjectType):
     def __init__(self, name="Array"):

src/translators/utils.py

@@ -3,4 +3,4 @@ def inner(self, node):
         self._nodes_stack.append(node)
         visit(self, node)
         self._nodes_stack.pop()
-    return inner
+    return inner