Refactor bridge forwarders

Author: odersky

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

@@ -116,81 +116,64 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
       root.delete(other)
       toBeRemoved += other
     }
-    /** Eta expand given `tree` that has the given method type `mt`, so that
-     *  it conforms to erased result type `pt`.
-     *  To do this correctly, we have to look at the tree's original pre-erasure
+
+    val memberCount = contextResultCount(member)
+
+    /** Eta expand application `ref(args)` as needed.
+     *  To do this correctly, we have to look at the member's original pre-erasure
      *  type and figure out which context function types in its result are
      *  not yet instantiated.
      */
-    def forwarder(ref: Tree, args: List[Tree], owner: Symbol, pt: Type, other: Symbol)(using Context): Tree =
-      val origOwner = ctx.owner
-      val member = ref.symbol
-      val memberCount = contextResultCount(member)
-      if memberCount == 0 then
-        ref.appliedToTermArgs(args)
-      else
-        def expandArgs(args: List[Tree], owner: Symbol)(using Context): List[Tree] = args match
-          case (bunchedParam @ Ident(nme.ALLARGS)) :: Nil =>
-            owner.info.firstParamTypes.indices.toList.map(n =>
-              bunchedParam
-                .select(nme.primitive.arrayApply)
-                .appliedTo(Literal(Constant(n)))).showing("Expand $args%, % --> $result%, %")
-          case _ => args
-
-        val toAbstract: List[TermSymbol] =
-          def anonFuns(tp: Type, n: Int, owner: Symbol): List[TermSymbol] =
-            if n <= 0 then Nil
-            else
-              val defn.ContextFunctionType(argTpes, resTpe, isErased) = tp: @unchecked
-              val anonFun = newAnonFun(
-                owner,
-                MethodType(if isErased then Nil else argTpes, resTpe),
-                coord = owner.coord)
-              anonFun :: anonFuns(resTpe, n - 1, anonFun)
-          if memberCount == 0 then Nil
+    def etaExpand(ref: Tree, args: List[Tree])(using Context): Tree =
+      val toAbstract: List[TermSymbol] =
+        def anonFuns(tp: Type, n: Int, owner: Symbol): List[TermSymbol] =
+          if n <= 0 then Nil
           else
-            val otherCount = contextResultCount(other)
-            val resType = contextFunctionResultTypeAfter(member, otherCount)(using preErasureCtx)
-            anonFuns(resType, memberCount - otherCount, owner)
-
-        def etaExpand(args: List[Tree], anonFuns: List[TermSymbol], owner: Symbol): Tree =
-          anonFuns match
-            case Nil =>
-              val app = untpd.cpy.Apply(ref)(ref, args)
-              assert(ctx.typer.isInstanceOf[Erasure.Typer])
-              ctx.typer.typed(app, pt)
-              //  .changeOwnerAfter(origOwner, ctx.owner, erasurePhase.asInstanceOf[Erasure])
-              //ref.appliedToTermArgs(args)//.changeOwner(ctx.owner, owner)
-            case anonFun :: anonFuns1 =>
-              val origType = anonFun.info
-              anonFun.info = transformInfo(anonFun, anonFun.info)
-              inContext(ctx.withOwner(owner)) {
-                def lambdaBody(refss: List[List[Tree]]) =
-                  val refs :: Nil = refss: @unchecked
-                  val expandedRefs = refs.map(_.withSpan(owner.span.endPos)) match
-                    case (bunchedParam @ Ident(nme.ALLARGS)) :: Nil =>
-                      origType.firstParamTypes.indices.toList.map(n =>
-                        bunchedParam
-                          .select(nme.primitive.arrayApply)
-                          .appliedTo(Literal(Constant(n))))
-                    case refs1 => refs1
-                  etaExpand(args ::: expandedRefs, anonFuns1, anonFun)
-
-                val unadapted = Closure(anonFun, lambdaBody)
-                cpy.Block(unadapted)(unadapted.stats,
-                  adaptClosure(unadapted.expr.asInstanceOf[Closure]))
-              }
-
-        //println(i"forward $ref with $args%, %, owner = $owner, $pt")
-        etaExpand(expandArgs(args, owner)(using preErasureCtx), toAbstract, owner)
-          //.showing(i"forward $ref with $args%, %, owner = $owner, $pt = $result")
-    end forwarder
+            val defn.ContextFunctionType(argTpes, resTpe, isErased) = tp: @unchecked
+            val anonFun = newAnonFun(
+              owner,
+              MethodType(if isErased then Nil else argTpes, resTpe),
+              coord = owner.coord)
+            anonFun :: anonFuns(resTpe, n - 1, anonFun)
+        val otherCount = contextResultCount(other)
+        val resType = contextFunctionResultTypeAfter(member, otherCount)(using preErasureCtx)
+        anonFuns(resType, memberCount - otherCount, bridge)
+
+      def expand(args: List[Tree], anonFuns: List[TermSymbol], owner: Symbol): Tree =
+        anonFuns match
+          case Nil =>
+            val app = untpd.cpy.Apply(ref)(ref, args)
+            assert(ctx.typer.isInstanceOf[Erasure.Typer])
+            ctx.typer.typed(app, member.info.finalResultType)
+          case anonFun :: anonFuns1 =>
+            val origType = anonFun.info
+            anonFun.info = transformInfo(anonFun, anonFun.info)
+            inContext(ctx.withOwner(owner)) {
+              def lambdaBody(refss: List[List[Tree]]) =
+                val refs :: Nil = refss: @unchecked
+                val expandedRefs = refs.map(_.withSpan(owner.span.endPos)) match
+                  case (bunchedParam @ Ident(nme.ALLARGS)) :: Nil =>
+                    origType.firstParamTypes.indices.toList.map(n =>
+                      bunchedParam
+                        .select(nme.primitive.arrayApply)
+                        .appliedTo(Literal(Constant(n))))
+                  case refs1 => refs1
+                expand(args ::: expandedRefs, anonFuns1, anonFun)
+
+              val unadapted = Closure(anonFun, lambdaBody)
+              cpy.Block(unadapted)(unadapted.stats,
+                adaptClosure(unadapted.expr.asInstanceOf[Closure]))
+            }
+
+      expand(args, toAbstract, bridge)
+    end etaExpand
 
     def bridgeRhs(argss: List[List[Tree]]) =
       assert(argss.tail.isEmpty)
       val ref = This(root).select(member)
       if member.info.isParameterless then ref // can happen if `member` is a module
-      else forwarder(ref, argss.head, bridge, member.info.finalResultType, other)
+      else if memberCount == 0 then ref.appliedToTermArgs(argss.head)
+      else etaExpand(ref, argss.head)
 
     bridges += DefDef(bridge, bridgeRhs(_).withSpan(bridge.span))
   }