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

@@ -394,11 +394,38 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       adaptVarargs: Boolean)(using Context): Block = {
     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
+        // Look up the SAM method from the parent to get its signature
+        val samMember = parents.head.member(name)
+        // Use SAM's signature if it exists and the SAM param erases to an array but the fn param
+        // does not. This handles cases like Array[? >: AnyRef] (erases to Object) vs
+        // Array[AnyRef] (erases to Array[Object]).
+        val useParentSig = samMember.exists && {
+          val samInfo = samMember.info
+          val fnInfo = fn.info
+          (samInfo, fnInfo) match
+            case (samMt: MethodType, fnMt: MethodType) =>
+              samMt.paramInfos.lazyZip(fnMt.paramInfos).exists { (samPt, fnPt) =>
+                val samErased = TypeErasure.erasure(samPt)
+                val fnErased = TypeErasure.erasure(fnPt)
+                // Only adapt when SAM expects an array but fn takes Object
+                samErased.isInstanceOf[JavaArrayType] && !fnErased.isInstanceOf[JavaArrayType]
+              }
+            case _ => false
+        }
+        val fwdMeth =
+          if useParentSig then
+            newSymbol(cls, name, Synthetic | Method | Final | Override, samMember.info).entered.asTerm
+          else
+            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(_))
+        if useParentSig then
+          // Need to cast args from SAM param types to fn param types
+          DefDef(fwdMeth, argss =>
+            ref(fn).appliedToArgss(argss.map(_.map(arg => arg.cast(arg.tpe.widen)))))
+        else
+          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

@@ -482,13 +482,10 @@ object Erasure {
       def sameClass(tp1: Type, tp2: Type) = tp1.classSymbol == tp2.classSymbol
 
       val paramAdaptationNeeded =
-        implParamTypes.lazyZip(samParamTypes).exists: (implType, samType) =>
-          !sameClass(implType, samType) && !autoAdaptedParam(implType)
-          || (samType, implType).match {
-            case (defn.ArrayOf(_), defn.ArrayOf(_)) => false
-            case (defn.ArrayOf(_), _) => true // see #23179
-            case _ => false
-          }
+        implParamTypes.lazyZip(samParamTypes).exists((implType, samType) =>
+          !sameClass(implType, samType) && (!autoAdaptedParam(implType)
+            // LambdaMetaFactory cannot auto-adapt between Object and Array types
+            || samType.isInstanceOf[JavaArrayType]))
       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]
+  }
+}