Address review comments

Author: bracevac

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

@@ -85,37 +85,35 @@ class ExpandSAMs extends MiniPhase:
               }
             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
+          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.stripPoly.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
+                )
+            )
       }
     case _ =>
       tree

tests/run/i23179.scala

@@ -1,8 +1,31 @@
 object Test {
+  // Basic case: SAM expects Array[AnyRef], impl has Array[? >: AnyRef]
   trait A { def f(a: Array[AnyRef]): Any }
   def g(a: A) = a.f(Array.empty[AnyRef])
 
+  // Multiple array parameters
+  trait MultiParam { def f(a: Array[AnyRef], b: Array[AnyRef]): Any }
+  def gMulti(a: MultiParam) = a.f(Array.empty[AnyRef], Array.empty[AnyRef])
+
+  // Mixed parameters: only some need adaptation
+  trait MixedParam { def f(a: Array[AnyRef], b: Int): Any }
+  def gMixed(a: MixedParam) = a.f(Array.empty[AnyRef], 42)
+
+  // Generic return type
+  trait GenericReturn[T] { def f(a: Array[AnyRef]): T }
+  def gGeneric[T](a: GenericReturn[T]): T = a.f(Array.empty[AnyRef])
+
   def main(args: Array[String]): Unit = {
+    // Basic case
     g((x: Array[? >: AnyRef]) => x.headOption)
+
+    // Multiple array parameters - both need adaptation
+    gMulti((x: Array[? >: AnyRef], y: Array[? >: AnyRef]) => (x.headOption, y.headOption))
+
+    // Mixed - only first param needs adaptation
+    gMixed((x: Array[? >: AnyRef], n: Int) => (x.headOption, n))
+
+    // Generic return type
+    val result: Option[?] = gGeneric((x: Array[? >: AnyRef]) => x.headOption)
   }
 }