Use FunctionNOf.apply instead of FunctionOf.apply

Author: nicolasstucki

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

@@ -410,7 +410,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       else if meth == defn.Caps_unsafeBoxFunArg then
         mapArgUsing:
           case defn.FunctionOf(paramtpe :: Nil, restpe, isContextual) =>
-            defn.FunctionOf(paramtpe.forceBoxStatus(true) :: Nil, restpe, isContextual)
+            defn.FunctionNOf(paramtpe.forceBoxStatus(true) :: Nil, restpe, isContextual)
 
       else
         super.recheckApply(tree, pt) match

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

@@ -1118,17 +1118,6 @@ class Definitions {
       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.
-     */
-    def apply(args: List[Type], resultType: Type, isContextual: Boolean = false)(using Context): Type =
-      val mt = MethodType.companion(isContextual, false)(args, resultType)
-      if mt.hasErasedParams then
-        RefinedType(PolyFunctionClass.typeRef, nme.apply, mt)
-      else
-        FunctionNOf(args, resultType, isContextual)
-
     /** 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.

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

@@ -2249,7 +2249,7 @@ trait Applications extends Compatibility {
               false
           val commonFormal =
             if (isPartial) defn.PartialFunctionOf(commonParamTypes.head, WildcardType)
-            else defn.FunctionOf(commonParamTypes, WildcardType, isContextual = untpd.isContextualClosure(arg))
+            else defn.FunctionNOf(commonParamTypes, WildcardType, isContextual = untpd.isContextualClosure(arg))
           overload.println(i"pretype arg $arg with expected type $commonFormal")
           if (commonParamTypes.forall(isFullyDefined(_, ForceDegree.flipBottom)))
             withMode(Mode.ImplicitsEnabled) {