Make the receiver type non-nullable.

This surfaced a few places when instantiating new objects where we
need to manipulate non-null values.

Author: sjrd

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

@@ -43,28 +43,23 @@ object TypeTransformer {
         Types.WasmRefType.nullable(
           Names.WasmTypeName.WasmStructTypeName.forArrayClass(tpe.arrayTypeRef)
         )
-      case IRTypes.ClassType(className) => transformClassByName(className)
+      case IRTypes.ClassType(className) => transformClassType(className)
       case IRTypes.RecordType(fields)   => ???
       case IRTypes.StringType | IRTypes.UndefType =>
         Types.WasmRefType.any
       case p: IRTypes.PrimTypeWithRef => transformPrimType(p)
     }
 
-  private def transformClassByName(
+  def transformClassType(
       className: IRNames.ClassName
-  )(implicit ctx: ReadOnlyWasmContext): Types.WasmType = {
-    className match {
-      case _ =>
-        val info = ctx.getClassInfo(className)
-        if (info.isAncestorOfHijackedClass)
-          Types.WasmRefType.anyref
-        else if (info.isInterface)
-          Types.WasmRefType.nullable(Types.WasmHeapType.ObjectType)
-        else
-          Types.WasmRefType.nullable(
-            Names.WasmTypeName.WasmStructTypeName.forClass(className)
-          )
-    }
+  )(implicit ctx: ReadOnlyWasmContext): Types.WasmRefType = {
+    val info = ctx.getClassInfo(className)
+    if (info.isAncestorOfHijackedClass)
+      Types.WasmRefType.anyref
+    else if (info.isInterface)
+      Types.WasmRefType.nullable(Types.WasmHeapType.ObjectType)
+    else
+      Types.WasmRefType.nullable(WasmTypeName.WasmStructTypeName.forClass(className))
   }
 
   private def transformPrimType(

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

@@ -487,29 +487,35 @@ class WasmBuilder(coreSpec: CoreSpec) {
       ctor.name.name
     )
 
+    val resultTyp = WasmRefType(typeName)
+
     implicit val fctx = WasmFunctionContext(
       WasmFunctionName.loadModule(clazz.className),
       Nil,
-      List(WasmRefType.nullable(typeName))
+      List(resultTyp)
     )
 
+    val instanceLocal = fctx.addLocal("instance", resultTyp)
+
     import fctx.instrs
 
-    // global.get $module_name
-    // ref.if_null
-    //   ref.null $module_type
-    //   call $module_init ;; should set to global
-    // end
-    // global.get $module_name
-    instrs += GLOBAL_GET(globalInstanceName) // [rt]
-    instrs += REF_IS_NULL // [rt] -> [i32] (bool)
-    instrs += IF(BlockType.ValueType())
-    instrs += CALL(WasmFunctionName.newDefault(clazz.name.name))
-    instrs += GLOBAL_SET(globalInstanceName)
-    instrs += GLOBAL_GET(globalInstanceName)
-    instrs += CALL(ctorName)
-    instrs += END
-    instrs += GLOBAL_GET(globalInstanceName) // [rt]
+    fctx.block(resultTyp) { nonNullLabel =>
+      // load global, return if not null
+      instrs += GLOBAL_GET(globalInstanceName)
+      instrs += BR_ON_NON_NULL(nonNullLabel)
+
+      // create an instance and call its constructor
+      instrs += CALL(WasmFunctionName.newDefault(clazz.name.name))
+      instrs += LOCAL_TEE(instanceLocal)
+      instrs += CALL(ctorName)
+
+      // store it in the global
+      instrs += LOCAL_GET(instanceLocal)
+      instrs += GLOBAL_SET(globalInstanceName)
+
+      // return it
+      instrs += LOCAL_GET(instanceLocal)
+    }
 
     fctx.buildAndAddToContext()
   }
@@ -1083,7 +1089,7 @@ class WasmBuilder(coreSpec: CoreSpec) {
       else if (isHijackedClass)
         Some(transformType(IRTypes.BoxedClassToPrimType(className)))
       else
-        Some(transformType(IRTypes.ClassType(className)))
+        Some(transformClassType(className).toNonNullable)
 
     // Prepare for function context, set receiver and parameters
     implicit val fctx = WasmFunctionContext(

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

@@ -1776,8 +1776,7 @@ private class WasmExpressionBuilder private (
      * if the given class is an ancestor of hijacked classes (which in practice
      * is only the case for j.l.Object).
      */
-    val instanceTyp =
-      Types.WasmRefType.nullable(WasmStructTypeName.forClass(n.className))
+    val instanceTyp = Types.WasmRefType(WasmStructTypeName.forClass(n.className))
     val localInstance = fctx.addSyntheticLocal(instanceTyp)
 
     instrs += CALL(WasmFunctionName.newDefault(n.className))
@@ -1804,7 +1803,7 @@ private class WasmExpressionBuilder private (
     val primLocal = fctx.addSyntheticLocal(primTyp)
 
     val boxClassType = IRTypes.ClassType(boxClassName)
-    val boxTyp = TypeTransformer.transformType(boxClassType)(ctx)
+    val boxTyp = TypeTransformer.transformClassType(boxClassName)(ctx).toNonNullable
     val instanceLocal = fctx.addSyntheticLocal(boxTyp)
 
     /* The generated code is as follows. Before the codegen, the stack contains
@@ -1847,19 +1846,19 @@ private class WasmExpressionBuilder private (
 
   private def genWrapAsThrowable(tree: IRTrees.WrapAsThrowable): IRTypes.Type = {
     val throwableClassType = IRTypes.ClassType(IRNames.ThrowableClass)
-    val throwableTyp = TypeTransformer.transformType(throwableClassType)(ctx)
+    val nonNullThrowableTyp = Types.WasmRefType(Types.WasmHeapType.ThrowableType)
 
-    val jsExceptionClassType = IRTypes.ClassType(SpecialNames.JSExceptionClass)
-    val jsExceptionTyp = TypeTransformer.transformType(jsExceptionClassType)(ctx)
+    val jsExceptionTyp =
+      TypeTransformer.transformClassType(SpecialNames.JSExceptionClass)(ctx).toNonNullable
 
-    fctx.block(throwableTyp) { doneLabel =>
+    fctx.block(nonNullThrowableTyp) { doneLabel =>
       genTree(tree.expr, IRTypes.AnyType)
 
       // if expr.isInstanceOf[Throwable], then br $done
       instrs += BR_ON_CAST(
         doneLabel,
         Types.WasmRefType.anyref,
-        Types.WasmRefType(Types.WasmHeapType.ThrowableType)
+        nonNullThrowableTyp
       )
 
       // otherwise, wrap in a new JavaScriptException

Diff for: wasm/src/main/scala/wasm4s/Types.scala

@@ -23,7 +23,10 @@ object Types {
   case object WasmInt8 extends WasmPackedType("i8", 0x78)
   case object WasmInt16 extends WasmPackedType("i16", 0x77)
 
-  final case class WasmRefType(nullable: Boolean, heapType: WasmHeapType) extends WasmType
+  final case class WasmRefType(nullable: Boolean, heapType: WasmHeapType) extends WasmType {
+    def toNullable: WasmRefType = WasmRefType(true, heapType)
+    def toNonNullable: WasmRefType = WasmRefType(false, heapType)
+  }
 
   object WasmRefType {