Wasm: Remove the isEffectivelyFinal analysis and its use for Apply.

sjrd · sjrd · commit 2cbe367b16c0 · 2024-08-24T11:41:36.000+02:00
The optimizer already replaces `Apply` nodes that can be statically
resolved by `ApplyStatically`. The `isEffectivelyFinal` analysis is
therefore not useful anymore.

Technically, it was still applicable to JS property/method *names*
that are not string constants, but that is too niche to justify
keeping the analysis. Also, arguably the correct fix for that would
be to make the optimizer also optimize JS property/method names,
since it would also benefit the JS backend.
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/wasmemitter/FunctionEmitter.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/wasmemitter/FunctionEmitter.scala
@@ -648,26 +648,20 @@ private class FunctionEmitter private (
         }
         val receiverClassInfo = ctx.getClassInfo(receiverClassName)
 
-        /* If possible, "optimize" this Apply node as an ApplyStatically call.
-         * We can do this if the receiver's class is a hijacked class or an
-         * array type (because they are known to be final) or if the target
-         * method is effectively final.
+        /* Hijacked classes do not receive tables at all, and `Apply`s on array
+         * types are considered to be statically resolved by the `Analyzer`.
+         * Therefore, if the receiver's static type is a prim type, hijacked
+         * class or array type, we must use static dispatch instead.
          *
-         * The latter condition is nothing but an optimization, and should be
-         * done by the optimizer instead. We will remove it once we can run the
-         * optimizer with Wasm.
-         *
-         * The former condition (being a hijacked class or an array type) will
-         * also never happen after we have the optimizer. But if we do not have
-         * the optimizer, we must still do it now because the preconditions of
-         * `genApplyWithDispatch` would not be met.
+         * This never happens when we use the optimizer, since it already turns
+         * any such `Apply` into an `ApplyStatically` (when it does not inline
+         * it altogether).
          */
-        val canUseStaticallyResolved = {
+        val useStaticDispatch = {
           receiverClassInfo.kind == ClassKind.HijackedClass ||
-          receiver.tpe.isInstanceOf[ArrayType] ||
-          receiverClassInfo.resolvedMethodInfos.get(method.name).exists(_.isEffectivelyFinal)
+          receiver.tpe.isInstanceOf[ArrayType]
         }
-        if (canUseStaticallyResolved) {
+        if (useStaticDispatch) {
           genApplyStatically(ApplyStatically(
               flags, receiver, receiverClassName, method, args)(tree.tpe)(tree.pos))
         } else {
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/wasmemitter/Preprocessor.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/wasmemitter/Preprocessor.scala
@@ -175,9 +175,6 @@ object Preprocessor {
           m.methodName
         }
 
-        for (methodName <- concretePublicMethodNames)
-          inherited.get(methodName).foreach(_.markOverridden())
-
         concretePublicMethodNames.foldLeft(inherited) { (prev, methodName) =>
           prev.updated(methodName, new ConcreteMethodInfo(className, methodName))
         }
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/wasmemitter/WasmContext.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/wasmemitter/WasmContext.scala
@@ -260,14 +260,11 @@ object WasmContext {
           val superTableEntries = superClass.fold[List[MethodName]](Nil)(_.tableEntries)
           val superTableEntrySet = superTableEntries.toSet
 
-          /* 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.
+          /* When computing the table entries to add for this class, exclude
+           * methods that are already in the super class' table entries.
            */
           val newTableEntries = methodsCalledDynamically
             .filter(!superTableEntrySet.contains(_))
-            .filterNot(m => resolvedMethodInfos.get(m).exists(_.isEffectivelyFinal))
             .sorted // for stability
 
           _tableEntries = superTableEntries ::: newTableEntries
@@ -289,13 +286,5 @@ object WasmContext {
 
   final class ConcreteMethodInfo(val ownerClass: ClassName, val methodName: MethodName) {
     val tableEntryID = genFunctionID.forTableEntry(ownerClass, methodName)
-
-    private var effectivelyFinal: Boolean = true
-
-    /** For use by `Preprocessor`. */
-    private[wasmemitter] def markOverridden(): Unit =
-      effectivelyFinal = false
-
-    def isEffectivelyFinal: Boolean = effectivelyFinal
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -175,9 +175,6 @@ object Preprocessor {`
`175`	`175`	`m.methodName`
`176`	`176`	`}`
`177`	`177`
`178`		`- for (methodName <- concretePublicMethodNames)`
`179`		`- inherited.get(methodName).foreach(_.markOverridden())`
`180`		`-`
`181`	`178`	`concretePublicMethodNames.foldLeft(inherited) { (prev, methodName) =>`
`182`	`179`	`prev.updated(methodName, new ConcreteMethodInfo(className, methodName))`
`183`	`180`	`}`