Make ClassBType components lazy, prevent forcing symbols unnecessarily

Make the `nestedClasses` and `nestedInfo` fields lazy to ensure the
corresponding symbol infos are only forced if necessary.

Author: lrytz

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

@@ -79,7 +79,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
     def tpeTK(tree: Tree): BType = typeToBType(tree.tpe)
 
     def log(msg: => AnyRef) {
-      global synchronized { global.log(msg) }
+      frontendLock synchronized { global.log(msg) }
     }
 
     /* ---------------- helper utils for generating classes and fields ---------------- */

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

@@ -32,6 +32,11 @@ import scala.tools.nsc.settings.ScalaSettings
 abstract class BTypes {
   import BTypes.InternalName
 
+  // Stages after code generation in the backend (optimizations, classfile writing) are prepared
+  // to run in parallel on multiple classes. This object should be used for synchronizing operations
+  // that may access the compiler frontend during these late stages.
+  val frontendLock: AnyRef = new Object()
+
   val backendUtils: BackendUtils[this.type]
 
   // Some core BTypes are required here, in class BType, where no Global instance is available.
@@ -223,13 +228,13 @@ abstract class BTypes {
       })
     }
 
-    val nestedClasses: List[ClassBType] = classNode.innerClasses.asScala.collect({
+    def nestedClasses: List[ClassBType] = classNode.innerClasses.asScala.collect({
       case i if nestedInCurrentClass(i) => classBTypeFromParsedClassfile(i.name)
     })(collection.breakOut)
 
     // if classNode is a nested class, it has an innerClass attribute for itself. in this
     // case we build the NestedInfo.
-    val nestedInfo = classNode.innerClasses.asScala.find(_.name == classNode.name) map {
+    def nestedInfo = classNode.innerClasses.asScala.find(_.name == classNode.name) map {
       case innerEntry =>
         val enclosingClass =
           if (innerEntry.outerName != null) {
@@ -248,7 +253,7 @@ abstract class BTypes {
 
     val interfaces: List[ClassBType] = classNode.interfaces.asScala.map(classBTypeFromParsedClassfile)(collection.breakOut)
 
-    classBType.info = Right(ClassInfo(superClass, interfaces, flags, nestedClasses, nestedInfo, inlineInfo))
+    classBType.info = Right(ClassInfo(superClass, interfaces, flags, Lazy(nestedClasses), Lazy(nestedInfo), inlineInfo))
     classBType
   }
 
@@ -895,7 +900,9 @@ abstract class BTypes {
         s"Invalid interfaces in $this: ${info.get.interfaces}"
       )
 
-      assert(info.get.nestedClasses.forall(c => ifInit(c)(_.isNestedClass.get)), info.get.nestedClasses)
+      info.get.nestedClasses.onForce { cs =>
+        assert(cs.forall(c => ifInit(c)(_.isNestedClass.get)), cs)
+      }
     }
 
     /**
@@ -923,17 +930,17 @@ abstract class BTypes {
 
     def isPublic: Either[NoClassBTypeInfo, Boolean] = info.map(i => (i.flags & asm.Opcodes.ACC_PUBLIC) != 0)
 
-    def isNestedClass: Either[NoClassBTypeInfo, Boolean] = info.map(_.nestedInfo.isDefined)
+    def isNestedClass: Either[NoClassBTypeInfo, Boolean] = info.map(_.nestedInfo.force.isDefined)
 
     def enclosingNestedClassesChain: Either[NoClassBTypeInfo, List[ClassBType]] = {
       isNestedClass.flatMap(isNested => {
         // if isNested is true, we know that info.get is defined, and nestedInfo.get is also defined.
-        if (isNested) info.get.nestedInfo.get.enclosingClass.enclosingNestedClassesChain.map(this :: _)
+        if (isNested) info.get.nestedInfo.force.get.enclosingClass.enclosingNestedClassesChain.map(this :: _)
         else Right(Nil)
       })
     }
 
-    def innerClassAttributeEntry: Either[NoClassBTypeInfo, Option[InnerClassEntry]] = info.map(i => i.nestedInfo map {
+    def innerClassAttributeEntry: Either[NoClassBTypeInfo, Option[InnerClassEntry]] = info.map(i => i.nestedInfo.force map {
       case NestedInfo(_, outerName, innerName, isStaticNestedClass) =>
         InnerClassEntry(
           internalName,
@@ -1066,9 +1073,49 @@ abstract class BTypes {
    * @param inlineInfo    Information about this class for the inliner.
    */
   final case class ClassInfo(superClass: Option[ClassBType], interfaces: List[ClassBType], flags: Int,
-                             nestedClasses: List[ClassBType], nestedInfo: Option[NestedInfo],
+                             nestedClasses: Lazy[List[ClassBType]], nestedInfo: Lazy[Option[NestedInfo]],
                              inlineInfo: InlineInfo)
 
+  object Lazy {
+    def apply[T <: AnyRef](t: => T): Lazy[T] = new Lazy[T](() => t)
+  }
+
+  final class Lazy[T <: AnyRef](t: () => T) {
+    private var value: T = null.asInstanceOf[T]
+
+    private var function = {
+      val tt = t // prevent allocating a field for t
+      () => { value = tt() }
+    }
+
+    override def toString = if (value == null) "<?>" else value.toString
+
+    def onForce(f: T => Unit): Unit = {
+      if (value != null) f(value)
+      else frontendLock.synchronized {
+        if (value != null) f(value)
+        else {
+          val prev = function
+          function = () => {
+            prev()
+            f(value)
+          }
+        }
+      }
+    }
+
+    def force: T = {
+      if (value != null) value
+      else frontendLock.synchronized {
+        if (value == null) {
+          function()
+          function = null
+        }
+        value
+      }
+    }
+  }
+
   /**
    * Information required to add a class to an InnerClass table.
    * The spec summary above explains what information is required for the InnerClass entry.

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

@@ -360,7 +360,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
      * declared but not otherwise referenced in C (from the bytecode or a method / field signature).
      * We collect them here.
      */
-    val nestedClassSymbols = {
+    lazy val nestedClassSymbols = {
       val linkedClass = exitingPickler(classSym.linkedClassOfClass) // linkedCoC does not work properly in late phases
 
       // The lambdalift phase lifts all nested classes to the enclosing class, so if we collect
@@ -432,7 +432,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
      * for A contain both the class B and the module class B.
      * Here we get rid of the module class B, making sure that the class B is present.
      */
-    val nestedClassSymbolsNoJavaModuleClasses = nestedClassSymbols.filter(s => {
+    def nestedClassSymbolsNoJavaModuleClasses = nestedClassSymbols.filter(s => {
       if (s.isJavaDefined && s.isModuleClass) {
         // We could also search in nestedClassSymbols for s.linkedClassOfClass, but sometimes that
         // returns NoSymbol, so it doesn't work.
@@ -442,9 +442,15 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
       } else true
     })
 
-    val nestedClasses = nestedClassSymbolsNoJavaModuleClasses.map(classBTypeFromSymbol)
+    val nestedClasses = {
+      val ph = phase
+      Lazy(enteringPhase(ph)(nestedClassSymbolsNoJavaModuleClasses.map(classBTypeFromSymbol)))
+    }
 
-    val nestedInfo = buildNestedInfo(classSym)
+    val nestedInfo = {
+      val ph = phase
+      Lazy(enteringPhase(ph)(buildNestedInfo(classSym)))
+    }
 
     val inlineInfo = buildInlineInfo(classSym, classBType.internalName)
 
@@ -634,13 +640,13 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     cachedClassBType(internalName).getOrElse({
       val c = ClassBType(internalName)(classBTypeCacheFromSymbol)
       // class info consistent with BCodeHelpers.genMirrorClass
-      val nested = exitingPickler(memberClassesForInnerClassTable(moduleClassSym)) map classBTypeFromSymbol
+      val nested = Lazy(exitingPickler(memberClassesForInnerClassTable(moduleClassSym)) map classBTypeFromSymbol)
       c.info = Right(ClassInfo(
         superClass = Some(ObjectRef),
         interfaces = Nil,
         flags = asm.Opcodes.ACC_SUPER | asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_FINAL,
         nestedClasses = nested,
-        nestedInfo = None,
+        nestedInfo = Lazy(None),
         inlineInfo = EmptyInlineInfo.copy(isEffectivelyFinal = true))) // no method inline infos needed, scala never invokes methods on the mirror class
       c
     })
@@ -654,8 +660,8 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
         superClass = Some(sbScalaBeanInfoRef),
         interfaces = Nil,
         flags = javaFlags(mainClass),
-        nestedClasses = Nil,
-        nestedInfo = None,
+        nestedClasses = Lazy(Nil),
+        nestedInfo = Lazy(None),
         inlineInfo = EmptyInlineInfo))
       c
     })

src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala

@@ -324,7 +324,7 @@ class BackendUtils[BT <: BTypes](val btypes: BT) {
     }
 
     visitInternalName(classNode.name)
-    innerClasses ++= classBTypeFromParsedClassfile(classNode.name).info.get.nestedClasses
+    innerClasses ++= classBTypeFromParsedClassfile(classNode.name).info.get.nestedClasses.force
 
     visitInternalName(classNode.superName)
     classNode.interfaces.asScala foreach visitInternalName

test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala

@@ -6,6 +6,7 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 
+import scala.collection.mutable
 import scala.tools.asm.Opcodes
 import scala.tools.testing.BytecodeTesting
 
@@ -80,6 +81,18 @@ class BTypesTest extends BytecodeTesting {
     }
   }
 
+  @Test
+  def lazyForceTest(): Unit = {
+    val res = new mutable.StringBuilder()
+    val l = Lazy({res append "1"; "hi"})
+    l.onForce(v => res append s"-2:$v")
+    l.onForce(v => res append s"-3:$v:${l.force}") // `force` within `onForce` returns the value
+    assertEquals("<?>", l.toString)
+    assertEquals("hi", l.force)
+    assertEquals("hi", l.toString)
+    assertEquals("1-2:hi-3:hi:hi", res.toString)
+  }
+
   // TODO @lry do more tests
   @Test
   def maxTypeTest() {

test/junit/scala/tools/nsc/backend/jvm/opt/BTypesFromClassfileTest.scala

@@ -6,6 +6,7 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 
+import scala.collection.mutable
 import scala.tools.asm.Opcodes._
 import scala.tools.nsc.backend.jvm.BTypes.InternalName
 import scala.tools.nsc.backend.jvm.BackendReporting._
@@ -52,7 +53,7 @@ class BTypesFromClassfileTest extends BytecodeTesting {
       // Nested class symbols can undergo makeNotPrivate (ExplicitOuter). But this is only applied
       // for symbols of class symbols that are being compiled, not those read from a pickle.
       // So a class may be public in bytecode, but the symbol still says private.
-      if (fromSym.nestedInfo.isEmpty) fromSym.flags == fromClassfile.flags
+      if (fromSym.nestedInfo.force.isEmpty) fromSym.flags == fromClassfile.flags
       else (fromSym.flags | ACC_PRIVATE | ACC_PUBLIC) == (fromClassfile.flags | ACC_PRIVATE | ACC_PUBLIC)
     }, s"class flags differ\n$fromSym\n$fromClassfile")
 
@@ -70,19 +71,38 @@ class BTypesFromClassfileTest extends BytecodeTesting {
     //   and anonymous classes as members of the outer class. But not for unpickled symbols).
     // The fromClassfile info has all nested classes, including anonymous and local. So we filter
     // them out: member classes are identified by having the `outerName` defined.
-    val memberClassesFromClassfile = fromClassfile.nestedClasses.filter(_.info.get.nestedInfo.get.outerName.isDefined)
+    val memberClassesFromClassfile = fromClassfile.nestedClasses.force.filter(_.info.get.nestedInfo.force.get.outerName.isDefined)
     // Sorting is required: the backend sorts all InnerClass entries by internalName before writing
     // them to the classfile (to make it deterministic: the entries are collected in a Set during
     // code generation).
-    val chk3 = sameBTypes(fromSym.nestedClasses.sortBy(_.internalName), memberClassesFromClassfile.sortBy(_.internalName), chk2)
-    sameBTypes(fromSym.nestedInfo.map(_.enclosingClass), fromClassfile.nestedInfo.map(_.enclosingClass), chk3)
+    val chk3 = sameBTypes(fromSym.nestedClasses.force.sortBy(_.internalName), memberClassesFromClassfile.sortBy(_.internalName), chk2)
+    sameBTypes(fromSym.nestedInfo.force.map(_.enclosingClass), fromClassfile.nestedInfo.force.map(_.enclosingClass), chk3)
+  }
+
+  // Force all lazy components of a `ClassBType`.
+  def forceLazy(classBType: ClassBType, done: mutable.Set[ClassBType] = mutable.Set.empty): Unit = {
+    if (!done(classBType)) {
+      done += classBType
+      val i = classBType.info.get
+      i.superClass.foreach(forceLazy(_, done))
+      i.interfaces.foreach(forceLazy(_, done))
+      i.nestedClasses.force.foreach(forceLazy(_, done))
+      i.nestedInfo.force.foreach(n => forceLazy(n.enclosingClass, done))
+    }
   }
 
   def check(classSym: Symbol): Unit = duringBackend {
     clearCache()
     val fromSymbol = classBTypeFromSymbol(classSym)
+    // We need to force all lazy components to ensure that all referenced `ClassBTypes` are
+    // constructed from symbols. If we keep them lazy, a `ClassBType` might be constructed from a
+    // classfile first and then picked up cachedClassBType and added to the `fromSymbol` type.
+    forceLazy(fromSymbol)
+
     clearCache()
-    val fromClassfile = bTypes.classBTypeFromParsedClassfile(fromSymbol.internalName)
+    val fromClassfile = classBTypeFromParsedClassfile(fromSymbol.internalName)
+    forceLazy(fromClassfile)
+
     sameBType(fromSymbol, fromClassfile)
   }