Fix #4616: Proper static dependency tracking for jl.Class

Author: gzm0

Diff for: linker/jvm/src/test/scala/org/scalajs/linker/RunTest.scala

@@ -0,0 +1,80 @@
+/*
+ * Scala.js (https://www.scala-js.org/)
+ *
+ * Copyright EPFL.
+ *
+ * Licensed under Apache License 2.0
+ * (https://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package org.scalajs.linker
+
+import scala.concurrent._
+import scala.concurrent.duration._
+
+import java.nio.file.Path
+
+import org.junit.{Rule, Test}
+import org.junit.Assert._
+import org.junit.rules.TemporaryFolder
+
+import org.scalajs.ir.Trees._
+
+import org.scalajs.junit.async._
+
+import org.scalajs.jsenv.nodejs.NodeJSEnv
+import org.scalajs.jsenv.test.kit.TestKit
+
+import org.scalajs.linker.interface._
+import org.scalajs.linker.testutils.LinkingUtils._
+import org.scalajs.linker.testutils.TestIRBuilder._
+
+class RunTest {
+  import scala.concurrent.ExecutionContext.Implicits.global
+
+  @(Rule @scala.annotation.meta.getter)
+  val tempFolder = new TemporaryFolder()
+
+  @Test
+  def jlClassIsCore_Issue4616(): AsyncResult = await {
+    // Check that if jl.Class is instantiated, it must be depended upon by jl.Object.
+
+    val classDefs = Seq(
+      mainTestClassDef({
+        consoleLog(ClassOf(T))
+      })
+    )
+
+    val linkerConfig = StandardConfig()
+      .withModuleKind(ModuleKind.ESModule)
+      .withModuleSplitStyle(ModuleSplitStyle.SmallestModules)
+      .withSourceMap(false)
+      .withOutputPatterns(OutputPatterns.fromJSFile("%s.mjs"))
+
+    testLinkAndRun(classDefs, MainTestModuleInitializers, linkerConfig,
+        TestKit.InputKind.ESModule)
+  }
+
+  private def testLinkAndRun(classDefs: Seq[ClassDef],
+      moduleInitializers: List[ModuleInitializer],
+      linkerConfig: StandardConfig, inputKind: TestKit.InputKind): Future[Unit] = {
+    val output = tempFolder.newFolder().toPath
+
+    val kit = new TestKit(new NodeJSEnv, timeout = 2.seconds, inputKind)
+
+    for {
+      report <- testLink(classDefs, moduleInitializers, linkerConfig, PathOutputDirectory(output))
+    } yield {
+      assertEquals(report.publicModules.size, 1)
+
+      val path = output.resolve(report.publicModules.head.jsFileName)
+
+      kit.withRun(Seq(kit.pathToInput(path))) {
+        _.succeeds()
+      }
+    }
+  }
+}

Diff for: linker/shared/src/main/scala/org/scalajs/linker/analyzer/Analyzer.scala

@@ -1270,6 +1270,17 @@ private final class Analyzer(config: CommonPhaseConfig,
       lookupClass(className)(_.accessData())
     }
 
+    if (data.accessedClassClass) {
+      /* java.lang.Class is only ever instantiated in the CoreJSLib.
+       * Therefore, make java.lang.Object depend on it instead of the caller itself.
+       */
+      objectClassInfo.staticDependencies += ClassClass
+      lookupClass(ClassClass) { clazz =>
+        clazz.instantiated()
+        clazz.callMethodStatically(MemberNamespace.Constructor, ObjectArgConstructorName)
+      }
+    }
+
     for (className <- data.referencedClasses) {
       /* No need to add to staticDependencies: The classes will not be
        * referenced in the final JS code.

Diff for: linker/shared/src/main/scala/org/scalajs/linker/analyzer/Infos.scala

@@ -90,6 +90,7 @@ object Infos {
       val usedInstanceTests: List[ClassName],
       val accessedClassData: List[ClassName],
       val referencedClasses: List[ClassName],
+      val accessedClassClass: Boolean,
       val accessedNewTarget: Boolean,
       val accessedImportMeta: Boolean
   )
@@ -98,7 +99,7 @@ object Infos {
     val Empty: ReachabilityInfo = {
       new ReachabilityInfo(Map.empty, Map.empty, Map.empty, Map.empty,
           Map.empty, Map.empty, Map.empty, Nil, Nil, Nil, Nil, Nil, false,
-          false)
+          false, false)
     }
   }
 
@@ -161,6 +162,7 @@ object Infos {
     private val usedInstanceTests = mutable.Set.empty[ClassName]
     private val accessedClassData = mutable.Set.empty[ClassName]
     private val referencedClasses = mutable.Set.empty[ClassName]
+    private var accessedClassClass = false
     private var accessedNewTarget = false
     private var accessedImportMeta = false
 
@@ -311,6 +313,11 @@ object Infos {
       this
     }
 
+    def addAccessedClassClass(): this.type = {
+      accessedClassClass = true
+      this
+    }
+
     def addAccessNewTarget(): this.type = {
       accessedNewTarget = true
       this
@@ -338,6 +345,7 @@ object Infos {
           usedInstanceTests = usedInstanceTests.toList,
           accessedClassData = accessedClassData.toList,
           referencedClasses = referencedClasses.toList,
+          accessedClassClass = accessedClassClass,
           accessedNewTarget = accessedNewTarget,
           accessedImportMeta = accessedImportMeta
       )
@@ -570,13 +578,10 @@ object Infos {
 
             case ClassOf(cls) =>
               builder.maybeAddAccessedClassData(cls)
-
-              // `ClassOf` instantiates a java.lang.Class.
-              builder.addInstantiatedClass(ClassClass, ObjectArgConstructorName)
+              builder.addAccessedClassClass()
 
             case GetClass(_) =>
-              // `GetClass` instantiates a java.lang.Class.
-              builder.addInstantiatedClass(ClassClass, ObjectArgConstructorName)
+              builder.addAccessedClassClass()
 
             case JSPrivateSelect(qualifier, className, field) =>
               builder.addPrivateJSFieldUsed(className, field.name)

Diff for: project/Build.scala

@@ -979,7 +979,8 @@ object Build {
       libraryDependencies ++= Seq(
           "com.google.javascript" % "closure-compiler" % "v20211201",
           "com.google.jimfs" % "jimfs" % "1.1" % "test",
-          "org.scala-js" %% "scalajs-env-nodejs" % "1.3.0" % "test"
+          "org.scala-js" %% "scalajs-env-nodejs" % "1.3.0" % "test",
+          "org.scala-js" %% "scalajs-js-envs-test-kit" % "1.3.0" % "test"
       ) ++ (
           parallelCollectionsDependencies(scalaVersion.value)
       ),