Move Scala.js array adaptation fix from tpd.AnonClass to ExpandSAMs

The fix for #23179 is now localized to ExpandSAMs where the SAM expansion
happens, rather than in the general-purpose tpd.AnonClass function.

Author: bracevac

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

@@ -394,38 +394,11 @@ 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) = {
-        // 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
+        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)
-        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(_))
+        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/ExpandSAMs.scala

@@ -3,6 +3,7 @@ package dotc
 package transform
 
 import core.*
+import core.TypeErasure.erasure
 import Scopes.newScope
 import Contexts.*, Symbols.*, Types.*, Flags.*, Decorators.*, StdNames.*, Constants.*
 import MegaPhase.*
@@ -69,14 +70,52 @@ class ExpandSAMs extends MiniPhase:
             case _ => tp
           val tpe1 = collectAndStripRefinements(tpe)
           val Seq(samDenot) = tpe1.possibleSamMethods
-          cpy.Block(tree)(stats,
-            transformFollowingDeep:
-              AnonClass(List(tpe1),
-                List(samDenot.symbol.asTerm.name -> fn.symbol.asTerm),
-                refinements.toList,
-                adaptVarargs = true
+          val implSym = fn.symbol.asTerm
+
+          // Check if SAM param erases to array but impl param doesn't (see #23179).
+          // E.g. SAM expects Array[AnyRef] (erases to Array[Object]) but impl has
+          // Array[? >: AnyRef] (erases to Object). In this case we need to create
+          // a wrapper with the SAM signature that casts arguments before forwarding.
+          val samInfo = samDenot.info
+          val implInfo = implSym.info
+          val needsArrayAdaptation = (samInfo, implInfo) match
+            case (samMt: MethodType, implMt: MethodType) =>
+              samMt.paramInfos.lazyZip(implMt.paramInfos).exists { (samPt, implPt) =>
+                erasure(samPt).isInstanceOf[JavaArrayType] && !erasure(implPt).isInstanceOf[JavaArrayType]
+              }
+            case _ => false
+
+          val forwarderSym =
+            if needsArrayAdaptation then
+              // Create a wrapper method with SAM's signature that casts args to impl's types
+              val wrapperSym = newSymbol(
+                implSym.owner, implSym.name.asTermName, Synthetic | Method,
+                samInfo, coord = implSym.span).entered.asTerm
+              val wrapperDef = DefDef(wrapperSym, paramss => {
+                val implMt = implInfo.asInstanceOf[MethodType]
+                val adaptedArgs = paramss.head.lazyZip(implMt.paramInfos).map { (arg, implPt) =>
+                  if arg.tpe =:= implPt then arg else arg.cast(implPt)
+                }
+                ref(implSym).appliedToTermArgs(adaptedArgs)
+              })
+              cpy.Block(tree)(fn :: wrapperDef :: Nil,
+                transformFollowingDeep:
+                  AnonClass(List(tpe1),
+                    List(samDenot.symbol.asTerm.name -> wrapperSym),
+                    refinements.toList,
+                    adaptVarargs = true
+                  )
               )
-          )
+            else
+              cpy.Block(tree)(stats,
+                transformFollowingDeep:
+                  AnonClass(List(tpe1),
+                    List(samDenot.symbol.asTerm.name -> implSym),
+                    refinements.toList,
+                    adaptVarargs = true
+                  )
+              )
+          forwarderSym
       }
     case _ =>
       tree