Use refined traits for erased functions

- `newFunctionNType` only emits empty traits for erased functions.
- function types with erased parameters are now always refined with the correct `apply` definition,
  for example:

    ErasedFunction2[Int, Int, Int] {
        def apply(x1: Int, erased x2: Int): Int
    }

Author: natsukagami

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

@@ -105,19 +105,13 @@ class Definitions {
    *        def apply(using $x0: T0, ..., $x{N_1}: T{N-1}): R
    *      }
    *
-   *  ErasedFunctionN traits follow this template:
+   *  ErasedFunctionN traits follow this template (they need to be refined):
    *
-   *      trait ErasedFunctionN[-T0,...,-T{N-1}, +R] extends Object {
-   *        def apply(erased $x0: T0, ..., $x{N_1}: T{N-1}): R
-   *      }
-   *
-   *  ErasedContextFunctionN traits follow this template:
+   *      trait ErasedFunctionN[-T0,...,-T{N-1}, +R] extends Object
    *
-   *      trait ErasedContextFunctionN[-T0,...,-T{N-1}, +R] extends Object {
-   *        def apply(using erased $x0: T0, ..., $x{N_1}: T{N-1}): R
-   *      }
+   *  ErasedContextFunctionN traits follow this template (they need to be refined):
    *
-   *  ErasedFunctionN and ErasedContextFunctionN erase to Function0.
+   *      trait ErasedContextFunctionN[-T0,...,-T{N-1}, +R] extend Object
    *
    *  ImpureXYZFunctionN follow this template:
    *
@@ -147,11 +141,12 @@ class Definitions {
             enterTypeParam(cls, paramNamePrefix ++ "T" ++ (i + 1).toString, Contravariant, decls).typeRef
           }
           val resParamRef = enterTypeParam(cls, paramNamePrefix ++ "R", Covariant, decls).typeRef
-          val methodType = MethodType.companion(
-            isContextual = name.isContextFunction,
-            isImplicit = false,
-            isErased = List(name.isErasedFunction)) // TODO @natsukagami fix this
-          decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
+          if !name.isErasedFunction then
+            val methodType = MethodType.companion(
+              isContextual = name.isContextFunction,
+              isImplicit = false,
+              isErased = List())
+            decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
           denot.info =
             ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: Nil, decls)
       }

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

@@ -208,15 +208,8 @@ object NameOps {
             if str == mustHave then found = true
             idx + str.length
           else idx
-        def skipErased(idx: Int) =
-          val erased = "Erased"
-          if first.startsWith(erased, idx) then
-            var ptr = idx + erased.length
-            while first(ptr) != 'X' do { ptr += 1 }
-            ptr + 1
-          else idx
 
-        skip(skipErased(skip(0, "Impure")), "Context") == suffixStart
+        skip(skip(skip(0, "Impure"), "Erased"), "Context") == suffixStart
         && found
       }
 
@@ -243,7 +236,7 @@ object NameOps {
       isFunctionPrefix(suffixStart, mustHave) && funArity(suffixStart) >= 0
 
     def isContextFunction(using Context): Boolean = isSpecificFunction("Context")
-    def isErasedFunction(using Context): Boolean = isSpecificFunction("Erased") // TODO @natsukagami change this
+    def isErasedFunction(using Context): Boolean = isSpecificFunction("Erased")
     def isImpureFunction(using Context): Boolean = isSpecificFunction("Impure")
 
     /** Is a synthetic function name, i.e. one of

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

@@ -1835,6 +1835,7 @@ object Types {
      */
     def toFunctionType(isJava: Boolean, dropLast: Int = 0, alwaysDependent: Boolean = false)(using Context): Type = this match {
       case mt: MethodType if !mt.isParamDependent =>
+        println(s"$mt to function type")
         val formals1 = if (dropLast == 0) mt.paramInfos else mt.paramInfos dropRight dropLast
         val isContextual = mt.isContextualMethod && !ctx.erasedTypes
         val isErased = mt.isErasedMethod && !ctx.erasedTypes // TODO @natsukagami fix this
@@ -1845,7 +1846,7 @@ object Types {
         val funType = defn.FunctionOf(
           formals1 mapConserve (_.translateFromRepeated(toArray = isJava)),
           result1, isContextual, isErased)
-        if alwaysDependent || mt.isResultDependent then RefinedType(funType, nme.apply, mt)
+        if alwaysDependent || isErased || mt.isResultDependent then RefinedType(funType, nme.apply, mt)
         else funType
     }
 

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1299,7 +1299,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
     val numArgs = args.length
     val isContextual = funFlags.is(Given)
-    val isErased = funFlags.is(Erased)
+    val isErased = args.collect({ case x: untpd.ValDef => x }).exists(_.mods.flags.is(Erased))
     val isImpure = funFlags.is(Impure)
     val funSym = defn.FunctionSymbol(numArgs, isContextual, isErased, isImpure)
 
@@ -1353,7 +1353,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     }
   }
 
-  def typedFunctionValue(tree: untpd.Function, pt: Type)(using Context): Tree = {
+  def typedFunctionValue(tree: untpd.Function, pt: Type)(using Context): Tree = trace.force(s"typedFunctionValue ${tree.show} => ${pt.show}", show = true) {
     val untpd.Function(params: List[untpd.ValDef] @unchecked, _) = tree: @unchecked
 
     val isContextual = tree match {
@@ -1459,9 +1459,16 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
     val (protoFormals, resultTpt) = decomposeProtoFunction(pt, params.length, tree.srcPos)
 
-    def protoFormal(i: Int): Type =
-      if (protoFormals.length == params.length) protoFormals(i)
-      else errorType(WrongNumberOfParameters(protoFormals.length), tree.srcPos)
+    val protoIsErased = pt match {
+      case RefinedType(_, _, mt: MethodType) if mt.isErasedMethod =>
+        mt.companion.asInstanceOf[ErasedMethodCompanion].isErased
+      case _ => List.fill(protoFormals.length)(false)
+    }
+
+    /** Returns the type and whether the parameter is erased */
+    def protoFormal(i: Int): (Type, Boolean) =
+      if (protoFormals.length == params.length) (protoFormals(i), protoIsErased(i))
+      else (errorType(WrongNumberOfParameters(protoFormals.length), tree.srcPos), false)
 
     /** Is `formal` a product type which is elementwise compatible with `params`? */
     def ptIsCorrectProduct(formal: Type) =
@@ -1499,7 +1506,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         for ((param, i) <- params.zipWithIndex) yield
           if (!param.tpt.isEmpty) param
           else
-            val formal = protoFormal(i)
+            val (formal, isErased) = protoFormal(i)
             val knownFormal = isFullyDefined(formal, ForceDegree.failBottom)
             val paramType =
               if knownFormal then formal
@@ -1510,14 +1517,17 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                   .withType(paramType.translateFromRepeated(toArray = false))
                   .withSpan(param.span.endPos)
               )
-            cpy.ValDef(param)(tpt = paramTpt)
+            val param1 = if isErased then param.withAddedFlags(Flags.Erased) else param
+            println(s" > $param1 => $paramType => ${param1.mods.flags.is(Flags.Erased)}")
+            cpy.ValDef(param1)(tpt = paramTpt)
       desugared = desugar.makeClosure(inferredParams, fnBody, resultTpt, isContextual, tree.span)
+      println(s">> ${desugared.show}")
 
     typed(desugared, pt)
       .showing(i"desugared fun $tree --> $desugared with pt = $pt", typr)
   }
 
-  def typedClosure(tree: untpd.Closure, pt: Type)(using Context): Tree = {
+  def typedClosure(tree: untpd.Closure, pt: Type)(using Context): Tree = trace.force(s"typedClosure ${tree.show} => ${pt.show}", show = true) {
     val env1 = tree.env mapconserve (typed(_))
     val meth1 = typedUnadapted(tree.meth)
     val target =