Generalize/simplify refined function type Erasure

The erasure now supports polymorphic function types with erased parameters.
We still need to add support for this in the typer.

Author: nicolasstucki

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

@@ -560,21 +560,19 @@ object TypeErasure {
     case _ => false
   }
 
-  /** The erasure of `PolyFunction { def apply: $applyInfo }` */
-  def erasePolyFunctionApply(applyInfo: Type)(using Context): Type =
-    assert(applyInfo.isInstanceOf[PolyType])
-    val res = applyInfo.resultType
-    val paramss = res.paramNamess
-    assert(paramss.length == 1)
-    erasure(defn.FunctionType(paramss.head.length,
-      isContextual = res.isImplicitMethod))
-
-  def eraseErasedFunctionApply(erasedFn: MethodType)(using Context): Type =
-    val fnType = defn.FunctionType(
-      n = erasedFn.erasedParams.count(_ == false),
-      isContextual = erasedFn.isContextualMethod,
-    )
-    erasure(fnType)
+  /** The erasure of `(PolyFunction | ErasedFunction) { def apply: $applyInfo }` */
+  def eraseRefinedFunctionApply(applyInfo: Type)(using Context): Type =
+    def functionType(info: Type): Type = info match {
+      case info: PolyType =>
+        functionType(info.resultType)
+      case info: MethodType =>
+        assert(!info.resultType.isInstanceOf[MethodicType])
+        defn.FunctionType(
+          n = info.erasedParams.count(_ == false),
+          isContextual = info.isImplicitMethod,
+        )
+    }
+    erasure(functionType(applyInfo))
 }
 
 import TypeErasure._
@@ -659,10 +657,8 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
         else SuperType(eThis, eSuper)
       case ExprType(rt) =>
         defn.FunctionType(0)
-      case RefinedType(parent, nme.apply, refinedInfo) if defn.isPolyFunctionType(parent) =>
-        erasePolyFunctionApply(refinedInfo)
-      case RefinedType(parent, nme.apply, refinedInfo: MethodType) if defn.isErasedFunctionType(parent) =>
-        eraseErasedFunctionApply(refinedInfo)
+      case RefinedType(parent, nme.apply, refinedInfo) if defn.isRefinedFunctionType(parent) =>
+        eraseRefinedFunctionApply(refinedInfo)
       case tp: TypeVar if !tp.isInstantiated =>
         assert(inSigName, i"Cannot erase uninstantiated type variable $tp")
         WildcardType

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

@@ -679,10 +679,8 @@ object Erasure {
           // Instead, we manually lookup the type of `apply` in the qualifier.
           inContext(preErasureCtx) {
             val qualTp = tree.qualifier.typeOpt.widen
-            if qualTp.derivesFrom(defn.PolyFunctionClass) then
-              erasePolyFunctionApply(qualTp.select(nme.apply).widen).classSymbol
-            else if defn.isErasedFunctionType(qualTp) then
-              eraseErasedFunctionApply(qualTp.select(nme.apply).widen.asInstanceOf[MethodType]).classSymbol
+            if defn.isRefinedFunctionType(qualTp) then
+              eraseRefinedFunctionApply(qualTp.select(nme.apply).widen).classSymbol
             else
               NoSymbol
           }