substitute_type_args => substitute_type

Author: theosotr

src/ir/types.py

@@ -124,18 +124,9 @@ 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 substitute_type(self, type_map,
+                        cond=lambda t: t.has_type_variables()):
+        return self
 
     def not_related(self, other: Type):
         return not(self.is_subtype(other) or other.is_subtype(self))
@@ -311,6 +302,20 @@ def is_subtype(self, other):
             return False
         return self.bound.is_subtype(other)
 
+    def substitute_type(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.bound is not None:
+                new_bound = self.bound.substitute_type(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 __eq__(self, other):
         return (self.__class__ == other.__class__ and
                 self.name == other.name and
@@ -359,10 +364,10 @@ def get_type_variables(self, factory):
         else:
             return {}
 
-    def substitute_type_args(self, type_map,
-                             cond=lambda t: t.has_type_variables()):
+    def substitute_type(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)
+            new_bound = self.bound.substitute_type(type_map, cond)
             return WildCardType(new_bound, variance=self.variance)
         t = type_map.get(self)
         if t is None or cond(t):
@@ -414,7 +419,7 @@ def is_primitive(self):
 
 
 def substitute_type(t, type_map):
-    return t.substitute_type_args(type_map, lambda t: False)
+    return t.substitute_type(type_map, lambda t: False)
 
 
 def perform_type_substitution(etype, type_map,
@@ -437,7 +442,7 @@ class X<T> : Y<Z<T>>()
     supertypes = []
     for t in etype.supertypes:
         if t.is_parameterized():
-            supertypes.append(t.substitute_type_args(type_map))
+            supertypes.append(t.substitute_type(type_map))
         else:
             supertypes.append(t)
     type_params = []
@@ -678,10 +683,10 @@ 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()):
+    def substitute_type(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))
+            type_args.append(t_arg.substitute_type(type_map, cond))
         new_type_map = {
             tp: type_args[i]
             for i, tp in enumerate(self.t_constructor.type_parameters)

src/ir/typescript_types.py

@@ -459,11 +459,11 @@ def is_subtype(self, other):
     def two_way_subtyping(self, other):
         return other in set(self.types)
 
-    def substitute_type_args(self, type_map,
-                             cond=lambda t: t.has_type_variables()):
+    def substitute_type(self, type_map,
+                        cond=lambda t: t.has_type_variables()):
         new_types = []
         for t in self.types:
-            new_t = (t.substitute_type_args(type_map, cond)
+            new_t = (t.substitute_type(type_map, cond)
                      if t.has_type_variables()
                      else t)
             new_types.append(new_t)