Implement support for classOf.

Including elementary support of methods of `java.lang.Class`.

We implement this in a way that is similar to the JavaScript
back-end: we have an internal `typeData` structure, which contains
the raw metadata that will be needed by a `java.lang.Class`
instance. It also contains a lazily evaluated pointer to the
unique `java.lang.Class` and the `typeData` of an array of that
type. If we need the `typeData` of a multi-dimensional array, we
follow the chain of `arrayOf` pointers.

The name is initially stored as an `(array u16)` so that it can be
initialized as a constant expression in globals. The `string`
value is lazily initialized from that raw data the first time it
is requested.

This machinery requires quite a bit of run-time helper functions.
These are hard-coded in `HelperFunctions.scala`. Again, this is
similar to the JS back-end, which defines a bunch of helper JS
functions in its `CoreJSLib.scala`.

The `typeData` of classes that have a `vtable` are inserted into
the `vtable` itself, making the latter a subtype of `typeData`.
This is done in anticipation of the support for `GetClass`: it
will be able to fetch the `vtable` field of the object as the
`typeData` from which to extract the `java.lang.Class` instance.
The `typeData` of other classes are stored as independent
globals.

Author: sjrd

Diff for: cli/src/main/scala/TestSuites.scala

@@ -8,6 +8,7 @@ object TestSuites {
     TestSuite("testsuite.core.VirtualDispatch"),
     TestSuite("testsuite.core.InterfaceCall"),
     TestSuite("testsuite.core.AsInstanceOfTest"),
+    TestSuite("testsuite.core.ClassOfTest"),
     TestSuite("testsuite.core.JSInteropTest"),
     TestSuite("testsuite.core.HijackedClassesDispatchTest"),
     TestSuite("testsuite.core.HijackedClassesMonoTest"),

Diff for: loader.mjs

@@ -61,6 +61,9 @@ const scalaJSHelpers = {
   tF: (x) => typeof x === 'number' && (Math.fround(x) === x || x !== x),
   tD: (x) => typeof x === 'number',
 
+  // Closure
+  closure: (f, data) => f.bind(void 0, data),
+
   // Strings
   emptyString: () => "",
   stringLength: (s) => s.length,

Diff for: test-suite/src/main/scala/testsuite/Assert.scala

@@ -14,4 +14,7 @@ package testsuite
 object Assert {
   def ok(cond: Boolean): Unit =
     if (!cond) null.toString() // Apply to Null should compile to unreachable
+
+  def assertSame(expected: Any, actual: Any): Unit =
+    ok(expected.asInstanceOf[AnyRef] eq actual.asInstanceOf[AnyRef])
 }

Diff for: test-suite/src/main/scala/testsuite/core/ClassOfTest.scala

@@ -0,0 +1,117 @@
+package testsuite.core
+
+import testsuite.Assert.ok
+import testsuite.Assert
+
+object ClassOfTest {
+  def main(): Unit = {
+    testGetName()
+    testUniqueness()
+    testIsPrimitive()
+    testIsInterface()
+    testIsArray()
+    testGetComponentType()
+  }
+
+  def testGetName(): Unit = {
+    Assert.assertSame("java.lang.String", classOf[String].getName())
+    Assert.assertSame("java.lang.StringBuilder", classOf[java.lang.StringBuilder].getName())
+    Assert.assertSame("int", classOf[Int].getName())
+    Assert.assertSame("void", classOf[Unit].getName())
+
+    Assert.assertSame("[Ljava.lang.Object;", classOf[Array[AnyRef]].getName())
+    Assert.assertSame("[Ljava.lang.String;", classOf[Array[String]].getName())
+    Assert.assertSame("[[Ljava.lang.CharSequence;", classOf[Array[Array[CharSequence]]].getName())
+
+    Assert.assertSame("[Z", classOf[Array[Boolean]].getName())
+    Assert.assertSame("[C", classOf[Array[Char]].getName())
+    Assert.assertSame("[B", classOf[Array[Byte]].getName())
+    Assert.assertSame("[S", classOf[Array[Short]].getName())
+    Assert.assertSame("[I", classOf[Array[Int]].getName())
+    Assert.assertSame("[J", classOf[Array[Long]].getName())
+    Assert.assertSame("[F", classOf[Array[Float]].getName())
+    Assert.assertSame("[D", classOf[Array[Double]].getName())
+  }
+
+  def testUniqueness(): Unit = {
+    Assert.assertSame(classOf[String], classOf[String])
+    Assert.assertSame(classOf[java.lang.StringBuilder], classOf[java.lang.StringBuilder])
+    Assert.assertSame(classOf[CharSequence], classOf[CharSequence])
+    Assert.assertSame(classOf[Int], classOf[Int])
+
+    Assert.assertSame(classOf[Array[Int]], classOf[Array[Int]])
+    Assert.assertSame(classOf[Array[Array[java.lang.Byte]]], classOf[Array[Array[java.lang.Byte]]])
+    Assert.assertSame(classOf[Array[Array[Int]]], classOf[Array[Array[Int]]])
+  }
+
+  def testIsPrimitive(): Unit = {
+    Assert.assertSame(false, classOf[AnyRef].isPrimitive())
+    Assert.assertSame(false, classOf[String].isPrimitive())
+    Assert.assertSame(false, classOf[CharSequence].isPrimitive())
+    Assert.assertSame(false, classOf[java.lang.Iterable[Any]].isPrimitive())
+    Assert.assertSame(false, classOf[Array[Int]].isPrimitive())
+    Assert.assertSame(false, classOf[Array[String]].isPrimitive())
+    Assert.assertSame(false, classOf[Array[CharSequence]].isPrimitive())
+
+    Assert.assertSame(true, classOf[Int].isPrimitive())
+    Assert.assertSame(true, classOf[Unit].isPrimitive())
+  }
+
+  def testIsInterface(): Unit = {
+    Assert.assertSame(false, classOf[AnyRef].isInterface())
+    Assert.assertSame(false, classOf[String].isInterface())
+    Assert.assertSame(false, classOf[Int].isInterface())
+    Assert.assertSame(false, classOf[Array[Int]].isInterface())
+    Assert.assertSame(false, classOf[Array[String]].isInterface())
+    Assert.assertSame(false, classOf[Array[CharSequence]].isInterface())
+
+    Assert.assertSame(true, classOf[CharSequence].isInterface())
+    Assert.assertSame(true, classOf[java.lang.Iterable[Any]].isInterface())
+  }
+
+  def testIsArray(): Unit = {
+    Assert.assertSame(false, classOf[AnyRef].isArray())
+    Assert.assertSame(false, classOf[String].isArray())
+    Assert.assertSame(false, classOf[Int].isArray())
+    Assert.assertSame(false, classOf[CharSequence].isArray())
+    Assert.assertSame(false, classOf[java.lang.Iterable[Any]].isArray())
+
+    Assert.assertSame(true, classOf[Array[Int]].isArray())
+    Assert.assertSame(true, classOf[Array[String]].isArray())
+    Assert.assertSame(true, classOf[Array[CharSequence]].isArray())
+  }
+
+  def testGetComponentType(): Unit = {
+    Assert.assertSame(null, classOf[AnyRef].getComponentType())
+    Assert.assertSame(null, classOf[String].getComponentType())
+    Assert.assertSame(null, classOf[Int].getComponentType())
+    Assert.assertSame(null, classOf[CharSequence].getComponentType())
+    Assert.assertSame(null, classOf[java.lang.Iterable[Any]].getComponentType())
+
+    Assert.assertSame(classOf[Int], classOf[Array[Int]].getComponentType())
+    Assert.assertSame(classOf[String], classOf[Array[String]].getComponentType())
+    Assert.assertSame(classOf[AnyRef], classOf[Array[AnyRef]].getComponentType())
+
+    Assert.assertSame(
+      classOf[Array[CharSequence]],
+      classOf[Array[Array[CharSequence]]].getComponentType()
+    )
+
+    Assert.assertSame(
+      classOf[Array[Long]],
+      classOf[Array[Array[Long]]].getComponentType()
+    )
+
+    Assert.assertSame(
+      classOf[Array[Array[java.lang.Byte]]],
+      classOf[Array[Array[Array[java.lang.Byte]]]].getComponentType()
+    )
+
+    Assert.assertSame(
+      classOf[Array[ClassForUniqueGetComponentTypeTest]].getComponentType(),
+      classOf[Array[ClassForUniqueGetComponentTypeTest]].getComponentType()
+    )
+  }
+
+  class ClassForUniqueGetComponentTypeTest
+}

Diff for: wasm/src/main/scala/Compiler.scala

@@ -4,8 +4,7 @@ import wasm.ir2wasm._
 import wasm.wasm4s._
 
 import org.scalajs.ir
-import org.scalajs.ir.Trees._
-import org.scalajs.ir.Types._
+import org.scalajs.ir.{Names => IRNames}
 
 import org.scalajs.linker.interface._
 import org.scalajs.linker.standard._
@@ -46,6 +45,7 @@ object Compiler {
      */
     val factory = SymbolRequirement.factory("wasm")
     val symbolRequirements = factory.multiple(
+      factory.instantiateClass(IRNames.ClassClass, SpecialNames.ClassCtor),
       factory.instantiateClass(SpecialNames.CharBoxClass, SpecialNames.CharBoxCtor),
       factory.instantiateClass(SpecialNames.LongBoxClass, SpecialNames.LongBoxCtor)
     )
@@ -70,6 +70,8 @@ object Compiler {
 
       Preprocessor.preprocess(sortedClasses)(context)
       println("preprocessed")
+      HelperFunctions.genGlobalHelpers()
+      builder.genPrimitiveTypeDataGlobals()
       sortedClasses.foreach { clazz =>
         builder.transformClassDef(clazz)
       }