Optimize function tests in NameOps

Author: odersky

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

@@ -1389,7 +1389,7 @@ class Definitions {
       !tp.isInstanceOf[RefinedType]
   }
 
-  /** Is `tp` a representation of a (possibly depenent) function type or an alias of such? */
+  /** Is `tp` a representation of a (possibly dependent) function type or an alias of such? */
   def isFunctionType(tp: Type)(using Context): Boolean =
     isNonRefinedFunction(tp.dropDependentRefinement)
 
@@ -1440,13 +1440,12 @@ class Definitions {
    *   - the upper bound of a TypeParamRef in the current constraint
    */
   def asContextFunctionType(tp: Type)(using Context): Type =
-    tp.stripTypeVar.dealias match {
+    tp.stripTypeVar.dealias match
       case tp1: TypeParamRef if ctx.typerState.constraint.contains(tp1) =>
         asContextFunctionType(TypeComparer.bounds(tp1).hiBound)
       case tp1 =>
-        if (isFunctionType(tp1) && tp1.typeSymbol.name.isContextFunction) tp1
+        if tp1.typeSymbol.name.isContextFunction && isFunctionType(tp1) then tp1
         else NoType
-    }
 
   /** Is `tp` an context function type? */
   def isContextFunctionType(tp: Type)(using Context): Boolean =
@@ -1468,7 +1467,7 @@ class Definitions {
         else None
 
   def isErasedFunctionType(tp: Type)(using Context): Boolean =
-    isFunctionType(tp) && tp.dealias.typeSymbol.name.isErasedFunction
+    tp.dealias.typeSymbol.name.isErasedFunction && isFunctionType(tp)
 
   /** A whitelist of Scala-2 classes that are known to be pure */
   def isAssuredNoInits(sym: Symbol): Boolean =

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

@@ -169,56 +169,89 @@ object NameOps {
       }
     }
 
-    def functionArity: Int =
-      functionArityFor(str.Function) max
-      functionArityFor(str.ContextFunction) max {
-        val n =
-          functionArityFor(str.ErasedFunction) max
-          functionArityFor(str.ErasedContextFunction)
-        if (n == 0) -1 else n
-      }
+    private def functionSuffixStart: Int =
+      val first = name.firstPart
+      var idx = first.length - 1
+      if idx >= 8 && first(idx).isDigit then
+        while
+          idx = idx - 1
+          idx >= 8 && first(idx).isDigit
+        do ()
+        if    first(idx - 7) == 'F'
+           && first(idx - 6) == 'u'
+           && first(idx - 5) == 'n'
+           && first(idx - 4) == 'c'
+           && first(idx - 3) == 't'
+           && first(idx - 2) == 'i'
+           && first(idx - 1) == 'o'
+           && first(idx)     == 'n'
+        then idx - 7
+        else -1
+      else -1
+
+    /** The arity of a name ending in the suffix `Function{\d}`, but -1
+     *  if the number is larger than Int.MaxValue / 10.
+     *  @param suffixStart  The index of the suffix
+     */
+    private def funArity(suffixStart: Int): Int =
+      inline val MaxSafeInt = MaxValue / 10
+      val first = name.firstPart
+      def collectDigits(acc: Int, idx: Int): Int =
+        if idx == first.length then acc
+        else
+          val d = digit2int(first(idx), 10)
+          if d < 0 || acc > MaxSafeInt then -1
+          else collectDigits(acc * 10 + d, idx + 1)
+      collectDigits(0, suffixStart + 8)
 
-    /** Is a function name, i.e one of FunctionXXL, FunctionN, ContextFunctionN for N >= 0 or ErasedFunctionN, ErasedContextFunctionN for N > 0
+    /** name[0..suffixStart) == `str` */
+    private def isPreceded(str: String, suffixStart: Int) =
+      str.length == suffixStart && name.firstPart.startsWith(str)
+
+    /** Same as `funArity`, except that it returns -1 if the prefix
+     *  is not one of "", "Context", "Erased", "ErasedContext"
+     */
+    private def checkedFunArity(suffixStart: Int) =
+      if suffixStart == 0
+         || isPreceded("Context", suffixStart)
+         || isPreceded("Erased", suffixStart)
+         || isPreceded("ErasedContext", suffixStart)
+      then funArity(suffixStart)
+      else -1
+
+    /** Is a function name, i.e one of FunctionXXL, FunctionN, ContextFunctionN, ErasedFunctionN, ErasedContextFunctionN for N >= 0
      */
-    def isFunction: Boolean = (name eq tpnme.FunctionXXL) || functionArity >= 0
+    def isFunction: Boolean =
+      (name eq tpnme.FunctionXXL) || checkedFunArity(functionSuffixStart) >= 0
 
-    /** Is an context function name, i.e one of ContextFunctionN for N >= 0 or ErasedContextFunctionN for N > 0
+    /** Is an context function name, i.e one of ContextFunctionN or ErasedContextFunctionN for N >= 0
      */
     def isContextFunction: Boolean =
-      functionArityFor(str.ContextFunction) >= 0 ||
-      functionArityFor(str.ErasedContextFunction) > 0
+      val suffixStart = functionSuffixStart
+      (isPreceded("Context", suffixStart) || isPreceded("ErasedContext", suffixStart))
+      && funArity(suffixStart) >= 0
 
-    /** Is an erased function name, i.e. one of ErasedFunctionN, ErasedContextFunctionN for N > 0
+    /** Is an erased function name, i.e. one of ErasedFunctionN, ErasedContextFunctionN for N >= 0
       */
     def isErasedFunction: Boolean =
-      functionArityFor(str.ErasedFunction) > 0 ||
-      functionArityFor(str.ErasedContextFunction) > 0
+      val suffixStart = functionSuffixStart
+      (isPreceded("Erased", suffixStart) || isPreceded("ErasedContext", suffixStart))
+      && funArity(suffixStart) >= 0
 
     /** Is a synthetic function name, i.e. one of
      *    - FunctionN for N > 22
      *    - ContextFunctionN for N >= 0
-     *    - ErasedFunctionN for N > 0
-     *    - ErasedContextFunctionN for N > 0
+     *    - ErasedFunctionN for N >= 0
+     *    - ErasedContextFunctionN for N >= 0
      */
     def isSyntheticFunction: Boolean =
-      functionArityFor(str.Function) > MaxImplementedFunctionArity ||
-      functionArityFor(str.ContextFunction) >= 0 ||
-      isErasedFunction
+      val suffixStart = functionSuffixStart
+      if suffixStart == 0 then funArity(suffixStart) > MaxImplementedFunctionArity
+      else checkedFunArity(suffixStart) >= 0
 
-    /** Parsed function arity for function with some specific prefix */
-    private def functionArityFor(prefix: String): Int =
-      inline val MaxSafeInt = MaxValue / 10
-      val first = name.firstPart
-      def collectDigits(acc: Int, idx: Int): Int =
-        if idx == first.length then acc
-        else
-          val d = digit2int(first(idx), 10)
-          if d < 0 || acc > MaxSafeInt then -1
-          else collectDigits(acc * 10 + d, idx + 1)
-      if first.startsWith(prefix) && prefix.length < first.length then
-        collectDigits(0, prefix.length)
-      else
-        -1
+    def functionArity: Int =
+      val suffixStart = functionSuffixStart
+      if suffixStart >= 0 then checkedFunArity(suffixStart) else -1
 
     /** The name of the generic runtime operation corresponding to an array operation */
     def genericArrayOp: TermName = name match {