Add PolyFunctionOf

Author: nicolasstucki

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

@@ -1138,6 +1138,18 @@ class Definitions {
       case _ => None
   }
 
+  object PolyFunctionOf {
+    /** Matches a refined `PolyFunction` type and extracts the apply info.
+     *
+     *  Pattern: `PolyFunction { def apply: $pt }`
+     */
+    def unapply(ft: Type)(using Context): Option[PolyType] = ft.dealias match
+      case RefinedType(parent, nme.apply, pt: PolyType)
+      if parent.derivesFrom(defn.PolyFunctionClass) =>
+        Some(pt)
+      case _ => None
+  }
+
   object ErasedFunctionOf {
     /** Matches a refined `ErasedFunction` type and extracts the apply info.
      *

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

@@ -1650,11 +1650,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     // If the expected type is a polymorphic function with the same number of
     // type and value parameters, then infer the types of value parameters from the expected type.
     val inferredVParams = pt match
-      case RefinedType(parent, nme.apply, poly @ PolyType(_, mt: MethodType))
-      if (parent.typeSymbol eq defn.PolyFunctionClass)
-      && tparams.lengthCompare(poly.paramNames) == 0
-      && vparams.lengthCompare(mt.paramNames) == 0
-      =>
+      case PolyFunctionOf(poly @ PolyType(_, mt: MethodType))
+      if tparams.lengthCompare(poly.paramNames) == 0 && vparams.lengthCompare(mt.paramNames) == 0 =>
         vparams.zipWithConserve(mt.paramInfos): (vparam, formal) =>
           // Unlike in typedFunctionValue, `formal` cannot be a TypeBounds since
           // it must be a valid method parameter type.
@@ -1669,7 +1666,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         vparams
 
     val resultTpt = pt.dealias match
-      case RefinedType(parent, nme.apply, poly @ PolyType(_, mt: MethodType)) if parent.classSymbol eq defn.PolyFunctionClass =>
+      case PolyFunctionOf(poly @ PolyType(_, mt: MethodType)) =>
         untpd.InLambdaTypeTree(isResult = true, (tsyms, vsyms) =>
           mt.resultType.substParams(mt, vsyms.map(_.termRef)).substParams(poly, tsyms.map(_.typeRef)))
       case _ => untpd.TypeTree()