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) {