Fixes in other code calling the compiler

Author: odersky

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

@@ -85,7 +85,8 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
   /** The context created for this run */
   given runContext[Dummy_so_its_a_def] as Context = myCtx
-  given runCState[Dummy_so_its_a_def] as CState = myCtx.cstate
+  given runCState[Dummy_so_its_a_def] as CState =
+    if myCtx == null then Nowhere else myCtx.cstate
 
   assert(currentRunId(using runContext) <= Periods.MaxPossibleRunId)
 

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

@@ -292,6 +292,7 @@ object Phases {
     def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
       units.map { unit =>
         val unitCtx = ctx.fresh.setPhase(this.start).setCompilationUnit(unit)
+        assert(unitCtx.compilationUnit != null)
         run(using unitCtx, unitCtx.cstate)
         unitCtx.compilationUnit
       }

compiler/test/dotty/tools/DottyTest.scala

@@ -22,6 +22,7 @@ trait DottyTest extends ContextEscapeDetection {
   dotc.parsing.Scanners // initialize keywords
 
   implicit var ctx: Context = initialCtx
+  given [DummySoItsADef] as CState = ctx.cstate
 
   protected def initialCtx: FreshContext = {
     val base = new ContextBase {}
@@ -54,7 +55,8 @@ trait DottyTest extends ContextEscapeDetection {
       val lastGroup = allPhases.find(x => x.contains(targetPhase)).get.takeWhile(x => !(x eq targetPhase))
       val checker = new Phase {
         def phaseName = "assertionChecker"
-        override def run(using ctx: Context): Unit = assertion(ctx.compilationUnit.tpdTree, ctx)
+        override def run(using ctx: Context, cs: CState): Unit =
+          assertion(ctx.compilationUnit.tpdTree, ctx)
       }
       val lastGroupAppended = List(lastGroup ::: targetPhase :: Nil)
 

compiler/test/dotty/tools/compilerSupport.scala

@@ -17,15 +17,15 @@ import dotc.core.Comments.{ContextDoc, ContextDocstrings}
  *  one used to compile the sources, this makes it easier to test for potential
  *  issues involving retrieving symbols defined in a previous run.
  */
-def inCompilerContext[T](classpath: String, separateRun: Boolean = true, scalaSources: String*)(op: Context ?=> T): T =
+def inCompilerContext[T](classpath: String, separateRun: Boolean = true, scalaSources: String*)(op: (Context, CState) ?=> T): T =
   val compiler = Compiler()
   val rootCtx = initCtx(classpath)
   val firstRun = compiler.newRun(using rootCtx)
   firstRun.compileFromStrings(scalaSources.toList)
   val opRun = if separateRun
     then compiler.newRun(using rootCtx)
     else firstRun
-  op(using opRun.runContext)
+  op(using opRun.runContext, opRun.runContext.cstate)
 
 private def initCtx(classpath: String): Context =
   val ctx0 = (new ContextBase).initialCtx.fresh

compiler/test/dotty/tools/dotc/ast/UntypedTreeMapTest.scala

@@ -22,7 +22,7 @@ class UntpdTreeMapTest extends DottyTest {
   def testMapInterpolatedString = {
     val tree = parse(""" q"hello ${2017}!" """)
     val identity = new UntypedTreeMap {
-      override def transform(tree: Tree)(using Context): Tree = tree match {
+      override def transform(tree: Tree)(using Context, CState): Tree = tree match {
         case _ =>  super.transform(tree)
       }
     }

compiler/test/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactoryTest.scala

@@ -4,7 +4,7 @@ import org.junit.Test
 import java.nio.file._
 import java.nio.file.attribute.FileTime
 
-import dotty.tools.dotc.core.Contexts.{Context, ContextBase, ctx}
+import dotty.tools.dotc.core.Contexts.{Context, ContextBase, CState, ctx}
 import dotty.tools.io.AbstractFile
 
 
@@ -16,7 +16,8 @@ class ZipAndJarFileLookupFactoryTest {
     val f = Files.createTempFile("test-", ".jar")
     Files.delete(f)
 
-    given Context = new ContextBase().initialCtx
+    given c as Context = new ContextBase().initialCtx
+    given CState = c.cstate
     assert(!ctx.settings.YdisableFlatCpCaching.value) // we're testing with our JAR metadata caching enabled.
 
     def createCp = ZipAndJarClassPathFactory.create(AbstractFile.getFile(f))

compiler/test/dotty/tools/dotc/core/tasty/CommentPicklingTest.scala

@@ -4,7 +4,7 @@ import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.ast.tpd.TreeOps
 import dotty.tools.dotc.{Driver, Main}
 import dotty.tools.dotc.core.Comments.CommentsContext
-import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Decorators.PreNamedString
 import dotty.tools.dotc.core.Mode
 import dotty.tools.dotc.core.Names.Name
@@ -59,6 +59,7 @@ class CommentPicklingTest {
 
   private def compileAndCheckComment(sources: List[String], treeName: Name, expectedComment: Option[String]): Unit = {
     compileAndUnpickle(sources) { (trees, ctx) =>
+      given CState = ctx.cstate
       findTreeNamed(treeName)(trees, ctx) match {
         case Some(md: tpd.MemberDef) =>
           val symbol = md.symbol(using ctx)
@@ -73,6 +74,7 @@ class CommentPicklingTest {
 
   private def findTreeNamed(name: Name)(trees: List[tpd.Tree], ctx: Context): Option[tpd.MemberDef] = {
     implicit val _ctx: Context = ctx
+    given CState = ctx.cstate
     trees.flatMap { _.find { case md: tpd.MemberDef => md.name == name; case _ => false }
       .map(_.asInstanceOf[tpd.MemberDef]).toList
     }.headOption
@@ -108,6 +110,7 @@ class CommentPicklingTest {
     override def initCtx = super.initCtx.addMode(Mode.ReadComments)
     def unpickle[T](args: Array[String], files: List[File])(fn: (List[tpd.Tree], Context) => T): T = {
       implicit val (_, ctx: Context) = setup(args, initCtx)
+      given CState = ctx.cstate
       ctx.initialize()
       val trees = files.flatMap { f =>
         val unpickler = new DottyUnpickler(f.toByteArray())

compiler/test/dotty/tools/dotc/parsing/DeSugarTest.scala

@@ -10,7 +10,7 @@ import ast.Trees._
 import ast.desugar
 import ast.desugar._
 import core.Mode
-import Contexts.Context
+import Contexts.{Context, CState}
 
 import scala.collection.mutable.ListBuffer
 
@@ -34,7 +34,7 @@ class DeSugarTest extends ParserTest {
     def transform(tree: Tree, mode: Mode)(using Context): Tree = withMode(mode) { transform(tree) }
     def transform(trees: List[Tree], mode: Mode)(using Context): List[Tree] = withMode(mode) { transform(trees) }
 
-    override def transform(tree: Tree)(using Context): Tree = {
+    override def transform(tree: Tree)(using Context, CState): Tree = {
       val tree1 = desugar(tree)(using ctx.withModeBits(curMode))
       tree1 match {
         case TypedSplice(t) =>

compiler/test/dotty/tools/dotc/parsing/ModifiersParsingTest.scala

@@ -14,7 +14,8 @@ import core.Contexts._
 import core.Flags
 
 object ModifiersParsingTest {
-  given Context = (new ContextBase).initialCtx
+  private given c as Context = (new ContextBase).initialCtx
+  private given CState = ctx.cstate
 
   def parse(code: String): Tree = {
     val (_, stats) = new Parser(SourceFile.virtual("<meta>", code)).templateStatSeq()

compiler/test/dotty/tools/dotc/parsing/parsePackage.scala

@@ -5,7 +5,7 @@ package parsing
 import dotty.tools.dotc._
 import core._, ast._
 import Trees._
-import Contexts.Context
+import Contexts.{Context, CState}
 
 object parsePackage extends ParserTest {
 
@@ -14,7 +14,7 @@ object parsePackage extends ParserTest {
   var nodes = 0
 
   val transformer = new UntypedTreeMap {
-    override def transform(tree: Tree)(using Context): Tree = {
+    override def transform(tree: Tree)(using Context, CState): Tree = {
       nodes += 1
       tree match {
         case Ident(name) =>