Drop bounds on HashMap Value type

Make lookup return a Value | Null result instead, which makes it a bit safer to use.
To support this well, forward port a casting method from the explicit-nulls branch.

Author: odersky

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -109,7 +109,7 @@ class Compiler {
     List(new Constructors,           // Collect initialization code in primary constructors
                                         // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
          new FunctionalInterfaces,   // Rewrites closures to implement @specialized types of Functions.
-         new Instrumentation) ::     // Count closure allocations under -Yinstrument-closures
+         new Instrumentation) ::     // Count calls and allocations under -Yinstrument
     List(new LambdaLift,             // Lifts out nested functions to class scope, storing free variables in environments
                                      // Note: in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here
          new ElimStaticThis,         // Replace `this` references to static objects by global identifiers

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -44,7 +44,7 @@ class TreePickler(pickler: TastyPickler) {
 
   private val symRefs = Symbols.newMutableSymbolMap[Addr]
   private val forwardSymRefs = Symbols.newMutableSymbolMap[List[Addr]]
-  private val pickledTypes = util.IdentityHashMap[Type, AnyRef]() // Value type is really Addr, but that's not compatible with null
+  private val pickledTypes = util.IdentityHashMap[Type, Addr]()
 
   /** A list of annotation trees for every member definition, so that later
    *  parallel position pickling does not need to access and force symbols.
@@ -169,14 +169,14 @@ class TreePickler(pickler: TastyPickler) {
   def pickleType(tpe0: Type, richTypes: Boolean = false)(using Context): Unit = {
     val tpe = tpe0.stripTypeVar
     try {
-      val prev = pickledTypes.lookup(tpe)
+      val prev: Addr | Null = pickledTypes.lookup(tpe)
       if (prev == null) {
-        pickledTypes(tpe) = currentAddr.asInstanceOf[AnyRef]
+        pickledTypes(tpe) = currentAddr
         pickleNewType(tpe, richTypes)
       }
       else {
         writeByte(SHAREDtype)
-        writeRef(prev.asInstanceOf[Addr])
+        writeRef(prev.uncheckedNN)
       }
     }
     catch {
@@ -244,9 +244,9 @@ class TreePickler(pickler: TastyPickler) {
       withLength { pickleType(tpe.thistpe); pickleType(tpe.supertpe) }
     case tpe: RecThis =>
       writeByte(RECthis)
-      val binderAddr = pickledTypes.lookup(tpe.binder)
+      val binderAddr: Addr | Null = pickledTypes.lookup(tpe.binder)
       assert(binderAddr != null, tpe.binder)
-      writeRef(binderAddr.asInstanceOf[Addr])
+      writeRef(binderAddr.uncheckedNN)
     case tpe: SkolemType =>
       pickleType(tpe.info)
     case tpe: RefinedType =>
@@ -314,11 +314,11 @@ class TreePickler(pickler: TastyPickler) {
   }
 
   def pickleParamRef(tpe: ParamRef)(using Context): Boolean = {
-    val binder = pickledTypes.lookup(tpe.binder)
+    val binder: Addr | Null = pickledTypes.lookup(tpe.binder)
     val pickled = binder != null
     if (pickled) {
       writeByte(PARAMtype)
-      withLength { writeRef(binder.asInstanceOf[Addr]); writeNat(tpe.paramNum) }
+      withLength { writeRef(binder.uncheckedNN); writeNat(tpe.paramNum) }
     }
     pickled
   }
@@ -605,7 +605,7 @@ class TreePickler(pickler: TastyPickler) {
           else {
             val refineCls = refinements.head.symbol.owner.asClass
             registerDef(refineCls)
-            pickledTypes(refineCls.typeRef) = currentAddr.asInstanceOf[AnyRef]
+            pickledTypes(refineCls.typeRef) = currentAddr
             writeByte(REFINEDtpt)
             refinements.foreach(preRegister)
             withLength { pickleTree(parent); refinements.foreach(pickleTree) }

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

@@ -1,4 +1,5 @@
-package dotty.tools.dotc.util
+package dotty.tools
+package dotc.util
 
 object GenericHashMap:
 
@@ -22,7 +23,7 @@ object GenericHashMap:
  *                           However, a table of size up to DenseLimit will be re-sized only
  *                           once the number of elements reaches the table's size.
  */
-abstract class GenericHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
+abstract class GenericHashMap[Key <: AnyRef, Value]
     (initialCapacity: Int, capacityMultiple: Int) extends MutableMap[Key, Value]:
   import GenericHashMap.DenseLimit
 
@@ -57,17 +58,20 @@ abstract class GenericHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
   protected def isEqual(x: Key, y: Key): Boolean
 
   /** Turn successor index or hash code `x` into a table index */
-  private def index(x: Int): Int = x & (table.length - 2)
+  inline protected def index(x: Int): Int = x & (table.length - 2)
 
-  private def firstIndex(key: Key) = if isDense then 0 else index(hash(key))
-  private def nextIndex(idx: Int) =
+  inline protected def firstIndex(key: Key) = if isDense then 0 else index(hash(key))
+  inline protected def nextIndex(idx: Int) =
     Stats.record(statsItem("miss"))
     index(idx + 2)
 
-  private def keyAt(idx: Int): Key = table(idx).asInstanceOf[Key]
-  private def valueAt(idx: Int): Value = table(idx + 1).asInstanceOf[Value]
+  inline protected def keyAt(idx: Int): Key = table(idx).asInstanceOf[Key]
+  inline protected def valueAt(idx: Int): Value = table(idx + 1).asInstanceOf[Value]
 
-  def lookup(key: Key): Value =
+  inline protected def setTable(idx: Int, value: Value) =
+    table(idx) = value.asInstanceOf[AnyRef]
+
+  def lookup(key: Key): Value | Null =
     Stats.record(statsItem("lookup"))
     var idx = firstIndex(key)
     var k = keyAt(idx)
@@ -83,12 +87,12 @@ abstract class GenericHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
     var k = keyAt(idx)
     while k != null do
       if isEqual(k, key) then
-        table(idx + 1) = value
+        setTable(idx + 1, value)
         return
       idx = nextIndex(idx)
       k = keyAt(idx)
     table(idx) = key
-    table(idx + 1) = value
+    setTable(idx + 1, value)
     used += 1
     if used > limit then growTable()
 
@@ -109,7 +113,7 @@ abstract class GenericHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
                // hash(k) is then logically at or before hole; can be moved forward to fill hole
           then
             table(hole) = k
-            table(hole + 1) = valueAt(idx)
+            setTable(hole + 1, valueAt(idx))
             hole = idx
         table(hole) = null
         used -= 1
@@ -118,9 +122,9 @@ abstract class GenericHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
       k = keyAt(idx)
 
   def getOrElseUpdate(key: Key, value: => Value): Value =
-    var v = lookup(key)
+    var v: Value | Null = lookup(key)
     if v == null then v = value
-    v
+    v.uncheckedNN
 
   private def addOld(key: Key, value: AnyRef): Unit =
     Stats.record(statsItem("re-enter"))

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

@@ -3,7 +3,7 @@ package dotty.tools.dotc.util
 /** A specialized implementation of GenericHashMap with standard hashCode and equals
  *  as comparison
  */
-class HashMap[Key <: AnyRef, Value >: Null <: AnyRef]
+class HashMap[Key <: AnyRef, Value]
     (initialCapacity: Int = 8, capacityMultiple: Int = 2)
 extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
   import GenericHashMap.DenseLimit
@@ -18,18 +18,7 @@ extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
   // The following methods are duplicated from GenericHashMap
   // to avoid polymorphic dispatches
 
-  /** Turn successor index or hash code `x` into a table index */
-  private def index(x: Int): Int = x & (table.length - 2)
-
-  private def firstIndex(key: Key) = if isDense then 0 else index(hash(key))
-  private def nextIndex(idx: Int) =
-    Stats.record(statsItem("miss"))
-    index(idx + 2)
-
-  private def keyAt(idx: Int): Key = table(idx).asInstanceOf[Key]
-  private def valueAt(idx: Int): Value = table(idx + 1).asInstanceOf[Value]
-
-  override def lookup(key: Key): Value =
+  override def lookup(key: Key): Value | Null =
     Stats.record(statsItem("lookup"))
     var idx = firstIndex(key)
     var k = keyAt(idx)
@@ -45,12 +34,12 @@ extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
     var k = keyAt(idx)
     while k != null do
       if isEqual(k, key) then
-        table(idx + 1) = value
+        setTable(idx + 1, value)
         return
       idx = nextIndex(idx)
       k = keyAt(idx)
     table(idx) = key
-    table(idx + 1) = value
+    setTable(idx + 1, value)
     used += 1
     if used > limit then growTable()
 

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

@@ -3,7 +3,7 @@ package dotty.tools.dotc.util
 /** A specialized implementation of GenericHashMap with identity hash and `eq`
  *  as comparison.
  */
-class IdentityHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
+class IdentityHashMap[Key <: AnyRef, Value]
     (initialCapacity: Int = 8, capacityMultiple: Int = 2)
 extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
   import GenericHashMap.DenseLimit
@@ -21,18 +21,7 @@ extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
   // Aside: It would be nice to have a @specialized annotation that does
   // this automatically
 
-  /** Turn successor index or hash code `x` into a table index */
-  private def index(x: Int): Int = x & (table.length - 2)
-
-  private def firstIndex(key: Key) = if isDense then 0 else index(hash(key))
-  private def nextIndex(idx: Int) =
-    Stats.record(statsItem("miss"))
-    index(idx + 2)
-
-  private def keyAt(idx: Int): Key = table(idx).asInstanceOf[Key]
-  private def valueAt(idx: Int): Value = table(idx + 1).asInstanceOf[Value]
-
-  override def lookup(key: Key): Value =
+  override def lookup(key: Key): Value | Null =
     Stats.record(statsItem("lookup"))
     var idx = firstIndex(key)
     var k = keyAt(idx)
@@ -48,12 +37,12 @@ extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
     var k = keyAt(idx)
     while k != null do
       if isEqual(k, key) then
-        table(idx + 1) = value
+        setTable(idx + 1, value)
         return
       idx = nextIndex(idx)
       k = keyAt(idx)
     table(idx) = key
-    table(idx + 1) = value
+    setTable(idx + 1, value)
     used += 1
     if used > limit then growTable()
 

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

@@ -1,10 +1,11 @@
-package dotty.tools.dotc.util
+package dotty.tools
+package dotc.util
 
 /** A common class for lightweight mutable maps.
  */
-abstract class MutableMap[Key <: AnyRef, Value >: Null <: AnyRef]:
+abstract class MutableMap[Key <: AnyRef, Value]:
 
-  def lookup(x: Key): Value /* | Null */
+  def lookup(x: Key): Value | Null
 
   def update(k: Key, v: Value): Unit
 
@@ -16,5 +17,6 @@ abstract class MutableMap[Key <: AnyRef, Value >: Null <: AnyRef]:
 
   def iterator: Iterator[(Key, Value)]
 
-  def get(x: Key): Option[Value] = Option(lookup(x))
-
+  def get(x: Key): Option[Value] = lookup(x) match
+    case null => None
+    case v => Some(v.uncheckedNN)

compiler/src/dotty/tools/package.scala

@@ -24,6 +24,14 @@ package object tools {
   def unsupported(methodName: String): Nothing =
     throw new UnsupportedOperationException(methodName)
 
+  /** Forward-ported from the explicit-nulls branch.
+   *  Should be used when we know from the context that `x` is not null.
+   *  Flow-typing under explicit nulls will automatically insert many necessary
+   *  occurrences of uncheckedNN.
+   */
+  extension [T](x: T | Null)
+    inline def uncheckedNN: T = x.asInstanceOf[T]
+
   object resultWrapper {
     opaque type WrappedResult[T] = T
     private[tools] def unwrap[T](x: WrappedResult[T]): T = x