From c2b866fe7ace5d8c4b6b0e7e68816377b4c3a7e7 Mon Sep 17 00:00:00 2001
From: Ilya Chernikov <ilya.chernikov@jetbrains.com>
Date: Mon, 9 Mar 2020 12:15:42 +0100
Subject: [PATCH] Reduce number of constraints simplifications

assuming that MutableVariableWithConstraints is constructed either
with no initial constraints or already from simplified list
---
 .../model/MutableConstraintStorage.kt         | 36 ++++++++++++-------
 .../model/NewConstraintSystemImpl.kt          |  2 +-
 2 files changed, 25 insertions(+), 13 deletions(-)

diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/MutableConstraintStorage.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/MutableConstraintStorage.kt
index 7b41a55bdff..1b126fb5168 100644
--- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/MutableConstraintStorage.kt
+++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/MutableConstraintStorage.kt
@@ -18,14 +18,19 @@ import kotlin.collections.ArrayList
 import kotlin.collections.LinkedHashMap
 
 
-class MutableVariableWithConstraints(
+class MutableVariableWithConstraints private constructor(
     override val typeVariable: TypeVariableMarker,
-    constraints: Collection<Constraint> = emptyList()
+    constraints: List<Constraint>? // assume simplified and deduplicated
 ) : VariableWithConstraints {
+
+    constructor(typeVariable: TypeVariableMarker) : this(typeVariable, null)
+
+    constructor(other: VariableWithConstraints) : this(other.typeVariable, other.constraints)
+
     override val constraints: List<Constraint>
         get() {
             if (simplifiedConstraints == null) {
-                simplifiedConstraints = simplifyConstraints()
+                simplifiedConstraints = mutableConstraints.simplifyConstraints()
             }
             return simplifiedConstraints!!
         }
@@ -36,9 +41,9 @@ class MutableVariableWithConstraints(
             .filter { it.position.from is OnlyInputTypeConstraintPosition || it.inputTypePositionBeforeIncorporation != null }
             .map { (it.type as KotlinType).unCapture().unwrap() }
 
-    private val mutableConstraints = ArrayList(constraints)
+    private val mutableConstraints = if (constraints == null) ArrayList() else ArrayList(constraints)
 
-    private var simplifiedConstraints: List<Constraint>? = null
+    private var simplifiedConstraints: List<Constraint>? = mutableConstraints
 
     // return new actual constraint, if this constraint is new
     fun addConstraint(constraint: Constraint): Constraint? {
@@ -80,13 +85,17 @@ class MutableVariableWithConstraints(
     // shouldRemove should give true only for tail elements
     internal fun removeLastConstraints(shouldRemove: (Constraint) -> Boolean) {
         mutableConstraints.trimToSize(mutableConstraints.indexOfLast { !shouldRemove(it) } + 1)
-        simplifiedConstraints = null
+        if (simplifiedConstraints !== mutableConstraints) {
+            simplifiedConstraints = null
+        }
     }
 
     // This method should be used only when constraint system has state COMPLETION
     internal fun removeConstrains(shouldRemove: (Constraint) -> Boolean) {
         mutableConstraints.removeAll(shouldRemove)
-        simplifiedConstraints = null
+        if (simplifiedConstraints !== mutableConstraints) {
+            simplifiedConstraints = null
+        }
     }
 
     private fun newConstraintIsUseless(old: Constraint, new: Constraint): Boolean {
@@ -102,11 +111,14 @@ class MutableVariableWithConstraints(
         }
     }
 
-    private fun simplifyConstraints(): List<Constraint> {
-        val equalityConstraints = mutableConstraints
-            .filter { it.kind == ConstraintKind.EQUALITY }
-            .groupBy { it.typeHashCode }
-        return mutableConstraints.filter { isUsefulConstraint(it, equalityConstraints) }
+    private fun List<Constraint>.simplifyConstraints(): List<Constraint> {
+        val equalityConstraints =
+            filter { it.kind == ConstraintKind.EQUALITY }
+                .groupBy { it.typeHashCode }
+        return when {
+            equalityConstraints.isEmpty() -> this
+            else -> filter { isUsefulConstraint(it, equalityConstraints) }
+        }
     }
 
     private fun isUsefulConstraint(constraint: Constraint, equalityConstraints: Map<Int, List<Constraint>>): Boolean {
diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/NewConstraintSystemImpl.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/NewConstraintSystemImpl.kt
index b2032cc429a..33a6e9ef118 100644
--- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/NewConstraintSystemImpl.kt
+++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/NewConstraintSystemImpl.kt
@@ -201,7 +201,7 @@ class NewConstraintSystemImpl(
             notProperTypesCache.clear()
         }
         for ((variable, constraints) in otherSystem.notFixedTypeVariables) {
-            notFixedTypeVariables[variable] = MutableVariableWithConstraints(constraints.typeVariable, constraints.constraints)
+            notFixedTypeVariables[variable] = MutableVariableWithConstraints(constraints)
         }
         storage.initialConstraints.addAll(otherSystem.initialConstraints)
         storage.maxTypeDepthFromInitialConstraints =