Fix #23179 for Scala.js and add regression tests

- Guard the Erasure.scala array adaptation check with !scalajs.value
  since Scala.js custom SAMs are handled differently (via ExpandSAMs)
- Add array type adaptation in tpd.AnonClass for Scala.js, which handles
  custom SAM closures that get expanded to anonymous classes before erasure
- Add neg test documenting that reverse cases (impl has Array, SAM erases
  to Object) are rejected by the type checker due to array invariance

Author: bracevac

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -392,13 +392,43 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       termForwarders: List[(TermName, TermSymbol)],
       typeMembers: List[(TypeName, TypeBounds)],
       adaptVarargs: Boolean)(using Context): Block = {
+    import core.TypeErasure.erasure
     AnonClass(termForwarders.head._2.owner, parents, termForwarders.map(_._2.span).reduceLeft(_ `union` _), adaptVarargs) { cls =>
       def forwarder(name: TermName, fn: TermSymbol) = {
-        val fwdMeth = fn.copy(cls, name, Synthetic | Method | Final).entered.asTerm
-        for overridden <- fwdMeth.allOverriddenSymbols do
-          if overridden.is(Extension) then fwdMeth.setFlag(Extension)
-          if !overridden.is(Deferred) then fwdMeth.setFlag(Override)
-        DefDef(fwdMeth, ref(fn).appliedToArgss(_))
+        // For Scala.js, check if parameter types will erase to different class symbols (see #23179).
+        // This happens e.g. when SAM expects Array[T] but impl has a wildcard that erases to Object.
+        // We need to use SAM's type and add casts in this case.
+        // On JVM, this is handled in Erasure.adaptClosure instead.
+        val needsAdaptation = ctx.settings.scalajs.value && {
+          val samInfo = parents.head.memberInfo(parents.head.member(name).symbol)
+          val implInfo = fn.info
+          (samInfo, implInfo) match
+            case (samMt: MethodType, implMt: MethodType) =>
+              samMt.paramInfos.lazyZip(implMt.paramInfos).exists((samPt, implPt) =>
+                erasure(samPt).classSymbol != erasure(implPt).classSymbol)
+            case _ => false
+        }
+        if needsAdaptation then
+          val samInfo = parents.head.memberInfo(parents.head.member(name).symbol)
+          val implInfo = fn.info
+          val fwdMeth = fn.copy(cls, name, Synthetic | Method | Final, info = samInfo).entered.asTerm
+          for overridden <- fwdMeth.allOverriddenSymbols do
+            if overridden.is(Extension) then fwdMeth.setFlag(Extension)
+            if !overridden.is(Deferred) then fwdMeth.setFlag(Override)
+          val implType = implInfo.asInstanceOf[MethodType]
+          DefDef(fwdMeth, paramss =>
+            val adaptedParams = paramss.head.lazyZip(implType.paramInfos).map { (param, implParamType) =>
+              if param.tpe =:= implParamType then param
+              else param.cast(implParamType)
+            }
+            ref(fn).appliedToTermArgs(adaptedParams)
+          )
+        else
+          val fwdMeth = fn.copy(cls, name, Synthetic | Method | Final).entered.asTerm
+          for overridden <- fwdMeth.allOverriddenSymbols do
+            if overridden.is(Extension) then fwdMeth.setFlag(Extension)
+            if !overridden.is(Deferred) then fwdMeth.setFlag(Override)
+          DefDef(fwdMeth, ref(fn).appliedToArgss(_))
       }
       termForwarders.map((name, sym) => forwarder(name, sym)) ++
       typeMembers.map((name, info) => TypeDef(newSymbol(cls, name, Synthetic, info).entered))

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -484,11 +484,12 @@ object Erasure {
       val paramAdaptationNeeded =
         implParamTypes.lazyZip(samParamTypes).exists: (implType, samType) =>
           !sameClass(implType, samType) && !autoAdaptedParam(implType)
-          || (samType, implType).match {
+          // For Scala.js, array adaptation is handled in tpd.AnonClass (see #23179)
+          || !ctx.settings.scalajs.value && ((samType, implType).match {
             case (defn.ArrayOf(_), defn.ArrayOf(_)) => false
             case (defn.ArrayOf(_), _) => true // see #23179
             case _ => false
-          }
+          })
       val resultAdaptationNeeded =
         !sameClass(implResultType, samResultType) && !autoAdaptedResult
 

tests/neg/i23179-reverse.scala

@@ -0,0 +1,22 @@
+// Test that reverse cases of #23179 are properly rejected by the type checker.
+// The original issue was about SAM expecting Array[T] but impl having Array[? >: T].
+// Due to array invariance, the reverse cases cannot occur.
+
+object TestReverse {
+  trait A { def f(a: Array[? <: AnyRef]): Any }
+  def g(a: A) = a.f(Array.empty[AnyRef])
+
+  def test(): Unit = {
+    g((x: Array[AnyRef]) => x.headOption) // error: Array[AnyRef] is not a subtype of Array[? <: AnyRef]
+  }
+}
+
+object TestResult {
+  trait A { def f(a: Int): Array[AnyRef] }
+  def g(a: A) = a.f(1)
+
+  def test(): Unit = {
+    val arr: Array[? >: AnyRef] = Array("hello")
+    g((x: Int) => arr) // error: Array[? >: AnyRef] is not a subtype of Array[AnyRef]
+  }
+}