Add support for static methods.

Author: sjrd

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

@@ -14,6 +14,7 @@ object TestSuites {
     TestSuite("testsuite.core.HijackedClassesDispatchTest"),
     TestSuite("testsuite.core.HijackedClassesMonoTest"),
     TestSuite("testsuite.core.HijackedClassesUpcastTest"),
+    TestSuite("testsuite.core.StaticMethodTest"),
     TestSuite("testsuite.core.ToStringTest")
   )
 }

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

@@ -0,0 +1,10 @@
+package testsuite.core
+
+import testsuite.Assert.ok
+
+object StaticMethodTest {
+  def main(): Unit = {
+    ok(java.lang.Integer.sum(5, 65) == 70)
+    ok(java.lang.Integer.reverseBytes(0x01020304) == 0x04030201)
+  }
+}

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

@@ -22,9 +22,9 @@ object Preprocessor {
   }
 
   private def preprocess(clazz: LinkedClass)(implicit ctx: WasmContext): Unit = {
-    val infos = clazz.methods.filterNot(_.flags.namespace.isConstructor).map { method =>
-      makeWasmFunctionInfo(clazz, method)
-    }
+    val infos = clazz.methods
+      .filter(_.flags.namespace == IRTrees.MemberNamespace.Public)
+      .map(method => makeWasmFunctionInfo(clazz, method))
 
     ctx.putClassInfo(
       clazz.name.name,

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

@@ -441,18 +441,20 @@ class WasmBuilder {
     // 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.
     val receiverTyp =
-      if (clazz.kind == ClassKind.HijackedClass)
-        transformType(IRTypes.BoxedClassToPrimType(clazz.name.name))
+      if (method.flags.namespace.isStatic)
+        None
+      else if (clazz.kind == ClassKind.HijackedClass)
+        Some(transformType(IRTypes.BoxedClassToPrimType(clazz.name.name)))
       else if (method.flags.namespace.isConstructor)
-        WasmRefNullType(WasmHeapType.Type(WasmTypeName.WasmStructTypeName(clazz.name.name)))
+        Some(WasmRefNullType(WasmHeapType.Type(WasmTypeName.WasmStructTypeName(clazz.name.name))))
       else
-        WasmRefType.any
+        Some(WasmRefType.any)
 
     // Prepare for function context, set receiver and parameters
     implicit val fctx = WasmFunctionContext(
       Some(clazz.className),
       functionName,
-      Some(receiverTyp),
+      receiverTyp,
       method.args,
       method.resultType
     )

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

@@ -108,6 +108,7 @@ private class WasmExpressionBuilder private (
       case t: IRTrees.This             => genThis(t)
       case t: IRTrees.ApplyStatically  => genApplyStatically(t)
       case t: IRTrees.Apply            => genApply(t)
+      case t: IRTrees.ApplyStatic      => genApplyStatic(t)
       case t: IRTrees.IsInstanceOf     => genIsInstanceOf(t)
       case t: IRTrees.AsInstanceOf     => genAsInstanceOf(t)
       case t: IRTrees.GetClass         => genGetClass(t)
@@ -599,6 +600,16 @@ private class WasmExpressionBuilder private (
     }
   }
 
+  private def genApplyStatic(tree: IRTrees.ApplyStatic): IRTypes.Type = {
+    genArgs(tree.args, tree.method.name)
+    val namespace = IRTrees.MemberNamespace.forStaticCall(tree.flags)
+    val funcName = Names.WasmFunctionName(namespace, tree.className, tree.method.name)
+    instrs += CALL(FuncIdx(funcName))
+    if (tree.tpe == IRTypes.NothingType)
+      instrs += UNREACHABLE
+    tree.tpe
+  }
+
   private def genArgs(args: List[IRTrees.Tree], methodName: IRNames.MethodName): Unit = {
     for ((arg, paramTypeRef) <- args.lazyZip(methodName.paramTypeRefs)) {
       val paramType = ctx.inferTypeFromTypeRef(paramTypeRef)

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

@@ -306,15 +306,11 @@ class WasmContext(val module: WasmModule) extends FunctionTypeWriterWasmContext
         case ModuleInitializerImpl.MainMethodWithArgs(className, encodedMainMethodName, args) =>
           () // TODO: but we don't use args yet in scala-wasm
         case ModuleInitializerImpl.VoidMainMethod(className, encodedMainMethodName) =>
-          val name = className.withSuffix("$")
-          instrs +=
-            WasmInstr.CALL(WasmImmediate.FuncIdx(Names.WasmFunctionName.loadModule(name)))
-          instrs += WasmInstr.REF_AS_NOT_NULL
           instrs +=
             WasmInstr.CALL(
               WasmImmediate.FuncIdx(WasmFunctionName(
-                IRTrees.MemberNamespace.Public,
-                name,
+                IRTrees.MemberNamespace.PublicStatic,
+                className,
                 encodedMainMethodName
               ))
             )