Cache (potential) jsSuperClass tree separately

gzm0 · gzm0 · commit afef6bd76984 · 2024-01-28T16:44:15.000+01:00
This removes the only desugarExpr call from buildClass. Since we'll
stop caching buildClass going forward, this is important.
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/ClassEmitter.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/ClassEmitter.scala
@@ -45,13 +45,13 @@ private[emitter] final class ClassEmitter(sjsGen: SJSGen) {
 
   def buildClass(className: ClassName, isJSClass: Boolean, jsClassCaptures: Option[List[ParamDef]],
       hasClassInitializer: Boolean,
-      superClass: Option[ClassIdent], jsSuperClass: Option[Tree], useESClass: Boolean,
+      superClass: Option[ClassIdent], storeJSSuperClass: Option[js.Tree], useESClass: Boolean,
       members: List[js.Tree])(
       implicit moduleContext: ModuleContext,
       globalKnowledge: GlobalKnowledge, pos: Position): WithGlobals[List[js.Tree]] = {
 
     if (!isJSClass) {
-      assert(jsSuperClass.isEmpty, className)
+      assert(storeJSSuperClass.isEmpty, className)
 
       if (useESClass) {
         val parentVarWithGlobals = for (parentIdent <- superClass) yield {
@@ -70,30 +70,23 @@ private[emitter] final class ClassEmitter(sjsGen: SJSGen) {
       // Wrap the entire class def in an accessor function
       import TreeDSL._
 
-      val genStoreJSSuperClass = jsSuperClass.map { jsSuperClass =>
-        for (rhs <- desugarExpr(jsSuperClass, resultType = AnyType)) yield {
-          js.VarDef(fileLevelVar(VarField.superClass).ident, Some(rhs))
-        }
-      }
-
       val classValueIdent = fileLevelVarIdent(VarField.b, genName(className))
       val classValueVar = js.VarRef(classValueIdent)
       val createClassValueVar = genEmptyMutableLet(classValueIdent)
 
       val entireClassDefWithGlobals = if (useESClass) {
-        genJSSuperCtor(superClass, jsSuperClass).map { jsSuperClass =>
+        genJSSuperCtor(superClass, storeJSSuperClass.isDefined).map { jsSuperClass =>
           List(classValueVar := js.ClassDef(Some(classValueIdent), Some(jsSuperClass), members))
         }
       } else {
         WithGlobals(members)
       }
 
       val classDefStatsWithGlobals = for {
-        optStoreJSSuperClass <- WithGlobals.option(genStoreJSSuperClass)
         entireClassDef <- entireClassDefWithGlobals
         createStaticFields <- genCreateStaticFieldsOfJSClass(className)
       } yield {
-        optStoreJSSuperClass.toList ::: entireClassDef ::: createStaticFields
+        storeJSSuperClass.toList ::: entireClassDef ::: createStaticFields
       }
 
       jsClassCaptures.fold {
@@ -225,7 +218,7 @@ private[emitter] final class ClassEmitter(sjsGen: SJSGen) {
 
   /** Generates the JS constructor for a JS class. */
   def genJSConstructor(className: ClassName, superClass: Option[ClassIdent],
-      jsSuperClass: Option[Tree], useESClass: Boolean, jsConstructorDef: JSConstructorDef)(
+      hasJSSuperClass: Boolean, useESClass: Boolean, jsConstructorDef: JSConstructorDef)(
       implicit moduleContext: ModuleContext,
       globalKnowledge: GlobalKnowledge, pos: Position): WithGlobals[List[js.Tree]] = {
 
@@ -240,7 +233,7 @@ private[emitter] final class ClassEmitter(sjsGen: SJSGen) {
     } else {
       for {
         ctorFun <- ctorFunWithGlobals
-        superCtor <- genJSSuperCtor(superClass, jsSuperClass)
+        superCtor <- genJSSuperCtor(superClass, hasJSSuperClass)
       } yield {
         import TreeDSL._
 
@@ -254,16 +247,24 @@ private[emitter] final class ClassEmitter(sjsGen: SJSGen) {
     }
   }
 
-  private def genJSSuperCtor(superClass: Option[ClassIdent], jsSuperClass: Option[Tree])(
+  private def genJSSuperCtor(superClass: Option[ClassIdent], hasJSSuperClass: Boolean)(
       implicit moduleContext: ModuleContext, globalKnowledge: GlobalKnowledge,
       pos: Position): WithGlobals[js.Tree] = {
-    if (jsSuperClass.isDefined) {
+    if (hasJSSuperClass) {
       WithGlobals(fileLevelVar(VarField.superClass))
     } else {
       genJSClassConstructor(superClass.get.name, keepOnlyDangerousVarNames = true)
     }
   }
 
+  def genStoreJSSuperClass(jsSuperClass: Tree)(
+      implicit moduleContext: ModuleContext, globalKnowledge: GlobalKnowledge,
+      pos: Position): WithGlobals[js.Tree] = {
+    for (rhs <- desugarExpr(jsSuperClass, resultType = AnyType)) yield {
+      js.VarDef(fileLevelVar(VarField.superClass).ident, Some(rhs))
+    }
+  }
+
   /** Generates the JavaScript constructor of a class, as a `js.Function`.
    *
    *  For ECMAScript 2015, that `js.Function` must be decomposed and reformed
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/Emitter.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/Emitter.scala
@@ -447,6 +447,13 @@ final class Emitter(config: Emitter.Config) {
         (isJSClass || linkedClass.ancestors.contains(ThrowableClass))
       }
 
+      val hasJSSuperClass = linkedClass.jsSuperClass.isDefined
+
+      val storeJSSuperClass = linkedClass.jsSuperClass.map { jsSuperClass =>
+        extractWithGlobals(classTreeCache.storeJSSuperClass.getOrElseUpdate(
+            classEmitter.genStoreJSSuperClass(jsSuperClass)(moduleContext, classCache, linkedClass.pos)))
+      }
+
       // JS constructor
       val ctorWithGlobals = {
         /* The constructor depends both on the class version, and the version
@@ -468,7 +475,7 @@ final class Emitter(config: Emitter.Config) {
               classEmitter.genJSConstructor(
                 className, // invalidated by overall class cache (part of ancestors)
                 linkedClass.superClass, // invalidated by class version
-                linkedClass.jsSuperClass, // invalidated by class version
+                hasJSSuperClass, // invalidated by class version
                 useESClass, // invalidated by class version
                 jsConstructorDef // part of ctor version
               )(moduleContext, ctorCache, linkedClass.pos))
@@ -579,7 +586,7 @@ final class Emitter(config: Emitter.Config) {
               linkedClass.jsClassCaptures, // invalidated by class version
               hasClassInitializer, // invalidated by class version (optimizer cannot remove it)
               linkedClass.superClass, // invalidated by class version
-              linkedClass.jsSuperClass, // invalidated by class version
+              storeJSSuperClass, // invalidated by class version
               useESClass, // invalidated by class version (depends on kind, config and ancestry only)
               ctor ::: memberMethods ::: exportedMembers.flatten // all 3 invalidated directly
             )(moduleContext, fullClassCache, linkedClass.pos) // pos invalidated by class version
@@ -1047,6 +1054,7 @@ object Emitter {
 
   private final class DesugaredClassCache {
     val privateJSFields = new OneTimeCache[WithGlobals[List[js.Tree]]]
+    val storeJSSuperClass = new OneTimeCache[WithGlobals[js.Tree]]
     val instanceTests = new OneTimeCache[WithGlobals[List[js.Tree]]]
     val typeData = new OneTimeCache[WithGlobals[List[js.Tree]]]
     val setTypeData = new OneTimeCache[js.Tree]
