Simplify function refactor.

Author: nicolasstucki

compiler/sjs/backend/sjs/JSCodeGen.scala

@@ -16,7 +16,6 @@ import SymDenotations._
 import Contexts._
 import Decorators._
 import Flags._
-import functions.ScalaFunction
 import dotty.tools.dotc.ast.Trees._
 import Types._
 import Symbols._
@@ -1904,7 +1903,7 @@ class JSCodeGen()(implicit ctx: Context) {
     if (jsdefn.isJSFunctionClass(funInterfaceSym)) {
       closure
     } else {
-      assert(!funInterfaceSym.exists || ScalaFunction(funInterfaceSym).exists,
+      assert(!funInterfaceSym.exists || defn.isFunctionClass(funInterfaceSym),
           s"Invalid functional interface $funInterfaceSym reached the back-end")
       val cls = "sjsr_AnonFunction" + formalParams.size
       val ctor = js.Ident("init___sjs_js_Function" + formalParams.size)

compiler/sjs/tools/dotc/config/SJSPlatform.scala

@@ -1,7 +1,6 @@
 package dotty.tools.dotc.config
 
 import dotty.tools.dotc.core._
-import functions.ScalaFunction
 import Contexts._
 import Symbols._
 
@@ -14,6 +13,6 @@ class SJSPlatform()(implicit ctx: Context) extends JavaPlatform {
 
   /** Is the SAMType `cls` also a SAM under the rules of the Scala.js back-end? */
   override def isSam(cls: ClassSymbol)(implicit ctx: Context): Boolean =
-    ScalaFunction(cls).exists || jsDefinitions.isJSFunctionClass(cls)
+    defn.isFunctionClass(cls) || jsDefinitions.isJSFunctionClass(cls)
 
 }

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

@@ -10,7 +10,6 @@ import scala.collection.{ mutable, immutable }
 import PartialFunction._
 import collection.mutable
 import scala.reflect.api.{ Universe => ApiUniverse }
-import functions._
 
 object Definitions {
 
@@ -91,7 +90,7 @@ class Definitions {
   }
 
   /** The trait FunctionN or ImplicitFunctionN, for some N
-   *  @param  function   The function name description of the trait to be created
+   *  @param  name   The name of the trait to be created
    *
    *  FunctionN traits follow this template:
    *
@@ -109,28 +108,32 @@ class Definitions {
    *        def apply(implicit $x0: T0, ..., $x{N_1}: T{N-1}): R
    *      }
    */
-  private def newFunctionNTrait(function: ScalaFunction) = {
+  private def newFunctionNTrait(name: TypeName) = {
     val completer = new LazyType {
       def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
         val cls = denot.asClass.classSymbol
         val decls = newScope
-        val tParamTpes = List.tabulate(function.arity + 1) { i =>
-          val variance = if (i < function.arity) Contravariant else Covariant
-          val paramName = tpnme.scala_ ++ "$" ++ function.name ++ "$$" ++ (if (i != function.arity) "T" + (i + 1) else "R")
-          enterTypeParam(cls, paramName, variance, decls).typeRef
-        }
+        val arity = name.functionArity
+        val argParams =
+          for (i <- List.range(0, arity)) yield
+            enterTypeParam(cls, name ++ "$T" ++ i.toString, Contravariant, decls)
+        val resParam = enterTypeParam(cls, name ++ "$R", Covariant, decls)
         val (methodType, parentTraits) =
-          if (function.isImplicit) {
-            val superTrait = function.withoutImplicit.typeRef.appliedTo(tParamTpes)
+          if (name.startsWith(tpnme.ImplicitFunction)) {
+            val superTrait =
+              FunctionType(arity).appliedTo(argParams.map(_.typeRef) ::: resParam.typeRef :: Nil)
             (ImplicitMethodType, ctx.normalizeToClassRefs(superTrait :: Nil, cls, decls))
           }
           else (MethodType, Nil)
-
-        decls.enter(newMethod(cls, nme.apply, methodType(tParamTpes.init, tParamTpes.last), Deferred))
-        denot.info = ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: parentTraits, decls)
+        val applyMeth =
+          decls.enter(
+            newMethod(cls, nme.apply,
+              methodType(argParams.map(_.typeRef), resParam.typeRef), Deferred))
+        denot.info =
+          ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: parentTraits, decls)
       }
     }
-    newClassSymbol(ScalaPackageClass, function.name, NoInitsTrait, completer)
+    newClassSymbol(ScalaPackageClass, name, Trait | NoInits, completer)
   }
 
   private def newMethod(cls: ClassSymbol, name: TermName, info: Type, flags: FlagSet = EmptyFlags): TermSymbol =
@@ -628,18 +631,16 @@ class Definitions {
     sym.owner.linkedClass.typeRef
 
   object FunctionOf {
-    def apply(args: List[Type], resultType: Type, isImplicit: Boolean = false)(implicit ctx: Context) = {
-      ScalaFunction(args, isImplicit).typeRef.appliedTo(args ::: resultType :: Nil)
-    }
+    def apply(args: List[Type], resultType: Type, isImplicit: Boolean = false)(implicit ctx: Context) =
+      FunctionType(args.length, isImplicit).appliedTo(args ::: resultType :: Nil)
     def unapply(ft: Type)(implicit ctx: Context) = {
       val tsym = ft.typeSymbol
-      val function = ScalaFunction(tsym)
-      if (function.exists) {
+      val isImplicitFun = isImplicitFunctionClass(tsym)
+      if (isImplicitFun || isFunctionClass(tsym)) {
         val targs = ft.dealias.argInfos
-        Some(targs.init, targs.last, function.isImplicit)
-      } else {
-        None
+        Some(targs.init, targs.last, isImplicitFun)
       }
+      else None
     }
   }
 
@@ -684,14 +685,23 @@ class Definitions {
   lazy val AbstractFunctionType = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0)
   val AbstractFunctionClassPerRun = new PerRun[Array[Symbol]](implicit ctx => AbstractFunctionType.map(_.symbol.asClass))
   def AbstractFunctionClass(n: Int)(implicit ctx: Context) = AbstractFunctionClassPerRun()(ctx)(n)
-  lazy val ImplementedFunctionType = mkArityArray("scala.Function", MaxImplementedFunctionArity, 0)
+  private lazy val ImplementedFunctionType = mkArityArray("scala.Function", MaxImplementedFunctionArity, 0)
   def FunctionClassPerRun = new PerRun[Array[Symbol]](implicit ctx => ImplementedFunctionType.map(_.symbol.asClass))
 
   lazy val TupleType = mkArityArray("scala.Tuple", MaxTupleArity, 2)
   lazy val ProductNType = mkArityArray("scala.Product", MaxTupleArity, 0)
 
-  lazy val Function0_applyR = ImplementedFunctionType(0).symbol.requiredMethodRef(nme.apply)
-  def Function0_apply(implicit ctx: Context) = Function0_applyR.symbol
+  def FunctionClass(n: Int, isImplicit: Boolean = false)(implicit ctx: Context) =
+    if (isImplicit) ctx.requiredClass("scala.ImplicitFunction" + n.toString)
+    else if (n < MaxImplementedFunctionArity) FunctionClassPerRun()(ctx)(n)
+    else ctx.requiredClass("scala.Function" + n.toString)
+
+    lazy val Function0_applyR = ImplementedFunctionType(0).symbol.requiredMethodRef(nme.apply)
+    def Function0_apply(implicit ctx: Context) = Function0_applyR.symbol
+
+  def FunctionType(n: Int, isImplicit: Boolean = false)(implicit ctx: Context): TypeRef =
+    if (n < MaxImplementedFunctionArity && (!isImplicit || ctx.erasedTypes)) ImplementedFunctionType(n)
+    else FunctionClass(n, isImplicit).typeRef
 
   private lazy val TupleTypes: Set[TypeRef] = TupleType.toSet
   private lazy val ProductTypes: Set[TypeRef] = ProductNType.toSet
@@ -715,10 +725,65 @@ class Definitions {
   def isBottomType(tp: Type) =
     tp.derivesFrom(NothingClass) || tp.derivesFrom(NullClass)
 
+  /** Is a function class.
+   *   - FunctionN for N >= 0
+   *   - ImplicitFunctionN for N >= 0
+   */
+  def isFunctionClass(cls: Symbol) =
+    scalaClassName(cls).isFunction
+
+  /** Is an implicit function class.
+   *   - ImplicitFunctionN for N >= 0
+   */
+  def isImplicitFunctionClass(cls: Symbol) =
+    scalaClassName(cls).isImplicitFunction
+
+  /** Is a class that will be erased to FunctionXXL
+   *   - FunctionN for N >= 22
+   *   - ImplicitFunctionN for N >= 22
+   */
+  def isXXLFunctionClass(cls: Symbol) =
+    scalaClassName(cls).functionArity > MaxImplementedFunctionArity
+
+  /** Is a synthetic function class
+   *    - FunctionN for N > 22
+   *    - ImplicitFunctionN for N >= 0
+   */
+  def isSyntheticFunctionClass(cls: Symbol) =
+    scalaClassName(cls).isSyntheticFunction
+
   def isAbstractFunctionClass(cls: Symbol) = isVarArityClass(cls, tpnme.AbstractFunction)
   def isTupleClass(cls: Symbol) = isVarArityClass(cls, tpnme.Tuple)
   def isProductClass(cls: Symbol) = isVarArityClass(cls, tpnme.Product)
 
+  /** Returns the erased class of the function class `cls`
+   *    - FunctionN for N > 22 becomes FunctionXXL
+   *    - FunctionN for 22 > N >= 0 remains as FunctionN
+   *    - ImplicitFunctionN for N > 22 becomes FunctionXXL
+   *    - ImplicitFunctionN for 22 > N >= 0 becomes FunctionN
+   *    - anything else becomes a NoSymbol
+   */
+  def erasedFunctionClass(cls: Symbol): Symbol = {
+    val arity = scalaClassName(cls).functionArity
+    if (arity > 22) defn.FunctionXXLClass
+    else if (arity >= 0) defn.FunctionClass(arity)
+    else NoSymbol
+  }
+
+  /** Returns the erased type of the function class `cls`
+   *    - FunctionN for N > 22 becomes FunctionXXL
+   *    - FunctionN for 22 > N >= 0 remains as FunctionN
+   *    - ImplicitFunctionN for N > 22 becomes FunctionXXL
+   *    - ImplicitFunctionN for 22 > N >= 0 becomes FunctionN
+   *    - anything else becomes a NoType
+   */
+  def erasedFunctionType(cls: Symbol): Type = {
+    val arity = scalaClassName(cls).functionArity
+    if (arity > 22) defn.FunctionXXLType
+    else if (arity >= 0) defn.FunctionType(arity)
+    else NoType
+  }
+
   val predefClassNames: Set[Name] =
     Set("Predef$", "DeprecatedPredef", "LowPriorityImplicits").map(_.toTypeName)
 
@@ -760,8 +825,7 @@ class Definitions {
    *  trait gets screwed up. Therefore, it is mandatory that FunctionXXL
    *  is treated as a NoInit trait.
    */
-  def isNoInitClass(cls: Symbol) =
-    cls.is(NoInitsTrait) || PhantomClasses(cls) || ScalaFunction(cls).exists
+  lazy val NoInitClasses = PhantomClasses + FunctionXXLClass
 
   def isPolymorphicAfterErasure(sym: Symbol) =
      (sym eq Any_isInstanceOf) || (sym eq Any_asInstanceOf)
@@ -788,17 +852,15 @@ class Definitions {
 
   /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ImplicitFunctionN ? */
   def isFunctionType(tp: Type)(implicit ctx: Context) = {
-    val function = ScalaFunction(tp.dealias.typeSymbol)
-    function.exists && tp.isRef(function.symbol)
+    val arity = functionArity(tp)
+    val sym = tp.dealias.typeSymbol
+    arity >= 0 && isFunctionClass(sym) && tp.isRef(FunctionType(arity, sym.name.isImplicitFunction).typeSymbol)
   }
 
-  def functionArity(tp: Type)(implicit ctx: Context) =
-    ScalaFunction(tp.dealias.typeSymbol).arity
+  def functionArity(tp: Type)(implicit ctx: Context) = tp.dealias.argInfos.length - 1
 
-  def isImplicitFunctionType(tp: Type)(implicit ctx: Context) = {
-    val function = ScalaFunction(tp.dealias.typeSymbol)
-    function.isImplicit && tp.isRef(function.symbol)
-  }
+  def isImplicitFunctionType(tp: Type)(implicit ctx: Context) =
+    isFunctionType(tp) && tp.dealias.typeSymbol.name.isImplicitFunction
 
   // ----- primitive value class machinery ------------------------------------------
 
@@ -881,9 +943,8 @@ class Definitions {
     val newDecls = new MutableScope(oldDecls) {
       override def lookupEntry(name: Name)(implicit ctx: Context): ScopeEntry = {
         val res = super.lookupEntry(name)
-        lazy val function = ScalaFunction(name.asTypeName)
-        if (res == null && name.isTypeName && function.isSynthetic)
-          newScopeEntry(newFunctionNTrait(function))
+        if (res == null && name.isTypeName && name.isSyntheticFunction)
+          newScopeEntry(newFunctionNTrait(name.asTypeName))
         else res
       }
     }
@@ -906,9 +967,6 @@ class Definitions {
     EmptyPackageVal,
     OpsPackageClass)
 
-  def isSyntheticScalaClass(sym: Symbol): Boolean =
-    syntheticScalaClasses.contains(sym) || ScalaFunction(sym).isSynthetic
-
   /** Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
   lazy val syntheticCoreMethods = AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod)
 

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

@@ -8,6 +8,7 @@ import Names._, StdNames._, Contexts._, Symbols._, Flags._
 import Decorators.StringDecorator
 import util.{Chars, NameTransformer}
 import Chars.isOperatorPart
+import Definitions._
 
 object NameOps {
 
@@ -231,6 +232,45 @@ object NameOps {
       }
     }
 
+    /** Is a synthetic function name
+     *    - N for FunctionN
+     *    - N for ImplicitFunctionN
+      *   - (-1) otherwise
+     */
+    def functionArity: Int =
+      functionArityFor(tpnme.Function) max functionArityFor(tpnme.ImplicitFunction)
+
+    /** Is a function name
+     *    - FunctionN for N >= 0
+     *    - ImplicitFunctionN for N >= 0
+     *    - false otherwise
+     */
+    def isFunction: Boolean = functionArity >= 0
+
+    /** Is a implicit function name
+     *    - ImplicitFunctionN for N >= 0
+     *    - false otherwise
+     */
+    def isImplicitFunction: Boolean = functionArityFor(tpnme.ImplicitFunction) >= 0
+
+    /** Is a synthetic function name
+     *    - FunctionN for N > 22
+     *    - ImplicitFunctionN for N >= 0
+     *    - false otherwise
+     */
+    def isSyntheticFunction: Boolean = {
+      functionArityFor(tpnme.Function) > MaxImplementedFunctionArity ||
+        functionArityFor(tpnme.ImplicitFunction) >= 0
+    }
+
+    /** Parsed function arity for function with some specific prefix */
+    private def functionArityFor(prefix: Name): Int = {
+      if (name.startsWith(prefix))
+        try name.toString.substring(prefix.length).toInt
+        catch { case _: NumberFormatException => -1 }
+      else -1
+    }
+
     /** The name of the generic runtime operation corresponding to an array operation */
     def genericArrayOp: TermName = name match {
       case nme.apply => nme.array_apply

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

@@ -183,7 +183,6 @@ object StdNames {
     final val ExprApi: N             = "ExprApi"
     final val Function: N            = "Function"
     final val ImplicitFunction: N    = "ImplicitFunction"
-    final val FunctionXXL: N         = "FunctionXXL"
     final val Mirror: N              = "Mirror"
     final val Nothing: N             = "Nothing"
     final val Null: N                = "Null"

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

@@ -10,7 +10,6 @@ import dotc.transform.ExplicitOuter._
 import dotc.transform.ValueClasses._
 import util.DotClass
 import Definitions.MaxImplementedFunctionArity
-import dotty.tools.dotc.core.functions.ScalaFunction
 
 /** Erased types are:
  *
@@ -45,7 +44,7 @@ object TypeErasure {
       val sym = tp.symbol
       sym.isClass &&
       sym != defn.AnyClass && sym != defn.ArrayClass &&
-      !ScalaFunction(sym).isSynthetic
+      !defn.isSyntheticFunctionClass(sym)
     case _: TermRef =>
       true
     case JavaArrayType(elem) =>
@@ -356,11 +355,10 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       tp
     case tp: TypeRef =>
       val sym = tp.symbol
-      lazy val function = ScalaFunction(sym)
       if (!sym.isClass) this(tp.info)
       else if (semiEraseVCs && isDerivedValueClass(sym)) eraseDerivedValueClassRef(tp)
       else if (sym == defn.ArrayClass) apply(tp.appliedTo(TypeBounds.empty)) // i966 shows that we can hit a raw Array type.
-      else if (function.exists) function.erased.typeRef
+      else if (defn.isSyntheticFunctionClass(sym)) defn.erasedFunctionType(sym)
       else eraseNormalClassRef(tp)
     case tp: RefinedType =>
       val parent = tp.parent
@@ -371,7 +369,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
     case SuperType(thistpe, supertpe) =>
       SuperType(this(thistpe), this(supertpe))
     case ExprType(rt) =>
-      defn.ImplementedFunctionType(0)
+      defn.FunctionType(0)
     case AndType(tp1, tp2) =>
       erasedGlb(this(tp1), this(tp2), isJava)
     case OrType(tp1, tp2) =>
@@ -497,9 +495,8 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
           val erasedVCRef = eraseDerivedValueClassRef(tp)
           if (erasedVCRef.exists) return sigName(erasedVCRef)
         }
-        val function = ScalaFunction(sym)
-        if (function.isSynthetic)
-          sigName(function.erased.typeRef)
+        if (defn.isSyntheticFunctionClass(sym))
+          sigName(defn.erasedFunctionType(sym))
         else
           normalizeClass(sym.asClass).fullName.asTypeName
       case defn.ArrayOf(elem) =>