Always just forward args in function expansion

som-snytt · som-snytt · commit c17d9ccffceb · 2025-06-03T21:12:00.000-07:00
Notice args of forwarder when generating it
diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
@@ -309,8 +309,9 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL {
                                       resTp: Type = functionResultType(fun.tpe),
                                       additionalFlags: FlagSet = NoFlags): DefDef = {
     val methSym = owner.newMethod(name, fun.pos, FINAL | additionalFlags)
-    // for sams, methParamProtos is the parameter symbols for the sam's method, so that we generate the correct override (based on parameter types)
-    val methParamSyms = methParamProtos.map { param => methSym.newSyntheticValueParam(param.tpe, param.name.toTermName) }
+    // for sams, methParamProtos is the parameter symbols for the sam's method,
+    // so that we generate the correct override (based on parameter types)
+    val methParamSyms = methParamProtos.map(param => methSym.newSyntheticValueParam(param.tpe, param.name.toTermName))
     methSym setInfo MethodType(methParamSyms, resTp)
 
     // we must rewire reference to the function's param symbols -- and not methParamProtos -- to methParamSyms
@@ -326,8 +327,8 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL {
       val enclosingStaticModules = owner.ownersIterator.filter(x => !x.hasPackageFlag && x.isModuleClass && x.isStatic)
       enclosingStaticModules.foldLeft(tree)((tree, moduleClass) => tree.substituteThis(moduleClass, gen.mkAttributedIdent(moduleClass.sourceModule)) )
     }
-
-    newDefDef(methSym, substThisForModule(moveToMethod(useMethodParams(fun.body))))(tpt = TypeTree(resTp))
+    val body = substThisForModule(moveToMethod(useMethodParams(fun.body)))
+    newDefDef(methSym, body)(tpt = TypeTree(resTp))
   }
 
   /**
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -21,6 +21,7 @@ import scala.collection.mutable.ListBuffer
 import scala.reflect.internal.util.ListOfNil
 import scala.tools.nsc.Reporting.WarningCategory
 import scala.tools.nsc.symtab.Flags._
+import scala.util.chaining._
 
 /** - uncurry all symbol and tree types (@see UnCurryPhase) -- this includes normalizing all proper types.
  *  - for every curried parameter list:  (ps_1) ... (ps_n) ==> (ps_1, ..., ps_n)
@@ -215,15 +216,32 @@ abstract class UnCurry extends InfoTransform
      *    new \$anon()
      *
      */
-    def transformFunction(fun: Function): Tree =
+    def transformFunction(fun: Function): Tree = {
+      // in the forwarding expansion def f(ps) = lifted_f(ps) ensure ps never applied
+      def noApplyInExpansion(expansion: Tree): Unit =
+        expansion match {
+          case Block(ClassDef(_, _, _, Template(_, _, body)) :: Nil, _) =>
+            body.last match {
+              case dd: DefDef =>
+                treeInfo.dissectApplied(dd.rhs).argss match {
+                  case args :: _ => args.foreach(noApply.addOne)
+                  case _ =>
+                }
+              case _ =>
+            }
+          case _ =>
+        }
       // Undo eta expansion for parameterless and nullary methods, EXCEPT if `fun` targets a SAM.
-      // Normally, we can unwrap `() => cbn` to `cbn` where `cbn` refers to a CBN argument (typically `cbn` is an Ident),
+      // 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)
+        gen.expandFunction(localTyper)(fun, inConstructorFlag).tap(noApplyInExpansion)
       } else {
         val mustExpand = mustExpandFunction(fun)
         // method definition with the same arguments, return type, and body as the original lambda
@@ -233,20 +251,23 @@ 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).tap(noApplyInExpansion)
+            //if (expr.vparams.exists(p => isByNameParamType(p.symbol.info)))
+            //  noApplyInExpansion(expansion)
+            treeCopy.Block(typedNewFun, stats, expansion)
+          case x => throw new MatchError(x)
         }
       }
+    }
 
     def transformArgs(pos: Position, fun: Symbol, args: List[Tree], params: List[Symbol]): List[Tree] = {
       val isJava = fun.isJavaDefined
@@ -333,7 +354,7 @@ abstract class UnCurry extends InfoTransform
             }
           }
         }
-        val args1 = ListBuffer[Tree]()
+        val args1 = ListBuffer.empty[Tree]
         args1 ++= args.iterator.take(params.length - 1)
         args1 += suffix setType params.last.info
         args1.toList
@@ -344,12 +365,14 @@ abstract class UnCurry extends InfoTransform
 
       map2Conserve(args1, params) { (arg, param) =>
         if (!isByNameParamType(param.info)) arg
-        else if (isByNameRef(arg)) { // thunk does not need to be forced because it's a reference to a by-name arg passed to a by-name param
+        else if (isByNameRef(arg)) {
+          // thunk does not need to be forced because it's a reference to a by-name arg passed to a by-name param
           byNameArgs += arg
           arg setType functionType(Nil, arg.tpe)
         } else {
           log(s"Argument '$arg' at line ${arg.pos.line} is ${param.info} from ${fun.fullName}")
-          def canUseDirectly(qual: Tree) = qual.tpe.typeSymbol.isSubClass(FunctionClass(0)) && treeInfo.isExprSafeToInline(qual)
+          def canUseDirectly(qual: Tree) =
+            qual.tpe.typeSymbol.isSubClass(FunctionClass(0)) && treeInfo.isExprSafeToInline(qual)
           arg match {
             // don't add a thunk for by-name argument if argument already is an application of
             // a Function0. We can then remove the application and use the existing Function0.
@@ -456,7 +479,7 @@ abstract class UnCurry extends InfoTransform
         else translateSynchronized(tree) match {
           case dd @ DefDef(mods, name, tparams, _, tpt, rhs) =>
             // Remove default argument trees from parameter ValDefs, scala/bug#4812
-            val vparamssNoRhs = dd.vparamss mapConserve (_ mapConserve {p =>
+            val vparamssNoRhs = dd.vparamss.mapConserve(_.mapConserve { p =>
               treeCopy.ValDef(p, p.mods, p.name, p.tpt, EmptyTree)
             })
 
@@ -546,10 +569,10 @@ abstract class UnCurry extends InfoTransform
             val tree1 = super.transform(tree)
             if (isByNameRef(tree1)) {
               val tree2 = tree1 setType functionType(Nil, tree1.tpe)
-              return {
-                if (noApply contains tree2) tree2
+              val tree3 =
+                if (noApply.contains(tree2)) tree2
                 else localTyper.typedPos(tree1.pos)(Apply(Select(tree2, nme.apply), Nil))
-              }
+              return tree3
             }
             tree1
         }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -3045,10 +3045,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,
@@ -3065,8 +3065,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,20 @@
+
+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)
+    // disallowed, by-name must be inferred
+    //val boxSemigroup: Semigroup[Box] = (x1: Box, x2: Box) => Box(Math.max(x1.i, x2.i))
+    assert(boxSemigroup.append(Box(1), Box(2)) == Box(3))
+  }
+}
+
+object Test extends App {
+  new R().run()
+}
