Handle ErasedFunctions as refined traits

Author: natsukagami

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

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

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

@@ -35,9 +35,11 @@ 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
+                                                           // erased parameter info here.
     MethodType.companion(
         isContextual = defn.isContextFunctionClass(tycon.classSymbol),
-        isErased = defn.isErasedFunctionClass(tycon.classSymbol)
+        isErased = List()
       )(argTypes, resType)
       .toFunctionType(isJava = false, alwaysDependent = true)
 

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

@@ -1501,7 +1501,7 @@ class Definitions {
    *   - ErasedFunctionN for N > 0
    *   - ErasedContextFunctionN for N > 0
    */
-  def isErasedFunctionClass(cls: Symbol): List[Boolean] = List(scalaClassName(cls).isErasedFunction) // TODO @natsukagami fix this
+  def isErasedFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isErasedFunction // TODO @natsukagami fix this
 
   /** Is either FunctionXXL or  a class that will be erased to FunctionXXL
    *   - FunctionXXL
@@ -1539,8 +1539,7 @@ class Definitions {
    */
   def functionTypeErasure(cls: Symbol): Type =
     val arity = scalaClassName(cls).functionArity
-    if cls.name.isErasedFunction then FunctionType(0)
-    else if arity > 22 then FunctionXXLClass.typeRef
+    if arity > 22 then FunctionXXLClass.typeRef
     else if arity >= 0 then FunctionType(arity)
     else NoType
 
@@ -1805,8 +1804,8 @@ class Definitions {
         else None
 
   def isErasedFunctionType(tp: Type)(using Context): Boolean =
-    false // TODO @natsukagami fix this
-    // tp.dealias.typeSymbol.name.isErasedFunction && isFunctionType(tp)
+    // false // TODO @natsukagami fix this
+    tp.dealias.typeSymbol.name.isErasedFunction && isFunctionType(tp)
 
   /** A whitelist of Scala-2 classes that are known to be pure */
   def isAssuredNoInits(sym: Symbol): Boolean =

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

@@ -536,6 +536,16 @@ object TypeErasure {
     assert(paramss.length == 1)
     erasure(defn.FunctionType(paramss.head.length,
       isContextual = res.isImplicitMethod, isErased = res.isErasedMethod))
+
+  def eraseErasedFunctionApply(applyInfo: Type)(using Context): Type =
+    val erasedFn = applyInfo.asInstanceOf[MethodType]
+    val companion = erasedFn.companion.asInstanceOf[ErasedMethodCompanion]
+    val fnType = defn.FunctionType(
+      n = companion.isErased.count(_ == false),
+      isErased = false,
+      isContextual = erasedFn.isContextualMethod,
+    )
+    erasure(fnType)
 }
 
 import TypeErasure._
@@ -612,6 +622,8 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
       defn.FunctionType(0)
     case RefinedType(parent, nme.apply, refinedInfo) if parent.typeSymbol eq defn.PolyFunctionClass =>
       erasePolyFunctionApply(refinedInfo)
+    case RefinedType(parent, nme.apply, refinedInfo) if defn.isErasedFunctionClass(parent.typeSymbol) =>
+      eraseErasedFunctionApply(refinedInfo)
     case tp: TypeProxy =>
       this(tp.underlying)
     case tp @ AndType(tp1, tp2) =>
@@ -648,14 +660,14 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
       val formals = formals0.mapConserve(paramErasure)
       eraseResult(tp.resultType) match {
         case rt: MethodType =>
-          tp.derivedLambdaType(names ++ rt.paramNames, formals ++ rt.paramInfos, rt.resultType)
+          tp.withoutErased.derivedLambdaType(names ++ rt.paramNames, formals ++ rt.paramInfos, rt.resultType)
         case NoType =>
           // Can happen if we smuggle in a Nothing in the qualifier. Normally we prevent that
           // in Checking.checkMembersOK, but compiler-generated code can bypass this test.
           // See i15377.scala for a test case.
           NoType
         case rt =>
-          tp.derivedLambdaType(names, formals, rt)
+          tp.withoutErased.derivedLambdaType(names, formals, rt)
       }
     case tp: PolyType =>
       this(tp.resultType)
@@ -864,6 +876,8 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
         // because RefinedTypes <: TypeProxy and it would be caught by
         // the case immediately below
         sigName(this(tp))
+      case tp @ RefinedType(parent, nme.apply, refinedInfo) if defn.isErasedFunctionClass(parent.typeSymbol) =>
+        sigName(this(tp))
       case tp: TypeProxy =>
         sigName(tp.underlying)
       case tp: WildcardType =>

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

@@ -1835,7 +1835,6 @@ 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
@@ -3912,6 +3911,15 @@ object Types {
       companion.eq(ContextualMethodType) ||
       companion.isInstanceOf[ErasedContextualMethodType]
 
+    def withoutErased(using Context): MethodType =
+      val newCompanion = companion match {
+        case _: ErasedMethodType => MethodType
+        case _: ErasedContextualMethodType => ContextualMethodType
+        case _: ErasedImplicitMethodType => ImplicitMethodType
+        case c => c
+      }
+      newCompanion(paramNames)(paramInfosExp, resultTypeExp)
+
     protected def prefixString: String = companion.prefixString
   }
 

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

@@ -500,7 +500,7 @@ object Erasure {
         if isFunction && !ctx.settings.scalajs.value then
           val arity = implParamTypes.length
           val specializedFunctionalInterface =
-            if defn.isSpecializableFunctionSAM(implParamTypes, implResultType) then
+            if !implType.isErasedMethod && defn.isSpecializableFunctionSAM(implParamTypes, implResultType) then
               // Using these subclasses is critical to avoid boxing since their
               // SAM is a specialized method `apply$mc*$sp` whose default
               // implementation in FunctionN boxes.
@@ -679,6 +679,8 @@ object Erasure {
             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).classSymbol
             else
               NoSymbol
           }

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

@@ -70,7 +70,7 @@ class SpecializeFunctions extends MiniPhase {
   /** Dispatch to specialized `apply`s in user code when available */
   override def transformApply(tree: Apply)(using Context) =
     tree match {
-      case Apply(fun: NameTree, args) if fun.name == nme.apply && args.size <= 3 && fun.symbol.owner.isType =>
+      case Apply(fun: NameTree, args) if fun.name == nme.apply && args.size <= 3 && fun.symbol.exists && fun.symbol.owner.isType =>
         val argTypes = fun.tpe.widen.firstParamTypes.map(_.widenSingleton.dealias)
         val retType  = tree.tpe.widenSingleton.dealias
         val isSpecializable =

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

@@ -1353,7 +1353,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     }
   }
 
-  def typedFunctionValue(tree: untpd.Function, pt: Type)(using Context): Tree = trace.force(s"typedFunctionValue ${tree.show} => ${pt.show}", show = true) {
+  def typedFunctionValue(tree: untpd.Function, pt: Type)(using Context): Tree = {
     val untpd.Function(params: List[untpd.ValDef] @unchecked, _) = tree: @unchecked
 
     val isContextual = tree match {
@@ -1518,16 +1518,14 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                   .withSpan(param.span.endPos)
               )
             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 = trace.force(s"typedClosure ${tree.show} => ${pt.show}", show = true) {
+  def typedClosure(tree: untpd.Closure, pt: Type)(using Context): Tree = {
     val env1 = tree.env mapconserve (typed(_))
     val meth1 = typedUnadapted(tree.meth)
     val target =