Remove isInitialized

Author: noti0na1

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

@@ -88,14 +88,14 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
   private var compiling = false
 
-  private var myCtx = rootContext(using ictx)
+  private var myCtx: Context | Null = rootContext(using ictx)
 
   /** The context created for this run */
-  given runContext[Dummy_so_its_a_def]: Context = myCtx
+  given runContext[Dummy_so_its_a_def]: Context = myCtx.nn
   assert(runContext.runId <= Periods.MaxPossibleRunId)
 
-  private var myUnits: List[CompilationUnit] = _
-  private var myUnitsCached: List[CompilationUnit] = _
+  private var myUnits: List[CompilationUnit] = Nil
+  private var myUnitsCached: List[CompilationUnit] = Nil
   private var myFiles: Set[AbstractFile] = _
 
   // `@nowarn` annotations by source file, populated during typer
@@ -206,7 +206,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       compileSources(sources)
     catch
       case NonFatal(ex) =>
-        if !units.isInitialized then report.echo(i"exception occurred while compiling $units%, %")
+        if units != Nil then report.echo(i"exception occurred while compiling $units%, %")
         else report.echo(s"exception occurred while compiling ${files.map(_.name).mkString(", ")}")
         throw ex
 
@@ -367,8 +367,8 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   override def reset(): Unit = {
     super[ImplicitRunInfo].reset()
     super[ConstraintRunInfo].reset()
-    myCtx = null.asInstanceOf
-    myUnits = null.asInstanceOf
-    myUnitsCached = null.asInstanceOf
+    myCtx = null
+    myUnits = Nil
+    myUnitsCached = Nil
   }
 }

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

@@ -296,15 +296,15 @@ object Trees {
   trait DefTree[-T >: Untyped] extends DenotingTree[T] {
     type ThisTree[-T >: Untyped] <: DefTree[T]
 
-    private var myMods: untpd.Modifiers = _
+    private var myMods: untpd.Modifiers | Null = _
 
     private[dotc] def rawMods: untpd.Modifiers =
-      if (!myMods.isInitialized) untpd.EmptyModifiers else myMods
+      if (myMods == null) untpd.EmptyModifiers else myMods.uncheckedNN
 
     def withAnnotations(annots: List[untpd.Tree]): ThisTree[Untyped] = withMods(rawMods.withAnnotations(annots))
 
     def withMods(mods: untpd.Modifiers): ThisTree[Untyped] = {
-      val tree = if (!myMods.isInitialized || (myMods == mods)) this else cloneIn(source)
+      val tree = if (myMods == null || (myMods == mods)) this else cloneIn(source)
       tree.setMods(mods)
       tree.asInstanceOf[ThisTree[Untyped]]
     }

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

@@ -1195,13 +1195,13 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   trait TreeProvider {
     protected def computeRootTrees(using Context): List[Tree]
 
-    private var myTrees: List[Tree] = _
+    private var myTrees: List[Tree] | Null = _
 
     /** Get trees defined by this provider. Cache them if -Yretain-trees is set. */
     def rootTrees(using Context): List[Tree] =
       if (ctx.settings.YretainTrees.value) {
-        if (!myTrees.isInitialized) myTrees = computeRootTrees
-        myTrees
+        if (myTrees == null) myTrees = computeRootTrees
+        myTrees.uncheckedNN
       }
       else computeRootTrees
 

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

@@ -272,7 +272,9 @@ object Contexts {
      *  the declarations of the current class.
      */
     def effectiveScope(using Context): Scope =
-      if owner.isInitialized && owner.isClass then owner.asClass.unforcedDecls
+      // TODO
+      val co: Symbol | Null = owner
+      if co != null && co.isClass then co.asClass.unforcedDecls
       else scope
 
     def nestingLevel: Int =
@@ -858,14 +860,14 @@ object Contexts {
     val initialCtx: Context = new InitialContext(this, settings)
 
     /** The platform, initialized by `initPlatform()`. */
-    private var _platform: Platform = _
+    private var _platform: Platform | Null = _
 
     /** The platform */
     def platform: Platform = {
-      if !_platform.isInitialized then
+      if _platform == null then
         throw new IllegalStateException(
             "initialize() must be called before accessing platform")
-      _platform
+      _platform.uncheckedNN
     }
 
     protected def newPlatform(using Context): Platform =

compiler/src/dotty/tools/package.scala

@@ -28,12 +28,6 @@ package object tools {
 
   /** Forward-ported from the explicit-nulls branch. */
   extension [T](x: T | Null)
-
-    /** Assert `x` is non null and strip `Null` from type */
-    // inline def nn: T =
-    //   assert(x != null)
-    //   x.asInstanceOf[T]
-
     /** 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.
@@ -44,8 +38,8 @@ package object tools {
       if x == null then None else Some(x.asInstanceOf[T])
   end extension
 
+  /** Nullable eq and ne. */
   extension [T <: AnyRef](x: T | Null)
-    // nullable eq
     inline def eqn (y: T | Null) =
       if x != null then
         if y != null then
@@ -55,11 +49,6 @@ package object tools {
 
     inline def nen(y: T | Null): Boolean = !eqn(y)
 
-  extension [T <: AnyRef](x: T)
-    // var x: T = _
-    // var x: T = uninitialized
-    def isInitialized: Boolean = (x: T | Null) != null
-
   object resultWrapper {
     opaque type WrappedResult[T] = T
     private[tools] def unwrap[T](x: WrappedResult[T]): T = x