Use FunctionNOf

Author: nicolasstucki

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

@@ -179,9 +179,9 @@ object Synthetics:
     val (et: ExprType) = symd.info: @unchecked
     val (enclThis: ThisType) = symd.owner.thisType: @unchecked
     def mapFinalResult(tp: Type, f: Type => Type): Type =
-      val defn.FunctionOf(args, res, isContextual) = tp: @unchecked
+      val defn.FunctionNOf(args, res, isContextual) = tp: @unchecked
       if defn.isFunctionNType(res) then
-        defn.FunctionOf(args, mapFinalResult(res, f), isContextual)
+        defn.FunctionNOf(args, mapFinalResult(res, f), isContextual)
       else
         f(tp)
     val resType1 =

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

@@ -1707,7 +1707,7 @@ trait Applications extends Compatibility {
           def apply(t: Type) = t match {
             case t @ AppliedType(tycon, args) =>
               def mapArg(arg: Type, tparam: TypeParamInfo) =
-                if (variance > 0 && tparam.paramVarianceSign < 0) defn.FunctionOf(arg :: Nil, defn.UnitType)
+                if (variance > 0 && tparam.paramVarianceSign < 0) defn.FunctionNOf(arg :: Nil, defn.UnitType)
                 else arg
               mapOver(t.derivedAppliedType(tycon, args.zipWithConserve(tycon.typeParams)(mapArg)))
             case _ => mapOver(t)

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

@@ -385,7 +385,7 @@ object ProtoTypes {
 
     private def isUndefined(tp: Type): Boolean = tp match {
       case _: WildcardType => true
-      case defn.FunctionOf(args, result, _) => args.exists(isUndefined) || isUndefined(result)
+      case defn.FunctionNOf(args, result, _) => args.exists(isUndefined) || isUndefined(result)
       case _ => false
     }
 
@@ -424,7 +424,7 @@ object ProtoTypes {
               case ValDef(_, tpt, _) if !tpt.isEmpty => typer.typedType(tpt).typeOpt
               case _ => WildcardType
             }
-            targ = arg.withType(defn.FunctionOf(paramTypes, WildcardType))
+            targ = arg.withType(defn.FunctionNOf(paramTypes, WildcardType))
           case Some(_) if !force =>
             targ = arg.withType(WildcardType)
           case _ =>

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

@@ -1324,7 +1324,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         case ft @ defn.FunctionRefinementOf(_, 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.FunctionOf(_, _, _) =>
+        case ft @ defn.FunctionNOf(_, _, _) =>
           // if expected parameter type(s) are wildcards, approximate from below.
           // if expected result type is a wildcard, approximate from above.
           // this can type the greatest set of admissible closures.