Apply the IR cleaner to the scalalib and the library-aux.

sjrd · sjrd · commit 613cd6d53450 · 2023-01-14T19:12:34.000+01:00
It is configured differently than for the javalib. We allow
references to `scala.*` (obviously) but disallow references to
`scala.scalajs.*`. We also avoid rewriting Scala functions to JS
functions, since that changes the binary APIs.

We use a local copy of `sjs.runtime.AnonFunctionN` classes in
`scala.runtime.*` to support the codegen of lambdas.
diff --git a/project/Build.scala b/project/Build.scala
@@ -571,9 +571,9 @@ object Build {
       }
   )
 
-  val cleanIRSettings = Def.settings(
+  def cleanIRSettings(forScalalib: Boolean): Seq[Setting[_]] = Def.settings(
       // In order to rewrite anonymous functions and tuples, the code must not be specialized
-      scalacOptions += "-no-specialization",
+      scalacOptions ++= (if (forScalalib) Nil else Seq("-no-specialization")),
 
       products in Compile := {
         val s = streams.value
@@ -582,7 +582,7 @@ object Build {
 
         val outputDir = crossTarget.value / "cleaned-classes"
 
-        val irCleaner = new JavalibIRCleaner((LocalRootProject / baseDirectory).value.toURI())
+        val irCleaner = new JavalibIRCleaner((LocalRootProject / baseDirectory).value.toURI(), forScalalib)
 
         val libFileMappings = (PathFinder(prevProducts) ** "*.sjsir")
           .pair(Path.rebase(prevProducts, outputDir))
@@ -1002,7 +1002,7 @@ object Build {
       name := "Scala.js linker private library",
       publishArtifact in Compile := false,
       delambdafySetting,
-      cleanIRSettings
+      cleanIRSettings(forScalalib = false),
   ).withScalaJSCompiler2_12.withScalaJSJUnitPlugin2_12.dependsOnLibrary2_12.dependsOn(
       jUnitRuntime.v2_12 % "test", testBridge.v2_12 % "test",
   )
@@ -1319,7 +1319,7 @@ object Build {
         Seq(output)
       }.taskValue,
 
-      cleanIRSettings,
+      cleanIRSettings(forScalalib = false),
 
       Compile / doc := {
         val dir = (Compile / doc / target).value
@@ -1516,6 +1516,8 @@ object Build {
 
       headerSources in Compile := Nil,
       headerSources in Test := Nil,
+
+      cleanIRSettings(forScalalib = true),
   ).withScalaJSCompiler.dependsOnLibraryNoJar
 
   lazy val libraryAux: MultiScalaProject = MultiScalaProject(
@@ -1531,6 +1533,8 @@ object Build {
       delambdafySetting,
 
       recompileAllOrNothingSettings,
+
+      cleanIRSettings(forScalalib = true),
   ).withScalaJSCompiler.dependsOnLibraryNoJar
 
   lazy val library: MultiScalaProject = MultiScalaProject(
diff --git a/project/JavalibIRCleaner.scala b/project/JavalibIRCleaner.scala
@@ -39,9 +39,13 @@ import sbt.{Logger, MessageOnlyException}
  *  Afterwards, we check that the IR does not contain any reference to classes
  *  under the `scala.*` package.
  */
-final class JavalibIRCleaner(baseDirectoryURI: URI) {
+final class JavalibIRCleaner(baseDirectoryURI: URI, forScalalib: Boolean) {
   import JavalibIRCleaner._
 
+  private val classNameSubstitutions: Map[ClassName, ClassName] =
+    if (forScalalib) ClassNameSubstitutionsForScalalib
+    else ClassNameSubstitutionsForJavalib
+
   def cleanIR(dependencyFiles: Seq[File], libFileMappings: Seq[(File, File)],
       logger: Logger): Set[File] = {
 
@@ -80,11 +84,19 @@ final class JavalibIRCleaner(baseDirectoryURI: URI) {
     }
 
     if (errorManager.hasErrors) {
-      throw new MessageOnlyException(
-          s"There were ${errorManager.errorCount} errors while " +
-          "postprocessing the IR of the javalanglib. " +
-          "The javalanglib must be written in a style that does not leak any " +
-          "reference to the Scala library.")
+      if (forScalalib) {
+        throw new MessageOnlyException(
+            s"There were ${errorManager.errorCount} errors while " +
+            "postprocessing the IR of the scalalib. " +
+            "The scalalib must be written in a style that does not leak any " +
+            "reference to the Scala.js standard library.")
+      } else {
+        throw new MessageOnlyException(
+            s"There were ${errorManager.errorCount} errors while " +
+            "postprocessing the IR of the javalib. " +
+            "The javalib must be written in a style that does not leak any " +
+            "reference to the Scala library.")
+      }
     }
 
     resultBuilder.result()
@@ -149,11 +161,16 @@ final class JavalibIRCleaner(baseDirectoryURI: URI) {
       /* Remove the `private def writeReplace__O` generated by scalac 2.13+
        * in the companion of serializable classes.
        */
-      val newMemberDefs = memberDefs.filter {
-        case MethodDef(_, MethodIdent(`writeReplaceMethodName`), _, _, _, _) =>
-          false
-        case _ =>
-          true
+      val newMemberDefs = if (forScalalib) {
+        // Don't do it for the scalalib
+        memberDefs
+      } else {
+         memberDefs.filter {
+          case MethodDef(_, MethodIdent(`writeReplaceMethodName`), _, _, _, _) =>
+            false
+          case _ =>
+            true
+        }
       }
 
       val preprocessedTree = ClassDef(name, originalName, kind, jsClassCaptures,
@@ -181,9 +198,13 @@ final class JavalibIRCleaner(baseDirectoryURI: URI) {
       /* Replace references to scala.Serializable by java.io.Serializable.
        * This works around the fact that scalac adds scala.Serializable to the
        * companion object of any class that extends java.io.Serializable.
+       *
+       * Don't do it for the scalalib.
        */
 
-      if (!interfaces.exists(_.name == ScalaSerializable)) {
+      if (forScalalib) {
+        interfaces
+      } else if (!interfaces.exists(_.name == ScalaSerializable)) {
         interfaces
       } else if (interfaces.exists(_.name == JavaIOSerializable)) {
         interfaces.filter(_.name != ScalaSerializable)
@@ -319,13 +340,13 @@ final class JavalibIRCleaner(baseDirectoryURI: URI) {
       implicit val pos = tree.pos
 
       tree match {
-        // new AnonFunctionN(closure)  -->  closure
-        case New(AnonFunctionNClass(n), _, List(closure)) =>
+        // javalib only: new AnonFunctionN(closure)  -->  closure
+        case New(AnonFunctionNClass(n), _, List(closure)) if !forScalalib =>
           closure
 
-        // someFunctionN.apply(args)  -->  someFunctionN(args)
+        // javalib only: someFunctionN.apply(args)  -->  someFunctionN(args)
         case Apply(ApplyFlags.empty, fun, MethodIdent(FunctionApplyMethodName(n)), args)
-            if isFunctionNType(n, fun.tpe) =>
+            if !forScalalib && isFunctionNType(n, fun.tpe) =>
           JSFunctionApply(fun, args)
 
         // <= 2.12 : toJSVarArgs(jsArrayOps(jsArray).toSeq) -> jsArray
@@ -584,7 +605,7 @@ final class JavalibIRCleaner(baseDirectoryURI: URI) {
     }
 
     private def transformClassName(cls: ClassName)(implicit pos: Position): ClassName = {
-      ClassNameSubstitutions.getOrElse(cls, {
+      classNameSubstitutions.getOrElse(cls, {
         validateClassName(cls)
         cls
       })
@@ -602,8 +623,13 @@ final class JavalibIRCleaner(baseDirectoryURI: URI) {
       def isAnException: Boolean =
         isJavaScriptExceptionWithinItself || isTypedArrayBufferBridgeWithinItself
 
-      if (cls.nameString.startsWith("scala.") && !isAnException)
-        reportError(s"Illegal reference to Scala class ${cls.nameString}")
+      if (forScalalib) {
+        if (cls.nameString.startsWith("scala.scalajs."))
+          reportError(s"Illegal reference to Scala.js class ${cls.nameString}")
+      } else {
+        if (cls.nameString.startsWith("scala.") && !isAnException)
+          reportError(s"Illegal reference to Scala class ${cls.nameString}")
+      }
     }
 
     private def transformNonJSClassName(cls: ClassName)(implicit pos: Position): ClassName = {
@@ -731,7 +757,7 @@ object JavalibIRCleaner {
       false
   }
 
-  private val ClassNameSubstitutions: Map[ClassName, ClassName] = {
+  private val ClassNameSubstitutionsForJavalib: Map[ClassName, ClassName] = {
     val functionTypePairs = for {
       funClass <- FunctionNClasses ++ AnonFunctionNClasses
     } yield {
@@ -764,4 +790,15 @@ object JavalibIRCleaner {
     val allPairs = functionTypePairs ++ refPairs ++ tuplePairs ++ otherPairs
     allPairs.toMap
   }
+
+  private val ClassNameSubstitutionsForScalalib: Map[ClassName, ClassName] = {
+    val anonFunctionPairs = for {
+      n <- (0 to 22).toList
+    } yield {
+      ClassName(s"scala.scalajs.runtime.AnonFunction$n") -> ClassName(s"scala.runtime.AnonFunction$n")
+    }
+
+    val allPairs = anonFunctionPairs
+    allPairs.toMap
+  }
 }
diff --git a/scalalib/overrides/scala/runtime/AnonFunctions.scala b/scalalib/overrides/scala/runtime/AnonFunctions.scala
@@ -0,0 +1,134 @@
+/*
+ * Scala.js (https://www.scala-js.org/)
+ *
+ * Copyright EPFL.
+ *
+ * Licensed under Apache License 2.0
+ * (https://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala.runtime
+
+import scala.scalajs.js
+
+// scalastyle:off line.size.limit
+
+@inline
+final class AnonFunction0[+R](f: js.Function0[R]) extends AbstractFunction0[R] {
+  override def apply(): R = f()
+}
+
+@inline
+final class AnonFunction1[-T1, +R](f: js.Function1[T1, R]) extends AbstractFunction1[T1, R] {
+  override def apply(arg1: T1): R = f(arg1)
+}
+
+@inline
+final class AnonFunction2[-T1, -T2, +R](f: js.Function2[T1, T2, R]) extends AbstractFunction2[T1, T2, R] {
+  override def apply(arg1: T1, arg2: T2): R = f(arg1, arg2)
+}
+
+@inline
+final class AnonFunction3[-T1, -T2, -T3, +R](f: js.Function3[T1, T2, T3, R]) extends AbstractFunction3[T1, T2, T3, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3): R = f(arg1, arg2, arg3)
+}
+
+@inline
+final class AnonFunction4[-T1, -T2, -T3, -T4, +R](f: js.Function4[T1, T2, T3, T4, R]) extends AbstractFunction4[T1, T2, T3, T4, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R = f(arg1, arg2, arg3, arg4)
+}
+
+@inline
+final class AnonFunction5[-T1, -T2, -T3, -T4, -T5, +R](f: js.Function5[T1, T2, T3, T4, T5, R]) extends AbstractFunction5[T1, T2, T3, T4, T5, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): R = f(arg1, arg2, arg3, arg4, arg5)
+}
+
+@inline
+final class AnonFunction6[-T1, -T2, -T3, -T4, -T5, -T6, +R](f: js.Function6[T1, T2, T3, T4, T5, T6, R]) extends AbstractFunction6[T1, T2, T3, T4, T5, T6, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6): R = f(arg1, arg2, arg3, arg4, arg5, arg6)
+}
+
+@inline
+final class AnonFunction7[-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R](f: js.Function7[T1, T2, T3, T4, T5, T6, T7, R]) extends AbstractFunction7[T1, T2, T3, T4, T5, T6, T7, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+}
+
+@inline
+final class AnonFunction8[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R](f: js.Function8[T1, T2, T3, T4, T5, T6, T7, T8, R]) extends AbstractFunction8[T1, T2, T3, T4, T5, T6, T7, T8, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+}
+
+@inline
+final class AnonFunction9[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +R](f: js.Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]) extends AbstractFunction9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
+}
+
+@inline
+final class AnonFunction10[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R](f: js.Function10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]) extends AbstractFunction10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9, arg10: T10): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
+}
+
+@inline
+final class AnonFunction11[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R](f: js.Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]) extends AbstractFunction11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9, arg10: T10, arg11: T11): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
+}
+
+@inline
+final class AnonFunction12[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, +R](f: js.Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]) extends AbstractFunction12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9, arg10: T10, arg11: T11, arg12: T12): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
+}
+
+@inline
+final class AnonFunction13[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, +R](f: js.Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]) extends AbstractFunction13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9, arg10: T10, arg11: T11, arg12: T12, arg13: T13): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
+}
+
+@inline
+final class AnonFunction14[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, +R](f: js.Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]) extends AbstractFunction14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9, arg10: T10, arg11: T11, arg12: T12, arg13: T13, arg14: T14): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14)
+}
+
+@inline
+final class AnonFunction15[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, +R](f: js.Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]) extends AbstractFunction15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9, arg10: T10, arg11: T11, arg12: T12, arg13: T13, arg14: T14, arg15: T15): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15)
+}
+
+@inline
+final class AnonFunction16[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, +R](f: js.Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]) extends AbstractFunction16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9, arg10: T10, arg11: T11, arg12: T12, arg13: T13, arg14: T14, arg15: T15, arg16: T16): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
+}
+
+@inline
+final class AnonFunction17[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, +R](f: js.Function17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]) extends AbstractFunction17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9, arg10: T10, arg11: T11, arg12: T12, arg13: T13, arg14: T14, arg15: T15, arg16: T16, arg17: T17): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17)
+}
+
+@inline
+final class AnonFunction18[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, +R](f: js.Function18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]) extends AbstractFunction18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9, arg10: T10, arg11: T11, arg12: T12, arg13: T13, arg14: T14, arg15: T15, arg16: T16, arg17: T17, arg18: T18): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18)
+}
+
+@inline
+final class AnonFunction19[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, +R](f: js.Function19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]) extends AbstractFunction19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9, arg10: T10, arg11: T11, arg12: T12, arg13: T13, arg14: T14, arg15: T15, arg16: T16, arg17: T17, arg18: T18, arg19: T19): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
+}
+
+@inline
+final class AnonFunction20[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, +R](f: js.Function20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]) extends AbstractFunction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9, arg10: T10, arg11: T11, arg12: T12, arg13: T13, arg14: T14, arg15: T15, arg16: T16, arg17: T17, arg18: T18, arg19: T19, arg20: T20): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20)
+}
+
+@inline
+final class AnonFunction21[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, +R](f: js.Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]) extends AbstractFunction21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9, arg10: T10, arg11: T11, arg12: T12, arg13: T13, arg14: T14, arg15: T15, arg16: T16, arg17: T17, arg18: T18, arg19: T19, arg20: T20, arg21: T21): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21)
+}
+
+@inline
+final class AnonFunction22[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, +R](f: js.Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R]) extends AbstractFunction22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R] {
+  override def apply(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9, arg10: T10, arg11: T11, arg12: T12, arg13: T13, arg14: T14, arg15: T15, arg16: T16, arg17: T17, arg18: T18, arg19: T19, arg20: T20, arg21: T21, arg22: T22): R = f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22)
+}
+
+// scalastyle:on line.size.limit
