Do not capture dependent function refinements in ContextFunctionOf

Author: nicolasstucki

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

@@ -1138,6 +1138,8 @@ class Definitions {
       asContextFunctionType(tp) match
         case PolyFunctionOf(mt: MethodType) =>
           Some((mt.paramInfos, mt.resType))
+        case DependentFunctionRefinementOf(_, mt) =>
+          None
         case tp1 if tp1.exists =>
           val args = tp1.functionArgInfos
           val erasedParams = List.fill(functionArity(tp1)) { false }

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

@@ -20,6 +20,10 @@ object ContextFunctionResults:
    */
   def annotateContextResults(mdef: DefDef)(using Context): Unit =
     def contextResultCount(rhs: Tree, tp: Type): Int = tp match
+      case defn.DependentFunctionRefinementOf(_, mt) if mt.isContextualMethod =>
+        rhs match
+          case closureDef(meth) => 1 + contextResultCount(meth.rhs, mt.resType)
+          case _ => 0
       case defn.ContextFunctionOf(_, resTpe) =>
         rhs match
           case closureDef(meth) => 1 + contextResultCount(meth.rhs, resTpe)
@@ -58,6 +62,8 @@ object ContextFunctionResults:
    */
   def contextResultsAreErased(sym: Symbol)(using Context): Boolean =
     def allErased(tp: Type): Boolean = tp.dealias match
+      case ft @ defn.DependentFunctionRefinementOf(_, mt) if mt.isContextualMethod =>
+        !defn.erasedFunctionParams(ft).contains(false) && allErased(mt.resType)
       case ft @ defn.ContextFunctionOf(_, resTpe) =>
         !defn.erasedFunctionParams(ft).contains(false) && allErased(resTpe)
       case _ => true
@@ -73,6 +79,8 @@ object ContextFunctionResults:
         integrateContextResults(rt, crCount)
       case tp: MethodOrPoly =>
         tp.derivedLambdaType(resType = integrateContextResults(tp.resType, crCount))
+      case defn.DependentFunctionRefinementOf(base, mt) if mt.isContextualMethod =>
+        integrateContextResults(base, crCount)
       case defn.ContextFunctionOf(argTypes, resType) =>
         MethodType(argTypes, integrateContextResults(resType, crCount - 1))
 
@@ -120,6 +128,8 @@ object ContextFunctionResults:
       case Select(qual, name) =>
         if name == nme.apply then
           qual.tpe match
+            case defn.DependentFunctionRefinementOf(_, mt) if mt.isContextualMethod =>
+              integrateSelect(qual, n + 1)
             case defn.ContextFunctionOf(_, _) =>
               integrateSelect(qual, n + 1)
             case _ if defn.isContextFunctionClass(tree.symbol.maybeOwner) => // for TermRefs