Add a root ErasedFunction class type

Helps with checking that types are `derivesFrom(ErasedFunctionClass)`.
Also make sure that we use `isErasedFunctionType` in most places
in place of `isErasedFunctionClass` (which is just a synthetic class check).

Author: natsukagami

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -910,7 +910,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
         val qualType = tree.qualifier.tpe
         hasRefinement(qualType) &&
           !qualType.derivesFrom(defn.PolyFunctionClass) &&
-          !defn.isErasedFunctionClass(qualType.typeSymbol)
+          !defn.isErasedFunctionType(qualType)
       }
     def loop(tree: Tree): Boolean = tree match
       case TypeApply(fun, _) =>

compiler/src/dotty/tools/dotc/cc/Setup.scala

@@ -35,7 +35,7 @@ extends tpd.TreeTraverser:
    *  arguments `argTypes` and result `resType`.
    */
   private def depFun(tycon: Type, argTypes: List[Type], resType: Type)(using Context): Type =
-    assert(!defn.isErasedFunctionClass(tycon.classSymbol)) // TODO @natsukagami not sure how to know
+    assert(!defn.isErasedFunctionType(tycon)) // TODO @natsukagami not sure how to know
                                                            // erased parameter info here.
     MethodType.companion(
         isContextual = defn.isContextFunctionClass(tycon.classSymbol),

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

@@ -147,8 +147,9 @@ class Definitions {
               isImplicit = false,
               isErased = List())
             decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
+          val parent = if name.isErasedFunction then List(ErasedFunctionType) else Nil
           denot.info =
-            ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: Nil, decls)
+            ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: parent, decls)
       }
     }
     if impure then
@@ -1445,6 +1446,9 @@ class Definitions {
   lazy val PolyFunctionClass = requiredClass("scala.PolyFunction")
   def PolyFunctionType = PolyFunctionClass.typeRef
 
+  lazy val ErasedFunctionClass = requiredClass("scala.ErasedFunction")
+  def ErasedFunctionType = ErasedFunctionClass.typeRef
+
   /** If `cls` is a class in the scala package, its name, otherwise EmptyTypeName */
   def scalaClassName(cls: Symbol)(using Context): TypeName = cls.denot match
     case clsd: ClassDenotation if clsd.owner eq ScalaPackageClass =>
@@ -1804,8 +1808,7 @@ class Definitions {
         else None
 
   def isErasedFunctionType(tp: Type)(using Context): Boolean =
-    // false // TODO @natsukagami fix this
-    tp.dealias.typeSymbol.name.isErasedFunction && isFunctionType(tp)
+    tp.derivesFrom(defn.ErasedFunctionClass)
 
   /** A whitelist of Scala-2 classes that are known to be pure */
   def isAssuredNoInits(sym: Symbol): Boolean =

library/src/scala/ErasedFunction.scala

@@ -0,0 +1,9 @@
+package scala
+
+/** Marker trait for erased function types.
+ *
+ *  This trait will be refined with an `apply` method with erased parameters:
+ *      ErasedFunction { def apply[T_1, ..., T_M]([erased] x_1: P_1, ..., [erased] x_N: P_N): R }
+ *  This type will be erased to FunctionM, where M is the number of non-erased parameters.
+ */
+trait ErasedFunction