Update type var assignments only when upper bound is not respected

Author: theosotr

src/ir/type_utils.py

@@ -494,7 +494,9 @@ def _get_type_arg_variance(t_param, variance_choices):
     return utils.random.choice(variances)
 
 
-def _update_type_var_bound_rec(t_param, t, t_args, indexes, type_var_map):
+def update_type_var_bound_rec(t_param: tp.TypeParameter,
+                              t: tp.Type, t_args: list, indexes: list,
+                              type_var_map: dict):
     """
     This method recursively updates the type assignment associated with the
     bound of a type variable.
@@ -510,11 +512,19 @@ def _update_type_var_bound_rec(t_param, t, t_args, indexes, type_var_map):
     the type assignment related to the bound of bounds.
     """
     if not (t_param.is_type_var() and t_param.bound is not None):
+        # Nothing to update. We don't encounter a type variable with an
+        # upper bound.
         return
     bound = t_param.bound
     if not bound.is_type_var():
         return
     try:
+        current_t = type_var_map[bound]
+        if t.is_subtype(current_t):
+            # The current assignment for the type variable corresponding to
+            # the upper bound of 't_param' is supertype of 't'. So we don't
+            # have to update anything.
+            return
         t_args[indexes[bound]] = t
         type_var_map[bound] = t
     except KeyError:
@@ -523,7 +533,7 @@ def _update_type_var_bound_rec(t_param, t, t_args, indexes, type_var_map):
         # case the type variable of the type constructor should be already
         # instantiated with a type that cannot be changed.
         assert bound in type_var_map
-    _update_type_var_bound_rec(bound, t, t_args, indexes, type_var_map)
+    update_type_var_bound_rec(bound, t, t_args, indexes, type_var_map)
 
 
 def _compute_type_variable_assignments(
@@ -561,8 +571,8 @@ def _compute_type_variable_assignments(
 
                 if is_covariant and not for_type_constructor:
                     t = tp.Nothing
-                _update_type_var_bound_rec(t_param, t, t_args, indexes,
-                                           type_var_map)
+                update_type_var_bound_rec(t_param, t, t_args, indexes,
+                                          type_var_map)
         else:
             a_types = []
             for k, v in type_var_map.items():

tests/test_type_utils.py

@@ -1,3 +1,5 @@
+from copy import deepcopy
+
 from src.ir import types as tp, kotlin_types as kt
 from src.ir import ast, type_utils as tutils, context as ctx
 
@@ -1301,3 +1303,55 @@ def test_build_type_variable_dependencies():
         baz.name: ["Baz.T1"],
         "Foo.T1": ["Bar.T3"]
     }
+
+
+def test_update_type_var_bound_rec():
+    type_param1 = tp.TypeParameter("T1")
+    type_param2 = tp.TypeParameter("T2", bound=type_param1)
+    type_param3 = tp.TypeParameter("T3", bound=type_param2)
+    type_param4 = tp.TypeParameter("T4")
+    type_var_map = {
+        type_param1: kt.String
+    }
+    indexes = {
+        type_param1: 0,
+        type_param2: 1,
+        type_param3: 2,
+        type_param4: 3,
+    }
+    targs = [kt.String]
+    old_type_var_map = deepcopy(type_var_map)
+    old_targs = deepcopy(targs)
+    tutils.update_type_var_bound_rec(tp.Classifier("Foo"), kt.String,
+                                     targs, indexes, type_var_map)
+    assert old_targs == targs
+    assert old_type_var_map == type_var_map
+
+    tutils.update_type_var_bound_rec(type_param4, kt.Integer,
+                                     targs, indexes, type_var_map)
+    assert old_targs == targs
+    assert old_type_var_map == type_var_map
+
+
+    tutils.update_type_var_bound_rec(type_param2, kt.Integer,
+                                     targs, indexes, type_var_map)
+    assert type_var_map == {type_param1: kt.Integer}
+    assert targs == [kt.Integer]
+
+    type_var_map = deepcopy(old_type_var_map)
+    type_var_map[type_param2] = kt.Boolean
+    targs = deepcopy(old_targs)
+    targs.append(kt.Boolean)
+
+    tutils.update_type_var_bound_rec(type_param3, kt.Integer,
+                                     targs, indexes, type_var_map)
+    assert type_var_map == {type_param1: kt.Integer, type_param2: kt.Integer}
+    assert targs == [kt.Integer, kt.Integer]
+
+    type_var_map[type_param1] = kt.Number
+    type_var_map[type_param2] = kt.Number
+    targs = [kt.Number, kt.Number]
+    tutils.update_type_var_bound_rec(type_param3, kt.Integer,
+                                     targs, indexes, type_var_map)
+    assert type_var_map == {type_param1: kt.Number, type_param2: kt.Number}
+    assert targs == [kt.Number, kt.Number]