[Type system] Fix algorithm of folding recursive types

There was a problem when we get type from type projection even if
  it is a star projection what is meaningless. Now we try to fold argument
  only if it's not a star projection

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/NewCommonSuperTypeCalculator.kt

@@ -205,18 +205,23 @@ object NewCommonSuperTypeCalculator {
                 }
             }
 
+            // This is used for folding recursive types like Inv<Inv<*>> into Inv<*>
+            fun collapseRecursiveArgumentIfPossible(argument: TypeArgumentMarker): TypeArgumentMarker {
+                if (argument.isStarProjection()) return argument
+                val argumentType = argument.getType().asSimpleType()
+                val argumentConstructor = argumentType?.typeConstructor()
+                return if (argument.getVariance() == TypeVariance.OUT && argumentConstructor == constructor && argumentType.asArgumentList()[index].isStarProjection()) {
+                    createStarProjection(parameter)
+                } else {
+                    argument
+                }
+            }
+
             val argument =
                 if (thereIsStar || typeProjections.isEmpty()) {
                     createStarProjection(parameter)
                 } else {
-                    val argument = calculateArgument(parameter, typeProjections, depth)
+                    collapseRecursiveArgumentIfPossible(calculateArgument(parameter, typeProjections, depth))
-                    val argumentType = argument.getType().asSimpleType()
-                    val argumentConstructor = argumentType?.typeConstructor()
-                    if (argument.getVariance() == TypeVariance.OUT && argumentConstructor == constructor && argumentType.asArgumentList()[index].isStarProjection()) {
-                        createStarProjection(parameter)
-                    } else {
-                        argument
-                    }
                 }
 
             arguments.add(argument)