Fix names

Author: noti0na1

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

@@ -273,7 +273,8 @@ object Contexts {
       else scope
 
     def nestingLevel: Int =
-      val sc = effectiveScope
+      // TODO
+      val sc: Scope | Null = effectiveScope
       if sc != null then sc.nestingLevel else 0
 
     /** Sourcefile corresponding to given abstract file, memoized */

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

@@ -2,7 +2,7 @@ package dotty.tools
 package dotc
 package core
 
-// import scala.language.{unsafeNulls => _}
+import scala.language.{unsafeNulls => _}
 
 import scala.io.Codec
 import util.NameTransformer
@@ -167,15 +167,15 @@ object Names {
     override def asTermName: TermName = this
 
     @sharable // because it is only modified in the synchronized block of toTypeName.
-    private var myTypeName: TypeName = null
+    private var myTypeName: TypeName | Null = null
       // Note: no @volatile needed since type names are immutable and therefore safely published
 
     override def toTypeName: TypeName =
       if myTypeName == null then
         synchronized {
           if myTypeName == null then myTypeName = new TypeName(this)
         }
-      myTypeName
+      myTypeName.nn
 
     override def likeSpaced(name: Name): TermName = name.toTermName
 
@@ -191,7 +191,7 @@ object Names {
           val derivedName = new DerivedName(this, info)
           derivedNames = derivedNames.updated(info, derivedName)
           derivedName
-        case derivedName =>
+        case derivedName: DerivedName =>
           derivedName
     }
 
@@ -229,10 +229,10 @@ object Names {
     }
 
     @sharable // because it's just a cache for performance
-    private var myMangledString: String = null
+    private var myMangledString: String | Null = null
 
     @sharable // because it's just a cache for performance
-    private var myMangled: Name = null
+    private var myMangled: Name | Null = null
 
     protected[Names] def mangle: ThisName
 
@@ -244,7 +244,7 @@ object Names {
     final def mangledString: String = {
       if (myMangledString == null)
         myMangledString = qualToString(_.mangledString, _.mangled.toString)
-      myMangledString
+      myMangledString.nn
     }
 
     /** If this a qualified name, split it into underlying, last part, and separator
@@ -263,11 +263,11 @@ object Names {
 
     protected def computeToString: String
 
-    @sharable private var myToString: String = null
+    @sharable private var myToString: String | Null = null
 
-    override def toString =
+    override def toString: String =
       if myToString == null then myToString = computeToString
-      myToString
+      myToString.nn
 
   }
 
@@ -390,7 +390,7 @@ object Names {
             // because asserts are caught in exception handlers which might
             // cause other failures. In that case the first, important failure
             // is lost.
-            System.err.println("Backend should not call Name#toString, Name#mangledString should be used instead.")
+            System.err.nn.println("Backend should not call Name#toString, Name#mangledString should be used instead.")
             Thread.dumpStack()
             assert(false)
           }
@@ -401,8 +401,8 @@ object Names {
      *  from GenBCode or it also contains one of the whitelisted methods below.
      */
     private def toStringOK = {
-      val trace = Thread.currentThread.getStackTrace
-      !trace.exists(_.getClassName.endsWith("GenBCode")) ||
+      val trace: Array[StackTraceElement] = Thread.currentThread.nn.getStackTrace.asInstanceOf[Array[StackTraceElement]]
+      !trace.exists(_.getClassName.nn.endsWith("GenBCode")) ||
       trace.exists(elem =>
           List(
               "mangledString",
@@ -546,10 +546,10 @@ object Names {
       Stats.record(statsItem("put"))
       val myTable = currentTable // could be outdated under parallel execution
       var idx = hashValue(cs, offset, len) & (myTable.length - 1)
-      var name = myTable(idx).asInstanceOf[SimpleName]
+      var name = myTable(idx).asInstanceOf[SimpleName | Null]
       while name != null do
-        if name.length == len && Names.equals(name.start, cs, offset, len) then
-          return name
+        if name.nn.length == len && Names.equals(name.nn.start, cs, offset, len) then
+          return name.nn
         Stats.record(statsItem("miss"))
         idx = (idx + 1) & (myTable.length - 1)
         name = myTable(idx).asInstanceOf[SimpleName]
@@ -567,7 +567,7 @@ object Names {
           ensureCapacity(nc + len)
           Array.copy(cs, offset, chrs, nc, len)
           nc += len
-          addEntryAt(idx, name)
+          addEntryAt(idx, name.nn)
         else
           enterIfNew(cs, offset, len)
       }
@@ -630,10 +630,10 @@ object Names {
    *  See `sliceToTermName` in `Decorators` for a more efficient version
    *  which however requires a Context for its operation.
    */
-  def termName(s: String): SimpleName = termName(s.toCharArray, 0, s.length)
+  def termName(s: String): SimpleName = termName(s.toCharArray.nn, 0, s.length)
 
   /** Create a type name from a string */
-  def typeName(s: String): TypeName = typeName(s.toCharArray, 0, s.length)
+  def typeName(s: String): TypeName = typeName(s.toCharArray.nn, 0, s.length)
 
   /** The type name represented by the empty string */
   val EmptyTypeName: TypeName = EmptyTermName.toTypeName

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -313,7 +313,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
        */
       def isDefinedInCurrentUnit(denot: Denotation)(using Context): Boolean = denot match {
         case MultiDenotation(d1, d2) => isDefinedInCurrentUnit(d1) || isDefinedInCurrentUnit(d2)
-        case denot: SingleDenotation => ctx.compilationUnit != null && denot.symbol.source == ctx.compilationUnit.source
+        case denot: SingleDenotation => (ctx.compilationUnit: CompilationUnit | Null) != null && denot.symbol.source == ctx.compilationUnit.source
       }
 
       /** Is `denot` the denotation of a self symbol? */

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

@@ -1,5 +1,7 @@
 package dotty.tools.dotc.util
 
+import scala.language.{unsafeNulls => _}
+
 object HashSet:
 
   /** The number of elements up to which dense packing is used.
@@ -29,12 +31,12 @@ class HashSet[T](initialCapacity: Int = 8, capacityMultiple: Int = 2) extends Mu
 
   private var used: Int = _
   private var limit: Int = _
-  private var table: Array[AnyRef] = _
+  private var table: Array[AnyRef | Null] = _
 
   clear()
 
   private def allocate(capacity: Int) =
-    table = new Array[AnyRef](capacity)
+    table = new Array[AnyRef | Null](capacity)
     limit = if capacity <= DenseLimit then capacity - 1 else capacity / capacityMultiple
 
   private def roundToPower(n: Int) =
@@ -67,22 +69,22 @@ class HashSet[T](initialCapacity: Int = 8, capacityMultiple: Int = 2) extends Mu
   /** Turn hashcode `x` into a table index */
   protected def index(x: Int): Int = x & (table.length - 1)
 
-  protected def currentTable: Array[AnyRef] = table
+  protected def currentTable: Array[AnyRef | Null] = table
 
   protected def firstIndex(x: T) = if isDense then 0 else index(hash(x))
   protected def nextIndex(idx: Int) =
     Stats.record(statsItem("miss"))
     index(idx + 1)
 
-  protected def entryAt(idx: Int) = table(idx).asInstanceOf[T]
-  protected def setEntry(idx: Int, x: T) = table(idx) = x.asInstanceOf[AnyRef]
+  protected def entryAt(idx: Int): T | Null = table(idx).asInstanceOf[T | Null]
+  protected def setEntry(idx: Int, x: T) = table(idx) = x.asInstanceOf[AnyRef | Null]
 
   def lookup(x: T): T | Null =
     Stats.record(statsItem("lookup"))
     var idx = firstIndex(x)
-    var e = entryAt(idx)
+    var e: T | Null = entryAt(idx)
     while e != null do
-      if isEqual(e, x) then return e
+      if isEqual(e.asInstanceOf[T], x) then return e.asInstanceOf[T]
       idx = nextIndex(idx)
       e = entryAt(idx)
     null
@@ -100,7 +102,7 @@ class HashSet[T](initialCapacity: Int = 8, capacityMultiple: Int = 2) extends Mu
     var idx = firstIndex(x)
     var e = entryAt(idx)
     while e != null do
-      if isEqual(e, x) then return e
+      if isEqual(e.asInstanceOf[T], x) then return e.asInstanceOf[T]
       idx = nextIndex(idx)
       e = entryAt(idx)
     addEntryAt(idx, x)
@@ -112,20 +114,20 @@ class HashSet[T](initialCapacity: Int = 8, capacityMultiple: Int = 2) extends Mu
     var idx = firstIndex(x)
     var e = entryAt(idx)
     while e != null do
-      if isEqual(e, x) then
+      if isEqual(e.asInstanceOf[T], x) then
         var hole = idx
         while
           idx = nextIndex(idx)
           e = entryAt(idx)
           e != null
         do
-          val eidx = index(hash(e))
+          val eidx = index(hash(e.asInstanceOf[T]))
           if isDense
             || index(eidx - (hole + 1)) > index(idx - (hole + 1))
                // entry `e` at `idx` can move unless `index(hash(e))` is in
                // the (ring-)interval [hole + 1 .. idx]
           then
-            setEntry(hole, e)
+            setEntry(hole, e.asInstanceOf[T])
             hole = idx
         table(hole) = null
         used -= 1
@@ -146,14 +148,14 @@ class HashSet[T](initialCapacity: Int = 8, capacityMultiple: Int = 2) extends Mu
       e = entryAt(idx)
     setEntry(idx, x)
 
-  def copyFrom(oldTable: Array[AnyRef]): Unit =
+  def copyFrom(oldTable: Array[AnyRef | Null]): Unit =
     if isDense then
       Array.copy(oldTable, 0, table, 0, oldTable.length)
     else
       var idx = 0
       while idx < oldTable.length do
-        val e = oldTable(idx).asInstanceOf[T]
-        if e != null then addOld(e)
+        val e = oldTable(idx).asInstanceOf[T | Null]
+        if e != null then addOld(e.asInstanceOf[T])
         idx += 1
 
   protected def growTable(): Unit =
@@ -165,14 +167,14 @@ class HashSet[T](initialCapacity: Int = 8, capacityMultiple: Int = 2) extends Mu
     copyFrom(oldTable)
 
   abstract class EntryIterator extends Iterator[T]:
-    def entry(idx: Int): T
+    def entry(idx: Int): T | Null
     private var idx = 0
     def hasNext =
       while idx < table.length && table(idx) == null do idx += 1
       idx < table.length
     def next() =
       require(hasNext)
-      try entry(idx) finally idx += 1
+      try entry(idx).asInstanceOf[T] finally idx += 1
 
   def iterator: Iterator[T] = new EntryIterator():
     def entry(idx: Int) = entryAt(idx)

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

@@ -1,23 +1,25 @@
 package dotty.tools.dotc.util
 
+import scala.language.{unsafeNulls => _}
+
 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] =
+opaque type LinearMap[K <: AnyRef, V <: AnyRef | Null] =
   immutable.Map[K, V] | HashMap[K, V]
 
 object LinearMap:
 
-  def empty[K <: AnyRef, V >: Null <: AnyRef]: LinearMap[K, V] =
+  def empty[K <: AnyRef, V <: AnyRef | Null]: LinearMap[K, V] =
     immutable.Map.empty[K, V]
 
-  extension [K <: AnyRef, V >: Null <: AnyRef](m: LinearMap[K, V])
+  extension [K <: AnyRef, V <: AnyRef | Null](m: LinearMap[K, V])
 
-    def lookup(key: K): V /*| Null*/ = (m: @unchecked) match
+    def lookup(key: K): V | Null = (m: @unchecked) match
       case m: immutable.AbstractMap[K, V] @unchecked =>
         if m.contains(key) then m(key) else null
       case m: HashMap[K, V] @unchecked =>