Break out dual maps in Names#derived into its own LinearMap data type.

The reason for using a linear map instead of a mutable.Map here is that
most derived instances are very small.

Author: odersky

compiler/src/dotty/tools/dotc/core/Names.scala

@@ -10,7 +10,7 @@ import StdNames.str
 import scala.internal.Chars.isIdentifierStart
 import collection.immutable
 import config.Config
-import java.util.HashMap
+import util.LinearMap
 
 import scala.annotation.internal.sharable
 
@@ -182,38 +182,16 @@ object Names {
     def underlying: TermName = unsupported("underlying")
 
     @sharable // because of synchronized block in `and`
-    private var derivedNames: immutable.Map[NameInfo, DerivedName] | HashMap[NameInfo, DerivedName] =
-      immutable.Map.empty[NameInfo, DerivedName]
-
-    private def getDerived(info: NameInfo): DerivedName /* | Null */ = (derivedNames: @unchecked) match {
-      case derivedNames: immutable.AbstractMap[NameInfo, DerivedName] @unchecked =>
-        if (derivedNames.contains(info)) derivedNames(info) else null
-      case derivedNames: HashMap[NameInfo, DerivedName] @unchecked =>
-        derivedNames.get(info)
-    }
-
-    private def putDerived(info: NameInfo, name: DerivedName): name.type = {
-      derivedNames match {
-        case derivedNames: immutable.Map[NameInfo, DerivedName] @unchecked =>
-          if (derivedNames.size < 4)
-            this.derivedNames = derivedNames.updated(info, name)
-          else {
-            val newMap = new HashMap[NameInfo, DerivedName]
-            derivedNames.foreach { case (k, v) => newMap.put(k, v) }
-            newMap.put(info, name)
-            this.derivedNames = newMap
-          }
-        case derivedNames: HashMap[NameInfo, DerivedName] @unchecked =>
-          derivedNames.put(info, name)
-      }
-      name
-    }
+    private var derivedNames: LinearMap[NameInfo, DerivedName] = LinearMap.Empty
 
     private def add(info: NameInfo): TermName = synchronized {
-      getDerived(info) match {
-        case null        => putDerived(info, new DerivedName(this, info))
-        case derivedName => derivedName
-      }
+      derivedNames(info) match
+        case null =>
+          val derivedName = new DerivedName(this, info)
+          derivedNames = derivedNames.updated(info, derivedName)
+          derivedName
+        case derivedName =>
+          derivedName
     }
 
     private def rewrap(underlying: TermName) =

compiler/src/dotty/tools/dotc/util/LinearMap.scala

@@ -0,0 +1,43 @@
+package dotty.tools.dotc.util
+
+import collection.immutable
+
+/** A linear map is a map where after an `updated` the previous map
+ *  value cannot be used anymore. The map is implemented as an immutable
+ *  map for sizes <= 4 (where immutable maps have specialized, compact
+ *  representations) and as a HashMap for larger sizes.
+ */
+opaque type LinearMap[K <: AnyRef, V >: Null <: AnyRef] =
+  immutable.Map[K, V] | HashMap[K, V]
+
+object LinearMap:
+
+  def Empty[K <: AnyRef, V >: Null <: AnyRef]: LinearMap[K, V] =
+    immutable.Map.empty[K, V]
+
+  extension [K <: AnyRef, V >: Null <: AnyRef](m: LinearMap[K, V]):
+
+    def apply(key: K): V /*| Null*/ = m match
+      case m: immutable.Map[K, V] @unchecked =>
+        if m.contains(key) then m(key) else null
+      case m: HashMap[K, V] @unchecked =>
+        m.get(key)
+
+    def updated(key: K, value: V): LinearMap[K, V] = m match
+      case m: immutable.Map[K, V] @unchecked =>
+        if m.size < 4 then
+          m.updated(key, value)
+        else
+          val m1 = HashMap[K, V]()
+          m.foreach(m1.put(_, _))
+          m1.put(key, value)
+          m1
+      case m: HashMap[K, V] @unchecked =>
+        m.put(key, value)
+        m
+
+    def size = m match
+      case m: immutable.Map[K, V] @unchecked => m.size
+      case m: HashMap[K, V] @unchecked => m.size
+
+end LinearMap