Add FunctionOf(MethodOrPoly) and improve derivedLambdaType

Author: nicolasstucki

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

@@ -1109,7 +1109,16 @@ class Definitions {
     sym.owner.linkedClass.typeRef
 
   object FunctionOf {
-    /** Create a `FunctionN`, `ContextFunctionN` or refined `PolyFunction` type applied to the arguments and result type
+    /** Create a `FunctionN`, `ContextFunctionN`, refined `PolyFunction` or dependent refinement of a `FunctionN`/`ContextFunctionN`.
+     *
+     *  `PolyFunction` is used if at least one of the parameters is annotated as erased.
+     */
+    def apply(mt: MethodOrPoly)(using Context): Type =
+      val ft = mt.toFunctionType(isJava = false)
+      assert(ft.exists, s"not a valid function type: $mt")
+      ft
+
+    /** Create a `FunctionN`/`ContextFunctionN` type applied to the arguments and result type or a refined `PolyFunction`.
      *
      *  `PolyFunction` is used if at least one of the arguments is annotated as erased.
      */

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

@@ -3675,7 +3675,7 @@ object Types {
   trait LambdaType extends BindingType with TermType { self =>
     type ThisName <: Name
     type PInfo <: Type
-    type This <: LambdaType{type PInfo = self.PInfo}
+    type This >: this.type <: LambdaType{type PInfo = self.PInfo}
     type ParamRefType <: ParamRef
 
     def paramNames: List[ThisName]
@@ -3733,7 +3733,7 @@ object Types {
 
     final def derivedLambdaType(paramNames: List[ThisName] = this.paramNames,
                           paramInfos: List[PInfo] = this.paramInfos,
-                          resType: Type = this.resType)(using Context): LambdaType =
+                          resType: Type = this.resType)(using Context): This =
       if ((paramNames eq this.paramNames) && (paramInfos eq this.paramInfos) && (resType eq this.resType)) this
       else newLikeThis(paramNames, paramInfos, resType)
 
@@ -3852,7 +3852,7 @@ object Types {
     import DepStatus._
     type ThisName = TermName
     type PInfo = Type
-    type This <: TermLambda
+    type This >: this.type <: TermLambda
     type ParamRefType = TermParamRef
 
     override def resultType(using Context): Type =
@@ -4149,7 +4149,7 @@ object Types {
   trait TypeLambda extends LambdaType {
     type ThisName = TypeName
     type PInfo = TypeBounds
-    type This <: TypeLambda
+    type This >: this.type <: TypeLambda
     type ParamRefType = TypeParamRef
 
     def isResultDependent(using Context): Boolean = true

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

@@ -845,9 +845,9 @@ object ProtoTypes {
               tp
             case pt: ApplyingProto =>
               if (rt eq mt.resultType) tp
-              else mt.derivedLambdaType(mt.paramNames, mt.paramInfos, rt)
+              else mt.derivedLambdaType(resType = rt)
             case _ =>
-              val ft = defn.FunctionOf(mt.paramInfos, rt)
+              val ft = defn.FunctionOf(mt.derivedLambdaType(resType = rt))
               if mt.paramInfos.nonEmpty || (ft frozen_<:< pt) then ft else rt
           }
         }