Rename isFunctionType to isFunctionNType

This way we are explicit on the fact that this methods does not cover
`PolyFunction` and `ErasedFunction`.

[Cherry-picked c03d69f][modified]

Author: Kordyjan

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

@@ -638,7 +638,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         case expected @ CapturingType(eparent, refs) =>
           CapturingType(recur(eparent), refs, boxed = expected.isBoxed)
         case expected @ defn.FunctionOf(args, resultType, isContextual)
-          if defn.isNonRefinedFunction(expected) && defn.isFunctionType(actual) && !defn.isNonRefinedFunction(actual) =>
+          if defn.isNonRefinedFunction(expected) && defn.isFunctionNType(actual) && !defn.isNonRefinedFunction(actual) =>
           val expected1 = toDepFun(args, resultType, isContextual)
           expected1
         case _ =>
@@ -707,7 +707,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           val (eargs, eres) = expected.dealias.stripCapturing match
             case defn.FunctionOf(eargs, eres, _) => (eargs, eres)
             case expected: MethodType => (expected.paramInfos, expected.resType)
-            case expected @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionType(expected) => (rinfo.paramInfos, rinfo.resType)
+            case expected @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionNType(expected) => (rinfo.paramInfos, rinfo.resType)
             case _ => (aargs.map(_ => WildcardType), WildcardType)
           val aargs1 = aargs.zipWithConserve(eargs) { (aarg, earg) => adapt(aarg, earg, !covariant) }
           val ares1 = adapt(ares, eres, covariant)

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

@@ -1700,21 +1700,25 @@ class Definitions {
    *  - scala.FunctionN
    *  - scala.ContextFunctionN
    */
-  def isFunctionType(tp: Type)(using Context): Boolean =
+  def isFunctionNType(tp: Type)(using Context): Boolean =
     isNonRefinedFunction(tp.dropDependentRefinement)
 
   /** Is `tp` a specialized, refined function type? Either an `ErasedFunction` or a `PolyFunction`. */
   def isRefinedFunctionType(tp: Type)(using Context): Boolean =
     tp.derivesFrom(defn.PolyFunctionClass) || isErasedFunctionType(tp)
 
+  /** Is `tp` a specialized, refined function type? Either an `ErasedFunction`. */
+  def isErasedFunctionType(tp: Type)(using Context): Boolean =
+    tp.derivesFrom(defn.ErasedFunctionClass)
+
   /** Returns whether `tp` is an instance or a refined instance of:
    *  - scala.FunctionN
    *  - scala.ContextFunctionN
    *  - ErasedFunction
    *  - PolyFunction
    */
   def isFunctionOrPolyType(tp: Type)(using Context): Boolean =
-    isFunctionType(tp) || isRefinedFunctionType(tp)
+    isFunctionNType(tp) || isRefinedFunctionType(tp)
 
   private def withSpecMethods(cls: ClassSymbol, bases: List[Name], paramTypes: Set[TypeRef]) =
     for base <- bases; tp <- paramTypes do
@@ -1818,7 +1822,7 @@ class Definitions {
       case tp1 @ RefinedType(parent, nme.apply, mt: MethodType) if isErasedFunctionType(parent) && mt.isContextualMethod =>
         tp1
       case tp1 =>
-        if tp1.typeSymbol.name.isContextFunction && isFunctionType(tp1) then tp1
+        if tp1.typeSymbol.name.isContextFunction && isFunctionNType(tp1) then tp1
         else NoType
 
   /** Is `tp` an context function type? */
@@ -1846,13 +1850,10 @@ class Definitions {
   /* Returns a list of erased booleans marking whether parameters are erased, for a function type. */
   def erasedFunctionParameters(tp: Type)(using Context): List[Boolean] = tp.dealias match {
     case RefinedType(parent, nme.apply, mt: MethodType) => mt.erasedParams
-    case tp if isFunctionType(tp) => List.fill(functionArity(tp)) { false }
+    case tp if isFunctionNType(tp) => List.fill(functionArity(tp)) { false }
     case _ => Nil
   }
 
-  def isErasedFunctionType(tp: Type)(using Context): Boolean =
-    tp.derivesFrom(defn.ErasedFunctionClass)
-
   /** A whitelist of Scala-2 classes that are known to be pure */
   def isAssuredNoInits(sym: Symbol): Boolean =
     (sym `eq` SomeClass) || isTupleClass(sym)

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

@@ -658,7 +658,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
               case _ =>
                 isSubType(info1, info2)
 
-            if defn.isFunctionType(tp2) then
+            if defn.isFunctionNType(tp2) then
               tp1w.widenDealias match
                 case tp1: RefinedType =>
                   return isSubInfo(tp1.refinedInfo, tp2.refinedInfo)

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

@@ -2760,7 +2760,7 @@ object Types {
     final def withPrefix(prefix: Type)(using Context): Type = {
       def reload(): NamedType = {
         val sym =
-          if lastSymbol.nn.isValidInCurrentRun then lastSymbol.nn 
+          if lastSymbol.nn.isValidInCurrentRun then lastSymbol.nn
           else computeSymbol
         val allowPrivate = !sym.exists || sym.is(Private)
         var d = memberDenot(prefix, name, allowPrivate)
@@ -4054,7 +4054,7 @@ object Types {
       def addInto(tp: Type): Type = tp match
         case tp @ AppliedType(tycon, args) if tycon.typeSymbol == defn.RepeatedParamClass =>
           tp.derivedAppliedType(tycon, addInto(args.head) :: Nil)
-        case tp @ AppliedType(tycon, args) if defn.isFunctionType(tp) =>
+        case tp @ AppliedType(tycon, args) if defn.isFunctionNType(tp) =>
           wrapConvertible(tp.derivedAppliedType(tycon, args.init :+ addInto(args.last)))
         case tp @ RefinedType(parent, rname, rinfo) if defn.isFunctionOrPolyType(tp) =>
           wrapConvertible(tp.derivedRefinedType(parent, rname, addInto(rinfo)))

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

@@ -90,7 +90,7 @@ object BetaReduce:
         recur(expr, argss)
       case _ => None
     tree match
-      case Apply(Select(fn, nme.apply), args) if defn.isFunctionType(fn.tpe) =>
+      case Apply(Select(fn, nme.apply), args) if defn.isFunctionNType(fn.tpe) =>
         recur(fn, List(args)) match
           case Some(reduced) =>
             seq(bindingsBuf.result(), reduced).withSpan(tree.span)

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

@@ -695,7 +695,7 @@ trait Applications extends Compatibility {
         val argtpe1 = argtpe.widen
 
         def SAMargOK =
-          defn.isFunctionType(argtpe1) && formal.match
+          defn.isFunctionNType(argtpe1) && formal.match
             case SAMType(sam) => argtpe <:< sam.toFunctionType(isJava = formal.classSymbol.is(JavaDefined))
             case _ => false
 

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

@@ -222,7 +222,7 @@ object Implicits:
             case pt: ViewProto =>
               viewCandidateKind(ref.widen, pt.argType, pt.resType)
             case _: ValueTypeOrProto =>
-              if (defn.isFunctionType(pt)) Candidate.Value
+              if (defn.isFunctionNType(pt)) Candidate.Value
               else valueTypeCandidateKind(ref.widen)
             case _ =>
               Candidate.Value
@@ -968,7 +968,7 @@ trait Implicits:
   /** A string indicating the formal parameter corresponding to a  missing argument */
   def implicitParamString(paramName: TermName, methodStr: String, tree: Tree)(using Context): String =
     tree match {
-      case Select(qual, nme.apply) if defn.isFunctionType(qual.tpe.widen) =>
+      case Select(qual, nme.apply) if defn.isFunctionNType(qual.tpe.widen) =>
         val qt = qual.tpe.widen
         val qt1 = qt.dealiasKeepAnnots
         def addendum = if (qt1 eq qt) "" else (i"\nWhere $qt is an alias of: $qt1")

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

@@ -106,15 +106,15 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
             defn.isContextFunctionType(baseFun))
         val arity: Int =
           if defn.isErasedFunctionType(fun) then -1 // TODO support?
-          else if defn.isFunctionType(fun) then
+          else if defn.isFunctionNType(fun) then
             // TupledFunction[(...) => R, ?]
             fun.functionArgInfos match
               case funArgs :+ funRet
               if functionTypeEqual(fun, defn.tupleType(funArgs) :: Nil, funRet, tupled) =>
                 // TupledFunction[(...funArgs...) => funRet, ?]
                 funArgs.size
               case _ => -1
-          else if defn.isFunctionType(tupled) then
+          else if defn.isFunctionNType(tupled) then
             // TupledFunction[?, (...) => R]
             tupled.functionArgInfos match
               case tupledArgs :: funRet :: Nil =>

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

@@ -1637,7 +1637,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           case mt: MethodType =>
             pt.findFunctionType match {
               case pt @ SAMType(sam)
-              if !defn.isFunctionType(pt) && mt <:< sam =>
+              if !defn.isFunctionNType(pt) && mt <:< sam =>
                 // SAMs of the form C[?] where C is a class cannot be conversion targets.
                 // The resulting class `class $anon extends C[?] {...}` would be illegal,
                 // since type arguments to `C`'s super constructor cannot be constructed.
@@ -2871,7 +2871,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   def typedAsFunction(tree: untpd.PostfixOp, pt: Type)(using Context): Tree = {
     val untpd.PostfixOp(qual, Ident(nme.WILDCARD)) = tree: @unchecked
-    val pt1 = if (defn.isFunctionType(pt)) pt else AnyFunctionProto
+    val pt1 = if (defn.isFunctionNType(pt)) pt else AnyFunctionProto
     val nestedCtx = ctx.fresh.setNewTyperState()
     val res = typed(qual, pt1)(using nestedCtx)
     res match {
@@ -3886,7 +3886,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         sym.isConstructor
         || sym.matchNullaryLoosely
         || Feature.warnOnMigration(msg, tree.srcPos, version = `3.0`)
-          && { 
+          && {
             msg.actions
               .headOption
               .foreach(Rewrites.applyAction)
@@ -3919,7 +3919,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           // Ignore `.apply` in `m.apply(...)`; it will later be simplified in typedSelect to `m(...)`
           adapt1(tree, pt1, locked)
         else
-          if (!defn.isFunctionType(pt))
+          if (!defn.isFunctionNType(pt))
             pt match {
               case SAMType(_) if !pt.classSymbol.hasAnnotation(defn.FunctionalInterfaceAnnot) =>
                 report.warning(em"${tree.symbol} is eta-expanded even though $pt does not have the @FunctionalInterface annotation.", tree.srcPos)
@@ -4034,7 +4034,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
     def adaptNoArgs(wtp: Type): Tree = {
       val ptNorm = underlyingApplied(pt)
-      def functionExpected = defn.isFunctionType(ptNorm)
+      def functionExpected = defn.isFunctionNType(ptNorm)
       def needsEta = pt.revealIgnored match
         case _: SingletonType | _: FunOrPolyProto => false
         case _ => true
@@ -4124,7 +4124,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       // convert function literal to SAM closure
       tree match {
         case closure(Nil, id @ Ident(nme.ANON_FUN), _)
-        if defn.isFunctionType(wtp) && !defn.isFunctionType(pt) =>
+        if defn.isFunctionNType(wtp) && !defn.isFunctionNType(pt) =>
           pt match {
             case SAMType(sam)
             if wtp <:< sam.toFunctionType(isJava = pt.classSymbol.is(JavaDefined)) =>

compiler/src/dotty/tools/dotc/util/Signatures.scala

@@ -302,7 +302,7 @@ object Signatures {
    * @param tree tree to validate
    */
   private def isValid(tree: tpd.Tree)(using Context): Boolean =
-    ctx.definitions.isTupleNType(tree.tpe) || ctx.definitions.isFunctionType(tree.tpe)
+    ctx.definitions.isTupleNType(tree.tpe) || ctx.definitions.isFunctionNType(tree.tpe)
 
   /**
    * Get unapply method result type omiting unknown types and another method calls.

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

@@ -1775,7 +1775,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         def baseType(cls: Symbol): TypeRepr = self.baseType(cls)
         def derivesFrom(cls: Symbol): Boolean = self.derivesFrom(cls)
         def isFunctionType: Boolean =
-          dotc.core.Symbols.defn.isFunctionType(self)
+          dotc.core.Symbols.defn.isFunctionNType(self)
         def isContextFunctionType: Boolean =
           dotc.core.Symbols.defn.isContextFunctionType(self)
         def isErasedFunctionType: Boolean =