Remove brittle ‘contains’ optimization in minus/removeAll/retainAll #KT-45438

libraries/stdlib/common/src/generated/_Collections.kt

@@ -2995,7 +2995,7 @@ public operator fun <T> Iterable<T>.minus(element: T): List<T> {
  */
 public operator fun <T> Iterable<T>.minus(elements: Array<out T>): List<T> {
     if (elements.isEmpty()) return this.toList()
-    val other = elements.toHashSet()
+    val other = elements.convertToSetForSetOperation()
     return this.filterNot { it in other }
 }
 
@@ -3019,7 +3019,7 @@ public operator fun <T> Iterable<T>.minus(elements: Iterable<T>): List<T> {
  * a correct and stable implementation of `hashCode()` that doesn't change between successive invocations.
  */
 public operator fun <T> Iterable<T>.minus(elements: Sequence<T>): List<T> {
-    val other = elements.toHashSet()
+    val other = elements.convertToSetForSetOperation()
     if (other.isEmpty())
         return this.toList()
     return this.filterNot { it in other }

libraries/stdlib/common/src/generated/_Sequences.kt

@@ -2449,7 +2449,7 @@ public operator fun <T> Sequence<T>.minus(elements: Array<out T>): Sequence<T> {
     if (elements.isEmpty()) return this
     return object: Sequence<T> {
         override fun iterator(): Iterator<T> {
-            val other = elements.toHashSet()
+            val other = elements.convertToSetForSetOperation()
             return this@minus.filterNot { it in other }.iterator()
         }
     }
@@ -2492,7 +2492,7 @@ public operator fun <T> Sequence<T>.minus(elements: Iterable<T>): Sequence<T> {
 public operator fun <T> Sequence<T>.minus(elements: Sequence<T>): Sequence<T> {
     return object: Sequence<T> {
         override fun iterator(): Iterator<T> {
-            val other = elements.toHashSet()
+            val other = elements.convertToSetForSetOperation()
             if (other.isEmpty())
                 return this@minus.iterator()
             else

libraries/stdlib/js/src/kotlin/collections.kt

@@ -265,4 +265,6 @@ internal actual fun mapCapacity(expectedSize: Int) = expectedSize
 @PublishedApi
 internal fun checkBuilderCapacity(capacity: Int) {
     require(capacity >= 0) { "capacity must be non-negative." }
-}
+}
+
+internal actual fun brittleContainsOptimizationEnabled(): Boolean = false

libraries/stdlib/jvm/src/kotlin/collections/CollectionsJVM.kt

@@ -123,3 +123,5 @@ internal actual inline fun checkCountOverflow(count: Int): Int {
     return count
 }
 
+
+internal actual fun brittleContainsOptimizationEnabled(): Boolean = System.getProperty("kotlin.collections.removing.legacymode").toBoolean()

libraries/stdlib/src/kotlin/collections/BrittleContainsOptimization.kt

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.collections
+
+
+/** Returns true if the brittle contains optimization is enabled. See KT-45438. */
+internal expect fun brittleContainsOptimizationEnabled(): Boolean
+
+/**
+ * Returns true if [brittleContainsOptimizationEnabled] is true
+ * and it's safe to convert this collection to a set without changing contains method behavior.
+ */
+private fun <T> Collection<T>.safeToConvertToSet() = brittleContainsOptimizationEnabled() && size > 2 && this is ArrayList
+
+/**
+ * When [brittleContainsOptimizationEnabled] is true:
+ * - Converts this [Iterable] to a set if it is not a [Collection].
+ * - Converts this [Collection] to a set, when it's worth so and it doesn't change contains method behavior.
+ * - Otherwise returns this.
+ * When [brittleContainsOptimizationEnabled] is false:
+ * - Converts this [Iterable] to a list if it is not a [Collection].
+ * - Otherwise returns this.
+ */
+internal fun <T> Iterable<T>.convertToSetForSetOperationWith(source: Iterable<T>): Collection<T> =
+    when (this) {
+        is Set -> this
+        is Collection ->
+            when {
+                source is Collection && source.size < 2 -> this
+                else -> if (this.safeToConvertToSet()) toHashSet() else this
+            }
+        else -> if (brittleContainsOptimizationEnabled()) toHashSet() else toList()
+    }
+
+/**
+ * When [brittleContainsOptimizationEnabled] is true:
+ * - Converts this [Iterable] to a set if it is not a [Collection].
+ * - Converts this [Collection] to a set, when it's worth so and it doesn't change contains method behavior.
+ * - Otherwise returns this.
+ * When [brittleContainsOptimizationEnabled] is false:
+ * - Converts this [Iterable] to a list if it is not a [Collection].
+ * - Otherwise returns this.
+ */
+internal fun <T> Iterable<T>.convertToSetForSetOperation(): Collection<T> =
+    when (this) {
+        is Set -> this
+        is Collection -> if (this.safeToConvertToSet()) toHashSet() else this
+        else -> if (brittleContainsOptimizationEnabled()) toHashSet() else toList()
+    }
+
+/**
+ * Converts this sequence to a set if [brittleContainsOptimizationEnabled] is true,
+ * otherwise converts it to a list.
+ */
+internal fun <T> Sequence<T>.convertToSetForSetOperation(): Collection<T> =
+    if (brittleContainsOptimizationEnabled()) toHashSet() else toList()
+
+/**
+ * Converts this array to a set if [brittleContainsOptimizationEnabled] is true,
+ * otherwise converts it to a list.
+ */
+internal fun <T> Array<T>.convertToSetForSetOperation(): Collection<T> =
+    if (brittleContainsOptimizationEnabled()) toHashSet() else asList()

libraries/stdlib/src/kotlin/collections/Iterables.kt

@@ -38,29 +38,6 @@ internal fun <T> Iterable<T>.collectionSizeOrNull(): Int? = if (this is Collecti
 @PublishedApi
 internal fun <T> Iterable<T>.collectionSizeOrDefault(default: Int): Int = if (this is Collection<*>) this.size else default
 
-/** Returns true when it's safe to convert this collection to a set without changing contains method behavior. */
-private fun <T> Collection<T>.safeToConvertToSet() = size > 2 && this is ArrayList
-
-/** Converts this collection to a set, when it's worth so and it doesn't change contains method behavior. */
-internal fun <T> Iterable<T>.convertToSetForSetOperationWith(source: Iterable<T>): Collection<T> =
-    when (this) {
-        is Set -> this
-        is Collection ->
-            when {
-                source is Collection && source.size < 2 -> this
-                else -> if (this.safeToConvertToSet()) toHashSet() else this
-            }
-        else -> toHashSet()
-    }
-
-/** Converts this collection to a set, when it's worth so and it doesn't change contains method behavior. */
-internal fun <T> Iterable<T>.convertToSetForSetOperation(): Collection<T> =
-    when (this) {
-        is Set -> this
-        is Collection -> if (this.safeToConvertToSet()) toHashSet() else this
-        else -> toHashSet()
-    }
-
 
 /**
  * Returns a single list of all elements from all collections in the given collection.

libraries/stdlib/src/kotlin/collections/MutableCollections.kt

@@ -152,7 +152,7 @@ public fun <T> MutableCollection<in T>.removeAll(elements: Iterable<T>): Boolean
  * Removes all elements from this [MutableCollection] that are also contained in the given [elements] sequence.
  */
 public fun <T> MutableCollection<in T>.removeAll(elements: Sequence<T>): Boolean {
-    val set = elements.toHashSet()
+    val set = elements.convertToSetForSetOperation()
     return set.isNotEmpty() && removeAll(set)
 }
 
@@ -160,7 +160,7 @@ public fun <T> MutableCollection<in T>.removeAll(elements: Sequence<T>): Boolean
  * Removes all elements from this [MutableCollection] that are also contained in the given [elements] array.
  */
 public fun <T> MutableCollection<in T>.removeAll(elements: Array<out T>): Boolean {
-    return elements.isNotEmpty() && removeAll(elements.toHashSet())
+    return elements.isNotEmpty() && removeAll(elements.convertToSetForSetOperation())
 }
 
 /**
@@ -175,7 +175,7 @@ public fun <T> MutableCollection<in T>.retainAll(elements: Iterable<T>): Boolean
  */
 public fun <T> MutableCollection<in T>.retainAll(elements: Array<out T>): Boolean {
     if (elements.isNotEmpty())
-        return retainAll(elements.toHashSet())
+        return retainAll(elements.convertToSetForSetOperation())
     else
         return retainNothing()
 }
@@ -184,7 +184,7 @@ public fun <T> MutableCollection<in T>.retainAll(elements: Array<out T>): Boolea
  * Retains only elements of this [MutableCollection] that are contained in the given [elements] sequence.
  */
 public fun <T> MutableCollection<in T>.retainAll(elements: Sequence<T>): Boolean {
-    val set = elements.toHashSet()
+    val set = elements.convertToSetForSetOperation()
     if (set.isNotEmpty())
         return retainAll(set)
     else

libraries/stdlib/wasm/src/kotlin/collections/Collections.kt

@@ -108,4 +108,6 @@ internal actual inline fun <K, V> buildMapInternal(builderAction: MutableMap<K,
 @kotlin.internal.InlineOnly
 internal actual inline fun <K, V> buildMapInternal(capacity: Int, builderAction: MutableMap<K, V>.() -> Unit): Map<K, V> {
     return TODO("Wasm stdlib: Collections")
-}
+}
+
+internal actual fun brittleContainsOptimizationEnabled(): Boolean = false