Erasure#Typer#makeBridgeDef: simplify implementation, add documentation

No need to handle multiple parameter lists: they have been erased at
this point.
- variable renaming: use the 'bridge' prefix for the bridge and 'impl'
  for the implementation to be bridged

Author: smarter

src/dotty/tools/dotc/transform/Erasure.scala

@@ -503,35 +503,34 @@ object Erasure extends TypeTestsCasts{
       traverse(newStats, oldStats)
     }
 
-    def makeBridgeDef(newDef: tpd.DefDef, parentSym: Symbol)(implicit ctx: Context): tpd.DefDef = {
-      val newDefSym = newDef.symbol
-      val currentClass = newDefSym.owner.asClass
+    /** Create a bridge DefDef which overrides a parent method.
+     *
+     *  @param implDef       The existing DefDef which needs bridging
+     *  @param overridenSym  A symbol corresponding to a parent method to override
+     */
+    def makeBridgeDef(implDef: tpd.DefDef, overridenSym: Symbol)(implicit ctx: Context): tpd.DefDef = {
+      val implDefSym = implDef.symbol
+      val currentClass = implDefSym.owner.asClass
 
-      def error(reason: String) = {
-        assert(false, s"failure creating bridge from ${newDefSym} to ${parentSym}, reason: $reason")
-        ???
-      }
       val bridge = ctx.newSymbol(currentClass,
-        parentSym.name, parentSym.flags | Flags.Bridge, parentSym.info, coord = newDefSym.owner.coord).asTerm
+        overridenSym.name, overridenSym.flags | Flags.Bridge, overridenSym.info, coord = implDefSym.owner.coord).asTerm
       bridge.enteredAfter(ctx.phase.prev.asInstanceOf[DenotTransformer]) // this should be safe, as we're executing in context of next phase
-      ctx.debuglog(s"generating bridge from ${newDefSym} to $bridge")
+      ctx.debuglog(s"generating bridge from ${implDefSym} to $bridge")
 
-      val sel: Tree = This(currentClass).select(newDefSym.termRef)
+      val implSel: Tree = This(currentClass).select(implDefSym.termRef)
 
-      val resultType = parentSym.info.widen.resultType
+      val bridgeResultType = overridenSym.info.widen.resultType
 
       val bridgeCtx = ctx.withOwner(bridge)
 
-      tpd.DefDef(bridge, { paramss: List[List[tpd.Tree]] =>
+      tpd.DefDef(bridge, { bridgeParamss: List[List[tpd.Tree]] =>
           implicit val ctx: Context = bridgeCtx
 
-          val rhs = paramss.foldLeft(sel)((fun, vparams) =>
-            fun.tpe.widen match {
-              case MethodType(names, types) => Apply(fun, (vparams, types).zipped.map(adapt(_, _, untpd.EmptyTree)))
-              case a => error(s"can not resolve apply type $a")
-
-            })
-          adapt(rhs, resultType)
+          // Multiple parameter lists have been erased at this point
+          val List(bridgeParams) = bridgeParamss
+          val List(implParamTypes) = implSel.tpe.widen.paramTypess
+          val rhs = Apply(implSel, (bridgeParams, implParamTypes).zipped.map(adapt(_, _, untpd.EmptyTree)))
+          adapt(rhs, bridgeResultType)
       })
     }