Port backend paralleism refactor from Scala 2

Author: WojciechMazur

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

@@ -16,7 +16,6 @@ import scala.tools.asm
  */
 abstract class BTypes { self =>
   val frontendAccess: PostProcessorFrontendAccess
-  import frontendAccess.{frontendSynch}
 
   val int: DottyBackendInterface
   import int.given
@@ -31,8 +30,7 @@ abstract class BTypes { self =>
    * Concurrent because stack map frames are computed when in the class writer, which might run
    * on multiple classes concurrently.
    */
-  protected def classBTypeFromInternalNameMap: collection.concurrent.Map[String, ClassBType]
-    // NOTE: Should be a lazy val but scalac does not allow abstract lazy vals (dotty does)
+  protected lazy val classBTypeFromInternalNameMap: collection.concurrent.Map[String, ClassBType]
 
   /**
    * Obtain a previously constructed ClassBType for a given internal name.

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

@@ -55,14 +55,16 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I, val frontendAcce
       (classSym != defn.NothingClass && classSym != defn.NullClass),
       s"Cannot create ClassBType for special class symbol ${classSym.showFullName}")
 
-    convertedClasses.getOrElse(classSym, {
-      val internalName = classSym.javaBinaryName
-      // We first create and add the ClassBType to the hash map before computing its info. This
-      // allows initializing cylic dependencies, see the comment on variable ClassBType._info.
-      val classBType = new ClassBType(internalName)
-      convertedClasses(classSym) = classBType
-      setClassInfo(classSym, classBType)
-    })
+    convertedClasses.synchronized {
+      convertedClasses.getOrElse(classSym, {
+        val internalName = classSym.javaBinaryName
+        // We first create and add the ClassBType to the hash map before computing its info. This
+        // allows initializing cylic dependencies, see the comment on variable ClassBType._info.
+        val classBType = new ClassBType(internalName)
+        convertedClasses(classSym) = classBType
+        setClassInfo(classSym, classBType)
+      })
+    }
   }
 
   final def mirrorClassBTypeFromSymbol(moduleClassSym: Symbol): ClassBType = {

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

@@ -17,8 +17,7 @@ import scala.language.unsafeNulls
 class BackendUtils(val postProcessor: PostProcessor) {
   import postProcessor.{bTypes, frontendAccess}
   import frontendAccess.{compilerSettings}
-  import bTypes.*
-  import coreBTypes.jliLambdaMetaFactoryAltMetafactoryHandle
+  import bTypes.{coreBTypes, ClassBType, MethodBType}
 
   // Keep synchronized with `minTargetVersion` and `maxTargetVersion` in ScalaSettings
   lazy val classfileVersion: Int = compilerSettings.target match {
@@ -45,6 +44,8 @@ class BackendUtils(val postProcessor: PostProcessor) {
   }
 
   def collectSerializableLambdas(classNode: ClassNode): Array[Handle] = {
+    import coreBTypes.jliLambdaMetaFactoryAltMetafactoryHandle
+
     val indyLambdaBodyMethods = new mutable.ArrayBuffer[Handle]
     for (m <- classNode.methods.asScala) {
       val iter = m.instructions.iterator
@@ -59,7 +60,7 @@ class BackendUtils(val postProcessor: PostProcessor) {
               if isSerializable then
                 val implMethod = indy.bsmArgs(1).asInstanceOf[Handle]
                 indyLambdaBodyMethods += implMethod
-          case _ =>
+          case _ => ()
         }
       }
     }
@@ -90,8 +91,7 @@ class BackendUtils(val postProcessor: PostProcessor) {
     */
   def addLambdaDeserialize(classNode: ClassNode, implMethodsArray: Array[Handle]): Unit = {
     import asm.Opcodes._
-    import bTypes._
-    import coreBTypes._
+    import coreBTypes.{jlIllegalArgExceptionRef, jliLambdaDeserializeBootstrapHandle}
 
     val cw = classNode
 
@@ -101,12 +101,10 @@ class BackendUtils(val postProcessor: PostProcessor) {
     // stack map frames and invokes the `getCommonSuperClass` method. This method expects all
     // ClassBTypes mentioned in the source code to exist in the map.
 
-    val serlamObjDesc = MethodBType(jliSerializedLambdaRef :: Nil, ObjectRef).descriptor
-
-    val mv = cw.visitMethod(ACC_PRIVATE + ACC_STATIC + ACC_SYNTHETIC, "$deserializeLambda$", serlamObjDesc, null, null)
+    val mv = cw.visitMethod(ACC_PRIVATE + ACC_STATIC + ACC_SYNTHETIC, "$deserializeLambda$", serializedLamdaObjDesc, null, null)
     def emitLambdaDeserializeIndy(targetMethods: Seq[Handle]): Unit = {
       mv.visitVarInsn(ALOAD, 0)
-      mv.visitInvokeDynamicInsn("lambdaDeserialize", serlamObjDesc, jliLambdaDeserializeBootstrapHandle, targetMethods: _*)
+      mv.visitInvokeDynamicInsn("lambdaDeserialize", serializedLamdaObjDesc, jliLambdaDeserializeBootstrapHandle, targetMethods: _*)
     }
 
     val targetMethodGroupLimit = 255 - 1 - 3 // JVM limit. See See MAX_MH_ARITY in CallSite.java
@@ -131,6 +129,11 @@ class BackendUtils(val postProcessor: PostProcessor) {
     mv.visitInsn(ARETURN)
   }
 
+  private lazy val serializedLamdaObjDesc = {
+    import coreBTypes.{ObjectRef, jliSerializedLambdaRef}
+    MethodBType(jliSerializedLambdaRef :: Nil, ObjectRef).descriptor
+  }
+
   /**
    * Visit the class node and collect all referenced nested classes.
    */