Remove erasure logic from ContextFunctionType

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -1879,17 +1879,14 @@ class Definitions {
    */
   object ContextFunctionType:
     def unapply(tp: Type)(using Context): Option[(List[Type], Type, List[Boolean])] =
-      if ctx.erasedTypes then
-        atPhase(erasurePhase)(unapply(tp))
-      else
-        asContextFunctionType(tp) match
-          case PolyFunctionOf(mt: MethodType) =>
-            Some((mt.paramInfos, mt.resType, mt.erasedParams))
-          case tp1 if tp1.exists =>
-            val args = tp1.functionArgInfos
-            val erasedParams = List.fill(functionArity(tp1)) { false }
-            Some((args.init, args.last, erasedParams))
-          case _ => None
+      asContextFunctionType(tp) match
+        case PolyFunctionOf(mt: MethodType) =>
+          Some((mt.paramInfos, mt.resType, mt.erasedParams))
+        case tp1 if tp1.exists =>
+          val args = tp1.functionArgInfos
+          val erasedParams = List.fill(functionArity(tp1)) { false }
+          Some((args.init, args.last, erasedParams))
+        case _ => None
 
   /** A whitelist of Scala-2 classes that are known to be pure */
   def isAssuredNoInits(sym: Symbol): Boolean =

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

@@ -129,25 +129,24 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
           assert(ctx.typer.isInstanceOf[Erasure.Typer])
           ctx.typer.typed(untpd.cpy.Apply(ref)(ref, args), member.info.finalResultType)
         else
-          val defn.ContextFunctionType(argTypes, resType, erasedParams) = tp: @unchecked
-          val anonFun = newAnonFun(ctx.owner,
-            MethodType(
-              argTypes.zip(erasedParams.padTo(argTypes.length, false))
-                      .flatMap((t, e) => if e then None else Some(t)),
-              resType),
-            coord = ctx.owner.coord)
+          val mtWithoutErasedParams = atPhase(erasurePhase) {
+            val defn.ContextFunctionType(argTypes, resType, erasedParams) = tp.dealias: @unchecked
+            val paramInfos = argTypes.zip(erasedParams).collect { case (argType, erased) if !erased => argType }
+            MethodType(paramInfos, resType)
+          }
+          val anonFun = newAnonFun(ctx.owner, mtWithoutErasedParams, 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 =>
+                mtWithoutErasedParams.paramInfos.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))
+            expand(args ::: expandedRefs, mtWithoutErasedParams.resType, n - 1)(using ctx.withOwner(anonFun))
 
           val unadapted = Closure(anonFun, lambdaBody)
           cpy.Block(unadapted)(unadapted.stats,