More consistent use of is{Refined,Poly,Erased}isFunctionType

Author: nicolasstucki

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

@@ -1714,9 +1714,13 @@ class Definitions {
 
   /** 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)
+    isPolyFunctionType(tp) || isErasedFunctionType(tp)
 
-  /** Is `tp` a specialized, refined function type? Either an `ErasedFunction`. */
+  /** Is `tp` a specialized, refined `PolyFunction` type? */
+  def isPolyFunctionType(tp: Type)(using Context): Boolean =
+    tp.derivesFrom(defn.PolyFunctionClass)
+
+  /** Is `tp` a specialized, refined `ErasedFunction` type? */
   def isErasedFunctionType(tp: Type)(using Context): Boolean =
     tp.derivesFrom(defn.ErasedFunctionClass)
 

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

@@ -509,8 +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.isErasedFunctionType(parent) => (mt.paramInfos :+ mt.resultType)
-    case RefinedType(parent, nme.apply, mt: MethodType) if parent.typeSymbol eq defn.PolyFunctionClass => (mt.paramInfos :+ mt.resultType)
+    case RefinedType(parent, nme.apply, mt: MethodType) if defn.isRefinedFunctionType(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

@@ -592,7 +592,7 @@ import TypeErasure._
  */
 class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConstructor: Boolean, isSymbol: Boolean, inSigName: Boolean) {
 
-  /**  The erasure |T| of a type T. 
+  /**  The erasure |T| of a type T.
    *
    *   If computing the erasure of T requires erasing a WildcardType or an
    *   uninstantiated type variable, then an exception signaling an internal
@@ -659,7 +659,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 parent.typeSymbol eq defn.PolyFunctionClass =>
+      case RefinedType(parent, nme.apply, refinedInfo) if defn.isPolyFunctionType(parent) =>
         erasePolyFunctionApply(refinedInfo)
       case RefinedType(parent, nme.apply, refinedInfo: MethodType) if defn.isErasedFunctionType(parent) =>
         eraseErasedFunctionApply(refinedInfo)
@@ -943,13 +943,11 @@ 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 parent.typeSymbol eq defn.PolyFunctionClass =>
+      case tp @ RefinedType(parent, nme.apply, _) if defn.isRefinedFunctionType(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
         sigName(this(tp))
-      case tp @ RefinedType(parent, nme.apply, refinedInfo) if defn.isErasedFunctionType(parent) =>
-        sigName(this(tp))
       case tp: TypeProxy =>
         sigName(tp.underlying)
       case tp: WildcardType =>

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

@@ -446,14 +446,12 @@ object TreeChecker {
       assert(tree.isTerm || !ctx.isAfterTyper, tree.show + " at " + ctx.phase)
       val tpe = tree.typeOpt
 
-      // Polymorphic apply methods stay structural until Erasure
-      val isPolyFunctionApply = (tree.name eq nme.apply) && tree.qualifier.typeOpt.derivesFrom(defn.PolyFunctionClass)
-      // Erased functions stay structural until Erasure
-      val isErasedFunctionApply = (tree.name eq nme.apply) && tree.qualifier.typeOpt.derivesFrom(defn.ErasedFunctionClass)
+      // PolyFunction and ErasedFunction apply methods stay structural until Erasure
+      val isRefinedFunctionApply = (tree.name eq nme.apply) && defn.isRefinedFunctionType(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)
-      if !(tree.isType || isPolyFunctionApply || isErasedFunctionApply || isOuterSelect || isPrimitiveArrayOp) then
+      if !(tree.isType || isRefinedFunctionApply || isOuterSelect || isPrimitiveArrayOp) then
         val denot = tree.denot
         assert(denot.exists, i"Selection $tree with type $tpe does not have a denotation")
         assert(denot.symbol.exists, i"Denotation $denot of selection $tree with type $tpe does not have a symbol, qualifier type = ${tree.qualifier.typeOpt}")