Implement method dispatch for hijacked classes.

When the type of the receiver of an `Apply` is an ancestor of any
hijacked class, it might contain a JS value instead of one of our
own objects. In that case, we must perform a more elaborate
dispatch that tests whether we have a true object, or whether we
must dispatch to a hijacked class method.

This change also surfaces that the methods of `j.l.Object` can
receive an arbitrary non-null value, i.e., a `(ref any)`. This has
to be reflected in vtables and itables, unfortunately.

Author: sjrd

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

@@ -9,6 +9,7 @@ object TestSuites {
     TestSuite("testsuite.core.virtualdispatch.VirtualDispatch", "virtualDispatch"),
     TestSuite("testsuite.core.interfacecall.InterfaceCall", "interfaceCall"),
     TestSuite("testsuite.core.asinstanceof.AsInstanceOfTest", "asInstanceOf"),
+    TestSuite("testsuite.core.hijackedclassesdispatch.HijackedClassesDispatchTest", "hijackedClassesDispatch"),
     TestSuite("testsuite.core.hijackedclassesmono.HijackedClassesMonoTest", "hijackedClassesMono"),
     TestSuite("testsuite.core.hijackedclassesupcast.HijackedClassesUpcastTest", "hijackedClassesUpcast"),
     TestSuite("testsuite.core.tostring.ToStringTest", "toStringConversions")

Diff for: loader.mjs

@@ -1,5 +1,17 @@
 import { readFileSync } from "node:fs";
 
+function stringHashCode(s) {
+  var res = 0;
+  var mul = 1;
+  var i = (s.length - 1) | 0;
+  while ((i >= 0)) {
+    res = ((res + Math.imul(s.charCodeAt(i), mul)) | 0);
+    mul = Math.imul(31, mul);
+    i = (i - 1) | 0;
+  }
+  return res;
+}
+
 const scalaJSHelpers = {
   // BinaryOp.===
   is: Object.is,
@@ -51,6 +63,19 @@ const scalaJSHelpers = {
   doubleToString: (d) => "" + d,
   stringConcat: (x, y) => ("" + x) + y, // the added "" is for the case where x === y === null
   isString: (x) => typeof x === 'string',
+
+  // Hash code, because it is overridden in all hijacked classes
+  jsValueHashCode: (x) => {
+    if (typeof x === 'number')
+      return x | 0; // TODO make this compliant for floats
+    if (typeof x === 'string')
+      return stringHashCode(x);
+    if (typeof x === 'boolean')
+      return x ? 1231 : 1237;
+    if (typeof x === 'undefined')
+      return 0;
+    return 42; // for any JS object
+  },
 }
 
 export async function load(wasmFileName) {

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

@@ -0,0 +1,93 @@
+package testsuite.core.hijackedclassesdispatch
+
+import scala.scalajs.js.annotation._
+
+object HijackedClassesDispatchTest {
+  def main(): Unit = { val _ = test() }
+
+  @JSExportTopLevel("hijackedClassesDispatch")
+  def test(): Boolean = {
+    val obj = new Test()
+    val otherObj = new Test()
+    val obj2 = new Test2()
+    val otherObj2 = new Test2()
+    testToString(true, "true") &&
+      testToString(54321, "54321") &&
+      testToString(obj, "Test class") &&
+      testToString(obj2, "[object]") &&
+      testToString('A', "A") &&
+      testHashCode(true, 1231) &&
+      testHashCode(54321, 54321) &&
+      testHashCode("foo", 101574) &&
+      testHashCode(obj, 123) &&
+      testHashCode(obj2, 42) &&
+      testHashCode('A', 65) &&
+      testIntValue(Int.box(5), 5) &&
+      testIntValue(Long.box(6L), 6) &&
+      testIntValue(Double.box(7.5), 7) &&
+      testIntValue(new CustomNumber(), 789) &&
+      testLength("foo", 3) &&
+      testLength(new CustomCharSeq(), 54) &&
+      testCharAt("foobar", 3, 'b') &&
+      testCharAt(new CustomCharSeq(), 3, 'A') &&
+      testEquals(true, 1, false) &&
+      testEquals(1.0, 1, true) &&
+      testEquals("foo", "foo", true) &&
+      testEquals("foo", "bar", false) &&
+      testEquals(obj, obj2, false) &&
+      testEquals(obj, otherObj, true) &&
+      testEquals(obj2, otherObj2, false) &&
+      testNotifyAll(true) &&
+      testNotifyAll(obj)
+  }
+
+  def testToString(x: Any, expected: String): Boolean =
+    x.toString() == expected
+
+  def testHashCode(x: Any, expected: Int): Boolean =
+    x.hashCode() == expected
+
+  def testIntValue(x: Number, expected: Int): Boolean =
+    x.intValue() == expected
+
+  def testLength(x: CharSequence, expected: Int): Boolean =
+    x.length() == expected
+
+  def testCharAt(x: CharSequence, i: Int, expected: Char): Boolean =
+    x.charAt(i) == expected
+
+  def testEquals(x: Any, y: Any, expected: Boolean): Boolean =
+    x.asInstanceOf[AnyRef].equals(y) == expected
+
+  def testNotifyAll(x: Any): Boolean = {
+    // This is just to test that the call validates and does not trap
+    x.asInstanceOf[AnyRef].notifyAll()
+    true
+  }
+
+  class Test {
+    override def toString(): String = "Test class"
+
+    override def hashCode(): Int = 123
+
+    override def equals(that: Any): Boolean =
+      that.isInstanceOf[Test]
+  }
+
+  class Test2
+
+  class CustomNumber() extends Number {
+    def value(): Int = 789
+    def intValue(): Int = value()
+    def longValue(): Long = 789L
+    def floatValue(): Float = 789.0f
+    def doubleValue(): Double = 789.0
+  }
+
+  class CustomCharSeq extends CharSequence {
+    def length(): Int = 54
+    override def toString(): String = "CustomCharSeq"
+    def charAt(index: Int): Char = 'A'
+    def subSequence(start: Int, end: Int): CharSequence = this
+  }
+}

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

@@ -266,6 +266,9 @@ final class WasmBinaryWriter(module: WasmModule) {
       case GlobalIdx(value)      => writeGlobalIdx(buf, value)
       case HeapType(value)       => writeHeapType(buf, value)
       case StructFieldIdx(value) => buf.u32(value)
+
+      case CastFlags(nullable1, nullable2) =>
+        buf.byte(((if (nullable1) 1 else 0) | (if (nullable2) 2 else 0)).toByte)
     }
   }
 }

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

@@ -217,13 +217,22 @@ 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 i: WasmImmediate.CastFlags =>
+        throw new UnsupportedOperationException(s"CastFlags $i must be handled directly in the instruction $instr")
       case _ =>
         println(i)
         ???
     }
     b.appendElement(str)
   }
 
+  private def writeRefTypeImmediate(i: WasmImmediate.HeapType, nullable: Boolean)(implicit b: WatBuilder): Unit = {
+    if (nullable)
+      b.appendElement(s"(ref null ${i.value.show})")
+    else
+      b.appendElement(s"(ref ${i.value.show})")
+  }
+
   private def writeInstr(instr: WasmInstr)(implicit b: WatBuilder): Unit = {
     instr match {
       case END | ELSE | _: CATCH => b.deindent()
@@ -237,7 +246,25 @@ class WasmTextWriter {
       case _ =>
         ()
     }
-    instr.immediates.foreach { i => writeImmediate(i, instr) }
+
+    def writeBrOnCastImmediates(
+      castFlags: WasmImmediate.CastFlags, label: WasmImmediate.LabelIdx,
+      from: WasmImmediate.HeapType, to: WasmImmediate.HeapType
+    ): Unit = {
+      writeImmediate(label, instr)
+      writeRefTypeImmediate(from, castFlags.nullable1)
+      writeRefTypeImmediate(to, castFlags.nullable2)
+    }
+
+    instr match {
+      case BR_ON_CAST(castFlags, label, from, to) =>
+        writeBrOnCastImmediates(castFlags, label, from, to)
+      case BR_ON_CAST_FAIL(castFlags, label, from, to) =>
+        writeBrOnCastImmediates(castFlags, label, from, to)
+      case _ =>
+        instr.immediates.foreach { i => writeImmediate(i, instr) }
+    }
+
     instr match {
       case _: BLOCK | _: LOOP | _: IF | ELSE | _: CATCH | _: TRY => b.indent()
       case _                                                     => ()

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

@@ -28,6 +28,7 @@ object Preprocessor {
         collectMethods(clazz)
       case ClassKind.JSClass | ClassKind.JSModuleClass | ClassKind.NativeJSModuleClass |
           ClassKind.AbstractJSType | ClassKind.NativeJSClass =>
+        println(s"${clazz.kind} ${clazz.fullName}")
         ???
     }
   }

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

@@ -10,7 +10,7 @@ import wasm4s._
 object TypeTransformer {
 
   val makeReceiverType: Types.WasmType =
-    Types.WasmRefNullType(Types.WasmHeapType.ObjectType)
+    Types.WasmRefType.any
 
   def transformFunctionType(
       // clazz: WasmContext.WasmClassInfo,
@@ -62,12 +62,12 @@ object TypeTransformer {
         className match {
           case _ =>
             val info = ctx.getClassInfo(clazz.className)
-            if (info.isInterface)
-              Types.WasmRefNullType(Types.WasmHeapType.ObjectType)
-            else if (info.kind == ClassKind.HijackedClass)
+            if (info.isAncestorOfHijackedClass)
               Types.WasmAnyRef
+            else if (info.isInterface)
+              Types.WasmRefNullType(Types.WasmHeapType.ObjectType)
             else
-              Types.WasmRefType(
+              Types.WasmRefNullType(
                 Types.WasmHeapType.Type(Names.WasmTypeName.WasmStructTypeName(className))
               )
         }

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

@@ -396,15 +396,15 @@ class WasmBuilder {
   )(implicit ctx: WasmContext): WasmFunction = {
     val receiver = WasmLocal(
       Names.WasmLocalName.receiver,
-      // Receiver type for non-constructor methods needs to be Object type because params are invariant
+      // Receiver type for non-constructor methods needs to be `(ref any)` because params are invariant
       // Otherwise, vtable can't be a subtype of the supertype's subtype
       // Constructor can use the exact type because it won't be registered to vtables.
       if (clazz.kind == ClassKind.HijackedClass)
         transformType(IRTypes.BoxedClassToPrimType(clazz.name.name))
       else if (method.flags.namespace.isConstructor)
         WasmRefNullType(WasmHeapType.Type(WasmTypeName.WasmStructTypeName(clazz.name.name)))
       else
-        WasmRefNullType(WasmHeapType.ObjectType),
+        WasmRefType.any,
       isParameter = true
     )
     val paramTys = receiver.typ +: