Simplify DependentFunctionRefinementOf

Author: nicolasstucki

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

@@ -532,7 +532,7 @@ class CheckCaptures extends Recheck, SymTransformer:
               meth.updateInfoBetween(preRecheckPhase, thisPhase, completer)
           pt.dealias match
             case defn.NonDependentFunctionOf(ptformals, _, _) => recheckFunction(ptformals)
-            case defn.DependentFunctionRefinementOf(_, mt) => recheckFunction(mt.paramInfos)
+            case defn.DependentFunctionRefinementOf(mt) => recheckFunction(mt.paramInfos)
             case _ =>
           mdef.rhs match
             case rhs @ closure(_, _, _) =>
@@ -711,7 +711,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           else CapturingType(eparent1, refs, boxed = expected0.isBoxed)
         case defn.NonDependentFunctionOf(args, resultType, isContextual) =>
           actual match
-            case defn.DependentFunctionRefinementOf(_, _) =>
+            case defn.DependentFunctionRefinementOf(_) =>
               toDepFun(args, resultType, isContextual)
             case _ =>
               expected

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

@@ -1198,9 +1198,10 @@ class Definitions {
      *
      *  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 isFunctionNType(parent) && mt.isResultDependent =>
-        Some((parent, mt))
+    def unapply(ft: Type)(using Context): Option[MethodType] = ft.dealias match
+      case RefinedType(parent, nme.apply, mt: MethodType)
+      if isFunctionNType(parent) && mt.isResultDependent =>
+        Some(mt)
       case _ => None
   }
 

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

@@ -20,7 +20,7 @@ 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 =>
+      case defn.DependentFunctionRefinementOf(mt) if mt.isContextualMethod =>
         rhs match
           case closureDef(meth) => 1 + contextResultCount(meth.rhs, mt.resType)
           case _ => 0
@@ -62,7 +62,7 @@ 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 =>
+      case ft @ defn.DependentFunctionRefinementOf(mt) if mt.isContextualMethod =>
         !defn.erasedFunctionParams(ft).contains(false) && allErased(mt.resType)
       case ft @ defn.NonDependentContextFunctionOf(_, resTpe) =>
         !defn.erasedFunctionParams(ft).contains(false) && allErased(resTpe)
@@ -79,8 +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.DependentFunctionRefinementOf(mt) if mt.isContextualMethod =>
+        mt.derivedLambdaType(resType = integrateContextResults(mt.resultType, crCount - 1))
       case defn.NonDependentContextFunctionOf(argTypes, resType) =>
         MethodType(argTypes, integrateContextResults(resType, crCount - 1))
 
@@ -128,7 +128,7 @@ object ContextFunctionResults:
       case Select(qual, name) =>
         if name == nme.apply then
           qual.tpe match
-            case defn.DependentFunctionRefinementOf(_, mt) if mt.isContextualMethod =>
+            case defn.DependentFunctionRefinementOf(mt) if mt.isContextualMethod =>
               integrateSelect(qual, n + 1)
             case defn.NonDependentContextFunctionOf(_, _) =>
               integrateSelect(qual, n + 1)

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

@@ -1893,7 +1893,7 @@ class Namer { typer: Typer =>
       val originalTp = defaultParamType
       val approxTp = wildApprox(originalTp)
       approxTp.stripPoly match
-        case defn.DependentFunctionRefinementOf(_, mt) if mt.isContextualMethod =>
+        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.NonDependentContextFunctionOf(_, resType)

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

@@ -1330,7 +1330,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         case ft @ defn.PolyFunctionOf(mt @ MethodTpe(_, formals, restpe)) =>
           if formals.length != defaultArity then fallbackProto
           else (formals, untpd.InLambdaTypeTree(isResult = true, (_, syms) => restpe.substParams(mt, syms.map(_.termRef))))
-        case ft @ defn.DependentFunctionRefinementOf(_, mt @ MethodTpe(_, formals, restpe)) =>
+        case ft @ defn.DependentFunctionRefinementOf(mt @ MethodTpe(_, formals, restpe)) =>
           if formals.length != defaultArity then fallbackProto
           else (formals, untpd.InLambdaTypeTree(isResult = true, (_, syms) => restpe.substParams(mt, syms.map(_.termRef))))
         case SAMType(mt @ MethodTpe(_, formals, _), samParent) =>

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

@@ -1800,7 +1800,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
             case _ => false
         def isDependentFunctionType: Boolean =
           self match
-            case dotc.core.Symbols.defn.DependentFunctionRefinementOf(_, _) => true
+            case dotc.core.Symbols.defn.DependentFunctionRefinementOf(_) => true
             case _ => false
         def isTupleN: Boolean =
           dotc.core.Symbols.defn.isTupleNType(self)