Pass separate context parameter CState

... and verify that context and cstate always agree on the period

Author: odersky

bench/src/main/scala/Benchmarks.scala

@@ -1,7 +1,7 @@
 package dotty.tools.benchmarks
 
 import dotty.tools.dotc._
-import core.Contexts.Context
+import core.Contexts._
 import dotty.tools.FatalError
 import reporting._
 
@@ -94,6 +94,7 @@ class CompilerOptions {
 class Worker extends Driver {
   // override to avoid printing summary information
   override  def doCompile(compiler: Compiler, fileNames: List[String])(implicit ctx: Context): Reporter =
+    given CState = ctx.cstate
     if (fileNames.nonEmpty)
       try {
         val run = compiler.newRun

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

@@ -39,7 +39,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
   import coreBTypes._
   import BCodeBodyBuilder._
 
-  private val primitives = new DottyPrimitives(ctx)
+  private val primitives = new DottyPrimitives(ctx, cs)
 
   /*
    * Functionality to build the body of ASM MethodNode, except for `synchronized` and `try` expressions.

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

@@ -846,7 +846,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     }
   }
 
-  private def getGenericSignatureHelper(sym: Symbol, owner: Symbol, memberTpe: Type)(using Context): Option[String] = {
+  private def getGenericSignatureHelper(sym: Symbol, owner: Symbol, memberTpe: Type)(using Context, CState): Option[String] = {
     if (needsGenericSignature(sym)) {
       val erasedTypeSym = TypeErasure.fullErasure(sym.denot.info).typeSymbol
       if (erasedTypeSym.isPrimitiveValueClass) {
@@ -866,7 +866,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     }
   }
 
-  private def verifySignature(sym: Symbol, sig: String)(using Context): Unit = {
+  private def verifySignature(sym: Symbol, sig: String)(using Context, CState): Unit = {
     import scala.tools.asm.util.CheckClassAdapter
     def wrap(body: => Unit): Unit = {
       try body
@@ -927,7 +927,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     throw new RuntimeException(msg)
   }
 
-  private def compilingArray(using Context) =
+  private def compilingArray(using Context, CState) =
     ctx.compilationUnit.source.file.name == "Array.scala"
 }
 

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

@@ -22,7 +22,7 @@ class CollectSuperCalls extends MiniPhase {
 
   def phaseName: String = "collectSuperCalls"
 
-  override def transformSelect(tree: Select)(using Context): Tree = {
+  override def transformSelect(tree: Select)(using Context, CState): Tree = {
     tree.qualifier match {
       case sup: Super =>
         if (tree.symbol.owner.is(Trait))
@@ -32,7 +32,7 @@ class CollectSuperCalls extends MiniPhase {
     tree
   }
 
-  private def registerSuperCall(sym: ClassSymbol, calls: ClassSymbol)(using Context) = {
+  private def registerSuperCall(sym: ClassSymbol, calls: ClassSymbol)(using Context, CState) = {
     genBCodePhase match {
       case genBCodePhase: GenBCode =>
         genBCodePhase.registerSuperCall(sym, calls)

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

@@ -36,7 +36,8 @@ import Names.TermName
 import Annotations.Annotation
 import Names.Name
 
-class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap: Map[Symbol, Set[ClassSymbol]])(using val ctx: Context) {
+class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap: Map[Symbol, Set[ClassSymbol]])
+  (using val ctx: Context, val cs: CState) {
 
   private val desugared = new java.util.IdentityHashMap[Type, tpd.Select]
 
@@ -109,16 +110,16 @@ object DottyBackendInterface {
     else clazz.getName
   }
 
-  def requiredClass(str: String)(using Context): ClassSymbol =
+  def requiredClass(str: String)(using Context, CState): ClassSymbol =
     Symbols.requiredClass(str)
 
-  def requiredClass[T](using evidence: ClassTag[T], ctx: Context): Symbol =
+  def requiredClass[T](using evidence: ClassTag[T], ctx: Context, cs: CState): Symbol =
     requiredClass(erasureString(evidence.runtimeClass))
 
-  def requiredModule(str: String)(using Context): Symbol =
+  def requiredModule(str: String)(using Context, CState): Symbol =
     Symbols.requiredModule(str)
 
-  def requiredModule[T](using evidence: ClassTag[T], ctx: Context): Symbol = {
+  def requiredModule[T](using evidence: ClassTag[T], ctx: Context, cs: CState): Symbol = {
     val moduleName = erasureString(evidence.runtimeClass)
     val className = if (moduleName.endsWith("$")) moduleName.dropRight(1)  else moduleName
     requiredModule(className)
@@ -127,19 +128,19 @@ object DottyBackendInterface {
   given symExtensions as AnyRef:
     extension (sym: Symbol):
 
-      def isInterface(using Context): Boolean = (sym.is(PureInterface)) || sym.is(Trait)
+      def isInterface(using Context, CState): Boolean = (sym.is(PureInterface)) || sym.is(Trait)
 
-      def isStaticConstructor(using Context): Boolean = (sym.isStaticMember && sym.isClassConstructor) || (sym.name eq nme.STATIC_CONSTRUCTOR)
+      def isStaticConstructor(using Context, CState): Boolean = (sym.isStaticMember && sym.isClassConstructor) || (sym.name eq nme.STATIC_CONSTRUCTOR)
 
-      def isStaticMember(using Context): Boolean = (sym ne NoSymbol) &&
+      def isStaticMember(using Context, CState): Boolean = (sym ne NoSymbol) &&
         (sym.is(JavaStatic) || sym.isScalaStatic)
         // guard against no sumbol cause this code is executed to select which call type(static\dynamic) to use to call array.clone
 
       /**
       * True for module classes of modules that are top-level or owned only by objects. Module classes
       * for such objects will get a MODULE$ flag and a corresponding static initializer.
       */
-      def isStaticModuleClass(using Context): Boolean =
+      def isStaticModuleClass(using Context, CState): Boolean =
         (sym.is(Module)) && {
           // scalac uses atPickling here
           // this would not work if modules are created after pickling
@@ -153,7 +154,7 @@ object DottyBackendInterface {
 
 
 
-      def originalLexicallyEnclosingClass(using Context): Symbol =
+      def originalLexicallyEnclosingClass(using Context, CState): Symbol =
         // used to populate the EnclosingMethod attribute.
         // it is very tricky in presence of classes(and annonymous classes) defined inside supper calls.
         if (sym.exists) {
@@ -167,15 +168,15 @@ object DottyBackendInterface {
       * True for module classes of package level objects. The backend will generate a mirror class for
       * such objects.
       */
-      def isTopLevelModuleClass(using Context): Boolean =
+      def isTopLevelModuleClass(using Context, CState): Boolean =
         sym.is(ModuleClass) &&
         atPhase(flattenPhase) {
           toDenot(sym).owner.is(PackageClass)
         }
 
-      def javaSimpleName(using Context): String = toDenot(sym).name.mangledString
-      def javaClassName(using Context): String = toDenot(sym).fullName.mangledString
-      def javaBinaryName(using Context): String = javaClassName.replace('.', '/')
+      def javaSimpleName(using Context, CState): String = toDenot(sym).name.mangledString
+      def javaClassName(using Context, CState): String = toDenot(sym).fullName.mangledString
+      def javaBinaryName(using Context, CState): String = javaClassName.replace('.', '/')
 
     end extension
 
@@ -197,7 +198,7 @@ object DottyBackendInterface {
    * True if the current compilation unit is of a primitive class (scala.Boolean et al).
    * Used only in assertions.
    */
-  def isCompilingPrimitive(using Context) = {
+  def isCompilingPrimitive(using Context, CState) = {
     primitiveCompilationUnits(ctx.compilationUnit.source.file.name)
   }
 

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

@@ -43,13 +43,13 @@ class GenBCode extends Phase {
 
   private var myOutput: AbstractFile = _
 
-  private def outputDir(using Context): AbstractFile = {
+  private def outputDir(using Context, CState): AbstractFile = {
     if (myOutput eq null)
       myOutput = ctx.settings.outputDir.value
     myOutput
   }
 
-  def run(using Context): Unit =
+  def run(using Context, CState): Unit =
     new GenBCodePipeline(
       new DottyBackendInterface(
         outputDir, superCallsMap.toMap
@@ -58,6 +58,7 @@ class GenBCode extends Phase {
 
 
   override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] = {
+    given CState = ctx.cstate
     try super.runOn(units)
     finally myOutput match {
       case jar: JarArchive =>
@@ -75,7 +76,7 @@ object GenBCode {
   val name: String = "genBCode"
 }
 
-class GenBCodePipeline(val int: DottyBackendInterface)(using Context) extends BCodeSyncAndTry {
+class GenBCodePipeline(val int: DottyBackendInterface)(using Context, CState) extends BCodeSyncAndTry {
   import DottyBackendInterface.symExtensions
 
   private var tree: Tree = _

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

@@ -31,7 +31,7 @@ import scala.collection.immutable
  *
  * Inspired from the `scalac` compiler.
  */
-class DottyPrimitives(ictx: Context) {
+class DottyPrimitives(ictx: Context, cs: CState) {
   import dotty.tools.backend.ScalaPrimitivesOps._
 
   @threadUnsafe private lazy val primitives: immutable.Map[Symbol, Int] = init
@@ -50,7 +50,7 @@ class DottyPrimitives(ictx: Context) {
    * @param tpe The type of the receiver object. It is used only for array
    *            operations
    */
-  def getPrimitive(app: Apply, tpe: Type)(using Context): Int = {
+  def getPrimitive(app: Apply, tpe: Type)(using Context, CState): Int = {
     val fun = app.fun.symbol
     val defn = ctx.definitions
     val code = app.fun match {
@@ -121,6 +121,7 @@ class DottyPrimitives(ictx: Context) {
   private def init: immutable.Map[Symbol, Int]  = {
 
     given Context = ictx
+    given CState = cs
 
     import Symbols.defn
     val primitives = Symbols.newMutableSymbolMap[Int]
@@ -131,7 +132,7 @@ class DottyPrimitives(ictx: Context) {
       primitives(s) = code
     }
 
-    def addPrimitives(cls: Symbol, method: TermName, code: Int)(using Context): Unit = {
+    def addPrimitives(cls: Symbol, method: TermName, code: Int)(using Context, CState): Unit = {
       val alts = cls.info.member(method).alternatives.map(_.symbol)
       if (alts.isEmpty)
         report.error(s"Unknown primitive method $cls.$method")
@@ -399,6 +400,7 @@ class DottyPrimitives(ictx: Context) {
 
   def isPrimitive(fun: Tree): Boolean =
     given Context = ictx
+    given CState = cs
     primitives.contains(fun.symbol)
     || (fun.symbol == NoSymbol // the only trees that do not have a symbol assigned are array.{update,select,length,clone}}
         && {

compiler/src/dotty/tools/backend/sjs/GenSJSIR.scala

@@ -11,6 +11,6 @@ class GenSJSIR extends Phase {
   override def isRunnable(using Context): Boolean =
     super.isRunnable && ctx.settings.scalajs.value
 
-  def run(using Context): Unit =
+  def run(using Context, CState): Unit =
     new JSCodeGen().run()
 }

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -56,14 +56,14 @@ import ScopedVar.withScopedVars
  *  - `genMethod()` and similar methods generate the declarations of methods.
  *  - `genStatOrExpr()` and everything else generate the bodies of methods.
  */
-class JSCodeGen()(using genCtx: Context) {
+class JSCodeGen()(using genCtx: Context, cs: CState) {
   import JSCodeGen._
   import tpd._
 
   private val jsdefn = JSDefinitions.jsdefn
-  private val primitives = new JSPrimitives(genCtx)
+  private val primitives = new JSPrimitives(genCtx, cs)
 
-  private val positionConversions = new JSPositions()(using genCtx)
+  private val positionConversions = new JSPositions()(using genCtx, cs)
   import positionConversions._
 
   // Some state --------------------------------------------------------------
@@ -2733,7 +2733,7 @@ class JSCodeGen()(using genCtx: Context) {
   private def genActualJSArgs(sym: Symbol, args: List[Tree])(
       implicit pos: Position): List[js.TreeOrJSSpread] = {
 
-    def paramNamesAndTypes(using Context): List[(Names.TermName, Type)] =
+    def paramNamesAndTypes(using Context, CState): List[(Names.TermName, Type)] =
       sym.info.paramNamess.flatten.zip(sym.info.paramInfoss.flatten)
 
     val wereRepeated = atPhase(elimRepeatedPhase) {