Implement GetClass.

When the value is one of our objects, we look at its `vtable`
field, which is also the appropriate `typeData` reference.

When it is a JS value, we implement the dispatch in a dedicated
helper function.

Author: sjrd

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

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

Diff for: loader.mjs

@@ -77,6 +77,32 @@ const scalaJSHelpers = {
   stringConcat: (x, y) => ("" + x) + y, // the added "" is for the case where x === y === null
   isString: (x) => typeof x === 'string',
 
+  /* Get the type of JS value of `x` in a single JS helper call, for the purpose of dispatch.
+   *
+   * 0: false
+   * 1: true
+   * 2: string
+   * 3: number
+   * 4: undefined
+   * 5: everything else
+   *
+   * This encoding has the following properties:
+   *
+   * - false and true also return their value as the appropriate i32.
+   * - the types implementing `Comparable` are consecutive from 0 to 3.
+   */
+  jsValueType: (x) => {
+    if (typeof x === 'number')
+      return 3;
+    if (typeof x === 'string')
+      return 2;
+    if (typeof x === 'boolean')
+      return x | 0;
+    if (typeof x === 'undefined')
+      return 4;
+    return 5;
+  },
+
   // Hash code, because it is overridden in all hijacked classes
   // Specified by the hashCode() method of the corresponding hijacked classes
   jsValueHashCode: (x) => {

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

@@ -0,0 +1,52 @@
+package testsuite.core
+
+import testsuite.Assert.assertSame
+
+object GetClassTest {
+  def main(): Unit = {
+    testNoHijackedDispatch()
+    testWithHijackedDispath()
+  }
+
+  class Foo
+
+  class Bar extends Foo
+
+  def testNoHijackedDispatch(): Unit = {
+    def getClassOfFoo(x: Foo): Class[_] = x.getClass()
+
+    assertSame(classOf[Foo], getClassOfFoo(new Foo))
+    assertSame(classOf[Bar], getClassOfFoo(new Bar))
+  }
+
+  def testWithHijackedDispath(): Unit = {
+    def getClassOf(x: Any): Class[_] = x.getClass()
+
+    assertSame(classOf[Foo], getClassOf(new Foo))
+    assertSame(classOf[Bar], getClassOf(new Bar))
+
+    assertSame(classOf[java.lang.Boolean], getClassOf(true))
+    assertSame(classOf[java.lang.Boolean], getClassOf(false))
+    assertSame(classOf[java.lang.Void], getClassOf(()))
+    assertSame(classOf[java.lang.String], getClassOf("foo"))
+
+    assertSame(classOf[java.lang.Byte], getClassOf(0.0))
+    assertSame(classOf[java.lang.Byte], getClassOf(56))
+    assertSame(classOf[java.lang.Byte], getClassOf(-128))
+    assertSame(classOf[java.lang.Short], getClassOf(200))
+    assertSame(classOf[java.lang.Short], getClassOf(-32000))
+    assertSame(classOf[java.lang.Integer], getClassOf(500000))
+    assertSame(classOf[java.lang.Integer], getClassOf(Int.MinValue))
+
+    assertSame(classOf[java.lang.Float], getClassOf(1.5))
+    assertSame(classOf[java.lang.Double], getClassOf(1.4))
+    assertSame(classOf[java.lang.Double], getClassOf(Float.MaxValue.toDouble * 8.0))
+
+    assertSame(classOf[java.lang.Float], getClassOf(-0.0))
+    assertSame(classOf[java.lang.Float], getClassOf(Double.PositiveInfinity))
+    assertSame(classOf[java.lang.Float], getClassOf(Double.NegativeInfinity))
+    assertSame(classOf[java.lang.Float], getClassOf(Double.NaN))
+
+    assertSame(null, getClassOf(scala.scalajs.js.Math))
+  }
+}

Diff for: wasm/src/main/scala/converters/WasmBinaryWriter.scala

@@ -278,7 +278,7 @@ final class WasmBinaryWriter(module: WasmModule) {
 
       case FuncIdx(value)        => writeFuncIdx(buf, value)
       case labelIdx: LabelIdx    => writeLabelIdx(buf, labelIdx)
-      case LabelIdxVector(value) => ???
+      case LabelIdxVector(value) => buf.vec(value)(writeLabelIdx(buf, _))
       case TypeIdx(value)        => writeTypeIdx(buf, value)
       case TableIdx(value)       => ???
       case TagIdx(value)         => ???

Diff for: wasm/src/main/scala/converters/WasmTextWriter.scala

@@ -223,11 +223,19 @@ class WasmTextWriter {
   }
 
   private def writeImmediate(i: WasmImmediate, instr: WasmInstr)(implicit b: WatBuilder): Unit = {
+    def floatString(v: Double): String = {
+      if (v.isNaN()) "nan"
+      else if (v == Double.PositiveInfinity) "inf"
+      else if (v == Double.NegativeInfinity) "-inf"
+      else if (v.equals(-0.0)) "-0.0"
+      else v.toString()
+    }
+
     val str = i match {
       case WasmImmediate.I64(v)          => v.toString()
       case WasmImmediate.I32(v)          => v.toString()
-      case WasmImmediate.F64(v)          => v.toString()
-      case WasmImmediate.F32(v)          => v.toString()
+      case WasmImmediate.F64(v)          => floatString(v)
+      case WasmImmediate.F32(v)          => floatString(v.toDouble)
       case WasmImmediate.LocalIdx(name)  => name.show
       case WasmImmediate.GlobalIdx(name) => name.show
       case WasmImmediate.HeapType(ht) =>
@@ -245,6 +253,8 @@ class WasmTextWriter {
       case WasmImmediate.BlockType.ValueType(optTy) =>
         optTy.fold("") { ty => s"(result ${ty.show})" }
       case WasmImmediate.LabelIdx(i) => s"$$${i.toString}" // `loop 0` seems to be invalid
+      case WasmImmediate.LabelIdxVector(indices) =>
+        indices.map(i => "$" + i.value).mkString(" ")
       case i: WasmImmediate.CastFlags =>
         throw new UnsupportedOperationException(s"CastFlags $i must be handled directly in the instruction $instr")
       case _ =>

Diff for: wasm/src/main/scala/ir2wasm/HelperFunctions.scala

@@ -18,8 +18,10 @@ object HelperFunctions {
     genCreateStringFromData()
     genTypeDataName()
     genCreateClassOf()
+    genGetClassOf()
     genArrayTypeData()
     genGetComponentType()
+    genAnyGetClass()
   }
 
   /** `createStringFromData: (ref array u16) -> (ref any)` (representing a `string`). */
@@ -338,6 +340,43 @@ object HelperFunctions {
     fctx.buildAndAddToContext()
   }
 
+  /** `getClassOf: (ref typeData) -> (ref jlClass)`.
+   *
+   *  Initializes the `java.lang.Class` instance associated with the given
+   *  `typeData` if not already done, and returns it.
+   *
+   *  This includes the fast-path and the slow-path to `createClassOf`, for
+   *  call sites that are not performance-sensitive.
+   */
+  private def genGetClassOf()(implicit ctx: WasmContext): Unit = {
+    import WasmImmediate._
+    import WasmTypeName.WasmStructTypeName
+
+    val typeDataType = WasmRefType(WasmHeapType.Type(WasmStructType.typeData.name))
+
+    val fctx = WasmFunctionContext(
+      WasmFunctionName.getClassOf,
+      List("typeData" -> typeDataType),
+      List(WasmRefType(WasmHeapType.ClassType))
+    )
+
+    val List(typeDataParam) = fctx.paramIndices
+
+    import fctx.instrs
+
+    fctx.block(WasmRefType(WasmHeapType.ClassType)) { alreadyInitializedLabel =>
+      // fast path
+      instrs += LOCAL_GET(typeDataParam)
+      instrs += STRUCT_GET(TypeIdx(WasmStructTypeName.typeData), WasmFieldName.typeData.classOfIdx)
+      instrs += BR_ON_NON_NULL(alreadyInitializedLabel)
+      // slow path
+      instrs += LOCAL_GET(typeDataParam)
+      instrs += CALL(FuncIdx(WasmFunctionName.createClassOf))
+    } // end bock alreadyInitializedLabel
+
+    fctx.buildAndAddToContext()
+  }
+
   /** `arrayTypeData: (ref typeData), i32 -> (ref typeData)`.
    *
    *  Returns the typeData of an array with `dims` dimensions over the given
@@ -434,24 +473,186 @@ object HelperFunctions {
     val componentTypeDataLocal = fctx.addLocal("componentTypeData", typeDataType)
 
     fctx.block() { nullResultLabel =>
-      fctx.block(Types.WasmRefType(Types.WasmHeapType.ClassType)) { nonNullClassOfLabel =>
-        // Try and extract non-null component type data
-        instrs += LOCAL_GET(typeDataParam)
-        instrs += STRUCT_GET(TypeIdx(WasmStructTypeName.typeData), WasmFieldName.typeData.componentTypeIdx)
-        instrs += BR_ON_NULL(nullResultLabel)
-        // fast path
-        instrs += LOCAL_TEE(componentTypeDataLocal)
-        instrs += STRUCT_GET(TypeIdx(WasmStructTypeName.typeData), WasmFieldName.typeData.classOfIdx)
-        instrs += BR_ON_NON_NULL(nonNullClassOfLabel)
-        // slow path
-        instrs += LOCAL_GET(componentTypeDataLocal)
-        instrs += CALL(FuncIdx(WasmFunctionName.createClassOf))
-      } // end bock nonNullClassOfLabel
+      // Try and extract non-null component type data
+      instrs += LOCAL_GET(typeDataParam)
+      instrs += STRUCT_GET(TypeIdx(WasmStructTypeName.typeData), WasmFieldName.typeData.componentTypeIdx)
+      instrs += BR_ON_NULL(nullResultLabel)
+      // Get the corresponding classOf
+      instrs += CALL(FuncIdx(WasmFunctionName.getClassOf))
       instrs += RETURN
     } // end block nullResultLabel
     instrs += REF_NULL(HeapType(WasmHeapType.ClassType))
 
     fctx.buildAndAddToContext()
   }
 
+  /** `anyGetClass: (ref any) -> (ref null jlClass)`.
+   *
+   *  This is the implementation of `value.getClass()` when `value` can be an
+   *  instance of a hijacked class, i.e., a primitive.
+   *
+   *  For `number`s, the result is based on the actual value, as specified by
+   *  [[https://www.scala-js.org/doc/semantics.html#getclass]].
+   */
+  private def genAnyGetClass()(implicit ctx: WasmContext): Unit = {
+    import WasmImmediate._
+    import WasmTypeName.WasmStructTypeName
+
+    val typeDataType = WasmRefType(WasmHeapType.Type(WasmStructType.typeData.name))
+
+    val fctx = WasmFunctionContext(
+      WasmFunctionName.anyGetClass,
+      List("value" -> WasmRefType.any),
+      List(WasmRefNullType(WasmHeapType.ClassType))
+    )
+
+    val List(valueParam) = fctx.paramIndices
+
+    import fctx.instrs
+
+    val objectTypeIdx = TypeIdx(WasmStructTypeName(IRNames.ObjectClass))
+    val typeDataLocal = fctx.addLocal("typeData", typeDataType)
+    val doubleValueLocal = fctx.addLocal("doubleValue", WasmFloat64)
+    val intValueLocal = fctx.addLocal("intValue", WasmInt32)
+
+    def getHijackedClassTypeDataInstr(className: IRNames.ClassName): WasmInstr =
+      GLOBAL_GET(GlobalIdx(WasmGlobalName.WasmGlobalVTableName(IRTypes.ClassRef(className))))
+
+    fctx.block(WasmRefNullType(WasmHeapType.ClassType)) { nonNullClassOfLabel =>
+      fctx.block(typeDataType) { gotTypeDataLabel =>
+        fctx.block(WasmRefType(WasmHeapType.ObjectType)) { ourObjectLabel =>
+          // if value is our object, jump to $ourObject
+          instrs += LOCAL_GET(valueParam)
+          instrs += BR_ON_CAST(
+            CastFlags(false, false),
+            ourObjectLabel,
+            WasmImmediate.HeapType(WasmHeapType.Simple.Any),
+            WasmImmediate.HeapType(WasmHeapType.ObjectType)
+          )
+
+          // switch(jsValueType(value)) { ... }
+          fctx.block() { typeOtherLabel =>
+            fctx.block() { typeUndefinedLabel =>
+              fctx.block() { typeNumberLabel =>
+                fctx.block() { typeStringLabel =>
+                  fctx.block() { typeBooleanLabel =>
+                    instrs += LOCAL_GET(valueParam)
+                    instrs += CALL(FuncIdx(WasmFunctionName.jsValueType))
+                    instrs += BR_TABLE(LabelIdxVector(List(
+                      typeBooleanLabel, // 0
+                      typeBooleanLabel, // 1
+                      typeStringLabel, // 2
+                      typeNumberLabel, // 3
+                      typeUndefinedLabel, // 4
+                    )), typeOtherLabel)
+                  }
+
+                  // typeBoolean:
+                  instrs += getHijackedClassTypeDataInstr(IRNames.BoxedBooleanClass)
+                  instrs += BR(gotTypeDataLabel)
+                }
+
+                // typeString:
+                instrs += getHijackedClassTypeDataInstr(IRNames.BoxedStringClass)
+                instrs += BR(gotTypeDataLabel)
+              }
+
+              /* typeNumber:
+               * For `number`s, the result is based on the actual value, as specified by
+               * [[https://www.scala-js.org/doc/semantics.html#getclass]].
+               */
+
+              // doubleValue := unboxDouble(value)
+              instrs += LOCAL_GET(valueParam)
+              instrs += CALL(FuncIdx(WasmFunctionName.unbox(IRTypes.DoubleRef)))
+              instrs += LOCAL_TEE(doubleValueLocal)
+
+              // intValue := doubleValue.toInt
+              instrs += I32_TRUNC_SAT_F64_S
+              instrs += LOCAL_TEE(intValueLocal)
+
+              // if same(intValue.toDouble, doubleValue) -- same bit pattern to avoid +0.0 == -0.0
+              instrs += F64_CONVERT_I32_S
+              instrs += I64_REINTERPRET_F64
+              instrs += LOCAL_GET(doubleValueLocal)
+              instrs += I64_REINTERPRET_F64
+              instrs += I64_EQ
+              fctx.ifThenElse() {
+                // then it is a Byte, a Short, or an Integer
+
+                // if intValue.toByte.toInt == intValue
+                instrs += LOCAL_GET(intValueLocal)
+                instrs += I32_EXTEND8_S
+                instrs += LOCAL_GET(intValueLocal)
+                instrs += I32_EQ
+                fctx.ifThenElse() {
+                  // then it is a Byte
+                  instrs += getHijackedClassTypeDataInstr(IRNames.BoxedByteClass)
+                  instrs += BR(gotTypeDataLabel)
+                } {
+                  // else, if intValue.toShort.toInt == intValue
+                  instrs += LOCAL_GET(intValueLocal)
+                  instrs += I32_EXTEND16_S
+                  instrs += LOCAL_GET(intValueLocal)
+                  instrs += I32_EQ
+                  fctx.ifThenElse() {
+                    // then it is a Short
+                    instrs += getHijackedClassTypeDataInstr(IRNames.BoxedShortClass)
+                    instrs += BR(gotTypeDataLabel)
+                  } {
+                    // else, it is an Integer
+                    instrs += getHijackedClassTypeDataInstr(IRNames.BoxedIntegerClass)
+                    instrs += BR(gotTypeDataLabel)
+                  }
+                }
+              } {
+                // else, it is a Float or a Double
+
+                // if doubleValue.toFloat.toDouble == doubleValue
+                instrs += LOCAL_GET(doubleValueLocal)
+                instrs += F32_DEMOTE_F64
+                instrs += F64_PROMOTE_F32
+                instrs += LOCAL_GET(doubleValueLocal)
+                instrs += F64_EQ
+                fctx.ifThenElse() {
+                  // then it is a Float
+                  instrs += getHijackedClassTypeDataInstr(IRNames.BoxedFloatClass)
+                  instrs += BR(gotTypeDataLabel)
+                } {
+                  // else, if it is NaN
+                  instrs += LOCAL_GET(doubleValueLocal)
+                  instrs += LOCAL_GET(doubleValueLocal)
+                  instrs += F64_NE
+                  fctx.ifThenElse() {
+                    // then it is a Float
+                    instrs += getHijackedClassTypeDataInstr(IRNames.BoxedFloatClass)
+                    instrs += BR(gotTypeDataLabel)
+                  } {
+                    // else, it is a Double
+                    instrs += getHijackedClassTypeDataInstr(IRNames.BoxedDoubleClass)
+                    instrs += BR(gotTypeDataLabel)
+                  }
+                }
+              }
+            }
+
+            // typeUndefined:
+            instrs += getHijackedClassTypeDataInstr(IRNames.BoxedUnitClass)
+            instrs += BR(gotTypeDataLabel)
+          }
+
+          // typeOther:
+          instrs += REF_NULL(HeapType(WasmHeapType.ClassType))
+          instrs += RETURN
+        }
+
+        instrs += STRUCT_GET(objectTypeIdx, StructFieldIdx(0))
+      }
+
+      instrs += CALL(FuncIdx(WasmFunctionName.getClassOf))
+    }
+
+    fctx.buildAndAddToContext()
+  }
+
 }

Diff for: wasm/src/main/scala/ir2wasm/WasmBuilder.scala

@@ -192,7 +192,7 @@ class WasmBuilder {
     // Declare the struct type for the class
     val vtableField = WasmStructField(
       Names.WasmFieldName.vtable,
-      WasmRefNullType(WasmHeapType.Type(vtableType.name)),
+      WasmRefType(WasmHeapType.Type(vtableType.name)),
       isMutable = false
     )
     val fields = clazz.fields.map(transformField)