Scala.js: Generalize js.Function's to allow user-defined ones.

Forward port of the upstream commit
scala-js/scala-js@7edacf5

Author: sjrd

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -2702,7 +2702,7 @@ class JSCodeGen()(using genCtx: Context) {
 
       case JSCallingConvention.Call =>
         requireNotSuper()
-        if (jsdefn.isJSThisFunctionClass(sym.owner))
+        if (sym.owner.isSubClass(jsdefn.JSThisFunctionClass))
           js.JSMethodApply(ruleOutGlobalScope(receiver), js.StringLiteral("call"), args)
         else
           js.JSFunctionApply(ruleOutGlobalScope(receiver), args)
@@ -3052,17 +3052,35 @@ class JSCodeGen()(using genCtx: Context) {
     }
     val (formalCaptures, actualCaptures) = formalAndActualCaptures.unzip
 
+    val funInterfaceSym = functionalInterface.tpe.typeSymbol
+    val hasRepeatedParam = {
+      funInterfaceSym.exists && {
+        val Seq(samMethodDenot) = funInterfaceSym.info.possibleSamMethods
+        val samMethod = samMethodDenot.symbol
+        atPhase(elimRepeatedPhase)(samMethod.info.paramInfoss.flatten.exists(_.isRepeatedParam))
+      }
+    }
+
     val formalParamNames = sym.info.paramNamess.flatten.drop(envSize)
     val formalParamTypes = sym.info.paramInfoss.flatten.drop(envSize)
-    val formalParamNamesAndTypes = formalParamNames.zip(formalParamTypes)
-    val formalAndActualParams = formalParamNamesAndTypes.map {
-      case (name, tpe) =>
+    val formalParamRepeateds =
+      if (hasRepeatedParam) (0 until (formalParamTypes.size - 1)).map(_ => false) :+ true
+      else (0 until formalParamTypes.size).map(_ => false)
+
+    val formalAndActualParams = formalParamNames.lazyZip(formalParamTypes).lazyZip(formalParamRepeateds).map {
+      (name, tpe, repeated) =>
         val formalParam = js.ParamDef(freshLocalIdent(name.toString),
             OriginalName(name.toString), jstpe.AnyType, mutable = false)
-        val actualParam = unbox(formalParam.ref, tpe)
+        val actualParam =
+          if (repeated) genJSArrayToVarArgs(formalParam.ref)(tree.sourcePos)
+          else unbox(formalParam.ref, tpe)
         (formalParam, actualParam)
     }
-    val (formalParams, actualParams) = formalAndActualParams.unzip
+    val (formalAndRestParams, actualParams) = formalAndActualParams.unzip
+
+    val (formalParams, restParam) =
+      if (hasRepeatedParam) (formalAndRestParams.init, Some(formalAndRestParams.last))
+      else (formalAndRestParams, None)
 
     val genBody = {
       val call = if (isStaticCall) {
@@ -3077,34 +3095,41 @@ class JSCodeGen()(using genCtx: Context) {
       box(call, sym.info.finalResultType)
     }
 
-    val funInterfaceSym = functionalInterface.tpe.typeSymbol
+    val isThisFunction = funInterfaceSym.isSubClass(jsdefn.JSThisFunctionClass) && {
+      val ok = formalParams.nonEmpty
+      if (!ok)
+        report.error("The SAM or apply method for a js.ThisFunction must have a leading non-varargs parameter", tree)
+      ok
+    }
 
-    if (jsdefn.isJSThisFunctionClass(funInterfaceSym)) {
+    if (isThisFunction) {
       val thisParam :: otherParams = formalParams
       js.Closure(
           arrow = false,
           formalCaptures,
           otherParams,
-          None,
+          restParam,
           js.Block(
               js.VarDef(thisParam.name, thisParam.originalName,
                   thisParam.ptpe, mutable = false,
                   js.This()(thisParam.ptpe)(thisParam.pos))(thisParam.pos),
               genBody),
           actualCaptures)
     } else {
-      val closure = js.Closure(arrow = true, formalCaptures, formalParams, None, genBody, actualCaptures)
+      val closure = js.Closure(arrow = true, formalCaptures, formalParams, restParam, genBody, actualCaptures)
 
-      if (jsdefn.isJSFunctionClass(funInterfaceSym)) {
-        closure
-      } else {
+      if (!funInterfaceSym.exists || defn.isFunctionClass(funInterfaceSym)) {
         assert(!funInterfaceSym.exists || defn.isFunctionClass(funInterfaceSym),
             s"Invalid functional interface $funInterfaceSym reached the back-end")
         val formalCount = formalParams.size
         val cls = ClassName("scala.scalajs.runtime.AnonFunction" + formalCount)
         val ctorName = MethodName.constructor(
             jstpe.ClassRef(ClassName("scala.scalajs.js.Function" + formalCount)) :: Nil)
         js.New(cls, js.MethodIdent(ctorName), List(closure))
+      } else {
+        assert(funInterfaceSym.isJSType,
+            s"Invalid functional interface $funInterfaceSym reached the back-end")
+        closure
       }
     }
   }

compiler/src/dotty/tools/backend/sjs/JSDefinitions.scala

@@ -46,8 +46,10 @@ final class JSDefinitions()(using Context) {
   def JSAnyClass(using Context) = JSAnyType.symbol.asClass
   @threadUnsafe lazy val JSObjectType: TypeRef = requiredClassRef("scala.scalajs.js.Object")
   def JSObjectClass(using Context) = JSObjectType.symbol.asClass
-  @threadUnsafe lazy val JSBaseThisFunctionType: TypeRef = requiredClassRef("scala.scalajs.js.ThisFunction")
-  def JSBaseThisFunctionClass(using Context) = JSBaseThisFunctionType.symbol.asClass
+  @threadUnsafe lazy val JSFunctionType: TypeRef = requiredClassRef("scala.scalajs.js.Function")
+  def JSFunctionClass(using Context) = JSFunctionType.symbol.asClass
+  @threadUnsafe lazy val JSThisFunctionType: TypeRef = requiredClassRef("scala.scalajs.js.ThisFunction")
+  def JSThisFunctionClass(using Context) = JSThisFunctionType.symbol.asClass
 
   @threadUnsafe lazy val PseudoUnionType: TypeRef = requiredClassRef("scala.scalajs.js.|")
   def PseudoUnionClass(using Context) = PseudoUnionType.symbol.asClass
@@ -66,11 +68,6 @@ final class JSDefinitions()(using Context) {
   @threadUnsafe lazy val JSDynamicType: TypeRef = requiredClassRef("scala.scalajs.js.Dynamic")
   def JSDynamicClass(using Context) = JSDynamicType.symbol.asClass
 
-  @threadUnsafe lazy val JSFunctionType = (0 to 22).map(n => requiredClassRef("scala.scalajs.js.Function" + n)).toArray
-  def JSFunctionClass(n: Int)(using Context) = JSFunctionType(n).symbol.asClass
-  @threadUnsafe lazy val JSThisFunctionType = (0 to 21).map(n => requiredClassRef("scala.scalajs.js.ThisFunction" + n)).toArray
-  def JSThisFunctionClass(n: Int)(using Context) = JSThisFunctionType(n).symbol.asClass
-
   @threadUnsafe lazy val RuntimeExceptionType: TypeRef = requiredClassRef("java.lang.RuntimeException")
   def RuntimeExceptionClass(using Context) = RuntimeExceptionType.symbol.asClass
   @threadUnsafe lazy val JavaScriptExceptionType: TypeRef = requiredClassRef("scala.scalajs.js.JavaScriptException")
@@ -236,27 +233,6 @@ final class JSDefinitions()(using Context) {
     allRefClassesCache
   }
 
-  /** If `cls` is a class in the scala package, its name, otherwise EmptyTypeName */
-  private def scalajsClassName(cls: Symbol)(using Context): TypeName =
-    if (cls.isClass && cls.owner == ScalaJSJSPackageClass) cls.asClass.name
-    else EmptyTypeName
-
-  /** Is the given `cls` a class of the form `scala.scalajs.js.prefixN` where
-   *  `N` is a number.
-   *
-   *  This is similar to `isVarArityClass` in `Definitions.scala`.
-   */
-  private def isScalaJSVarArityClass(cls: Symbol, prefix: String): Boolean = {
-    val name = scalajsClassName(cls)
-    name.startsWith(prefix) && name.toString.drop(prefix.length).forall(_.isDigit)
-  }
-
-  def isJSFunctionClass(cls: Symbol): Boolean =
-    isScalaJSVarArityClass(cls, str.Function)
-
-  def isJSThisFunctionClass(cls: Symbol): Boolean =
-    isScalaJSVarArityClass(cls, "ThisFunction")
-
   /** Definitions related to the treatment of JUnit bootstrappers. */
   object junit {
     @threadUnsafe lazy val TestAnnotType: TypeRef = requiredClassRef("org.junit.Test")

compiler/src/dotty/tools/dotc/config/SJSPlatform.scala

@@ -23,8 +23,7 @@ class SJSPlatform()(using Context) extends JavaPlatform {
   /** Is the SAMType `cls` also a SAM under the rules of the Scala.js back-end? */
   override def isSam(cls: ClassSymbol)(using Context): Boolean =
     defn.isFunctionClass(cls)
-      || jsDefinitions.isJSFunctionClass(cls)
-      || jsDefinitions.isJSThisFunctionClass(cls)
+      || cls.superClass == jsDefinitions.JSFunctionClass
 
   /** Is the given class symbol eligible for Java serialization-specific methods?
    *

compiler/src/dotty/tools/dotc/transform/sjs/JSSymUtils.scala

@@ -161,6 +161,9 @@ object JSSymUtils {
     def jsCallingConvention(using Context): JSCallingConvention =
       JSCallingConvention.of(sym)
 
+    def hasJSCallCallingConvention(using Context): Boolean =
+      sym.jsCallingConvention == JSCallingConvention.Call
+
     /** Gets the unqualified JS name of the symbol.
      *
      *  If it is not explicitly specified with an `@JSName` annotation, the

compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala

@@ -241,6 +241,32 @@ class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisP
 
     private def transformStatOrExpr(tree: Tree)(using Context): Tree = {
       tree match {
+        case Closure(env, call, functionalInterface) =>
+          val tpeSym = functionalInterface.tpe.typeSymbol
+          if (tpeSym.isJSType) {
+            def reportError(reasonAndExplanation: String): Unit = {
+              report.error(
+                  "Using an anonymous function as a SAM for the JavaScript type " +
+                  i"${tpeSym.fullName} is not allowed because " +
+                  reasonAndExplanation,
+                  tree)
+            }
+            if (!tpeSym.is(Trait) || tpeSym.asClass.superClass != jsdefn.JSFunctionClass) {
+              reportError(
+                  "it is not a trait extending js.Function. " +
+                  "Use an anonymous class instead.")
+            } else if (tpeSym.hasAnnotation(jsdefn.JSNativeAnnot)) {
+              reportError(
+                  "it is a native JS type. " +
+                  "It is not possible to directly implement it.")
+            } else if (!tree.tpe.possibleSamMethods.exists(_.symbol.hasJSCallCallingConvention)) {
+              reportError(
+                  "its single abstract method is not named `apply`. " +
+                  "Use an anonymous class instead.")
+            }
+          }
+          super.transform(tree)
+
         // Validate js.constructorOf[T]
         case TypeApply(ctorOfTree, List(tpeArg))
             if ctorOfTree.symbol == jsdefn.JSPackage_constructorOf =>
@@ -617,8 +643,27 @@ class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisP
           case JSCallingConvention.Property(_) => // checked above
           case JSCallingConvention.Method(_)   => // no checks needed
 
-          case JSCallingConvention.Call =>
-            report.error("A non-native JS class cannot declare a method named `apply` without `@JSName`", tree)
+          case JSCallingConvention.Call if !sym.is(Deferred) =>
+            report.error("A non-native JS class cannot declare a concrete method named `apply` without `@JSName`", tree)
+
+          case JSCallingConvention.Call => // if sym.isDeferred
+            /* Allow an abstract `def apply` only if the owner is a plausible
+             * JS function SAM trait.
+             */
+            val owner = sym.owner
+            val isPlausibleJSFunctionType = {
+              owner.is(Trait) &&
+              owner.asClass.superClass == jsdefn.JSFunctionClass &&
+              owner.typeRef.possibleSamMethods.map(_.symbol) == Seq(sym) &&
+              !sym.info.isInstanceOf[PolyType]
+            }
+            if (!isPlausibleJSFunctionType) {
+              report.error(
+                  "A non-native JS type can only declare an abstract method named `apply` without `@JSName` " +
+                  "if it is the SAM of a trait that extends js.Function",
+                  tree)
+            }
+
           case JSCallingConvention.BracketAccess =>
             report.error("@JSBracketAccess is not allowed in non-native JS classes", tree)
           case JSCallingConvention.BracketCall =>

project/Build.scala

@@ -1115,9 +1115,7 @@ object Build {
           ++ (dir / "js/src/test/require-2.12" ** (("*.scala": FileFilter)
             -- "JSOptionalTest212.scala" // TODO: Enable once we use a Scala.js with https://github.com/scala-js/scala-js/pull/4451 in
             )).get
-          ++ (dir / "js/src/test/require-sam" ** (("*.scala": FileFilter)
-            -- "CustomJSFunctionTest.scala" // TODO: Custom JS function types are not implemented yet
-            )).get
+          ++ (dir / "js/src/test/require-sam" ** "*.scala").get
           ++ (dir / "js/src/test/scala-new-collections" ** "*.scala").get
         )
       },

tests/neg-scalajs/js-custom-function-types-backend.scala

@@ -0,0 +1,13 @@
+import scala.scalajs.js
+import scala.scalajs.js.annotation.*
+
+trait BadThisFunction1 extends js.ThisFunction {
+  def apply(): Int
+}
+trait BadThisFunction2 extends js.ThisFunction {
+  def apply(args: Int*): Int
+}
+class A {
+  val badThisFunction1: BadThisFunction1 = () => 42 // error
+  val badThisFunction2: BadThisFunction2 = args => args.size // error
+}

tests/neg-scalajs/js-custom-function-types-prepjsinterop.scala

@@ -0,0 +1,24 @@
+import scala.scalajs.js
+import scala.scalajs.js.annotation.*
+
+class BadFunctionIsClass extends js.Function {
+  def apply(x: Int): Int // error
+}
+trait BadFunctionExtendsNonFunction extends js.Object {
+  def apply(x: Int): Int // error
+}
+class SubclassOfFunction extends js.Function
+trait BadFunctionExtendsSubclassOfFunction extends SubclassOfFunction {
+  def apply(x: Int): Int // error
+}
+trait BadFunctionParametricMethod extends js.Function {
+  def apply[A](x: A): A // error
+}
+trait BadFunctionOverloaded extends js.Function {
+  def apply(x: Int): Int // error
+  def apply(x: String): String // error
+}
+trait BadFunctionMultipleAbstract extends js.Function {
+  def apply(x: Int): Int // error
+  def foo(x: Int): Int
+}

tests/neg-scalajs/js-non-native-members.check

@@ -1,7 +1,7 @@
 -- Error: tests/neg-scalajs/js-non-native-members.scala:5:6 ------------------------------------------------------------
 5 |  def apply(arg: Int): Int = arg // error
   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |  A non-native JS class cannot declare a method named `apply` without `@JSName`
+  |  A non-native JS class cannot declare a concrete method named `apply` without `@JSName`
 -- Error: tests/neg-scalajs/js-non-native-members.scala:8:6 ------------------------------------------------------------
 7 |  @JSBracketAccess
 8 |  def foo(index: Int, arg: Int): Int = arg // error

tests/neg-scalajs/js-sam-of-non-function-type.scala

@@ -0,0 +1,38 @@
+import scala.scalajs.js
+import scala.scalajs.js.annotation.*
+
+@js.native
+trait A1 extends js.Object {
+  def foo(x: Int): Int
+}
+trait A2 extends js.Object {
+  def bar(x: Int): Int
+}
+class A3 extends js.Function {
+  def foobar(x: Int): Int
+}
+class A4 {
+  val foo: A1 = x => x + 1 // error
+  val bar: A2 = x => x + 1 // error
+  val foobar: A3 = x => x + 1 // error
+}
+
+@js.native
+trait B1 extends js.Function {
+  def apply(x: Int): Int
+}
+@js.native
+trait B2 extends js.Function {
+  def bar(x: Int = 5): Int
+}
+class B3 {
+  val foo: B1 = x => x + 1 // error
+  val bar: B2 = x => x + 1 // error
+}
+
+trait C1 extends js.Function {
+  def foo(x: Int): Int
+}
+class C2 {
+  val foo: C1 = x => x + 1 // error
+}