Change isFunctionType to only recognize synthesized Function traits

Poly and Erased functions are recognized in `isRefinedFunctionType`.
Comments are updated to reflect this.

Author: natsukagami

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

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

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

@@ -739,7 +739,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             case actual @ AppliedType(tycon, args) if defn.isNonRefinedFunction(actual) =>
               adaptFun(actual, args.init, args.last, expected, covariant, insertBox,
                   (aargs1, ares1) => actual.derivedAppliedType(tycon, aargs1 :+ ares1))
-            case actual @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionType(actual) =>
+            case actual @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionOrPolyType(actual) =>
               // TODO Find a way to combine handling of generic and dependent function types (here and elsewhere)
               adaptFun(actual, rinfo.paramInfos, rinfo.resType, expected, covariant, insertBox,
                 (aargs1, ares1) =>
@@ -962,7 +962,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             case CapturingType(parent, refs) =>
               healCaptureSet(refs)
               traverse(parent)
-            case tp @ RefinedType(parent, rname, rinfo: MethodType) if defn.isFunctionType(tp) =>
+            case tp @ RefinedType(parent, rname, rinfo: MethodType) if defn.isFunctionOrPolyType(tp) =>
               traverse(rinfo)
             case tp: TermLambda =>
               val saved = allowed

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

@@ -54,7 +54,7 @@ extends tpd.TreeTraverser:
         val boxedRes = recur(res)
         if boxedRes eq res then tp
         else tp1.derivedAppliedType(tycon, args.init :+ boxedRes)
-      case tp1 @ RefinedType(_, _, rinfo) if defn.isFunctionType(tp1) =>
+      case tp1 @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionOrPolyType(tp1) =>
         val boxedRinfo = recur(rinfo)
         if boxedRinfo eq rinfo then tp
         else boxedRinfo.toFunctionType(isJava = false, alwaysDependent = true)
@@ -231,7 +231,7 @@ extends tpd.TreeTraverser:
                 tp.derivedAppliedType(tycon1, args1 :+ res1)
           else
             tp.derivedAppliedType(tycon1, args.mapConserve(arg => this(arg)))
-        case tp @ RefinedType(core, rname, rinfo) if defn.isFunctionType(tp) =>
+        case tp @ RefinedType(core, rname, rinfo: MethodType) if defn.isFunctionOrPolyType(tp) =>
           val rinfo1 = apply(rinfo)
           if rinfo1 ne rinfo then rinfo1.toFunctionType(isJava = false, alwaysDependent = true)
           else tp
@@ -327,7 +327,7 @@ extends tpd.TreeTraverser:
               args.last, CaptureSet.empty, currentCs ++ outerCs)
             tp.derivedAppliedType(tycon1, args1 :+ resType1)
         tp1.capturing(outerCs)
-      case tp @ RefinedType(parent, nme.apply, rinfo: MethodType) if defn.isFunctionType(tp) =>
+      case tp @ RefinedType(parent, nme.apply, rinfo: MethodType) if defn.isFunctionOrPolyType(tp) =>
         propagateDepFunctionResult(mapOver(tp), currentCs ++ outerCs)
           .capturing(outerCs)
       case _ =>

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

@@ -1483,7 +1483,6 @@ class Definitions {
 
   /** Is any function class where
    *   - FunctionXXL
-   *   - ErasedFunction
    *   - FunctionN for N >= 0
    *   - ContextFunctionN for N >= 0
    */
@@ -1684,12 +1683,25 @@ class Definitions {
         skipRefined = false)
   end isNonRefinedFunction
 
-  /** Is `tp` a representation of a (possibly dependent) function type or an alias of such? */
+  /** Returns whether `tp` is an instance or a refined instance of:
+   *  - scala.FunctionN
+   *  - scala.ContextFunctionN
+   */
   def isFunctionType(tp: Type)(using Context): Boolean =
-    isNonRefinedFunction(tp.dropDependentRefinement) || isErasedFunctionType(tp)
+    isNonRefinedFunction(tp.dropDependentRefinement)
+
+  /** Is `tp` a specialized, refined function type? Either an `ErasedFunction` or a `PolyFunction`. */
+  def isRefinedFunctionType(tp: Type)(using Context): Boolean =
+    tp.derivesFrom(defn.PolyFunctionClass) || isErasedFunctionType(tp)
 
+  /** Returns whether `tp` is an instance or a refined instance of:
+   *  - scala.FunctionN
+   *  - scala.ContextFunctionN
+   *  - ErasedFunction
+   *  - PolyFunction
+   */
   def isFunctionOrPolyType(tp: Type)(using Context): Boolean =
-    isFunctionType(tp) || (tp.typeSymbol eq defn.PolyFunctionClass)
+    isFunctionType(tp) || isRefinedFunctionType(tp)
 
   private def withSpecMethods(cls: ClassSymbol, bases: List[Name], paramTypes: Set[TypeRef]) =
     for base <- bases; tp <- paramTypes do

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

@@ -225,11 +225,10 @@ object NameOps {
     private def checkedFunArity(suffixStart: Int)(using Context): Int =
       if isFunctionPrefix(suffixStart) then funArity(suffixStart) else -1
 
-    /** Is a function name, i.e one of FunctionXXL, FunctionN, ContextFunctionN, ErasedFunctionN, ErasedContextFunctionN for N >= 0
+    /** Is a function name, i.e one of FunctionXXL, FunctionN, ContextFunctionN, ImpureFunctionN, ImpureContextFunctionN for N >= 0
      */
     def isFunction(using Context): Boolean =
       (name eq tpnme.FunctionXXL)
-      || (name eq tpnme.ErasedFunction)
       || checkedFunArity(functionSuffixStart) >= 0
 
     /** Is a function name
@@ -248,8 +247,6 @@ object NameOps {
     /** Is a synthetic function name, i.e. one of
      *    - FunctionN for N > 22
      *    - ContextFunctionN for N >= 0
-     *    - ErasedFunctionN for N >= 0
-     *    - ErasedContextFunctionN for N >= 0
      */
     def isSyntheticFunction(using Context): Boolean =
       val suffixStart = functionSuffixStart