Rename {FunctionOf,ContextFunctionOf}.unapply to NonDependent*

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -1149,7 +1149,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     def etaExpandCFT(using Context): Tree =
       def expand(target: Tree, tp: Type)(using Context): Tree = tp match
-        case defn.ContextFunctionOf(argTypes, resType) =>
+        case defn.NonDependentContextFunctionOf(argTypes, resType) =>
           val anonFun = newAnonFun(
             ctx.owner,
             MethodType.companion(isContextual = true)(argTypes, resType),

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

@@ -409,7 +409,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         mapArgUsing(_.forceBoxStatus(false))
       else if meth == defn.Caps_unsafeBoxFunArg then
         mapArgUsing:
-          case defn.FunctionOf(paramtpe :: Nil, restpe, isContextual) =>
+          case defn.NonDependentFunctionOf(paramtpe :: Nil, restpe, isContextual) =>
             defn.FunctionNOf(paramtpe.forceBoxStatus(true) :: Nil, restpe, isContextual)
 
       else
@@ -531,7 +531,7 @@ class CheckCaptures extends Recheck, SymTransformer:
                   recheckDef(mdef, meth)
               meth.updateInfoBetween(preRecheckPhase, thisPhase, completer)
           pt.dealias match
-            case defn.FunctionOf(ptformals, _, _) => recheckFunction(ptformals)
+            case defn.NonDependentFunctionOf(ptformals, _, _) => recheckFunction(ptformals)
             case defn.DependentFunctionRefinementOf(_, mt) => recheckFunction(mt.paramInfos)
             case _ =>
           mdef.rhs match
@@ -709,7 +709,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           val eparent1 = recur(eparent)
           if eparent1 eq eparent then expected
           else CapturingType(eparent1, refs, boxed = expected0.isBoxed)
-        case defn.FunctionOf(args, resultType, isContextual) =>
+        case defn.NonDependentFunctionOf(args, resultType, isContextual) =>
           actual match
             case defn.DependentFunctionRefinementOf(_, _) =>
               toDepFun(args, resultType, isContextual)
@@ -785,7 +785,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
         try
           val (eargs, eres) = expected.dealias.stripCapturing match
-            case defn.FunctionOf(eargs, eres, _) => (eargs, eres)
+            case defn.NonDependentFunctionOf(eargs, eres, _) => (eargs, eres)
             case expected: MethodType => (expected.paramInfos, expected.resType)
             case expected @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionNType(expected) => (rinfo.paramInfos, rinfo.resType)
             case _ => (aargs.map(_ => WildcardType), WildcardType)

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

@@ -1117,7 +1117,9 @@ class Definitions {
       val ft = mt.toFunctionType(isJava = false)
       assert(ft.exists, s"not a valid function type: $mt")
       ft
+  }
 
+  object NonDependentFunctionOf {
     /** Matches a (possibly aliased) `FunctionN[...]`, `ContextFunctionN[...]` or refined `PolyFunction`.
      *  Extracts the list of function argument types, the result type and whether function is contextual.
      *  It only matches a `PolyFunction` if the function type is not result dependent.
@@ -1156,10 +1158,10 @@ class Definitions {
    *  dependent refinements. Optionally returns a triple consisting of the argument
    *  types `As`, the result type `B` and a whether the type is an erased context function.
    */
-  object ContextFunctionOf:
+  object NonDependentContextFunctionOf:
     def unapply(tp: Type)(using Context): Option[(List[Type], Type)] =
       tp match
-        case FunctionOf(argTypes, resultType, true) => Some((argTypes, resultType))
+        case NonDependentFunctionOf(argTypes, resultType, true) => Some((argTypes, resultType))
         case _ => None
 
   object PolyFunctionOf {
@@ -1173,8 +1175,8 @@ class Definitions {
      *
      *  Pattern: `PolyFunction { def apply: $mt }`
      */
-    def unapply(ft: Type)(using Context): Option[MethodicType] = ft.dealias match
-      case RefinedType(parent, nme.apply, mt: MethodicType)
+    def unapply(ft: Type)(using Context): Option[MethodOrPoly] = ft.dealias match
+      case RefinedType(parent, nme.apply, mt: MethodOrPoly)
       if parent.derivesFrom(defn.PolyFunctionClass) =>
         Some(mt)
       case _ => None

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

@@ -131,7 +131,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
         else
           val (argTypes, resType, erasedParams) = atPhase(erasurePhase) {
             tp match
-              case defn.ContextFunctionOf(argTypes, resType) =>
+              case defn.NonDependentContextFunctionOf(argTypes, resType) =>
                 (argTypes, resType, defn.erasedFunctionParams(tp))
           }
           val anonFun = newAnonFun(ctx.owner,

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

@@ -24,7 +24,7 @@ object ContextFunctionResults:
         rhs match
           case closureDef(meth) => 1 + contextResultCount(meth.rhs, mt.resType)
           case _ => 0
-      case defn.ContextFunctionOf(_, resTpe) =>
+      case defn.NonDependentContextFunctionOf(_, resTpe) =>
         rhs match
           case closureDef(meth) => 1 + contextResultCount(meth.rhs, resTpe)
           case _ => 0
@@ -64,7 +64,7 @@ object ContextFunctionResults:
     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) =>
+      case ft @ defn.NonDependentContextFunctionOf(_, resTpe) =>
         !defn.erasedFunctionParams(ft).contains(false) && allErased(resTpe)
       case _ => true
     contextResultCount(sym) > 0 && allErased(sym.info.finalResultType)
@@ -81,7 +81,7 @@ object ContextFunctionResults:
         tp.derivedLambdaType(resType = integrateContextResults(tp.resType, crCount))
       case defn.DependentFunctionRefinementOf(base, mt) if mt.isContextualMethod =>
         integrateContextResults(base, crCount)
-      case defn.ContextFunctionOf(argTypes, resType) =>
+      case defn.NonDependentContextFunctionOf(argTypes, resType) =>
         MethodType(argTypes, integrateContextResults(resType, crCount - 1))
 
   /** The total number of parameters of method `sym`, not counting
@@ -92,7 +92,7 @@ object ContextFunctionResults:
     def contextParamCount(tp: Type, crCount: Int): Int =
       if crCount == 0 then 0
       else
-        val defn.ContextFunctionOf(params, resTpe) = tp: @unchecked
+        val defn.NonDependentContextFunctionOf(params, resTpe) = tp: @unchecked
         val erasedParams = defn.erasedFunctionParams(tp)
         val rest = contextParamCount(resTpe, crCount - 1)
         if erasedParams.contains(true) then erasedParams.count(_ == false) + rest else params.length + rest
@@ -113,7 +113,7 @@ object ContextFunctionResults:
     def recur(tp: Type, n: Int): Type =
       if n == 0 then tp
       else tp match
-        case defn.ContextFunctionOf(_, resTpe) => recur(resTpe, n - 1)
+        case defn.NonDependentContextFunctionOf(_, resTpe) => recur(resTpe, n - 1)
     recur(meth.info.finalResultType, depth)
 
   /** Should selection `tree` be eliminated since it refers to an `apply`
@@ -130,7 +130,7 @@ object ContextFunctionResults:
           qual.tpe match
             case defn.DependentFunctionRefinementOf(_, mt) if mt.isContextualMethod =>
               integrateSelect(qual, n + 1)
-            case defn.ContextFunctionOf(_, _) =>
+            case defn.NonDependentContextFunctionOf(_, _) =>
               integrateSelect(qual, n + 1)
             case _ if defn.isContextFunctionClass(tree.symbol.maybeOwner) => // for TermRefs
               integrateSelect(qual, n + 1)

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

@@ -1975,7 +1975,7 @@ trait Applications extends Compatibility {
           val formals = ref.widen.firstParamTypes
           if formals.length > idx then
             formals(idx) match
-              case defn.FunctionOf(args, _, _) => args.length
+              case defn.NonDependentFunctionOf(args, _, _) => args.length
               case _ => -1
           else -1
 
@@ -2061,7 +2061,7 @@ trait Applications extends Compatibility {
 
       case pt =>
         val compat0 = pt match
-          case defn.FunctionOf(args, resType, _) =>
+          case defn.NonDependentFunctionOf(args, resType, _) =>
             narrowByTypes(alts, args, resType)
           case _ =>
             Nil
@@ -2226,7 +2226,7 @@ trait Applications extends Compatibility {
         val formalsForArg: List[Type] = altFormals.map(_.head)
         def argTypesOfFormal(formal: Type): List[Type] =
           formal.dealias match {
-            case defn.FunctionOf(args, result, isImplicit) => args
+            case defn.NonDependentFunctionOf(args, result, isImplicit) => args
             case defn.PartialFunctionOf(arg, result) => arg :: Nil
             case _ => Nil
           }

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

@@ -167,7 +167,7 @@ object ErrorReporting {
       val normPt = normalize(pt, pt)
 
       def contextFunctionCount(tp: Type): Int = tp.stripped match
-        case defn.ContextFunctionOf(_, restp) => 1 + contextFunctionCount(restp)
+        case defn.NonDependentContextFunctionOf(_, restp) => 1 + contextFunctionCount(restp)
         case _ => 0
       def strippedTpCount = contextFunctionCount(tree.tpe) - contextFunctionCount(normTp)
       def strippedPtCount = contextFunctionCount(pt) - contextFunctionCount(normPt)

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

@@ -1896,7 +1896,7 @@ class Namer { typer: Typer =>
         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)
+        case atp @ defn.NonDependentContextFunctionOf(_, resType)
         if resType.existsPart(_.isInstanceOf[WildcardType], StopAt.Static, forceLazy = false) =>
           originalTp
         case _ =>

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

@@ -3193,7 +3193,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     tree
 
   protected def makeContextualFunction(tree: untpd.Tree, pt: Type)(using Context): Tree = {
-    val defn.FunctionOf(formals, _, true) = pt.dropDependentRefinement: @unchecked
+    val defn.NonDependentContextFunctionOf(formals, _) = pt.dropDependentRefinement: @unchecked
 
     // The getter of default parameters may reach here.
     // Given the code below