Statically resolve Apply calls when possible.

When the statically resolved method of an `Apply` node exists and
is "effectively final" (i.e., it is never overridden), we can use
the compilation scheme of `ApplyStatically` instead.

This also allows to remove methods from the vtables if they are
always called in such a situation.

The analysis is not optimal: consider 3 classes A, B, C. B and C
both extend A, but only B overrides method m. Then a call on a
`(c: C).m` will "resolve" to `A.m` which is not effectively final,
so it won't be optimized. A better analysis would be costly in our
setup, but will be free to obtain from the Scala.js Optimizer when
we can enable it, so we don't push the design too much for now.

Nevertheless, it is worth doing now in its limited form. It reduces
the size of the fastLink output by 18% and the fullLink output by
28% for the Scala.js test suite. Not to mention the likely
performance improvements.

Author: sjrd

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

@@ -334,36 +334,35 @@ private class WasmExpressionBuilder private (
         instrs += UNREACHABLE // trap
         IRTypes.NothingType
 
-      case prim: IRTypes.PrimType =>
-        // statically resolved call with non-null argument
-        val receiverClassName = IRTypes.PrimTypeToBoxedClass(prim)
-        genApplyStatically(
-          IRTrees.ApplyStatically(t.flags, t.receiver, receiverClassName, t.method, t.args)(t.tpe)(
-            t.pos
-          )
-        )
-
-      case IRTypes.ClassType(className) if IRNames.HijackedClasses.contains(className) =>
-        // statically resolved call with maybe-null argument
-        genApplyStatically(
-          IRTrees.ApplyStatically(t.flags, t.receiver, className, t.method, t.args)(t.tpe)(t.pos)
-        )
-
       case _ if t.method.name.isReflectiveProxy =>
         genReflectiveCall(t)
 
-      case IRTypes.ArrayType(_) =>
-        /* Array classes always inherit all their methods from jl.Object, so we
-         * can always statically resolve the call.
-         */
-        genApplyStatically(
-          IRTrees.ApplyStatically(t.flags, t.receiver, IRNames.ObjectClass, t.method, t.args)(
-            t.tpe
-          )(t.pos)
-        )
-
       case _ =>
-        genApplyNonPrim(t)
+        val receiverClassName = t.receiver.tpe match {
+          case prim: IRTypes.PrimType  => IRTypes.PrimTypeToBoxedClass(prim)
+          case IRTypes.ClassType(cls)  => cls
+          case IRTypes.AnyType         => IRNames.ObjectClass
+          case IRTypes.ArrayType(_)    => IRNames.ObjectClass
+          case tpe: IRTypes.RecordType => throw new AssertionError(s"Invalid receiver type $tpe")
+        }
+        val receiverClassInfo = ctx.getClassInfo(receiverClassName)
+
+        val canUseStaticallyResolved = {
+          receiverClassInfo.kind == ClassKind.HijackedClass ||
+          t.receiver.tpe.isInstanceOf[IRTypes.ArrayType] ||
+          receiverClassInfo.resolvedMethodInfos.get(t.method.name).exists(_.isEffectivelyFinal)
+        }
+        if (canUseStaticallyResolved) {
+          genApplyStatically(
+            IRTrees.ApplyStatically(t.flags, t.receiver, receiverClassName, t.method, t.args)(
+              t.tpe
+            )(
+              t.pos
+            )
+          )
+        } else {
+          genApplyWithDispatch(t, receiverClassInfo)
+        }
     }
   }
 
@@ -409,21 +408,18 @@ private class WasmExpressionBuilder private (
     // done
   }
 
-  /** Generates the code an `Apply` call where the receiver's type is not statically known to be a
-    * primitive or hijacked class.
+  /** Generates the code an `Apply` call that requires dynamic dispatch.
     *
     * In that case, there is always at least a vtable/itable-based dispatch. It may also contain
     * primitive-based dispatch if the receiver's type is an ancestor of a hijacked class.
     */
-  private def genApplyNonPrim(t: IRTrees.Apply): IRTypes.Type = {
+  private def genApplyWithDispatch(
+      t: IRTrees.Apply,
+      receiverClassInfo: WasmContext.WasmClassInfo
+  ): IRTypes.Type = {
     implicit val pos: Position = t.pos
 
-    val receiverClassName = t.receiver.tpe match {
-      case ClassType(className) => className
-      case IRTypes.AnyType      => IRNames.ObjectClass
-      case _                    => throw new Error(s"Invalid receiver type ${t.receiver.tpe}")
-    }
-    val receiverClassInfo = ctx.getClassInfo(receiverClassName)
+    val receiverClassName = receiverClassInfo.name
 
     /* Similar to transformType(t.receiver.tpe), but:
      * - it is non-null,

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

@@ -735,6 +735,9 @@ object WasmContext {
           case None             => Map.empty
         }
 
+        for (methodName <- classConcretePublicMethodNames)
+          inherited.get(methodName).foreach(_.markOverridden())
+
         classConcretePublicMethodNames.foldLeft(inherited) { (prev, methodName) =>
           prev.updated(methodName, new ConcreteMethodInfo(name, methodName))
         }
@@ -815,8 +818,14 @@ object WasmContext {
               _.tableMethodInfos
             )
 
+          /* When computing the table entries to add for this class, exclude:
+           * - methods that are already in the super class' table entries, and
+           * - methods that are effectively final, since they will always be
+           *   statically resolved instead of using the table dispatch.
+           */
           val newTableEntries = methodsCalledDynamically.toList
             .filter(!superTableMethodInfos.contains(_))
+            .filterNot(m => resolvedMethodInfos.get(m).exists(_.isEffectivelyFinal))
             .sorted // for stability
 
           val baseIndex = superTableMethodInfos.size
@@ -871,6 +880,13 @@ object WasmContext {
       val methodName: IRNames.MethodName
   ) {
     val wasmName = WasmFunctionName(IRTrees.MemberNamespace.Public, ownerClass, methodName)
+
+    private var effectivelyFinal: Boolean = true
+
+    private[WasmContext] def markOverridden(): Unit =
+      effectivelyFinal = false
+
+    def isEffectivelyFinal: Boolean = effectivelyFinal
   }
 
   final class TableMethodInfo(val methodName: IRNames.MethodName, val tableIndex: Int)