Fix isPlainFunctionClass

Previous implementation is incorrect, as scala.Function1$ would qualify.

Author: liufengyun

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

@@ -1198,9 +1198,9 @@ class Definitions {
   def isFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isFunction
 
   /** Is a function class where
-   *    - FunctionN for N >= 0
+   *    - FunctionN for N >= 0 and N != XXL
    */
-  def isPlainFunctionClass(cls: Symbol) = scalaClassName(cls).isPlainFunction
+  def isPlainFunctionClass(cls: Symbol) = isVarArityClass(cls, str.Function)
 
   /** Is an context function class.
    *   - ContextFunctionN for N >= 0

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

@@ -182,11 +182,6 @@ object NameOps {
      */
     def isFunction: Boolean = (name eq tpnme.FunctionXXL) || functionArity >= 0
 
-    /** Is a function name
-     *    - FunctionN for N >= 0
-     */
-    def isPlainFunction: Boolean = functionArityFor(str.Function) >= 0
-
     /** Is an context function name, i.e one of ContextFunctionN for N >= 0 or ErasedContextFunctionN for N > 0
      */
     def isContextFunction: Boolean =

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

@@ -22,7 +22,7 @@ class SpecializedApplyMethods extends MiniPhase with InfoTransformer {
 
   val phaseName = "specializedApplyMethods"
 
-  private def specApply(sym: Symbol, args: List[Type], ret: Type)(using Context): Symbol = {
+  private def specApplySymbol(sym: Symbol, args: List[Type], ret: Type)(using Context): Symbol = {
     val name = nme.apply.specializedFunction(ret, args)
     newSymbol(sym, name, Flags.Method, MethodType(args, ret))
   }
@@ -55,17 +55,17 @@ class SpecializedApplyMethods extends MiniPhase with InfoTransformer {
       sym.name.functionArity match {
         case 0 =>
           val scope = tp.decls.cloneScope
-          specFun0 { r => scope.enter(specApply(sym, Nil, r)) }
+          specFun0 { r => scope.enter(specApplySymbol(sym, Nil, r)) }
           tp.derivedClassInfo(decls = scope)
 
         case 1 =>
           val scope = tp.decls.cloneScope
-          specFun1 { (t1, r) => scope.enter(specApply(sym, List(t1), r)) }
+          specFun1 { (t1, r) => scope.enter(specApplySymbol(sym, List(t1), r)) }
           tp.derivedClassInfo(decls = scope)
 
         case 2 =>
           val scope = tp.decls.cloneScope
-          specFun2 { (t1, t2, r) => scope.enter(specApply(sym, List(t1, t2), r)) }
+          specFun2 { (t1, t2, r) => scope.enter(specApplySymbol(sym, List(t1, t2), r)) }
           tp.derivedClassInfo(decls = scope)
 
         case _ =>