Rename enabling old behavior property and make it cached in a field

Mention the property name in the note about conversion to set.

#KT-45438

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

@@ -2990,8 +2990,9 @@ public operator fun <T> Iterable<T>.minus(element: T): List<T> {
 /**
  * Returns a list containing all elements of the original collection except the elements contained in the given [elements] array.
  * 
- * The [elements] array may be converted to a [HashSet] to speed up the operation, thus the elements are required to have
- * a correct and stable implementation of `hashCode()` that doesn't change between successive invocations.
+ * Before Kotlin 1.6, the [elements] array may have been converted to a [HashSet] to speed up the operation, thus the elements were required to have
+ * a correct and stable implementation of `hashCode()` that didn't change between successive invocations.
+ * On JVM, you can enable this behavior back with the system property `kotlin.collections.convert_arg_to_set_in_removeAll` set to `true`.
  */
 public operator fun <T> Iterable<T>.minus(elements: Array<out T>): List<T> {
     if (elements.isEmpty()) return this.toList()
@@ -3002,8 +3003,9 @@ public operator fun <T> Iterable<T>.minus(elements: Array<out T>): List<T> {
 /**
  * Returns a list containing all elements of the original collection except the elements contained in the given [elements] collection.
  * 
- * The [elements] collection may be converted to a [HashSet] to speed up the operation, thus the elements are required to have
- * a correct and stable implementation of `hashCode()` that doesn't change between successive invocations.
+ * Before Kotlin 1.6, the [elements] collection may have been converted to a [HashSet] to speed up the operation, thus the elements were required to have
+ * a correct and stable implementation of `hashCode()` that didn't change between successive invocations.
+ * On JVM, you can enable this behavior back with the system property `kotlin.collections.convert_arg_to_set_in_removeAll` set to `true`.
  */
 public operator fun <T> Iterable<T>.minus(elements: Iterable<T>): List<T> {
     val other = elements.convertToSetForSetOperationWith(this)
@@ -3015,8 +3017,9 @@ public operator fun <T> Iterable<T>.minus(elements: Iterable<T>): List<T> {
 /**
  * Returns a list containing all elements of the original collection except the elements contained in the given [elements] sequence.
  * 
- * The [elements] sequence may be converted to a [HashSet] to speed up the operation, thus the elements are required to have
- * a correct and stable implementation of `hashCode()` that doesn't change between successive invocations.
+ * Before Kotlin 1.6, the [elements] sequence may have been converted to a [HashSet] to speed up the operation, thus the elements were required to have
+ * a correct and stable implementation of `hashCode()` that didn't change between successive invocations.
+ * On JVM, you can enable this behavior back with the system property `kotlin.collections.convert_arg_to_set_in_removeAll` set to `true`.
  */
 public operator fun <T> Iterable<T>.minus(elements: Sequence<T>): List<T> {
     val other = elements.convertToSetForSetOperation()

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

@@ -2440,8 +2440,9 @@ public operator fun <T> Sequence<T>.minus(element: T): Sequence<T> {
  * Note that the source sequence and the array being subtracted are iterated only when an `iterator` is requested from
  * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
  * 
- * The [elements] array may be converted to a [HashSet] to speed up the operation, thus the elements are required to have
- * a correct and stable implementation of `hashCode()` that doesn't change between successive invocations.
+ * Before Kotlin 1.6, the [elements] array may have been converted to a [HashSet] to speed up the operation, thus the elements were required to have
+ * a correct and stable implementation of `hashCode()` that didn't change between successive invocations.
+ * On JVM, you can enable this behavior back with the system property `kotlin.collections.convert_arg_to_set_in_removeAll` set to `true`.
  *
  * The operation is _intermediate_ and _stateful_.
  */
@@ -2461,8 +2462,9 @@ public operator fun <T> Sequence<T>.minus(elements: Array<out T>): Sequence<T> {
  * Note that the source sequence and the collection being subtracted are iterated only when an `iterator` is requested from
  * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
  * 
- * The [elements] collection may be converted to a [HashSet] to speed up the operation, thus the elements are required to have
- * a correct and stable implementation of `hashCode()` that doesn't change between successive invocations.
+ * Before Kotlin 1.6, the [elements] collection may have been converted to a [HashSet] to speed up the operation, thus the elements were required to have
+ * a correct and stable implementation of `hashCode()` that didn't change between successive invocations.
+ * On JVM, you can enable this behavior back with the system property `kotlin.collections.convert_arg_to_set_in_removeAll` set to `true`.
  *
  * The operation is _intermediate_ and _stateful_.
  */
@@ -2486,8 +2488,9 @@ public operator fun <T> Sequence<T>.minus(elements: Iterable<T>): Sequence<T> {
  * 
  * The operation is _intermediate_ for this sequence and _terminal_ and _stateful_ for the [elements] sequence.
  * 
- * The [elements] sequence may be converted to a [HashSet] to speed up the operation, thus the elements are required to have
- * a correct and stable implementation of `hashCode()` that doesn't change between successive invocations.
+ * Before Kotlin 1.6, the [elements] sequence may have been converted to a [HashSet] to speed up the operation, thus the elements were required to have
+ * a correct and stable implementation of `hashCode()` that didn't change between successive invocations.
+ * On JVM, you can enable this behavior back with the system property `kotlin.collections.convert_arg_to_set_in_removeAll` set to `true`.
  */
 public operator fun <T> Sequence<T>.minus(elements: Sequence<T>): Sequence<T> {
     return object: Sequence<T> {

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

@@ -33,8 +33,9 @@ public operator fun <T> Set<T>.minus(element: T): Set<T> {
  * 
  * The returned set preserves the element iteration order of the original set.
  * 
- * The [elements] array may be converted to a [HashSet] to speed up the operation, thus the elements are required to have
- * a correct and stable implementation of `hashCode()` that doesn't change between successive invocations.
+ * Before Kotlin 1.6, the [elements] array may have been converted to a [HashSet] to speed up the operation, thus the elements were required to have
+ * a correct and stable implementation of `hashCode()` that didn't change between successive invocations.
+ * On JVM, you can enable this behavior back with the system property `kotlin.collections.convert_arg_to_set_in_removeAll` set to `true`.
  */
 public operator fun <T> Set<T>.minus(elements: Array<out T>): Set<T> {
     val result = LinkedHashSet<T>(this)
@@ -47,8 +48,9 @@ public operator fun <T> Set<T>.minus(elements: Array<out T>): Set<T> {
  * 
  * The returned set preserves the element iteration order of the original set.
  * 
- * The [elements] collection may be converted to a [HashSet] to speed up the operation, thus the elements are required to have
- * a correct and stable implementation of `hashCode()` that doesn't change between successive invocations.
+ * Before Kotlin 1.6, the [elements] collection may have been converted to a [HashSet] to speed up the operation, thus the elements were required to have
+ * a correct and stable implementation of `hashCode()` that didn't change between successive invocations.
+ * On JVM, you can enable this behavior back with the system property `kotlin.collections.convert_arg_to_set_in_removeAll` set to `true`.
  */
 public operator fun <T> Set<T>.minus(elements: Iterable<T>): Set<T> {
     val other = elements.convertToSetForSetOperationWith(this)
@@ -66,8 +68,9 @@ public operator fun <T> Set<T>.minus(elements: Iterable<T>): Set<T> {
  * 
  * The returned set preserves the element iteration order of the original set.
  * 
- * The [elements] sequence may be converted to a [HashSet] to speed up the operation, thus the elements are required to have
- * a correct and stable implementation of `hashCode()` that doesn't change between successive invocations.
+ * Before Kotlin 1.6, the [elements] sequence may have been converted to a [HashSet] to speed up the operation, thus the elements were required to have
+ * a correct and stable implementation of `hashCode()` that didn't change between successive invocations.
+ * On JVM, you can enable this behavior back with the system property `kotlin.collections.convert_arg_to_set_in_removeAll` set to `true`.
  */
 public operator fun <T> Set<T>.minus(elements: Sequence<T>): Set<T> {
     val result = LinkedHashSet<T>(this)