Factor out logic for scala functions.

Author: nicolasstucki

compiler/sjs/backend/sjs/JSCodeGen.scala

@@ -16,6 +16,7 @@ import SymDenotations._
 import Contexts._
 import Decorators._
 import Flags._
+import functions.ScalaFunction
 import dotty.tools.dotc.ast.Trees._
 import Types._
 import Symbols._
@@ -1903,7 +1904,7 @@ class JSCodeGen()(implicit ctx: Context) {
     if (jsdefn.isJSFunctionClass(funInterfaceSym)) {
       closure
     } else {
-      assert(!funInterfaceSym.exists || defn.isFunctionClass(funInterfaceSym),
+      assert(!funInterfaceSym.exists || ScalaFunction(funInterfaceSym).exists,
           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,6 +1,7 @@
 package dotty.tools.dotc.config
 
 import dotty.tools.dotc.core._
+import functions.ScalaFunction
 import Contexts._
 import Symbols._
 
@@ -13,6 +14,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 =
-    defn.isFunctionClass(cls) || jsDefinitions.isJSFunctionClass(cls)
+    ScalaFunction(cls).exists || jsDefinitions.isJSFunctionClass(cls)
 
 }

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

@@ -10,6 +10,7 @@ import scala.collection.{ mutable, immutable }
 import PartialFunction._
 import collection.mutable
 import scala.reflect.api.{ Universe => ApiUniverse }
+import functions._
 
 object Definitions {
 
@@ -90,7 +91,7 @@ class Definitions {
   }
 
   /** The trait FunctionN or ImplicitFunctionN, for some N
-   *  @param  name   The name of the trait to be created
+   *  @param  function   The function name description of the trait to be created
    *
    *  FunctionN traits follow this template:
    *
@@ -108,32 +109,28 @@ class Definitions {
    *        def apply(implicit $x0: T0, ..., $x{N_1}: T{N-1}): R
    *      }
    */
-  private def newFunctionNTrait(name: TypeName) = {
+  private def newFunctionNTrait(function: ScalaFunction) = {
     val completer = new LazyType {
       def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
         val cls = denot.asClass.classSymbol
         val decls = newScope
-        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 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 (methodType, parentTraits) =
-          if (name.startsWith(tpnme.ImplicitFunction)) {
-            val superTrait =
-              FunctionType(arity).appliedTo(argParams.map(_.typeRef) ::: resParam.typeRef :: Nil)
+          if (function.isImplicit) {
+            val superTrait = function.withoutImplicit.typeRef.appliedTo(tParamTpes)
             (ImplicitMethodType, ctx.normalizeToClassRefs(superTrait :: Nil, cls, decls))
           }
           else (MethodType, Nil)
-        val applyMeth =
-          decls.enter(
-            newMethod(cls, nme.apply,
-              methodType(argParams.map(_.typeRef), resParam.typeRef), Deferred))
-        denot.info =
-          ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: parentTraits, decls)
+
+        decls.enter(newMethod(cls, nme.apply, methodType(tParamTpes.init, tParamTpes.last), Deferred))
+        denot.info = ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: parentTraits, decls)
       }
     }
-    newClassSymbol(ScalaPackageClass, name, Trait | NoInits, completer)
+    newClassSymbol(ScalaPackageClass, function.name, NoInitsTrait, completer)
   }
 
   private def newMethod(cls: ClassSymbol, name: TermName, info: Type, flags: FlagSet = EmptyFlags): TermSymbol =
@@ -631,19 +628,18 @@ class Definitions {
     sym.owner.linkedClass.typeRef
 
   object FunctionOf {
-    def apply(args: List[Type], resultType: Type, isImplicit: Boolean = false)(implicit ctx: Context) =
-      FunctionType(args.length, isImplicit).appliedTo(args ::: resultType :: Nil)
+    def apply(args: List[Type], resultType: Type, isImplicit: Boolean = false)(implicit ctx: Context) = {
+      ScalaFunction(args, isImplicit).typeRef.appliedTo(args ::: resultType :: Nil)
+    }
     def unapply(ft: Type)(implicit ctx: Context) = {
       val tsym = ft.typeSymbol
-      val isImplicitFun = isImplicitFunctionClass(tsym)
-      if (isImplicitFun || isFunctionClass(tsym)) {
-        val targs = ft.argInfos
-        val numArgs = targs.length - 1
-        if (numArgs >= 0 && FunctionType(numArgs, isImplicitFun).symbol == tsym)
-          Some(targs.init, targs.last, isImplicitFun)
-        else None
+      val function = ScalaFunction(tsym)
+      if (function.exists) {
+        val targs = ft.dealias.argInfos
+        Some(targs.init, targs.last, function.isImplicit)
+      } else {
+        None
       }
-      else None
     }
   }
 
@@ -688,26 +684,14 @@ 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)
-  private lazy val ImplementedFunctionType = mkArityArray("scala.Function", MaxImplementedFunctionArity, 0)
+  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)
 
-  def FunctionClass(n: Int)(implicit ctx: Context) =
-    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 ImplicitFunctionClass(n: Int)(implicit ctx: Context) =
-    ctx.requiredClass("scala.ImplicitFunction" + n.toString)
-
-  def FunctionType(n: Int, isImplicit: Boolean = false)(implicit ctx: Context): TypeRef =
-    if (isImplicit && !ctx.erasedTypes) ImplicitFunctionClass(n).typeRef
-    else if (n < MaxImplementedFunctionArity) ImplementedFunctionType(n)
-    else FunctionClass(n).typeRef
+  lazy val Function0_applyR = ImplementedFunctionType(0).symbol.requiredMethodRef(nme.apply)
+  def Function0_apply(implicit ctx: Context) = Function0_applyR.symbol
 
   private lazy val TupleTypes: Set[TypeRef] = TupleType.toSet
   private lazy val ProductTypes: Set[TypeRef] = ProductNType.toSet
@@ -731,10 +715,6 @@ class Definitions {
   def isBottomType(tp: Type) =
     tp.derivesFrom(NothingClass) || tp.derivesFrom(NullClass)
 
-  def isFunctionClass(cls: Symbol) = isVarArityClass(cls, tpnme.Function)
-  def isImplicitFunctionClass(cls: Symbol) = isVarArityClass(cls, tpnme.ImplicitFunction)
-  /** Is a class that will be erased to FunctionXXL */
-  def isXXLFunctionClass(cls: Symbol) = cls.name.functionArity > MaxImplementedFunctionArity
   def isAbstractFunctionClass(cls: Symbol) = isVarArityClass(cls, tpnme.AbstractFunction)
   def isTupleClass(cls: Symbol) = isVarArityClass(cls, tpnme.Tuple)
   def isProductClass(cls: Symbol) = isVarArityClass(cls, tpnme.Product)
@@ -780,7 +760,8 @@ class Definitions {
    *  trait gets screwed up. Therefore, it is mandatory that FunctionXXL
    *  is treated as a NoInit trait.
    */
-  lazy val NoInitClasses = PhantomClasses + FunctionXXLClass
+  def isNoInitClass(cls: Symbol) =
+    cls.is(NoInitsTrait) || PhantomClasses(cls) || ScalaFunction(cls).exists
 
   def isPolymorphicAfterErasure(sym: Symbol) =
      (sym eq Any_isInstanceOf) || (sym eq Any_asInstanceOf)
@@ -807,18 +788,17 @@ class Definitions {
 
   /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ImplicitFunctionN ? */
   def isFunctionType(tp: Type)(implicit ctx: Context) = {
-    val arity = functionArity(tp)
-    val sym = tp.dealias.typeSymbol
-    arity >= 0 && (
-      isFunctionClass(sym) && tp.isRef(FunctionType(arity, isImplicit = false).typeSymbol) ||
-      isImplicitFunctionClass(sym) && tp.isRef(FunctionType(arity, isImplicit = true).typeSymbol)
-    )
+    val function = ScalaFunction(tp.dealias.typeSymbol)
+    function.exists && tp.isRef(function.symbol)
   }
 
-  def functionArity(tp: Type)(implicit ctx: Context) = tp.dealias.argInfos.length - 1
+  def functionArity(tp: Type)(implicit ctx: Context) =
+    ScalaFunction(tp.dealias.typeSymbol).arity
 
-  def isImplicitFunctionType(tp: Type)(implicit ctx: Context) =
-    isFunctionType(tp) && tp.dealias.typeSymbol.name.startsWith(tpnme.ImplicitFunction)
+  def isImplicitFunctionType(tp: Type)(implicit ctx: Context) = {
+    val function = ScalaFunction(tp.dealias.typeSymbol)
+    function.isImplicit && tp.isRef(function.symbol)
+  }
 
   // ----- primitive value class machinery ------------------------------------------
 
@@ -892,9 +872,6 @@ class Definitions {
 
   // ----- Initialization ---------------------------------------------------
 
-  private def maxImplemented(name: Name) =
-    if (name `startsWith` tpnme.Function) MaxImplementedFunctionArity else 0
-
   /** Give the scala package a scope where a FunctionN trait is automatically
    *  added when someone looks for it.
    */
@@ -904,8 +881,9 @@ class Definitions {
     val newDecls = new MutableScope(oldDecls) {
       override def lookupEntry(name: Name)(implicit ctx: Context): ScopeEntry = {
         val res = super.lookupEntry(name)
-        if (res == null && name.isTypeName && name.functionArity > maxImplemented(name))
-          newScopeEntry(newFunctionNTrait(name.asTypeName))
+        lazy val function = ScalaFunction(name.asTypeName)
+        if (res == null && name.isTypeName && function.isSynthetic)
+          newScopeEntry(newFunctionNTrait(function))
         else res
       }
     }
@@ -928,6 +906,9 @@ 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

@@ -231,15 +231,6 @@ object NameOps {
       }
     }
 
-    def functionArity: Int = {
-      def test(prefix: Name): Int =
-        if (name.startsWith(prefix))
-          try name.drop(prefix.length).toString.toInt
-          catch { case ex: NumberFormatException => -1 }
-        else -1
-      test(tpnme.Function) max test(tpnme.ImplicitFunction)
-    }
-
     /** 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,6 +183,7 @@ 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,6 +10,7 @@ import dotc.transform.ExplicitOuter._
 import dotc.transform.ValueClasses._
 import util.DotClass
 import Definitions.MaxImplementedFunctionArity
+import dotty.tools.dotc.core.functions.ScalaFunction
 
 /** Erased types are:
  *
@@ -44,7 +45,7 @@ object TypeErasure {
       val sym = tp.symbol
       sym.isClass &&
       sym != defn.AnyClass && sym != defn.ArrayClass &&
-      !defn.isXXLFunctionClass(sym) && !defn.isImplicitFunctionClass(sym)
+      !ScalaFunction(sym).isSynthetic
     case _: TermRef =>
       true
     case JavaArrayType(elem) =>
@@ -355,11 +356,11 @@ 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 (defn.isXXLFunctionClass(sym)) defn.FunctionXXLType
-      else if (defn.isImplicitFunctionClass(sym)) apply(defn.FunctionType(sym.name.functionArity))
+      else if (function.exists) function.erased.typeRef
       else eraseNormalClassRef(tp)
     case tp: RefinedType =>
       val parent = tp.parent
@@ -370,7 +371,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
     case SuperType(thistpe, supertpe) =>
       SuperType(this(thistpe), this(supertpe))
     case ExprType(rt) =>
-      defn.FunctionClass(0).typeRef
+      defn.ImplementedFunctionType(0)
     case AndType(tp1, tp2) =>
       erasedGlb(this(tp1), this(tp2), isJava)
     case OrType(tp1, tp2) =>
@@ -496,8 +497,9 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
           val erasedVCRef = eraseDerivedValueClassRef(tp)
           if (erasedVCRef.exists) return sigName(erasedVCRef)
         }
-        if (defn.isImplicitFunctionClass(sym))
-          sigName(defn.FunctionType(sym.name.functionArity))
+        val function = ScalaFunction(sym)
+        if (function.isSynthetic)
+          sigName(function.erased.typeRef)
         else
           normalizeClass(sym.asClass).fullName.asTypeName
       case defn.ArrayOf(elem) =>

compiler/src/dotty/tools/dotc/core/functions/ScalaFunction.scala

@@ -0,0 +1,76 @@
+package dotty.tools.dotc.core.functions
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Definitions._
+import dotty.tools.dotc.core.Names._
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+
+trait ScalaFunction {
+  def arity: Int
+  def isImplicit: Boolean
+
+  def symbol(implicit ctx: Context): Symbol
+  def typeRef(implicit ctx: Context): TypeRef
+
+  def name: TypeName
+  protected def fullName: TypeName = tpnme.scala_ ++ "." ++ name
+
+  override def toString(): String = s"ScalaFunction($name)"
+}
+
+object ScalaFunction {
+
+  def apply(sym: Symbol)(implicit ctx: Context): ScalaFunction = apply(defn.scalaClassName(sym))
+
+  def apply(name: TypeName)(implicit ctx: Context): ScalaFunction = {
+    val functionArity = testArity(tpnme.Function, name)
+    lazy val implicitFunctionArity = testArity(tpnme.ImplicitFunction, name)
+    if (functionArity != -1)
+      new SimpleFunction(functionArity, isImplicit = false)
+    else if (implicitFunctionArity != -1)
+      new SimpleFunction(implicitFunctionArity, isImplicit = true)
+    else if (name == tpnme.FunctionXXL) ScalaFunctionXXL
+    else new NotAFunctionName(name)
+  }
+
+  def apply(args: List[Type], isImplicit: Boolean)(implicit ctx: Context): ScalaFunction = {
+    new SimpleFunction(args.size, isImplicit)
+  }
+
+  def apply(arity: Int, isImplicit: Boolean = false): SimpleFunction =
+    new SimpleFunction(arity, isImplicit)
+
+  private class NotAFunctionName(val name: TypeName) extends ScalaFunction {
+    override def symbol(implicit ctx: Context): Symbol = NoSymbol
+    def typeRef(implicit ctx: Context): TypeRef = throw new UnsupportedOperationException()
+    def arity: Int = -1
+    def isImplicit: Boolean = false
+    override def toString(): String = "NotAFunctionName"
+  }
+
+  implicit class Ops(fun: ScalaFunction) {
+    def exists: Boolean = !fun.isInstanceOf[NotAFunctionName]
+    def isFunctionXXL: Boolean = fun eq ScalaFunctionXXL
+    def isSynthetic: Boolean = exists && (fun.isImplicit || fun.arity > MaxImplementedFunctionArity)
+
+    def erased: ScalaFunction = {
+      if (fun.arity > MaxImplementedFunctionArity) ScalaFunctionXXL
+      else fun.withoutImplicit
+    }
+
+    def withoutImplicit: ScalaFunction = fun match {
+      case f: SimpleFunction if f.isImplicit => new SimpleFunction(f.arity, isImplicit = false)
+      case _ => fun
+    }
+  }
+
+  private def testArity(prefix: Name, name: Name): Int = {
+    if (name.startsWith(prefix))
+      try name.toString.substring(prefix.length).toInt
+      catch { case ex: NumberFormatException => -1 }
+    else -1
+  }
+
+}