Rewrite type for SimpleIdenMap

Author: noti0na1

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

@@ -308,7 +308,7 @@ object Contexts {
     def getFile(name: String): AbstractFile = getFile(name.toTermName)
 
 
-    private var related: SimpleIdentityMap[Phase | SourceFile, Context | Null] | Null = null
+    private var related: SimpleIdentityMap[Phase | SourceFile, Context] | Null = null
 
     private def lookup(key: Phase | SourceFile): Context | Null =
       util.Stats.record("Context.related.lookup")

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

@@ -1784,7 +1784,7 @@ class Definitions {
   def isValueSubClass(sym1: Symbol, sym2: Symbol): Boolean =
     valueTypeEnc(sym2.asClass.name) % valueTypeEnc(sym1.asClass.name) == 0
 
-  @tu lazy val specialErasure: SimpleIdentityMap[Symbol, ClassSymbol | Null] =
+  @tu lazy val specialErasure: SimpleIdentityMap[Symbol, ClassSymbol] =
     SimpleIdentityMap.empty[Symbol]
       .updated(AnyClass, ObjectClass)
       .updated(MatchableClass, ObjectClass)

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

@@ -62,8 +62,8 @@ sealed abstract class GadtConstraint extends Showable {
 
 final class ProperGadtConstraint private(
   private var myConstraint: Constraint,
-  private var mapping: SimpleIdentityMap[Symbol, TypeVar | Null],
-  private var reverseMapping: SimpleIdentityMap[TypeParamRef, Symbol | Null],
+  private var mapping: SimpleIdentityMap[Symbol, TypeVar],
+  private var reverseMapping: SimpleIdentityMap[TypeParamRef, Symbol],
   private var wasConstrained: Boolean
 ) extends GadtConstraint with ConstraintHandling {
   import dotty.tools.dotc.config.Printers.{gadts, gadtsConstr}

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

@@ -17,7 +17,7 @@ import annotation.internal.sharable
 
 object OrderingConstraint {
 
-  type ArrayValuedMap[T] = SimpleIdentityMap[TypeLambda, Array[T] | Null]
+  type ArrayValuedMap[T] = SimpleIdentityMap[TypeLambda, Array[T]]
 
   /** The type of `OrderingConstraint#boundsMap` */
   type ParamBounds = ArrayValuedMap[Type]

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import core._
 import Contexts._, Symbols._, Decorators._, Comments.{_, given}
 import ast.tpd

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.ast.untpd

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import ast._
 import core._
 import Types._, ProtoTypes._, Contexts._, Decorators._, Denotations._, Symbols._
@@ -294,7 +296,7 @@ class ImplicitSearchError(
     }
 
     """\$\{\s*([^}\s]+)\s*\}""".r.replaceAllIn(raw, (_: Regex.Match) match {
-      case Regex.Groups(v) => quoteReplacement(translate(v).getOrElse(""))
+      case Regex.Groups(v) => quoteReplacement(translate(v).getOrElse("")).nn
     })
   }
 

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import core._
 import ast.{Trees, untpd, tpd}
 import Contexts._

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import backend.sjs.JSDefinitions
 import core._
 import ast.{Trees, TreeTypeMap, untpd, tpd, DesugarEnums}
@@ -105,13 +107,13 @@ object Implicits:
      */
     def companionRefs: TermRefSet = TermRefSet.empty
 
-    private var mySingletonClass: ClassSymbol = null
+    private var mySingletonClass: ClassSymbol | Null = null
 
     /** Widen type so that it is neither a singleton type nor a type that inherits from scala.Singleton. */
     private def widenSingleton(tp: Type)(using Context): Type = {
       if (mySingletonClass == null) mySingletonClass = defn.SingletonClass
       val wtp = tp.widenSingleton
-      if (wtp.derivesFrom(mySingletonClass)) defn.AnyType else wtp
+      if (wtp.derivesFrom(mySingletonClass.uncheckedNN)) defn.AnyType else wtp
     }
 
     protected def isAccessible(ref: TermRef)(using Context): Boolean
@@ -272,7 +274,7 @@ object Implicits:
    *  @param companionRefs   the companion objects in the implicit scope.
    */
   class OfTypeImplicits(tp: Type, override val companionRefs: TermRefSet)(initctx: Context) extends ImplicitRefs(initctx) {
-    assert(initctx.typer != null)
+    // assert(initctx.typer != null)
     implicits.println(i"implicit scope of type $tp = ${companionRefs.showAsList}%, %")
     @threadUnsafe lazy val refs: List[ImplicitRef] = {
       val buf = new mutable.ListBuffer[TermRef]
@@ -312,23 +314,23 @@ object Implicits:
      *  Scala2 mode, since we do not want to change the implicit disambiguation then.
      */
     override val level: Int =
-      def isSameOwner = irefCtx.owner eq outerImplicits.irefCtx.owner
-      def isSameScope = irefCtx.scope eq outerImplicits.irefCtx.scope
+      def isSameOwner = irefCtx.owner eq outerImplicits.uncheckedNN.irefCtx.owner
+      def isSameScope = irefCtx.scope eq outerImplicits.uncheckedNN.irefCtx.scope
       def isLazyImplicit = refs.head.implicitName.is(LazyImplicitName)
 
       if outerImplicits == null then 1
       else if migrateTo3(using irefCtx)
               || isSameOwner && (isImport || isSameScope && !isLazyImplicit)
-      then outerImplicits.level
-      else outerImplicits.level + 1
+      then outerImplicits.uncheckedNN.level
+      else outerImplicits.uncheckedNN.level + 1
     end level
 
     /** Is this the outermost implicits? This is the case if it either the implicits
      *  of NoContext, or the last one before it.
      */
     private def isOuterMost = {
       val finalImplicits = NoContext.implicits
-      (this eq finalImplicits) || (outerImplicits eq finalImplicits)
+      (this eq finalImplicits) || (outerImplicits eqn finalImplicits)
     }
 
     private def combineEligibles(ownEligible: List[Candidate], outerEligible: List[Candidate]): List[Candidate] =
@@ -370,7 +372,7 @@ object Implicits:
       if (monitored) record(s"check eligible refs in irefCtx", refs.length)
       val ownEligible = filterMatching(tp)
       if isOuterMost then ownEligible
-      else combineEligibles(ownEligible, outerImplicits.eligible(tp))
+      else combineEligibles(ownEligible, outerImplicits.uncheckedNN.eligible(tp))
     }
 
     override def isAccessible(ref: TermRef)(using Context): Boolean =
@@ -387,9 +389,9 @@ object Implicits:
     def exclude(root: Symbol): ContextualImplicits =
       if (this == NoContext.implicits) this
       else {
-        val outerExcluded = outerImplicits exclude root
+        val outerExcluded = outerImplicits.uncheckedNN exclude root
         if (irefCtx.importInfo.site.termSymbol == root) outerExcluded
-        else if (outerExcluded eq outerImplicits) this
+        else if (outerExcluded eqn outerImplicits) this
         else new ContextualImplicits(refs, outerExcluded, isImport)(irefCtx)
       }
   }
@@ -848,7 +850,7 @@ trait Implicits:
     }
   }
 
-  private var synthesizer: Synthesizer = null
+  private var synthesizer: Synthesizer | Null = null
 
   /** Find an implicit argument for parameter `formal`.
    *  Return a failure as a SearchFailureType in the type of the returned tree.
@@ -860,7 +862,7 @@ trait Implicits:
         if fail.isAmbiguous then failed
         else
           if synthesizer == null then synthesizer = Synthesizer(this)
-          synthesizer.tryAll(formal, span).orElse(failed)
+          synthesizer.uncheckedNN.tryAll(formal, span).orElse(failed)
 
   /** Search an implicit argument and report error if not found */
   def implicitArgTree(formal: Type, span: Span)(using Context): Tree = {
@@ -1678,11 +1680,11 @@ final class SearchRoot extends SearchHistory:
   var nestedSearches: Int = 0
 
   /** The dictionary of recursive implicit types and corresponding terms for this search. */
-  var myImplicitDictionary: mutable.Map[Type, (TermRef, tpd.Tree)] = null
+  var myImplicitDictionary: mutable.Map[Type, (TermRef, tpd.Tree)] | Null = null
   private def implicitDictionary =
     if myImplicitDictionary == null then
       myImplicitDictionary = mutable.Map.empty[Type, (TermRef, tpd.Tree)]
-    myImplicitDictionary
+    myImplicitDictionary.uncheckedNN
 
   /**
    * Link a reference to an under-construction implicit for the provided type to its
@@ -1861,10 +1863,12 @@ sealed class TermRefSet(using Context):
     if !that.isEmpty then that.foreach(+=)
 
   def foreach[U](f: TermRef => U): Unit =
-    elems.forEach((sym: TermSymbol, prefixes: Type | List[Type]) =>
+    // TODO
+    def handle(sym: TermSymbol | Null, prefixes: Type | List[Type] | Null): Unit =
       prefixes match
-        case prefix: Type => f(TermRef(prefix, sym))
-        case prefixes: List[Type] => prefixes.foreach(pre => f(TermRef(pre, sym))))
+        case prefix: Type => f(TermRef(prefix, sym.uncheckedNN))
+        case prefixes: List[Type] => prefixes.foreach(pre => f(TermRef(pre, sym.uncheckedNN)))
+    elems.forEach(handle)
 
   // used only for debugging
   def showAsList: List[TermRef] = {

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import ast.{tpd, untpd}
 import ast.Trees._
 import core._
@@ -67,9 +69,9 @@ class ImportInfo(symf: Context ?=> Symbol,
       mySym = symf
       assert(mySym != null)
     }
-    mySym
+    mySym.uncheckedNN
   }
-  private var mySym: Symbol = _
+  private var mySym: Symbol | Null = _
 
   /** The (TermRef) type of the qualifier of the import clause */
   def site(using Context): Type = importSym.info match {
@@ -78,23 +80,23 @@ class ImportInfo(symf: Context ?=> Symbol,
   }
 
   /** The names that are excluded from any wildcard import */
-  def excluded: Set[TermName] = { ensureInitialized(); myExcluded }
+  def excluded: Set[TermName] = { ensureInitialized(); myExcluded.nn }
 
   /** A mapping from original to renamed names */
-  def forwardMapping: SimpleIdentityMap[TermName, TermName] = { ensureInitialized(); myForwardMapping }
+  def forwardMapping: SimpleIdentityMap[TermName, TermName] = { ensureInitialized(); myForwardMapping.nn }
 
   /** A mapping from renamed to original names */
-  def reverseMapping: SimpleIdentityMap[TermName, TermName] = { ensureInitialized(); myReverseMapping }
+  def reverseMapping: SimpleIdentityMap[TermName, TermName] = { ensureInitialized(); myReverseMapping.nn }
 
   /** Does the import clause contain wildcard selectors (both `_` and `given` count)? */
   def isWildcardImport: Boolean = { ensureInitialized(); myWildcardImport }
 
   /** Does the import clause have at least one `given` selector? */
   def isGivenImport: Boolean = { ensureInitialized(); myGivenImport }
 
-  private var myExcluded: Set[TermName] = null
-  private var myForwardMapping: SimpleIdentityMap[TermName, TermName] = null
-  private var myReverseMapping: SimpleIdentityMap[TermName, TermName] = null
+  private var myExcluded: Set[TermName] | Null = null
+  private var myForwardMapping: SimpleIdentityMap[TermName, TermName] | Null = null
+  private var myReverseMapping: SimpleIdentityMap[TermName, TermName] | Null = null
   private var myWildcardImport: Boolean = false
   private var myGivenImport: Boolean = false
   private var myWildcardBound: Type = NoType
@@ -111,10 +113,10 @@ class ImportInfo(symf: Context ?=> Symbol,
         if sel.isGiven then myGivenImport = true
       else
         if sel.rename != sel.name then
-          myExcluded += sel.name
+          myExcluded = myExcluded.nn + sel.name
         if sel.rename != nme.WILDCARD then
-          myForwardMapping = myForwardMapping.updated(sel.name, sel.rename)
-          myReverseMapping = myReverseMapping.updated(sel.rename, sel.name)
+          myForwardMapping = myForwardMapping.uncheckedNN.updated(sel.name, sel.rename)
+          myReverseMapping = myReverseMapping.uncheckedNN.updated(sel.rename, sel.name)
 
   /** The upper bound for `given` wildcards, or `Nothing` if there are none */
   def givenBound(using Context) =
@@ -151,9 +153,9 @@ class ImportInfo(symf: Context ?=> Symbol,
     else
       for
         renamed <- reverseMapping.keys
-        denot <- pre.member(reverseMapping(renamed)).altsWith(_.isOneOf(GivenOrImplicitVal))
+        denot <- pre.member(reverseMapping(renamed).nn).altsWith(_.isOneOf(GivenOrImplicitVal))
       yield
-        val original = reverseMapping(renamed)
+        val original = reverseMapping(renamed).nn
         val ref = TermRef(pre, original, denot)
         if renamed == original then ref
         else RenamedImplicitRef(ref, renamed)
@@ -179,11 +181,11 @@ class ImportInfo(symf: Context ?=> Symbol,
         if maybeShadowsRoot && defn.rootImportTypes.exists(_.symbol == sym) then sym
         else NoSymbol
       assert(myUnimported != null)
-    myUnimported
+    myUnimported.uncheckedNN
 
   private val isLanguageImport: Boolean = untpd.languageImport(qualifier).isDefined
 
-  private var myUnimported: Symbol = _
+  private var myUnimported: Symbol | Null = _
 
   private var featureCache: SimpleIdentityMap[TermName, java.lang.Boolean] = SimpleIdentityMap.empty
 
@@ -222,9 +224,10 @@ class ImportInfo(symf: Context ?=> Symbol,
           case None =>
             var c = ctx.outer
             while c.importInfo eq ctx.importInfo do c = c.outer
-            (c.importInfo != null) && c.importInfo.featureImported(feature)(using c)
+            // TODO
+            ((c.importInfo: ImportInfo | Null) != null) && c.importInfo.featureImported(feature)(using c)
       )
-    featureCache(feature)
+    featureCache(feature).nn
 
   def toText(printer: Printer): Text = printer.toText(this)
 }