Rename isRefinedFunctionType to isPolyOrErasedFunctionType

[Cherry-picked 96af363]

Author: nicolasstucki

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

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

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

@@ -1705,7 +1705,7 @@ class Definitions {
     isNonRefinedFunction(tp.dropDependentRefinement)
 
   /** Is `tp` a specialized, refined function type? Either an `ErasedFunction` or a `PolyFunction`. */
-  def isRefinedFunctionType(tp: Type)(using Context): Boolean =
+  def isPolyOrErasedFunctionType(tp: Type)(using Context): Boolean =
     isPolyFunctionType(tp) || isErasedFunctionType(tp)
 
   /** Is `tp` a specialized, refined `PolyFunction` type? */
@@ -1723,7 +1723,7 @@ class Definitions {
    *  - PolyFunction
    */
   def isFunctionType(tp: Type)(using Context): Boolean =
-    isFunctionNType(tp) || isRefinedFunctionType(tp)
+    isFunctionNType(tp) || isPolyOrErasedFunctionType(tp)
 
   private def withSpecMethods(cls: ClassSymbol, bases: List[Name], paramTypes: Set[TypeRef]) =
     for base <- bases; tp <- paramTypes do

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

@@ -509,7 +509,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  Handles `ErasedFunction`s and poly functions gracefully.
    */
   final def functionArgInfos(using Context): List[Type] = self.dealias match
-    case RefinedType(parent, nme.apply, mt: MethodType) if defn.isRefinedFunctionType(parent) => (mt.paramInfos :+ mt.resultType)
+    case RefinedType(parent, nme.apply, mt: MethodType) if defn.isPolyOrErasedFunctionType(parent) => (mt.paramInfos :+ mt.resultType)
     case _ => self.dropDependentRefinement.dealias.argInfos
 
   /** Argument types where existential types in arguments are disallowed */

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

@@ -654,7 +654,7 @@ 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.isRefinedFunctionType(parent) =>
+      case RefinedType(parent, nme.apply, refinedInfo) if defn.isPolyOrErasedFunctionType(parent) =>
         eraseRefinedFunctionApply(refinedInfo)
       case tp: TypeVar if !tp.isInstantiated =>
         assert(inSigName, i"Cannot erase uninstantiated type variable $tp")
@@ -936,7 +936,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
         sigName(defn.FunctionOf(Nil, rt))
       case tp: TypeVar if !tp.isInstantiated =>
         tpnme.Uninstantiated
-      case tp @ RefinedType(parent, nme.apply, _) if defn.isRefinedFunctionType(parent) =>
+      case tp @ RefinedType(parent, nme.apply, _) if defn.isPolyOrErasedFunctionType(parent) =>
         // we need this case rather than falling through to the default
         // because RefinedTypes <: TypeProxy and it would be caught by
         // the case immediately below

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

@@ -677,7 +677,7 @@ object Erasure {
           // Instead, we manually lookup the type of `apply` in the qualifier.
           inContext(preErasureCtx) {
             val qualTp = tree.qualifier.typeOpt.widen
-            if defn.isRefinedFunctionType(qualTp) then
+            if defn.isPolyOrErasedFunctionType(qualTp) then
               eraseRefinedFunctionApply(qualTp.select(nme.apply).widen).classSymbol
             else
               NoSymbol

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

@@ -446,7 +446,7 @@ object TreeChecker {
       val tpe = tree.typeOpt
 
       // PolyFunction and ErasedFunction apply methods stay structural until Erasure
-      val isRefinedFunctionApply = (tree.name eq nme.apply) && defn.isRefinedFunctionType(tree.qualifier.typeOpt)
+      val isRefinedFunctionApply = (tree.name eq nme.apply) && defn.isPolyOrErasedFunctionType(tree.qualifier.typeOpt)
       // Outer selects are pickled specially so don't require a symbol
       val isOuterSelect = tree.name.is(OuterSelectName)
       val isPrimitiveArrayOp = ctx.erasedTypes && nme.isPrimitiveName(tree.name)