Fix scala-js#3953: Patch the types of ParamDefs to match their method signature.

In some rare cases that involve Higher Kinded Types and type
aliases, scalac produces DefDef's whose params' types do not match
the method type. This is filed upstream as
scala/bug#11884

We work around the issue by patching a posteriori the types of
`js.ParamDef`s and their `js.VarRef`s to match the type advertised
by the method type.

In the entire test suite, the only method that requires a patch is
the `PartialFunction`'s `applyOrElse` in the newly added test case.

Author: sjrd

compiler/src/main/scala/org/scalajs/nscplugin/GenJSCode.scala

@@ -1809,7 +1809,7 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
           params.map(genParamDef(_))
         }
 
-        if (isAbstractMethod(dd)) {
+        val jsMethodDef = if (isAbstractMethod(dd)) {
           val body = if (scalaUsesImplClasses &&
               sym.hasAnnotation(JavaDefaultMethodAnnotation)) {
             /* For an interface method with @JavaDefaultMethod, make it a
@@ -1899,6 +1899,24 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
 
           methodDefWithoutUselessVars
         }
+
+        /* #3953 Patch the param defs to have the type advertised by the method's type.
+         * This works around https://github.com/scala/bug/issues/11884, whose fix
+         * upstream is blocked because it is not binary compatible. The fix here
+         * only affects the inside of the js.MethodDef, so it is binary compat.
+         */
+        val paramTypeRewrites = jsParams.zip(sym.tpe.paramTypes.map(toIRType(_))).collect {
+          case (js.ParamDef(name, _, tpe, _), sigType) if tpe != sigType => name.name -> sigType
+        }
+        if (paramTypeRewrites.isEmpty) {
+          // Overwhelmingly common case: all the types match, so there is nothing to do
+          jsMethodDef
+        } else {
+          devWarning(
+              "Working around https://github.com/scala/bug/issues/11884 " +
+              s"for ${sym.fullName} at ${sym.pos}")
+          patchTypeOfParamDefs(jsMethodDef, paramTypeRewrites.toMap)
+        }
       }
     }
 
@@ -1958,6 +1976,42 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
           newBody)(methodDef.optimizerHints, None)(methodDef.pos)
     }
 
+    /** Patches the type of selected param defs in a [[js.MethodDef]].
+     *
+     *  @param patches
+     *    Map from local name to new type. For param defs not in the map, the
+     *    type is untouched.
+     */
+    private def patchTypeOfParamDefs(methodDef: js.MethodDef,
+        patches: Map[LocalName, jstpe.Type]): js.MethodDef = {
+
+      def newType(name: js.LocalIdent, oldType: jstpe.Type): jstpe.Type =
+        patches.getOrElse(name.name, oldType)
+
+      val js.MethodDef(flags, methodName, originalName, params, resultType, body) =
+        methodDef
+      val newParams = for {
+        p @ js.ParamDef(name, originalName, ptpe, mutable) <- params
+      } yield {
+        js.ParamDef(name, originalName, newType(name, ptpe), mutable)(p.pos)
+      }
+      val transformer = new ir.Transformers.Transformer {
+        override def transform(tree: js.Tree, isStat: Boolean): js.Tree = tree match {
+          case tree @ js.VarRef(name) =>
+            js.VarRef(name)(newType(name, tree.tpe))(tree.pos)
+          case js.Closure(arrow, captureParams, params, restParam, body, captureValues) =>
+            js.Closure(arrow, captureParams, params, restParam, body,
+                captureValues.map(transformExpr))(tree.pos)
+          case _ =>
+            super.transform(tree, isStat)
+        }
+      }
+      val newBody = body.map(
+          b => transformer.transform(b, isStat = resultType == jstpe.NoType))
+      js.MethodDef(flags, methodName, originalName, newParams, resultType,
+          newBody)(methodDef.optimizerHints, None)(methodDef.pos)
+    }
+
     /** Generates the JSNativeMemberDef of a JS native method. */
     def genJSNativeMemberDef(tree: DefDef): js.JSNativeMemberDef = {
       implicit val pos = tree.pos

test-suite/shared/src/test/scala/org/scalajs/testsuite/compiler/RegressionTest.scala

@@ -870,6 +870,27 @@ class RegressionTest {
     assertEquals("lazily always", ex2.getMessage())
   }
 
+  @Test def paramDefWithWrongTypeWithHKTAndTypeAliases_Issue3953(): Unit = {
+    assumeFalse("Scala/JVM 2.11.x produces wrong bytecode for this test",
+        Platform.executingInJVM && Platform.scalaVersion.startsWith("2.11."))
+
+    import scala.language.higherKinds
+
+    sealed class StreamT[M[_]](val step: M[Step[StreamT[M]]])
+
+    sealed abstract class Step[S]
+
+    def mustMatch[A](actual: A)(f: PartialFunction[A, Boolean]): Boolean =
+      f.applyOrElse(actual, (_: Any) => false)
+
+    type Id[A] = A
+
+    val result = mustMatch(new StreamT[Id](null).step) {
+      case _ => true
+    }
+    assertTrue(result)
+  }
+
 }
 
 object RegressionTest {