Refactor bridge forwarders (2)

Author: odersky

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

@@ -125,47 +125,36 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
      *  not yet instantiated.
      */
     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 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)
+      def expand(args: List[Tree], tp: Type, n: Int)(using Context): Tree =
+        if n <= 0 then
+          assert(ctx.typer.isInstanceOf[Erasure.Typer])
+          ctx.typer.typed(untpd.cpy.Apply(ref)(ref, args), member.info.finalResultType)
+        else
+          val defn.ContextFunctionType(argTypes, resType, isErased) = tp: @unchecked
+          val anonFun = newAnonFun(ctx.owner,
+            MethodType(if isErased then Nil else argTypes, resType),
+            coord = ctx.owner.coord)
+          anonFun.info = transformInfo(anonFun, anonFun.info)
+
+          def lambdaBody(refss: List[List[Tree]]) =
+            val refs :: Nil = refss: @unchecked
+            val expandedRefs = refs.map(_.withSpan(ctx.owner.span.endPos)) match
+              case (bunchedParam @ Ident(nme.ALLARGS)) :: Nil =>
+                argTypes.indices.toList.map(n =>
+                  bunchedParam
+                    .select(nme.primitive.arrayApply)
+                    .appliedTo(Literal(Constant(n))))
+              case refs1 => refs1
+            expand(args ::: expandedRefs, resType, n - 1)(using ctx.withOwner(anonFun))
+
+          val unadapted = Closure(anonFun, lambdaBody)
+          cpy.Block(unadapted)(unadapted.stats,
+            adaptClosure(unadapted.expr.asInstanceOf[Closure]))
+      end expand
+
+      val otherCount = contextResultCount(other)
+      val start = contextFunctionResultTypeAfter(member, otherCount)(using preErasureCtx)
+      expand(args, start, memberCount - otherCount)(using ctx.withOwner(bridge))
     end etaExpand
 
     def bridgeRhs(argss: List[List[Tree]]) =