Add more nulls

Author: noti0na1

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -1420,9 +1420,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def tupleTypeTree(elems: List[Tree])(using Context): Tree = {
     val arity = elems.length
     if arity <= Definitions.MaxTupleArity then
-      val tupleTp: TypeRef | Null = defn.TupleType{arity}
+      val tupleTp: TypeRef | Null = defn.TupleType(arity)
       if tupleTp != null then
-        AppliedTypeTree(TypeTree(defn.TupleType(arity)), elems)
+        AppliedTypeTree(TypeTree(tupleTp), elems)
       else nestedPairsTypeTree(elems)
     else nestedPairsTypeTree(elems)
   }

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

@@ -160,7 +160,7 @@ object Constants {
             case TypeBounds(lo, hi) =>
               if (hi.classSymbol.isPrimitiveValueClass) hi //constrain further with high bound
               else classBound(lo)
-            case NoType => classBound(param.binder.paramInfos.nn(param.paramNum).lo) // TODO
+            case NoType => classBound(param.binder.paramInfos(param.paramNum).lo) // TODO
             case inst => classBound(inst)
           }
         case pt => pt

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

@@ -426,7 +426,8 @@ trait ConstraintHandling {
     val e = constraint.entry(param)
     if (e.exists) e.bounds
     else {
-      val pinfos = param.binder.paramInfos
+      // TODO
+      val pinfos: List[param.binder.PInfo] | Null = param.binder.paramInfos
       if (pinfos != null) pinfos(param.paramNum) // pinfos == null happens in pos/i536.scala
       else TypeBounds.empty
     }
@@ -501,7 +502,7 @@ trait ConstraintHandling {
           def apply(t: Type): Type = t match {
             case t @ TypeParamRef(tl: TypeLambda, n) if comparedTypeLambdas contains tl =>
               // TODO: do we need to check null here?
-              val bounds = tl.paramInfos.nn(n)
+              val bounds = tl.paramInfos(n)
               range(bounds.lo, bounds.hi)
             case _ =>
               mapOver(t)

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

@@ -1,6 +1,8 @@
 package dotty.tools.dotc
 package core
 
+import scala.language.{unsafeNulls => _}
+
 import Contexts._
 import config.Printers.{default, typr}
 
@@ -14,7 +16,7 @@ trait ConstraintRunInfo { self: Run =>
     }
   def printMaxConstraint()(using Context): Unit = {
     val printer = if (ctx.settings.YdetailedStats.value) default else typr
-    if (maxSize > 0) printer.println(s"max constraint = ${maxConstraint.show}")
+    if (maxSize > 0) printer.println(s"max constraint = ${maxConstraint.nn.show}")
   }
   protected def reset(): Unit = maxConstraint = null
 }

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package core
 
+import scala.language.{unsafeNulls => _}
+
 import Symbols._, Types._, Contexts._, Flags._, Names._, StdNames._, Phases._
 import Flags.JavaDefined
 import Uniques.unique
@@ -77,7 +79,7 @@ object TypeErasure {
   def normalizeClass(cls: ClassSymbol)(using Context): ClassSymbol = {
     if (cls.owner == defn.ScalaPackageClass) {
       if (defn.specialErasure.contains(cls))
-        return defn.specialErasure(cls)
+        return defn.specialErasure(cls).uncheckedNN
       if (cls == defn.UnitClass)
         return defn.BoxedUnitClass
     }

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package core
 
+import scala.language.{unsafeNulls => _}
+
 import Types._
 import Symbols._
 import Flags._
@@ -18,8 +20,10 @@ class TypeError(msg: String) extends Exception(msg) {
   def this() = this("")
   final def toMessage(using Context): Message =
     withMode(Mode.Printing)(produceMessage)
-  def produceMessage(using Context): Message = super.getMessage
-  override def getMessage: String = super.getMessage
+  def produceMessage(using Context): Message =
+    val msg: String = super.getMessage.uncheckedNN
+    msg
+  override def getMessage: String = super.getMessage.nn
 }
 
 class MalformedType(pre: Type, denot: Denotation, absMembers: Set[Name]) extends TypeError {
@@ -78,7 +82,7 @@ class RecursionOverflow(val op: String, details: => String, val previous: Throwa
   }
 
   override def fillInStackTrace(): Throwable = this
-  override def getStackTrace(): Array[StackTraceElement] = previous.getStackTrace()
+  override def getStackTrace(): Array[StackTraceElement] = previous.getStackTrace().asInstanceOf
 }
 
 /** Post-process exceptions that might result from StackOverflow to add
@@ -95,7 +99,7 @@ object handleRecursive {
         case _: RecursionOverflow =>
           throw new RecursionOverflow(op, details, exc, weight)
         case _ =>
-          var e = exc
+          var e: Throwable | Null = exc
           while (e != null && !e.isInstanceOf[StackOverflowError]) e = e.getCause
           if (e != null) throw new RecursionOverflow(op, details, e, weight)
           else throw exc
@@ -155,7 +159,8 @@ object CyclicReference {
     val ex = new CyclicReference(denot)
     if (!(ctx.mode is Mode.CheckCyclic) || ctx.settings.Ydebug.value) {
       cyclicErrors.println(s"Cyclic reference involving! $denot")
-      for (elem <- ex.getStackTrace take 200)
+      val sts = ex.getStackTrace.asInstanceOf[Array[StackTraceElement]]
+      for (elem <- sts take 200)
         cyclicErrors.println(elem.toString)
     }
     ex

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package core
 
+import scala.language.{unsafeNulls => _}
+
 import Contexts._, Types._, Symbols._, Names._, Flags._
 import SymDenotations._
 import util.Spans._
@@ -783,7 +785,7 @@ object TypeOps:
     //
     // See tests/patmat/i3938.scala
     class InferPrefixMap extends TypeMap {
-      var prefixTVar: Type = null
+      var prefixTVar: Type | Null = null
       def apply(tp: Type): Type = tp match {
         case ThisType(tref: TypeRef) if !tref.symbol.isStaticOwner =>
           if (tref.symbol.is(Module))
@@ -794,7 +796,7 @@ object TypeOps:
             prefixTVar = WildcardType  // prevent recursive call from assigning it
             val tref2 = this(tref.applyIfParameterized(tref.typeParams.map(_ => TypeBounds.empty)))
             prefixTVar = newTypeVar(TypeBounds.upper(tref2))
-            prefixTVar
+            prefixTVar.uncheckedNN
           }
         case tp => mapOver(tp)
       }

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package core
 
+import scala.language.{unsafeNulls => _}
+
 import Types._
 import Contexts._
 import util.{SimpleIdentityMap, SimpleIdentitySet}
@@ -45,7 +47,7 @@ class TyperState() {
   private var myId: Int = _
   def id: Int = myId
 
-  private var previous: TyperState /* | Null */ = _
+  private var previous: TyperState | Null = _
 
   private var myReporter: Reporter = _
 
@@ -75,7 +77,7 @@ class TyperState() {
     this
 
   def isGlobalCommittable: Boolean =
-    isCommittable && (previous == null || previous.isGlobalCommittable)
+    isCommittable && (previous == null || previous.uncheckedNN.isGlobalCommittable)
 
   private var isCommitted: Boolean = _
 
@@ -92,7 +94,7 @@ class TyperState() {
   /** Initializes all fields except reporter, isCommittable, which need to be
    *  set separately.
    */
-  private[core] def init(previous: TyperState /* | Null */, constraint: Constraint): this.type =
+  private[core] def init(previous: TyperState | Null, constraint: Constraint): this.type =
     this.myId = TyperState.nextId
     TyperState.nextId += 1
     this.previous = previous
@@ -117,7 +119,8 @@ class TyperState() {
    *  which is not yet committed, or which does not have a parent.
    */
   def uncommittedAncestor: TyperState =
-    if (isCommitted) previous.uncommittedAncestor else this
+    // TODO
+    if (isCommitted) previous.nn.uncommittedAncestor else this
 
   /** Commit typer state so that its information is copied into current typer state
    *  In addition (1) the owning state of undetermined or temporarily instantiated
@@ -179,7 +182,7 @@ class TyperState() {
       var ts = this
       while ts.constraint.domainLambdas.contains(tl) do
         ts.constraint = ts.constraint.subst(tl, tl1)
-        ts = ts.previous
+        ts = ts.previous.nn
 
   /** Integrate the constraints from `that` into this TyperState.
    *
@@ -235,14 +238,14 @@ class TyperState() {
    *       each tvar can only be instantiated by one TyperState.
    */
   private def includeVar(tvar: TypeVar)(using Context): Unit =
-    val oldState = tvar.owningState.get
+    val oldState = tvar.owningState.nn.get
     assert(oldState == null || !oldState.isCommittable,
       i"$this attempted to take ownership of $tvar which is already owned by committable $oldState")
     tvar.owningState = new WeakReference(this)
     ownedVars += tvar
 
   private def isOwnedAnywhere(ts: TyperState, tvar: TypeVar): Boolean =
-    ts.ownedVars.contains(tvar) || ts.previous != null && isOwnedAnywhere(ts.previous, tvar)
+    ts.ownedVars.contains(tvar) || ts.previous != null && isOwnedAnywhere(ts.previous.uncheckedNN, tvar)
 
   /** Make type variable instances permanent by assigning to `inst` field if
    *  type variable instantiation cannot be retracted anymore. Then, remove
@@ -253,7 +256,8 @@ class TyperState() {
       Stats.record("typerState.gc")
       val toCollect = new mutable.ListBuffer[TypeLambda]
       for tvar <- ownedVars do
-        assert(tvar.owningState.get eq this, s"Inconsistent state in $this: it owns $tvar whose owningState is ${tvar.owningState.get}")
+        val tvaros = tvar.owningState.nn.get
+        assert(tvaros != null && (tvaros eq this), s"Inconsistent state in $this: it owns $tvar whose owningState is ${tvaros}")
         assert(!tvar.inst.exists, s"Inconsistent state in $this: it owns $tvar which is already instantiated")
         val inst = constraint.instType(tvar)
         if inst.exists then
@@ -266,9 +270,9 @@ class TyperState() {
   override def toString: String = {
     def ids(state: TyperState): List[String] =
       s"${state.id}${if (state.isCommittable) "" else "X"}" ::
-        (if (state.previous == null) Nil else ids(state.previous))
+        (if (state.previous == null) Nil else ids(state.previous.uncheckedNN))
     s"TS[${ids(this).mkString(", ")}]"
   }
 
-  def stateChainStr: String = s"$this${if (previous == null) "" else previous.stateChainStr}"
+  def stateChainStr: String = s"$this${if (previous == null) "" else previous.uncheckedNN.stateChainStr}"
 }

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

@@ -3423,7 +3423,7 @@ object Types {
     type ParamRefType <: ParamRef
 
     def paramNames: List[ThisName]
-    def paramInfos: List[PInfo] | Null
+    def paramInfos: List[PInfo]
     def resType: Type
     protected def newParamRef(n: Int): ParamRefType
 

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

@@ -1,6 +1,8 @@
 package dotty.tools.dotc
 package core
 
+import scala.language.{unsafeNulls => _}
+
 import Types._, Contexts._, util.Stats._, Hashable._, Names._
 import config.Config
 import Decorators._
@@ -52,7 +54,7 @@ object Uniques:
         val oldHead = table(bucket)
 
         @tailrec
-        def linkedListLoop(entry: Entry[NamedType]): NamedType = entry match
+        def linkedListLoop(entry: Entry[NamedType] | Null): NamedType = entry match
           case null                    => addEntryAt(bucket, newType, h, oldHead)
           case _                       =>
             val e = entry.get
@@ -79,7 +81,7 @@ object Uniques:
         val oldHead = table(bucket)
 
         @tailrec
-        def linkedListLoop(entry: Entry[AppliedType]): AppliedType = entry match
+        def linkedListLoop(entry: Entry[AppliedType] | Null): AppliedType = entry match
           case null                    => addEntryAt(bucket, newType, h, oldHead)
           case _                       =>
             val e = entry.get