Add DependentFunctionRefinementOf

Author: nicolasstucki

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -707,10 +707,13 @@ class CheckCaptures extends Recheck, SymTransformer:
           val eparent1 = recur(eparent)
           if eparent1 eq eparent then expected
           else CapturingType(eparent1, refs, boxed = expected0.isBoxed)
-        case expected @ defn.FunctionOf(args, resultType, isContextual)
-          if defn.isNonRefinedFunction(expected) && defn.isFunctionNType(actual) && !defn.isNonRefinedFunction(actual) =>
-          val expected1 = toDepFun(args, resultType, isContextual)
-          expected1
+        case defn.DependentFunctionRefinementOf(_, _) =>
+          expected
+        case expected @ defn.FunctionOf(args, resultType, isContextual) =>
+          actual match
+            case defn.DependentFunctionRefinementOf(_, _) => expected
+            case _ if defn.isFunctionNType(actual) => toDepFun(args, resultType, isContextual)
+            case _ => expected
         case _ =>
           expected
       recur(expected)
@@ -842,7 +845,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
           // Adapt the inner shape type: get the adapted shape type, and the capture set leaked during adaptation
           val (styp1, leaked) = styp match {
-            case actual @ AppliedType(tycon, args) if defn.isNonRefinedFunction(actual) =>
+            case actual @ AppliedType(tycon, args) if defn.isFunctionNType(actual) =>
               adaptFun(actual, args.init, args.last, expected, covariant, insertBox,
                   (aargs1, ares1) => actual.derivedAppliedType(tycon, aargs1 :+ ares1))
             case actual @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionType(actual) =>

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

@@ -1174,6 +1174,17 @@ class Definitions {
         case _ => isValidMethodType(info)
   }
 
+  object DependentFunctionRefinementOf {
+    /** Matches a refined function FT type and extracts FT and apply info.
+     *
+     *  Pattern: `$ft { def apply: $mt }`
+     */
+    def unapply(ft: Type)(using Context): Option[(Type, MethodType)] = ft.dealias match
+      case RefinedType(parent, nme.apply, mt: MethodType) if isNonRefinedFunction(parent) =>
+        Some((parent, mt))
+      case _ => None
+  }
+
   object PartialFunctionOf {
     def apply(arg: Type, result: Type)(using Context): Type =
       PartialFunctionClass.typeRef.appliedTo(arg :: result :: Nil)

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

@@ -1893,9 +1893,11 @@ class Namer { typer: Typer =>
       val originalTp = defaultParamType
       val approxTp = wildApprox(originalTp)
       approxTp.stripPoly match
+        case defn.DependentFunctionRefinementOf(_, mt) if mt.isContextualMethod =>
+          // in this case `resType` is lying, gives us only the non-dependent upper bound
+          originalTp
         case atp @ defn.ContextFunctionOf(_, resType)
-        if !defn.isNonRefinedFunction(atp) // in this case `resType` is lying, gives us only the non-dependent upper bound
-            || resType.existsPart(_.isInstanceOf[WildcardType], StopAt.Static, forceLazy = false) =>
+        if resType.existsPart(_.isInstanceOf[WildcardType], StopAt.Static, forceLazy = false) =>
           originalTp
         case _ =>
           approxTp

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -1799,9 +1799,9 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
                 case PolyType(_, _, mt1) => mt1.hasErasedParams
             case _ => false
         def isDependentFunctionType: Boolean =
-          val tpNoRefinement = self.dropDependentRefinement
-          tpNoRefinement != self
-          && dotc.core.Symbols.defn.isNonRefinedFunction(tpNoRefinement)
+          self match
+            case dotc.core.Symbols.defn.DependentFunctionRefinementOf(_, _) => true
+            case _ => false
         def isTupleN: Boolean =
           dotc.core.Symbols.defn.isTupleNType(self)
         def select(sym: Symbol): TypeRepr = self.select(sym)