Merge branch 'perf-backport/6967-needless-storage-scope' into perf-backport/omnibus

Author: retronym

library/src/scala/Enumeration.scala

@@ -25,6 +25,11 @@ import scala.util.matching.Regex
  *  `Value` type member of the enumeration (`Value` selected on the stable
  *  identifier path of the enumeration instance).
  *
+ *  Values SHOULD NOT be added to an enumeration after its construction;
+ *  doing so makes the enumeration thread-unsafe. If values are added to an
+ *  enumeration from multiple threads (in a non-synchronized fashion) after
+ *  construction, the behavior of the enumeration is undefined.
+ *
  * @example {{{
  * // Define a new enumeration with a type alias and work with the full set of enumerated values
  * object WeekDay extends Enumeration {

library/src/scala/collection/immutable/HashMap.scala

@@ -297,7 +297,7 @@ object HashMap extends ImmutableMapFactory[HashMap] with BitOperations.Int {
     protected override def merge0[B1 >: B](that: HashMap[A, B1], level: Int, merger: Merger[A, B1]): HashMap[A, B1] = {
       // this can be made more efficient by passing the entire ListMap at once
       var m = that
-      for (p <- kvs) m = m.updated0(p._1, this.hash, level, p._2, p, merger)
+      for (p <- kvs) m = m.updated0(p._1, this.hash, level, p._2, p, merger.invert)
       m
     }
   }

library/src/scala/collection/mutable/ArrayBuilder.scala

@@ -60,9 +60,9 @@ object ArrayBuilder {
     private var size: Int = 0
 
     private def mkArray(size: Int): Array[T] = {
-      val newelems = new Array[T](size)
-      if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size)
-      newelems
+      if (capacity == size && capacity > 0) elems
+      else if (elems eq null) new Array[T](size)
+      else java.util.Arrays.copyOf[T](elems, size)
     }
 
     private def resize(size: Int) {

library/src/scala/collection/mutable/HashMap.scala

@@ -75,18 +75,25 @@ extends AbstractMap[A, B]
   override def getOrElseUpdate(key: A, defaultValue: => B): B = {
     val hash = elemHashCode(key)
     val i = index(hash)
-    val entry = findEntry(key, i)
-    if (entry != null) entry.value
+    val firstEntry = findEntry(key, i)
+    if (firstEntry != null) firstEntry.value
     else {
       val table0 = table
       val default = defaultValue
       // Avoid recomputing index if the `defaultValue()` hasn't triggered
       // a table resize.
       val newEntryIndex = if (table0 eq table) i else index(hash)
-      addEntry(createNewEntry(key, default), newEntryIndex)
+      val e = createNewEntry(key, default)
+      // Repeat search
+      // because evaluation of `default` can bring entry with `key`
+      val secondEntry = findEntry(key, newEntryIndex)
+      if (secondEntry == null) addEntry0(e, newEntryIndex)
+      else secondEntry.value = default
+      default
     }
   }
 
+
   /* inlined HashTable.findEntry0 to preserve its visibility */
   private[this] def findEntry(key: A, h: Int): Entry = {
     var e = table(h).asInstanceOf[Entry]