Take inherited fields into account.

In `LinkedClass`es, the `fields` only list fields declared directly
in the given class. When allocating Wasm structs and computing
indices, we must take inherited fields into account as well.

Author: sjrd

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.FieldsTest"),
     TestSuite("testsuite.core.GetClassTest"),
     TestSuite("testsuite.core.JSInteropTest"),
     TestSuite("testsuite.core.HijackedClassesDispatchTest"),

test-suite/src/main/scala/testsuite/core/FieldsTest.scala

@@ -0,0 +1,29 @@
+package testsuite.core
+
+import testsuite.Assert.ok
+
+object FieldsTest {
+  def main(): Unit = {
+    val parent = new Parent(5)
+    ok(parent.x == 5)
+    ok(parent.getX == 5)
+
+    val child = new Child(6, "foo")
+    ok(child.x == 6)
+    ok(child.getX == 6)
+    ok(child.foo() == 3)
+
+    val child2 = new Child(-6, "foo")
+    ok(child2.x == -6)
+    ok(child2.getX == -6)
+    ok(child2.foo() == -3)
+  }
+
+  class Parent(val x: Int) {
+    def getX: Int = x
+  }
+
+  class Child(x2: Int, y: String) extends Parent(x2) {
+    def foo(): Int = if (x >= 0) y.length() else -y.length()
+  }
+}

wasm/src/main/scala/Compiler.scala

@@ -63,8 +63,14 @@ object Compiler {
     } yield {
       val onlyModule = moduleSet.modules.head
 
-      // Sort for stability
-      val sortedClasses = onlyModule.classDefs.sortBy(_.className)
+      /* Sort by ancestor count so that superclasses always appear before
+       * subclasses, then tie-break by name for stability.
+       */
+      val sortedClasses = onlyModule.classDefs.sortWith { (a, b) =>
+        val cmp = a.ancestors.sizeCompare(b.ancestors)
+        if (cmp != 0) cmp < 0
+        else a.className.compareTo(b.className) < 0
+      }
 
       sortedClasses.foreach(showLinkedClass(_))
 

wasm/src/main/scala/ir2wasm/Preprocessor.scala

@@ -22,6 +22,23 @@ object Preprocessor {
   }
 
   private def preprocess(clazz: LinkedClass)(implicit ctx: WasmContext): Unit = {
+    val allFieldDefs: List[IRTrees.FieldDef] =
+      if (clazz.kind.isClass) {
+        val inheritedFields = clazz.superClass match {
+          case None => Nil
+          case Some(sup) => ctx.getClassInfo(sup.name).allFieldDefs
+        }
+        val myFieldDefs = clazz.fields.map {
+          case fd: IRTrees.FieldDef =>
+            fd
+          case fd: IRTrees.JSFieldDef =>
+            throw new AssertionError(s"Illegal $fd in Scala class ${clazz.className}")
+        }
+        inheritedFields ::: myFieldDefs
+      } else {
+        Nil
+      }
+
     val infos = clazz.methods
       .filter(_.flags.namespace == IRTrees.MemberNamespace.Public)
       .map(method => makeWasmFunctionInfo(clazz, method))
@@ -32,7 +49,7 @@ object Preprocessor {
         clazz.name.name,
         clazz.kind,
         infos,
-        clazz.fields.collect { case f: IRTrees.FieldDef => Names.WasmFieldName(f.name.name) },
+        allFieldDefs,
         clazz.superClass.map(_.name),
         clazz.interfaces.map(_.name),
         clazz.ancestors,

wasm/src/main/scala/ir2wasm/WasmBuilder.scala

@@ -143,6 +143,7 @@ class WasmBuilder {
 
     val className = clazz.name.name
     val typeRef = IRTypes.ClassRef(className)
+    val classInfo = ctx.getClassInfo(className)
 
     // generate vtable type, this should be done for both abstract and concrete classes
     val vtable = ctx.calculateVtableType(className)
@@ -185,7 +186,7 @@ class WasmBuilder {
       WasmRefType(WasmHeapType.Type(vtableType.name)),
       isMutable = false
     )
-    val fields = clazz.fields.map(transformField)
+    val fields = classInfo.allFieldDefs.map(transformField)
     val structType = WasmStructType(
       Names.WasmTypeName.WasmStructTypeName(clazz.name.name),
       vtableField +: WasmStructField.itables +: fields,
@@ -195,7 +196,7 @@ class WasmBuilder {
 
     // Define the `new` function, unless the class is abstract
     if (!isAbstractClass)
-      genStructNewDefault(clazz, Some(gVtable), gItable)
+      genStructNewDefault(classInfo, Some(gVtable), gItable)
 
     structType
   }
@@ -269,15 +270,17 @@ class WasmBuilder {
   }
 
   private def genStructNewDefault(
-      clazz: LinkedClass,
+      classInfo: WasmClassInfo,
       vtable: Option[WasmGlobal],
       itable: Option[WasmGlobal]
   )(implicit ctx: WasmContext): Unit = {
+    val className = classInfo.name
+
     val getVTable = vtable match {
       case None =>
         REF_NULL(
           WasmImmediate.HeapType(
-            WasmHeapType.Type(WasmTypeName.WasmVTableTypeName(clazz.name.name))
+            WasmHeapType.Type(WasmTypeName.WasmVTableTypeName(className))
           )
         )
       case Some(v) => GLOBAL_GET(WasmImmediate.GlobalIdx(v.name))
@@ -288,19 +291,19 @@ class WasmBuilder {
     }
     val defaultFields =
       getVTable +: getITable +:
-        clazz.fields.collect { case f: IRTrees.FieldDef =>
+        classInfo.allFieldDefs.map { f =>
           val ty = transformType(f.ftpe)
           Defaults.defaultValue(ty)
         }
 
-    val className = WasmTypeName.WasmStructTypeName(clazz.name.name)
+    val structName = WasmTypeName.WasmStructTypeName(className)
     val body =
-      defaultFields :+ STRUCT_NEW(WasmImmediate.TypeIdx(className))
+      defaultFields :+ STRUCT_NEW(WasmImmediate.TypeIdx(structName))
     val sig =
-      WasmFunctionSignature(Nil, List(WasmRefType(WasmHeapType.Type(className))))
+      WasmFunctionSignature(Nil, List(WasmRefType(WasmHeapType.Type(structName))))
     val newDefaultTypeName = ctx.addFunctionType(sig)
     val func = WasmFunction(
-      WasmFunctionName.newDefault(clazz.name.name),
+      WasmFunctionName.newDefault(className),
       WasmFunctionType(newDefaultTypeName, sig),
       Nil,
       WasmExpr(body)
@@ -467,17 +470,10 @@ class WasmBuilder {
   }
 
   private def transformField(
-      field: IRTrees.AnyFieldDef
+      field: IRTrees.FieldDef
   )(implicit ctx: WasmContext): WasmStructField = {
-    val fieldName =
-      field match {
-        case f: IRTrees.FieldDef =>
-          Names.WasmFieldName(f.name.name)
-        // TODO
-        case js: IRTrees.JSFieldDef => ???
-      }
     WasmStructField(
-      fieldName,
+      Names.WasmFieldName(field.name.name),
       transformType(field.ftpe),
       // needs to be mutable even if it's flags.isMutable = false
       // because it's initialized by constructor

wasm/src/main/scala/ir2wasm/WasmExpressionBuilder.scala

@@ -220,7 +220,7 @@ private class WasmExpressionBuilder private (
       case sel: IRTrees.Select =>
         val className = sel.field.name.className
         val fieldName = WasmFieldName(sel.field.name)
-        val idx = ctx.getClassInfo(className).getFieldIdx(fieldName)
+        val idx = ctx.getClassInfo(className).getFieldIdx(sel.field.name)
 
         // For Select, the receiver can never be a hijacked class, so we can use genTreeAuto
         genTreeAuto(sel.qualifier)
@@ -231,7 +231,7 @@ private class WasmExpressionBuilder private (
       case sel: IRTrees.SelectStatic => // OK?
         val className = sel.field.name.className
         val fieldName = WasmFieldName(sel.field.name)
-        val idx = ctx.getClassInfo(className).getFieldIdx(fieldName)
+        val idx = ctx.getClassInfo(className).getFieldIdx(sel.field.name)
         instrs += GLOBAL_GET(
           GlobalIdx(Names.WasmGlobalName.WasmModuleInstanceName.fromIR(className))
         )
@@ -675,7 +675,7 @@ private class WasmExpressionBuilder private (
   private def genSelect(sel: IRTrees.Select): IRTypes.Type = {
     val className = sel.field.name.className
     val fieldName = WasmFieldName(sel.field.name)
-    val idx = ctx.getClassInfo(className).getFieldIdx(fieldName)
+    val idx = ctx.getClassInfo(className).getFieldIdx(sel.field.name)
 
     // For Select, the receiver can never be a hijacked class, so we can use genTreeAuto
     genTreeAuto(sel.qualifier)

wasm/src/main/scala/wasm4s/WasmContext.scala

@@ -370,13 +370,16 @@ object WasmContext {
       val name: IRNames.ClassName,
       val kind: ClassKind,
       private var _methods: List[WasmFunctionInfo],
-      private val fields: List[WasmFieldName],
+      val allFieldDefs: List[IRTrees.FieldDef],
       val superClass: Option[IRNames.ClassName],
       val interfaces: List[IRNames.ClassName],
       val ancestors: List[IRNames.ClassName],
       val jsNativeLoadSpec: Option[IRTrees.JSNativeLoadSpec],
       val jsNativeMembers: Map[IRNames.MethodName, IRTrees.JSNativeLoadSpec]
   ) {
+    private val fieldIdxByName: Map[IRNames.FieldName, Int] =
+      allFieldDefs.map(_.name.name).zipWithIndex.map(p => p._1 -> (p._2 + classFieldOffset)).toMap
+
     def isAncestorOfHijackedClass: Boolean = AncestorsOfHijackedClasses.contains(name)
 
     def isInterface = kind == ClassKind.Interface
@@ -400,11 +403,13 @@ object WasmContext {
       }
     }
 
-    def getFieldIdx(name: WasmFieldName): WasmImmediate.StructFieldIdx =
-      fields.indexWhere(_ == name) match {
-        case i if i < 0 => throw new Error(s"Field not found: $name")
-        case i          => WasmImmediate.StructFieldIdx(i + classFieldOffset)
-      }
+    def getFieldIdx(name: IRNames.FieldName): WasmImmediate.StructFieldIdx = {
+      WasmImmediate.StructFieldIdx(fieldIdxByName.getOrElse(name, {
+        throw new AssertionError(
+          s"Unknown field ${name.nameString} in class ${this.name.nameString}"
+        )
+      }))
+    }
   }
 
   case class WasmFunctionInfo(