Explicitly include the namespace of methods in their Wasm names.

This will make sure that we do not confuse static and non-static
methods with the same signatures.

Author: sjrd

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

@@ -322,7 +322,11 @@ object HelperFunctions {
     // TODO: "isInstance", "isAssignableFrom", "checkCast", "newArrayOfThisClass"
 
     // Call java.lang.Class::<init>(dataObject)
-    instrs += CALL(FuncIdx(WasmFunctionName(IRNames.ClassClass, SpecialNames.ClassCtor)))
+    instrs += CALL(FuncIdx(WasmFunctionName(
+      IRTrees.MemberNamespace.Constructor,
+      IRNames.ClassClass,
+      SpecialNames.ClassCtor
+    )))
 
     // typeData.classOf := classInstance
     instrs += LOCAL_GET(typeDataParam)

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

@@ -47,7 +47,7 @@ object Preprocessor {
       method: IRTrees.MethodDef
   ): WasmFunctionInfo = {
     WasmFunctionInfo(
-      Names.WasmFunctionName(clazz.name.name, method.name.name),
+      Names.WasmFunctionName(method.flags.namespace, clazz.name.name, method.name.name),
       method.args.map(_.ptpe),
       method.resultType,
       isAbstract = method.body.isEmpty

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

@@ -235,7 +235,13 @@ class WasmBuilder {
       .getOrElse(throw new Error(s"Module class should have a constructor, ${clazz.name}"))
     val typeName = WasmTypeName.WasmStructTypeName(clazz.name.name)
     val globalInstanceName = WasmGlobalName.WasmModuleInstanceName.fromIR(clazz.name.name)
-    val ctorName = WasmFunctionName(clazz.name.name, ctor.name.name)
+
+    val ctorName = WasmFunctionName(
+      ctor.flags.namespace,
+      clazz.name.name,
+      ctor.name.name
+    )
+
     val body = List(
       // global.get $module_name
       // ref.if_null
@@ -360,7 +366,7 @@ class WasmBuilder {
       Names.WasmTypeName.WasmITableTypeName(className),
       classInfo.methods.map { m =>
         WasmStructField(
-          Names.WasmFieldName(m.name.methodName),
+          Names.WasmFieldName(m.name.simpleName),
           WasmRefNullType(WasmHeapType.Func(m.toWasmFunctionType().name)),
           isMutable = false
         )
@@ -429,7 +435,11 @@ class WasmBuilder {
       clazz: LinkedClass,
       method: IRTrees.MethodDef
   )(implicit ctx: WasmContext): WasmFunction = {
-    val functionName = Names.WasmFunctionName(clazz.name.name, method.name.name)
+    val functionName = Names.WasmFunctionName(
+      method.flags.namespace,
+      clazz.name.name,
+      method.name.name
+    )
 
     // 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

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

@@ -337,7 +337,11 @@ private class WasmExpressionBuilder private (
      * After this code gen, the stack contains the result.
      */
     def genHijackedClassCall(hijackedClass: IRNames.ClassName): Unit = {
-      val funcName = Names.WasmFunctionName(hijackedClass, t.method.name)
+      val funcName = Names.WasmFunctionName(
+        IRTrees.MemberNamespace.Public,
+        hijackedClass,
+        t.method.name
+      )
       instrs += CALL(FuncIdx(funcName))
     }
 
@@ -522,7 +526,11 @@ private class WasmExpressionBuilder private (
 
       val (methodIdx, info) = ctx
         .calculateVtableType(receiverClassName)
-        .resolveWithIdx(WasmFunctionName(receiverClassName, methodName))
+        .resolveWithIdx(WasmFunctionName(
+          IRTrees.MemberNamespace.Public,
+          receiverClassName,
+          methodName
+        ))
 
       // // push args to the stacks
       // local.get $this ;; for accessing funcref
@@ -582,7 +590,8 @@ private class WasmExpressionBuilder private (
         }
 
         genArgs(t.args, t.method.name)
-        val funcName = Names.WasmFunctionName(t.className, t.method.name)
+        val namespace = IRTrees.MemberNamespace.forNonStaticCall(t.flags)
+        val funcName = Names.WasmFunctionName(namespace, t.className, t.method.name)
         instrs += CALL(FuncIdx(funcName))
         if (t.tpe == IRTypes.NothingType)
           instrs += UNREACHABLE
@@ -1325,7 +1334,11 @@ private class WasmExpressionBuilder private (
     instrs += CALL(FuncIdx(WasmFunctionName.newDefault(n.className)))
     instrs += LOCAL_TEE(LocalIdx(localInstance.name))
     genArgs(n.args, n.ctor.name)
-    instrs += CALL(FuncIdx(WasmFunctionName(n.className, n.ctor.name)))
+    instrs += CALL(FuncIdx(WasmFunctionName(
+      IRTrees.MemberNamespace.Constructor,
+      n.className,
+      n.ctor.name
+    )))
     instrs += LOCAL_GET(LocalIdx(localInstance.name))
     n.tpe
   }

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

@@ -97,23 +97,46 @@ object Names {
   // }
 
   case class WasmFunctionName private (
-      val className: String,
-      val methodName: String
-  ) extends WasmName(s"$className#$methodName")
+      val namespace: String,
+      val simpleName: String
+  ) extends WasmName(namespace + "#" + simpleName)
+
   object WasmFunctionName {
-    def apply(clazz: IRNames.ClassName, method: IRNames.MethodName): WasmFunctionName =
-      new WasmFunctionName(clazz.nameString, method.nameString)
+    def apply(
+      namespace: IRTrees.MemberNamespace,
+      clazz: IRNames.ClassName,
+      method: IRNames.MethodName
+    ): WasmFunctionName = {
+      new WasmFunctionName(
+        namespaceString(namespace) + "#" + clazz.nameString,
+        method.nameString
+      )
+    }
+
+    private def namespaceString(namespace: IRTrees.MemberNamespace): String = {
+      import IRTrees.MemberNamespace._
+
+      // These strings are the same ones that the JS back-end uses
+      namespace match {
+        case Public            => "f"
+        case Private           => "p"
+        case PublicStatic      => "s"
+        case PrivateStatic     => "ps"
+        case Constructor       => "ct"
+        case StaticConstructor => "sct"
+      }
+    }
 
     def forExport(exportedName: String): WasmFunctionName =
-      new WasmFunctionName(exportedName, "")
+      new WasmFunctionName("export", exportedName)
 
     // Adding prefix __ to avoid name clashes with user code.
     // It should be safe not to add prefix to the method name
     // since loadModule is a static method and it's not registered in the vtable.
     def loadModule(clazz: IRNames.ClassName): WasmFunctionName =
-      new WasmFunctionName(s"__${clazz.nameString}", "loadModule")
+      new WasmFunctionName("loadModule", clazz.nameString)
     def newDefault(clazz: IRNames.ClassName): WasmFunctionName =
-      new WasmFunctionName(s"__${clazz.nameString}", "newDefault")
+      new WasmFunctionName("new", clazz.nameString)
 
     val start = new WasmFunctionName("start", "start")
 

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

@@ -70,7 +70,7 @@ trait ReadOnlyWasmContext {
   ): List[WasmFunctionInfo] = {
     collectMethods(name, includeAbstractMethods)
       .foldLeft(Array.empty[WasmFunctionInfo]) { case (acc, m) =>
-        acc.indexWhere(_.name.methodName == m.name.methodName) match {
+        acc.indexWhere(_.name.simpleName == m.name.simpleName) match {
           case i if i < 0 => acc :+ m
           case i          => acc.updated(i, m)
         }
@@ -197,7 +197,7 @@ class WasmContext(val module: WasmModule) extends FunctionTypeWriterWasmContext
   ): Unit = {
     val sig = WasmFunctionSignature(params, results)
     val typ = WasmFunctionType(addFunctionType(sig), sig)
-    module.addImport(WasmImport(name.className, name.methodName, WasmImportDesc.Func(name, typ)))
+    module.addImport(WasmImport(name.namespace, name.simpleName, WasmImportDesc.Func(name, typ)))
   }
 
   addGCType(WasmStructType.typeData)
@@ -312,7 +312,11 @@ class WasmContext(val module: WasmModule) extends FunctionTypeWriterWasmContext
           instrs += WasmInstr.REF_AS_NOT_NULL
           instrs +=
             WasmInstr.CALL(
-              WasmImmediate.FuncIdx(WasmFunctionName(name, encodedMainMethodName))
+              WasmImmediate.FuncIdx(WasmFunctionName(
+                IRTrees.MemberNamespace.Public,
+                name,
+                encodedMainMethodName
+              ))
             )
       }
     }
@@ -376,16 +380,16 @@ object WasmContext {
     def methods: List[WasmFunctionInfo] = _methods
 
     def maybeAddAbstractMethod(methodName: IRNames.MethodName, ctx: WasmContext): Unit = {
-      if (!methods.exists(_.name.methodName == methodName.nameString)) {
-        val wasmName = WasmFunctionName(name, methodName)
+      if (!methods.exists(_.name.simpleName == methodName.nameString)) {
+        val wasmName = WasmFunctionName(IRTrees.MemberNamespace.Public, name, methodName)
         val argTypes = methodName.paramTypeRefs.map(ctx.inferTypeFromTypeRef(_))
         val resultType = ctx.inferTypeFromTypeRef(methodName.resultTypeRef)
         _methods = _methods :+ WasmFunctionInfo(wasmName, argTypes, resultType, isAbstract = true)
       }
     }
 
     def getMethodInfo(methodName: IRNames.MethodName): WasmFunctionInfo = {
-      methods.find(_.name.methodName == methodName.nameString).getOrElse {
+      methods.find(_.name.simpleName == methodName.nameString).getOrElse {
         throw new IllegalArgumentException(
           s"Cannot find method ${methodName.nameString} in class ${name.nameString}"
         )
@@ -432,7 +436,7 @@ object WasmContext {
       val itableIdx =
         itables.lastIndexWhere { classInfo =>
           val methodIdx = classInfo.methods.lastIndexWhere { func =>
-            func.name.methodName == name.nameString
+            func.name.simpleName == name.nameString
           }
           if (methodIdx >= 0) {
             foundMethodIdx = methodIdx
@@ -447,12 +451,12 @@ object WasmContext {
   case class WasmVTable(val functions: List[WasmFunctionInfo]) {
     def resolve(name: WasmFunctionName): WasmFunctionInfo =
       functions
-        .find(_.name.methodName == name.methodName)
+        .find(_.name.simpleName == name.simpleName)
         .getOrElse(throw new Error(s"Function not found: $name"))
     def resolveWithIdx(name: WasmFunctionName): (Int, WasmFunctionInfo) = {
-      val idx = functions.indexWhere(_.name.methodName == name.methodName)
+      val idx = functions.indexWhere(_.name.simpleName == name.simpleName)
       if (idx < 0)
-        throw new Error(s"Function not found: $name among ${functions.map(_.name.methodName)}")
+        throw new Error(s"Function not found: $name among ${functions.map(_.name.simpleName)}")
       else (idx, functions(idx))
     }
   }