Always just forward args in function expansion

som-snytt · som-snytt · commit 5381be8ca19b · 2024-08-21T17:16:12.000-07:00
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -220,7 +220,10 @@ abstract class UnCurry extends InfoTransform
       // Normally, we can unwrap `() => cbn` to `cbn` where `cbn` refers to a CBN argument (typically `cbn` is an Ident),
       // because we know `cbn` will already be a `Function0` thunk. When we're targeting a SAM,
       // the types don't align and we must preserve the function wrapper.
-      if (fun.vparams.isEmpty && isByNameRef(fun.body) && fun.attachments.get[SAMFunction].isEmpty) { noApply += fun.body ; fun.body }
+      if (fun.vparams.isEmpty && isByNameRef(fun.body) && !fun.attachments.contains[SAMFunction]) {
+        noApply += fun.body
+        fun.body
+      }
       else if (forceExpandFunction || inConstructorFlag != 0) {
         // Expand the function body into an anonymous class
         gen.expandFunction(localTyper)(fun, inConstructorFlag)
@@ -233,18 +236,26 @@ abstract class UnCurry extends InfoTransform
         val newFun = deriveFunction(fun)(_ => localTyper.typedPos(fun.pos)(
           gen.mkForwarder(gen.mkAttributedRef(liftedMethod.symbol), (fun.vparams map (_.symbol)) :: Nil)
         ))
+        def typeNewFun = localTyper.typedPos(fun.pos)(Block(liftedMethod :: Nil, super.transform(newFun)))
 
         if (!mustExpand) {
           liftedMethod.symbol.updateAttachment(DelambdafyTarget)
           liftedMethod.updateAttachment(DelambdafyTarget)
+          typeNewFun
         }
-
-        val typedNewFun = localTyper.typedPos(fun.pos)(Block(liftedMethod :: Nil, super.transform(newFun)))
-        if (mustExpand) {
-          val Block(stats, expr : Function) = typedNewFun: @unchecked
-          treeCopy.Block(typedNewFun, stats, gen.expandFunction(localTyper)(expr, inConstructorFlag))
-        } else {
-          typedNewFun
+        else typeNewFun match {
+          case typedNewFun @ Block(stats, expr: Function) =>
+            val expansion = gen.expandFunction(localTyper)(expr, inConstructorFlag)
+            expansion match {
+              case Block(ClassDef(_, _, _, Template(_, _, body)) :: Nil, _) =>
+                body.last match {
+                  case DefDef(_, _, _, _, _, Apply(_, args)) => noApply.addAll(args) // samDef args are pass-thru
+                  case _ =>
+                }
+              case _ =>
+            }
+            treeCopy.Block(typedNewFun, stats, expansion)
+          case x => throw new MatchError(x)
         }
       }
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -3069,10 +3069,10 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
             if (samTp eq NoType) false
             else {
               /* Make a synthetic class symbol to represent the synthetic class that
-             * will be spun up by LMF for this function. This is necessary because
-             * it's possible that the SAM method might need bridges, and they have
-             * to go somewhere. Erasure knows to compute bridges for these classes
-             * just as if they were real templates extending the SAM type. */
+               * will be spun up by LMF for this function. This is necessary because
+               * it's possible that the SAM method might need bridges, and they have
+               * to go somewhere. Erasure knows to compute bridges for these classes
+               * just as if they were real templates extending the SAM type. */
               val synthCls = fun.symbol.owner.newClassWithInfo(
                 name = tpnme.ANON_CLASS_NAME,
                 parents = ObjectTpe :: samTp :: Nil,
@@ -3089,8 +3089,8 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
               fun.setType(samTp)
 
               /* Arguably I should do `fun.setSymbol(samCls)` rather than leaning
-             * on an attachment, but doing that confounds lambdalift's free var
-             * analysis in a way which does not seem to be trivially reparable. */
+               * on an attachment, but doing that confounds lambdalift's free var
+               * analysis in a way which does not seem to be trivially reparable. */
               fun.updateAttachment(SAMFunction(samTp, sam, synthCls))
 
               true
diff --git a/src/reflect/scala/reflect/macros/Attachments.scala b/src/reflect/scala/reflect/macros/Attachments.scala
@@ -66,8 +66,15 @@ abstract class Attachments { self =>
   }
 
   /** Check underlying payload contains an instance of type `T`. */
-  def contains[T: ClassTag]: Boolean =
-    !isEmpty && (all exists matchesTag[T])
+  def contains[T: ClassTag]: Boolean = !isEmpty && {
+    val it = all.iterator
+    val matchesTagFn = matchesTag[T]
+    while (it.hasNext) { // OPT: hotspot, hand roll `Set.exists`.
+      val datum = it.next()
+      if (matchesTagFn(datum)) return true
+    }
+    false
+  }
 
   /** Creates a copy of this attachment with the payload slot of T added/updated with the provided value.
    *  Replaces an existing payload of the same type, if exists.
diff --git a/test/files/run/t11237.scala b/test/files/run/t11237.scala
@@ -0,0 +1,19 @@
+//> abusing options -Vprint:~uncurry
+trait Semigroup[F] { self =>
+  def append(f1: F, f2: => F): F
+  val z = 10
+}
+
+case class Box(i: Int)
+
+class R extends Runnable {
+  def run() = {
+    val boxSemigroup: Semigroup[Box] = (x1, x2) => Box(x1.i + x2.i)
+    //val boxSemigroup: Semigroup[Box] = (x1: Box, x2: Box) => Box(Math.max(x1.i, x2.i)) // disallowed, by-name must be inferred
+    assert(boxSemigroup.append(Box(1), Box(2)) == Box(3))
+  }
+}
+
+object Test extends App {
+  new R().run()
+}
