Delete LazyVar usage

Author: WojciechMazur

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

@@ -1255,7 +1255,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
             .toList
 
           // `StringConcatFactory` only got added in JDK 9, so use `StringBuilder` for lower
-          if (backendUtils.classfileVersion.get < asm.Opcodes.V9) {
+          if (backendUtils.classfileVersion < asm.Opcodes.V9) {
 
             // Estimate capacity needed for the string builder
             val approxBuilderSize = concatArguments.view.map {

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

@@ -599,7 +599,7 @@ trait BCodeHelpers extends BCodeIdiomatic {
 
       val mirrorClass = new asm.tree.ClassNode
       mirrorClass.visit(
-        backendUtils.classfileVersion.get,
+        backendUtils.classfileVersion,
         bType.info.flags,
         mirrorName,
         null /* no java-generic-signature */,

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

@@ -271,7 +271,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
       val flags = javaFlags(claszSymbol)
 
       val thisSignature = getGenericSignature(claszSymbol, claszSymbol.owner)
-      cnode.visit(backendUtils.classfileVersion.get, flags,
+      cnode.visit(backendUtils.classfileVersion, flags,
                   thisName, thisSignature,
                   superClass, interfaceNames.toArray)
 

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

@@ -861,55 +861,6 @@ abstract class BTypes { self =>
    */
   /*final*/ case class MethodNameAndType(name: String, methodType: MethodBType)
 
-
-  import dotty.tools.dotc.core.Contexts.Context
-
-  // The [[LazyVar]] class would conceptually be better placed within
-  // PostProcessorFrontendAccess (they access the `frontendLock` defined in that class). However,
-  // for every component in which we define nested classes, we need to make sure that the compiler
-  // knows that all component instances (val frontendAccess) in various classes are all the same,
-  // otherwise the prefixes don't match and we get type mismatch errors.
-  // Since we already do this dance (val bTypes: GenBCode.this.bTypes.type = GenBCode.this.bTypes)
-  // for BTypes, it's easier to add those nested classes to BTypes.
-
-  /**
-  * Create state that lazily evaluated (to work around / not worry about initialization ordering
-  * issues). The state is re-initialized in each compiler run when the component is initialized.
-  */
-  type Contextual[T] = Context ?=> T
-  def perRunLazy[T](component: PerRunInit)(init: => Contextual[T]): LazyVar[T] = {
-    val r = new LazyVar(() => init)
-    component.perRunInit(r.reInitialize())
-    r
-  }
-
-  /**
-  * This implements a lazy value that can be reset and re-initialized.
-  * It synchronizes on `frontendLock` so that lazy state created through this utility can
-  * be safely initialized in the post-processor.
-  * 
-  * Note that values defined as `LazyVar`s are usually `lazy val`s themselves (created through the
-  * `perRunLazy` method). This ensures that re-initializing a component only re-initializes those
-  * `LazyVar`s that have actually been used in the previous compiler run.
-  */
-  class LazyVar[T](init: Contextual[() => T]) {
-    @volatile private var isInit: Boolean = false
-    private var v: T = _
-
-    def get(using Context): T = {
-      if (isInit) v
-      else frontendSynch {
-        if (!isInit) v = init()
-        isInit = true
-        v
-      }
-    }
-
-    def reInitialize(): Unit = frontendSynch{
-      isInit = false
-    }
-  }
-
 }
 
 object BTypes {

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

@@ -36,10 +36,6 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I, val frontendAcce
   }
   import coreBTypes._
 
-  final def initialize()(using Context): Unit = {
-    coreBTypes.initialize()
-  }
-
   @threadUnsafe protected lazy val classBTypeFromInternalNameMap = 
     collection.concurrent.TrieMap.empty[String, ClassBType]
 

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

@@ -14,33 +14,31 @@ import scala.language.unsafeNulls
  * This component hosts tools and utilities used in the backend that require access to a `BTypes`
  * instance.
  */
-class BackendUtils(val postProcessor: PostProcessor) extends PerRunInit {
+class BackendUtils(val postProcessor: PostProcessor) {
   import postProcessor.{bTypes, frontendAccess}
   import frontendAccess.{compilerSettings}
   import bTypes.*
   import coreBTypes.jliLambdaMetaFactoryAltMetafactoryHandle
 
   // Keep synchronized with `minTargetVersion` and `maxTargetVersion` in ScalaSettings
-  lazy val classfileVersion: LazyVar[Int] = perRunLazy(this){
-    compilerSettings.target match {
-      case "8"  => asm.Opcodes.V1_8
-      case "9"  => asm.Opcodes.V9
-      case "10" => asm.Opcodes.V10
-      case "11" => asm.Opcodes.V11
-      case "12" => asm.Opcodes.V12
-      case "13" => asm.Opcodes.V13
-      case "14" => asm.Opcodes.V14
-      case "15" => asm.Opcodes.V15
-      case "16" => asm.Opcodes.V16
-      case "17" => asm.Opcodes.V17
-      case "18" => asm.Opcodes.V18
-      case "19" => asm.Opcodes.V19
-    }
+  lazy val classfileVersion: Int = compilerSettings.target match {
+    case "8"  => asm.Opcodes.V1_8
+    case "9"  => asm.Opcodes.V9
+    case "10" => asm.Opcodes.V10
+    case "11" => asm.Opcodes.V11
+    case "12" => asm.Opcodes.V12
+    case "13" => asm.Opcodes.V13
+    case "14" => asm.Opcodes.V14
+    case "15" => asm.Opcodes.V15
+    case "16" => asm.Opcodes.V16
+    case "17" => asm.Opcodes.V17
+    case "18" => asm.Opcodes.V18
+    case "19" => asm.Opcodes.V19
   }
 
-  lazy val extraProc: LazyVar[Int] = perRunLazy(this){
+  lazy val extraProc: Int = {
     import GenBCodeOps.addFlagIf
-    val majorVersion: Int = (classfileVersion.get & 0xFF)
+    val majorVersion: Int = (classfileVersion & 0xFF)
     val emitStackMapFrame = (majorVersion >= 50)
     asm.ClassWriter.COMPUTE_MAXS
       .addFlagIf(emitStackMapFrame, asm.ClassWriter.COMPUTE_FRAMES)

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

@@ -38,11 +38,12 @@ import scala.tools.asm.ClassTooLargeException
 import dotty.tools.dotc.util.NoSourcePosition
 
 
-class CodeGen(val int: DottyBackendInterface, val primitives: DottyPrimitives)( val bTypes: BTypesFromSymbols[int.type]) extends PerRunInit { self =>
+class CodeGen(val int: DottyBackendInterface, val primitives: DottyPrimitives)( val bTypes: BTypesFromSymbols[int.type]) { self =>
   import DottyBackendInterface.symExtensions
   import bTypes._
+  import int.given
 
-  private lazy val mirrorCodeGen = perRunLazy(this)(Impl.JMirrorBuilder())
+  private lazy val mirrorCodeGen = Impl.JMirrorBuilder()
 
   def apply()(using Context): Unit = {
     val unit = ctx.compilationUnit
@@ -90,7 +91,6 @@ class CodeGen(val int: DottyBackendInterface, val primitives: DottyPrimitives)(
     genClassDefs(unit.tpdTree)
   }
 
-  import int.given
   private def onFileCreated(cls: ClassNode, claszSymbol: Symbol, sourceFile: interfaces.SourceFile): AbstractFile => Unit = clsFile => {
     val (fullClassName, isLocal) = atPhase(sbtExtractDependenciesPhase) {
       (ExtractDependencies.classNameAsString(claszSymbol), claszSymbol.isLocal)
@@ -99,13 +99,12 @@ class CodeGen(val int: DottyBackendInterface, val primitives: DottyPrimitives)(
     val className = cls.name.replace('/', '.')
     if (ctx.compilerCallback != null)
       ctx.compilerCallback.onClassGenerated(sourceFile, convertAbstractFile(clsFile), className)
+    
     if (ctx.sbtCallback != null) {
-      if (isLocal)
-        ctx.sbtCallback.generatedLocalClass(sourceFile.jfile.orElse(null), clsFile.file)
-      else {
-        ctx.sbtCallback.generatedNonLocalClass(sourceFile.jfile.orElse(null), clsFile.file,
-          className, fullClassName)
-      }
+      val jSourceFile = sourceFile.jfile.orElse(null)
+      val cb = ctx.sbtCallback
+      if (isLocal) cb.generatedLocalClass(jSourceFile, clsFile.file)
+      else cb.generatedNonLocalClass(jSourceFile, clsFile.file, className, fullClassName)
     }
   }
 
@@ -140,23 +139,25 @@ class CodeGen(val int: DottyBackendInterface, val primitives: DottyPrimitives)(
     }
 
   private def genClass(cd: TypeDef, unit: CompilationUnit): ClassNode = {
-    checkForCaseConflict(cd.symbol.javaClassName, cd.symbol)
     val b = new Impl.SyncAndTryBuilder(unit) {}
     b.genPlainClass(cd)
-    b.cnode
+    val cls = b.cnode
+    checkForCaseConflict(cls.name, cd.symbol)
+    cls
   }
 
   private def genMirrorClass(classSym: Symbol, unit: CompilationUnit): ClassNode = {
-    // checkForCaseConflict(classSym.javaClassName, classSym)
-    mirrorCodeGen.get.genMirrorClass(classSym, unit)
+    val cls = mirrorCodeGen.genMirrorClass(classSym, unit)
+    checkForCaseConflict(cls.name, classSym)
+    cls
   }
 
-  private val lowerCaseNames = perRunLazy(this)(mutable.HashMap.empty[String, Symbol])
+  private val lowerCaseNames = mutable.HashMap.empty[String, Symbol]
   private def checkForCaseConflict(javaClassName: String, classSymbol: Symbol) = {
     val lowerCaseName = javaClassName.toLowerCase
-    lowerCaseNames.get.get(lowerCaseName) match {
+    lowerCaseNames.get(lowerCaseName) match {
       case None =>
-        lowerCaseNames.get.put(lowerCaseName, classSymbol)
+        lowerCaseNames.put(lowerCaseName, classSymbol)
       case Some(dupClassSym) =>
         // Order is not deterministic so we enforce lexicographic order between the duplicates for error-reporting
         val (cl1, cl2) =