Change ctx.run to nullable

Author: noti0na1

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -75,7 +75,7 @@ class GenBCode extends Phase {
     try super.runOn(units)
     finally outputDir match {
       case jar: JarArchive =>
-        if (ctx.run.suspendedUnits.nonEmpty)
+        if (ctx.run.nn.suspendedUnits.nonEmpty)
           // If we close the jar the next run will not be able to write on the jar.
           // But if we do not close it we cannot use it as part of the macro classpath of the suspended files.
           report.error("Can not suspend and output to a jar at the same time. See suspension with -Xprint-suspension.")

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

@@ -71,7 +71,7 @@ class CompilationUnit protected (val source: SourceFile) {
       if (ctx.settings.XprintSuspension.value)
         report.echo(i"suspended: $this")
       suspended = true
-      ctx.run.suspendedUnits += this
+      ctx.run.nn.suspendedUnits += this
       if ctx.phase == Phases.inliningPhase then
         suspendedAtInliningPhase = true
     throw CompilationUnit.SuspendException()

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

@@ -152,7 +152,7 @@ class Compiler {
 
   def reset()(using Context): Unit = {
     ctx.base.reset()
-    val run: Run | Null = ctx.run
+    val run = ctx.run
     if (run != null) run.reset()
   }
 

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

@@ -49,7 +49,7 @@ object Contexts {
   private val (printerFnLoc,        store3) = store2.newLocation[Context => Printer](new RefinedPrinter(_))
   private val (settingsStateLoc,    store4) = store3.newLocation[SettingsState]()
   private val (compilationUnitLoc,  store5) = store4.newLocation[CompilationUnit]()
-  private val (runLoc,              store6) = store5.newLocation[Run]()
+  private val (runLoc,              store6) = store5.newLocation[Run | Null]()
   private val (profilerLoc,         store7) = store6.newLocation[Profiler]()
   private val (notNullInfosLoc,     store8) = store7.newLocation[List[NotNullInfo]]()
   private val (importInfoLoc,       store9) = store8.newLocation[ImportInfo]()
@@ -227,7 +227,7 @@ object Contexts {
     def compilationUnit: CompilationUnit = store(compilationUnitLoc)
 
     /** The current compiler-run */
-    def run: Run = store(runLoc)
+    def run: Run | Null = store(runLoc)
 
     /**  The current compiler-run profiler */
     def profiler: Profiler = store(profilerLoc)
@@ -655,7 +655,7 @@ object Contexts {
     def setSbtCallback(callback: AnalysisCallback): this.type = updateStore(sbtCallbackLoc, callback)
     def setPrinterFn(printer: Context => Printer): this.type = updateStore(printerFnLoc, printer)
     def setSettings(settingsState: SettingsState): this.type = updateStore(settingsStateLoc, settingsState)
-    def setRun(run: Run): this.type = updateStore(runLoc, run)
+    def setRun(run: Run | Null): this.type = updateStore(runLoc, run)
     def setProfiler(profiler: Profiler): this.type = updateStore(profilerLoc, profiler)
     def setNotNullInfos(notNullInfos: List[NotNullInfo]): this.type = updateStore(notNullInfosLoc, notNullInfos)
     def setImportInfo(importInfo: ImportInfo): this.type =

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

@@ -1318,7 +1318,7 @@ object Denotations {
         recurSimple(path.length, wrap)
     }
 
-    val run: Run | Null = ctx.run
+    val run = ctx.run
     if run == null then recur(path)
     else run.staticRefs.getOrElseUpdate(path, recur(path))
   }

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

@@ -29,7 +29,7 @@ object OrderingConstraint {
       empty
     else
       val result = new OrderingConstraint(boundsMap, lowerMap, upperMap)
-      ctx.run.recordConstraintSize(result, result.boundsMap.size)
+      ctx.run.nn.recordConstraintSize(result, result.boundsMap.size)
       result
 
   /** A lens for updating a single entry array in one of the three constraint maps */

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

@@ -426,7 +426,7 @@ class SourcefileLoader(val srcfile: AbstractFile) extends SymbolLoader {
   def description(using Context): String = "source file " + srcfile.toString
   override def sourceFileOrNull: AbstractFile | Null = srcfile
   def doComplete(root: SymDenotation)(using Context): Unit =
-    ctx.run.lateCompile(srcfile, typeCheck = ctx.settings.YretainTrees.value)
+    ctx.run.nn.lateCompile(srcfile, typeCheck = ctx.settings.YretainTrees.value)
 }
 
 /** A NoCompleter which is also a SymbolLoader. */

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

@@ -142,7 +142,7 @@ object Symbols {
 
     /** Does this symbol come from a currently compiled source file? */
     final def isDefinedInCurrentRun(using Context): Boolean =
-      span.exists && defRunId == ctx.runId && associatedFileMatches(ctx.run.files.contains)
+      span.exists && defRunId == ctx.runId && associatedFileMatches(ctx.run.nn.files.contains)
 
     /** Is this symbol valid in the current run and has an associated file that is
       * not a binary file. e.g. This will return true for

compiler/src/dotty/tools/dotc/decompiler/IDEDecompilerDriver.scala

@@ -37,7 +37,7 @@ class IDEDecompilerDriver(val settings: List[String]) extends dotc.Driver {
     inContext(run.runContext) {
       run.compile(List(tastyFile))
       run.printSummary()
-      val unit = ctx.run.units.head
+      val unit = ctx.run.nn.units.head
 
       val decompiled = QuotesImpl.showDecompiledTree(unit.tpdTree)
       val tree = new TastyHTMLPrinter(unit.pickled.head._2()).showContents()

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -353,7 +353,7 @@ object Completion {
       val extMethodsFromGivensInScope = extractMemberExtensionMethods(givensInScope)
 
       // 3. The reference is of the form r.m and the extension method is defined in the implicit scope of the type of r.
-      val implicitScopeCompanions = ctx.run.implicitScope(qual.tpe).companionRefs.showAsList
+      val implicitScopeCompanions = ctx.run.nn.implicitScope(qual.tpe).companionRefs.showAsList
       val extMethodsFromImplicitScope = extractMemberExtensionMethods(implicitScopeCompanions)
 
       // 4. The reference is of the form r.m and the extension method is defined in some given instance in the implicit scope of the type of r.

compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala

@@ -164,7 +164,8 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
 
       run.compileSources(List(source))
       run.printSummary()
-      val unit = if ctx.run.units.nonEmpty then ctx.run.units.head else ctx.run.suspendedUnits.head
+      val ctxrun = ctx.run.nn
+      val unit = if ctxrun.units.nonEmpty then ctxrun.units.head else ctxrun.suspendedUnits.head
       val t = unit.tpdTree
       cleanup(t)
       myOpenedTrees(uri) = topLevelTrees(t, source)

compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -181,7 +181,7 @@ abstract class Reporter extends interfaces.ReporterResult {
     // `ctx.run` can be null in test, also in the repl when parsing the first line. The parser runs early, the Run is
     // only created in ReplDriver.compile when a line is submitted. This means that `@nowarn` doesnt work on parser
     // warnings in the first line.
-    val run: Run | Null = ctx.run
+    val run = ctx.run
     dia match
       case w: Warning if run != null =>
         val sup = run.suppressions

compiler/src/dotty/tools/dotc/transform/Inlining.scala

@@ -30,7 +30,7 @@ class Inlining extends MacroTransform {
 
   override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
     val newUnits = super.runOn(units).filterNot(_.suspended)
-    ctx.run.checkSuspendedUnits(newUnits)
+    ctx.run.nn.checkSuspendedUnits(newUnits)
     newUnits
 
   override def checkPostCondition(tree: Tree)(using Context): Unit =

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

@@ -1039,7 +1039,7 @@ trait Implicits:
 
   /** Try to typecheck an implicit reference */
   def typedImplicit(cand: Candidate, pt: Type, argument: Tree, span: Span)(using Context): SearchResult =  trace(i"typed implicit ${cand.ref}, pt = $pt, implicitsEnabled == ${ctx.mode is ImplicitsEnabled}", implicits, show = true) {
-    if ctx.run.isCancelled then NoMatchingImplicitsFailure
+    if ctx.run.nn.isCancelled then NoMatchingImplicitsFailure
     else
       record("typedImplicit")
       val ref = cand.ref
@@ -1503,7 +1503,7 @@ trait Implicits:
           searchImplicit(contextual = true)
     end bestImplicit
 
-    def implicitScope(tp: Type): OfTypeImplicits = ctx.run.implicitScope(tp)
+    def implicitScope(tp: Type): OfTypeImplicits = ctx.run.nn.implicitScope(tp)
 
     /** All available implicits, without ranking */
     def allImplicits: Set[TermRef] = {

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

@@ -148,7 +148,7 @@ trait ImportSuggestions:
    */
   private def importSuggestions(pt: Type)(using Context): (List[TermRef], List[TermRef]) =
     val timer = new Timer()
-    val allotted = ctx.run.importSuggestionBudget
+    val allotted = ctx.run.nn.importSuggestionBudget
     if allotted <= 1 then return (Nil, Nil)
     implicits.println(i"looking for import suggestions, timeout = ${allotted}ms")
     val start = System.currentTimeMillis()
@@ -160,7 +160,7 @@ trait ImportSuggestions:
     val alreadyAvailableCandidates: Set[Symbol] = {
       val wildProto = wildApprox(pt)
       val contextualCandidates = ctx.implicits.eligible(wildProto)
-      val implicitScopeCandidates = ctx.run.implicitScope(wildProto).eligible
+      val implicitScopeCandidates = ctx.run.nn.implicitScope(wildProto).eligible
       val allCandidates = contextualCandidates ++ implicitScopeCandidates
       allCandidates.map(_.implicitRef.underlyingRef.symbol).toSet
     }
@@ -196,7 +196,7 @@ trait ImportSuggestions:
         val task = new TimerTask:
           def run() =
             println(i"Cancelling test of $ref when making suggestions for error in ${ctx.source}")
-            ctx.run.isCancelled = true
+            ctx.run.nn.isCancelled = true
         val span = ctx.owner.srcPos.span
         val (expectedType, argument, kind) = pt match
           case ViewProto(argType, resType) =>
@@ -212,11 +212,12 @@ trait ImportSuggestions:
           typedImplicit(candidate, expectedType, argument, span)(
             using testContext()).isSuccess
         finally
+          val run = ctx.run.nn
           if task.cancel() then // timer task has not run yet
-            assert(!ctx.run.isCancelled)
+            assert(!run.isCancelled)
           else
-            while !ctx.run.isCancelled do () // wait until timer task has run to completion
-            ctx.run.isCancelled = false
+            while !run.isCancelled do () // wait until timer task has run to completion
+            run.isCancelled = false
       }
     end deepTest
 
@@ -265,8 +266,9 @@ trait ImportSuggestions:
    *  for current search, but but never less than to half of the previous budget.
    */
   private def reduceTimeBudget(used: Int)(using Context) =
-    ctx.run.importSuggestionBudget =
-      (ctx.run.importSuggestionBudget - used) max (ctx.run.importSuggestionBudget / 2)
+    val run = ctx.run.nn
+    run.importSuggestionBudget =
+      (run.importSuggestionBudget - used) max (run.importSuggestionBudget / 2)
 
   /** The `ref` parts of this list of pairs, discarding subsequent elements that
    *  have the same String part. Elements are sorted by their String parts.

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

@@ -2184,7 +2184,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val sup = Suppression(tree.sourcePos, filters, range.start, range.end, verbose)
     // invalid suppressions, don't report as unused
     if filters == List(MessageFilter.None) then sup.markUsed()
-    ctx.run.suppressions.addSuppression(sup)
+    ctx.run.nn.suppressions.addSuppression(sup)
 
   def typedValDef(vdef: untpd.ValDef, sym: Symbol)(using Context): Tree = {
     val ValDef(name, tpt, _) = vdef
@@ -2937,7 +2937,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         assertPositioned(tree)
       if tree.source != ctx.source && tree.source.exists then
         typed(tree, pt, locked)(using ctx.withSource(tree.source))
-      else if ctx.run.isCancelled then
+      else if ctx.run.nn.isCancelled then
         tree.withType(WildcardType)
       else adapt(typedUnadapted(tree, pt, locked), pt, locked)
     }

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

@@ -44,7 +44,7 @@ class TyperPhase(addRootImports: Boolean = true) extends Phase {
         typr.println("typed: " + unit.source)
         record("retained untyped trees", unit.untpdTree.treeSize)
         record("retained typed trees after typer", unit.tpdTree.treeSize)
-        ctx.run.suppressions.reportSuspendedMessages(unit.source)
+        ctx.run.nn.suppressions.reportSuspendedMessages(unit.source)
     catch
       case ex: CompilationUnit.SuspendException =>
   }
@@ -86,7 +86,7 @@ class TyperPhase(addRootImports: Boolean = true) extends Phase {
     unitContexts.foreach(javaCheck(using _)) // after typechecking to avoid cycles
 
     val newUnits = unitContexts.map(_.compilationUnit).filterNot(discardAfterTyper)
-    ctx.run.checkSuspendedUnits(newUnits)
+    ctx.run.nn.checkSuspendedUnits(newUnits)
     newUnits
 
   def run(using Context): Unit = unsupported("run")

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

@@ -7,24 +7,24 @@ object Store {
   val empty: Store = new Store(Array())
 }
 
-class Store(private val elems: Array[AnyRef]) extends AnyVal {
+class Store(private val elems: Array[AnyRef | Null]) extends AnyVal {
   import Store._
 
   def newLocation[T](): (Location[T], Store) = {
-    val elems1 = new Array[AnyRef](elems.length + 1)
+    val elems1 = new Array[AnyRef | Null](elems.length + 1)
     System.arraycopy(elems, 0, elems1, 0, elems.length)
     (new Location(elems.length), new Store(elems1))
   }
 
   def newLocation[T](initial: T): (Location[T], Store) = {
     val (loc, store) = newLocation[T]()
-    store.elems(loc.idx) = initial.asInstanceOf[AnyRef]
+    store.elems(loc.idx) = initial.asInstanceOf[AnyRef | Null]
     (loc, store)
   }
 
   def updated[T](loc: Location[T], value: T): Store = {
     val elems1 = elems.clone
-    elems1(loc.idx) = value.asInstanceOf[AnyRef]
+    elems1(loc.idx) = value.asInstanceOf[AnyRef | Null]
     new Store(elems1)
   }
 

compiler/src/dotty/tools/repl/ReplCompiler.scala

@@ -163,8 +163,8 @@ class ReplCompiler extends Compiler {
 
   private def runCompilationUnit(unit: CompilationUnit, state: State): Result[(CompilationUnit, State)] = {
     val ctx = state.context
-    ctx.run.compileUnits(unit :: Nil)
-    ctx.run.printSummary() // this outputs "2 errors found" like normal - but we might decide that's needlessly noisy for the REPL
+    ctx.run.nn.compileUnits(unit :: Nil)
+    ctx.run.nn.printSummary() // this outputs "2 errors found" like normal - but we might decide that's needlessly noisy for the REPL
 
     if (!ctx.reporter.hasErrors) (unit, state).result
     else ctx.reporter.removeBufferedMessages(using ctx).errors
@@ -291,7 +291,7 @@ class ReplCompiler extends Compiler {
       wrapped(expr, src, state).flatMap { pkg =>
         val unit = CompilationUnit(src)
         unit.untpdTree = pkg
-        ctx.run.compileUnits(unit :: Nil, ctx)
+        ctx.run.nn.compileUnits(unit :: Nil, ctx)
 
         if (errorsAllowed || !ctx.reporter.hasErrors)
           unwrapped(unit.tpdTree, src)

scaladoc/src/dotty/tools/scaladoc/tasty/TastyParser.scala

@@ -37,7 +37,7 @@ case class ScaladocTastyInspector()(using ctx: DocContext) extends DocTastyInspe
     // however, path-dependent types disallow doing so w/o using casts
     inline def hackForeachTree(thunk: reflect.Tree => Unit): Unit =
       given dctx: dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
-      dctx.run.units.foreach { compilationUnit =>
+      dctx.run.nn.units.foreach { compilationUnit =>
         // mirrors code from TastyInspector
         thunk(compilationUnit.tpdTree.asInstanceOf[reflect.Tree])
       }