Cache all memberNamed results

Use a full cache instead of an LRU cache. For `typer/*.scala`, this
reduced computed member searches on normal ClassDenotations from 520K to
170K. Cache hit rate improves to 97.5%, from 92.5%. (Without member caching
there are almost 7Mio computed members for the same code base).

Author: odersky

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

@@ -1564,14 +1564,14 @@ object SymDenotations {
     initPrivateWithin: Symbol)
     extends SymDenotation(symbol, maybeOwner, name, initFlags, initInfo, initPrivateWithin) {
 
-    import util.LRUCache
+    import util.LinearTable
 
     // ----- caches -------------------------------------------------------
 
     private var myTypeParams: List[TypeSymbol] = null
     private var fullNameCache: SimpleIdentityMap[QualifiedNameKind, Name] = SimpleIdentityMap.Empty
 
-    private var myMemberCache: LRUCache[Name, PreDenotation] = null
+    private var myMemberCache: LinearTable[Name, PreDenotation] = null
     private var myMemberCachePeriod: Period = Nowhere
 
     /** A cache from types T to baseType(T, C) */
@@ -1582,9 +1582,9 @@ object SymDenotations {
     private var baseDataCache: BaseData = BaseData.None
     private var memberNamesCache: MemberNames = MemberNames.None
 
-    private def memberCache(using Context): LRUCache[Name, PreDenotation] = {
+    private def memberCache(using Context): LinearTable[Name, PreDenotation] = {
       if (myMemberCachePeriod != ctx.period) {
-        myMemberCache = new LRUCache
+        myMemberCache = LinearTable.empty
         myMemberCachePeriod = ctx.period
       }
       myMemberCache
@@ -1868,10 +1868,10 @@ object SymDenotations {
     final def nonPrivateMembersNamed(name: Name)(using Context): PreDenotation = {
       Stats.record("nonPrivateMembersNamed")
       if (Config.cacheMembersNamed) {
-        var denots: PreDenotation = memberCache lookup name
+        var denots: PreDenotation = memberCache.lookup(name)
         if (denots == null) {
           denots = computeNPMembersNamed(name)
-          memberCache.enter(name, denots)
+          myMemberCache = memberCache.enter(name, denots)
         }
         else if (Config.checkCacheMembersNamed) {
           val denots1 = computeNPMembersNamed(name)

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

@@ -0,0 +1,89 @@
+package dotty.tools.dotc.util
+
+/** A table with an immutable API that must be used linearly since it uses
+ *  mutation internally. A packed array representation is used for sizes
+ *  up to 8, and a hash table is used for larger sizes.
+ */
+abstract class LinearTable[Key >: Null <: AnyRef, Value >: Null <: AnyRef]:
+  def lookup(key: Key): Value
+  def enter(key: Key, value: Value): LinearTable[Key, Value]
+  def invalidate(key: Key): Unit
+  def size: Int
+
+object LinearTable:
+  def empty[Key >: Null <: AnyRef, Value >: Null <: AnyRef]: LinearTable[Key, Value] =
+    ArrayTable[Key, Value](8)
+
+class ArrayTable[Key >: Null <: AnyRef, Value >: Null <: AnyRef](capacity: Int) extends LinearTable[Key, Value]:
+
+  val elems = new Array[AnyRef](capacity * 2)
+  var size = 0
+
+  def lookup(key: Key): Value =
+    var i = 0
+    while i < elems.length do
+      if elems(i) eq key then
+        return elems(i + 1).asInstanceOf[Value]
+      if elems(i) == null then
+        return null
+      i += 2
+    null
+
+  def enter(key: Key, value: Value): LinearTable[Key, Value] =
+    var i = 0
+    while i < elems.length do
+      if elems(i) eq key then
+        elems(i + 1) = value
+        return this
+      if elems(i) == null then
+        elems(i) = key
+        elems(i + 1) = value
+        size += 1
+        return this
+      i += 2
+    val ht = HashTable[Key, Value](initialCapacity = 16)
+    i = 0
+    while i < elems.length do
+      ht.enter(elems(i).asInstanceOf[Key], elems(i + 1).asInstanceOf[Value])
+      i += 2
+    ht.enter(key, value)
+    ht
+
+  def invalidate(key: Key): Unit =
+    var i = 0
+    while i < elems.length do
+      if elems(i) eq key then
+        size -= 1
+        elems(i) = null
+        return
+      i += 2
+
+  override def toString: String =
+    val buf = new StringBuilder
+    var i = 0
+    while i < elems.length do
+      buf.append(if i == 0 then "ArrayTable(" else ", ")
+      if elems(i) != null then
+        buf.append(elems(i))
+        buf.append(" -> ")
+        buf.append(elems(i + 1))
+      i += 2
+    buf.append(")")
+    buf.toString
+end ArrayTable
+
+class HashTable[Key >: Null <: AnyRef, Value >: Null <: AnyRef](initialCapacity: Int) extends LinearTable[Key, Value]:
+  private val table = java.util.HashMap[Key, Value](initialCapacity)
+
+  def lookup(key: Key): Value =
+    table.get(key)
+  def enter(key: Key, value: Value): LinearTable[Key, Value] =
+    table.put(key, value)
+    this
+  def invalidate(key: Key): Unit =
+    table.remove(key)
+  def size: Int =
+    table.size
+
+  override def toString: String = table.toString
+end HashTable