Name changes and resolving PR comments

Author: alexisthedev

src/generators/generator.py

@@ -1951,7 +1951,7 @@ def get_types(self,
                   exclude_contravariants=False,
                   exclude_type_vars=False,
                   exclude_function_types=False,
-                  exclude_dynamic_types=False) -> List[tp.Type]:
+                  exclude_native_compound_types=False) -> List[tp.Type]:
         """Get all available types.
 
         Including user-defined types, built-ins, and function types.
@@ -1965,7 +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.
+            exclude_native_compound_types: exclude native compound types.
 
         Returns:
             A list of available types.
@@ -1995,20 +1995,20 @@ def get_types(self,
                 if t.name != self.bt_factory.get_array_type().name
             ]
 
-        dynamic = (self.bt_factory.get_dynamic_types(self)
-                   if not exclude_dynamic_types
+        compound_types = (self.bt_factory.get_compound_types(self)
+                   if not exclude_native_compound_types
                    else [])
         if exclude_function_types:
-            return usr_types + builtins + dynamic
-        return usr_types + builtins + dynamic + self.function_types
+            return usr_types + builtins + compound_types
+        return usr_types + builtins + compound_types + self.function_types
 
     def select_type(self,
                     ret_types=True,
                     exclude_arrays=False,
                     exclude_covariants=False,
                     exclude_contravariants=False,
                     exclude_function_types=False,
-                    exclude_dynamic_types=False) -> tp.Type:
+                    exclude_native_compound_types=False) -> tp.Type:
         """Select a type from the all available types.
 
         It will always instantiating type constructors to parameterized types.
@@ -2020,7 +2020,7 @@ def select_type(self,
             exclude_covariants: exclude covariant type parameters.
             exclude_contravariants: exclude contravariant type parameters.
             exclude_function_types: exclude function types.
-            eclude_dynamic_types: exclude dynamic types.
+            exclude_native_compound_types: exclude native compound types.
 
         Returns:
             Returns a type.
@@ -2030,7 +2030,7 @@ def select_type(self,
                                exclude_covariants=exclude_covariants,
                                exclude_contravariants=exclude_contravariants,
                                exclude_function_types=exclude_function_types,
-                               exclude_dynamic_types=exclude_dynamic_types)
+                               exclude_native_compound_types=exclude_native_compound_types)
         stype = ut.random.choice(types)
         if stype.is_type_constructor():
             exclude_type_vars = stype.name == self.bt_factory.get_array_type().name
@@ -2040,7 +2040,7 @@ def select_type(self,
                                       exclude_contravariants=True,
                                       exclude_type_vars=exclude_type_vars,
                                       exclude_function_types=exclude_function_types,
-                                      exclude_dynamic_types=exclude_dynamic_types),
+                                      exclude_native_compound_types=exclude_native_compound_types),
                 enable_pecs=self.enable_pecs,
                 disable_variance_functions=self.disable_variance_functions,
                 variance_choices={}
@@ -2899,8 +2899,8 @@ def _create_type_params_from_etype(self, etype: tp.Type):
             type_params[0].variance = tp.Invariant
             return type_params, {etype: type_params[0]}, True
 
-        # the given type is combound
-        assert etype.is_combound() or etype.is_wildcard()
+        # the given type is compound
+        assert etype.is_compound() or etype.is_wildcard()
         type_vars = etype.get_type_variables(self.bt_factory)
         type_params = self.gen_type_params(
             len(type_vars), with_variance=self.language == 'kotlin')

src/ir/builtins.py

@@ -138,9 +138,10 @@ def get_function_types(self, max_parameters):
     def get_nothing(self):
         raise NotImplementedError
 
-    def get_dynamic_types(self, gen_object):
-        """ A type is considered dynamic if it can utilize
-        both a builtin type and a user-defined type.
+    def get_compound_types(self, gen_object):
+        """ A type is considered compound if it can consist
+        of other types. This function is used to add a lanuage's
+        native compound types to the generator.
 
         Eg. A TypeScript Union Type: string | myClass
 

src/ir/type_utils.py

@@ -1040,9 +1040,9 @@ def unify_types(t1: tp.Type, t2: tp.Type, factory,
       class A<T>
       class B : A<String>()
     """
-    if t2.is_combound() and not t2.is_parameterized():
+    if t2.is_compound() and not t2.is_parameterized():
         return t2.unify_types(t1, factory, same_type)
-    elif t1.is_combound() and t2.is_type_var():
+    elif t1.is_compound() and t2.is_type_var():
         bound = t2.get_bound_rec(factory)
         if bound is None or t1.is_subtype(bound):
             return {t2: t1}
@@ -1110,8 +1110,8 @@ class B : A<String>()
                     if not _update_type_var_map(type_var_map, t_var, t_arg1):
                         return {}
                     continue
-                is_parameterized = t_var.bound.is_combound()
-                is_parameterized2 = t_arg1.is_combound()
+                is_parameterized = t_var.bound.is_compound()
+                is_parameterized2 = t_arg1.is_compound()
                 if is_parameterized and is_parameterized2:
                     res = unify_types(t_arg1, t_var.bound, factory)
                     if not res or any(

src/ir/types.py

@@ -100,7 +100,7 @@ def is_type_var(self):
     def is_wildcard(self):
         return False
 
-    def is_combound(self):
+    def is_compound(self):
         return False
 
     def is_parameterized(self):
@@ -354,7 +354,7 @@ def get_type_variables(self, factory):
             return self.bound.get_type_variables(factory)
         elif self.bound.is_type_var():
             return {self.bound: {self.bound.get_bound_rec(factory)}}
-        elif self.bound.is_combound():
+        elif self.bound.is_compound():
             return self.bound.get_type_variables(factory)
         else:
             return {}
@@ -539,7 +539,7 @@ def _to_type_variable_free(t: Type, t_param, factory) -> Type:
             )
         )
         return WildCardType(bound, variance)
-    elif t.is_combound():
+    elif t.is_compound():
         return t.to_type_variable_free(factory)
     else:
         return t
@@ -595,7 +595,7 @@ def __init__(self, t_constructor: TypeConstructor,
         # XXX revisit
         self.supertypes = copy(self.t_constructor.supertypes)
 
-    def is_combound(self):
+    def is_compound(self):
         return True
 
     def is_parameterized(self):
@@ -671,7 +671,7 @@ def get_type_variables(self, factory) -> Dict[TypeParameter, Set[Type]]:
             if t_arg.is_type_var():
                 type_vars[t_arg].add(
                     t_arg.get_bound_rec(factory))
-            elif t_arg.is_combound() or t_arg.is_wildcard():
+            elif t_arg.is_compound() or t_arg.is_wildcard():
                 for k, v in t_arg.get_type_variables(factory).items():
                     type_vars[k].update(v)
             else:

src/ir/typescript_types.py

@@ -96,7 +96,7 @@ def update_add_node_to_parent(self):
             ts_ast.TypeAliasDeclaration: add_type_alias,
         }
 
-    def get_dynamic_types(self, gen_object):
+    def get_compound_types(self, gen_object):
         return [
             union_types.get_union_type(gen_object),
         ]
@@ -432,7 +432,7 @@ def __init__(self, types, name="UnionType", primitive=False):
     def get_types(self):
         return self.types
 
-    def is_combound(self):
+    def is_compound(self):
         return True
 
     @two_way_subtyping
@@ -468,7 +468,7 @@ def get_type_variables(self, factory):
             if t.is_type_var():
                 type_vars[t].add(
                     t.get_bound_rec(factory))
-            elif t.is_combound() or t.is_wildcard():
+            elif t.is_compound() or t.is_wildcard():
                 for k, v in t.get_type_variables(factory).items():
                     type_vars[k].update(v)
             else:
@@ -479,7 +479,7 @@ def to_variance_free(self, type_var_map=None):
         new_types = []
         for t in self.types:
             new_types.append(t.to_variance_free(type_var_map)
-                             if t.is_combound()
+                             if t.is_compound()
                              else t)
         return UnionType(new_types)
 
@@ -489,7 +489,7 @@ def to_type_variable_free(self, factory):
         # type variable free.
         new_types = []
         for t in self.types:
-            if t.is_combound():
+            if t.is_compound():
                 new_type = t.to_type_variable_free(factory)
             elif t.is_type_var():
                 bound = t.get_bound_rec(factory)
@@ -517,7 +517,7 @@ def unify_types(self, t1, factory, same_type=True):
             return {}
 
         # If T1 is a union type, then get all its types.
-        t1_types = (t1.types if t1.is_combound() and
+        t1_types = (t1.types if t1.is_compound() and
                      not t1.is_parameterized()
                      else [t1])
 
@@ -715,7 +715,7 @@ def __hash__(self):
         return hash(str(self.name) + str(self.types))
 
 
-class UnionTypeFactory:
+class UnionTypeFactory(object):
     def __init__(self, max_ut, max_in_union):
         self.max_ut = max_ut
         self.unions = []
@@ -728,7 +728,7 @@ 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)
+            t = gen.select_type(exclude_native_compound_types=True)
             types.add(t)
         return list(types)