Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit 960d7eb

Browse files
sjrdsjrd
committed
Squash: Put the toXVarArgs methods in scala.scalajs.runtime.*.
Instead of the scalalib. This variant avoids augmenting the ABI of the `scalalib` artifact compared to `scala-library.jar`. We have never done that in the past.
1 parent 3215203 commit 960d7eb

File tree

7 files changed

+130
-115
lines changed

7 files changed

+130
-115
lines changed

‎compiler/src/main/scala/org/scalajs/nscplugin/GenJSCode.scala

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -5917,17 +5917,17 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
59175917
/* If the argument is a call to the compiler's chosen `wrapArray`
59185918
* method with an array literal as argument, we know it actually
59195919
* came from expanded varargs. In that case, rewrite to calling our
5920-
* custom `ScalaRunTime.to*VarArgs` method. These methods choose
5921-
* the best implementation of varargs depending on the target
5922-
* platform.
5920+
* custom `scala.scalajs.runtime.to*VarArgs` method. These methods
5921+
* choose the best implementation of varargs depending on the
5922+
* target platform.
59235923
*/
59245924
arg match {
59255925
case MaybeAsInstanceOf(wrapArray @ WrapArray(
59265926
MaybeAsInstanceOf(arrayValue: ArrayValue))) =>
59275927
implicit val pos = wrapArray.pos
59285928
js.Apply(
59295929
js.ApplyFlags.empty,
5930-
genLoadModule(ScalaRunTimeModule),
5930+
genLoadModule(RuntimePackageModule),
59315931
js.MethodIdent(WrapArray.wrapArraySymToToVarArgsName(wrapArray.symbol)),
59325932
List(genExpr(arrayValue))
59335933
)(jstpe.ClassType(encodeClassName(SeqClass), nullable = true))

‎compiler/src/test/scala/org/scalajs/nscplugin/test/OptimizationTest.scala

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -702,7 +702,7 @@ class OptimizationTest extends JSASTTest {
702702
object OptimizationTest {
703703

704704
private val ArrayModuleClass = ClassName("scala.Array$")
705-
private val ScalaRunTimeModuleClass = ClassName("scala.runtime.ScalaRunTime$")
705+
private val ScalaJSRunTimeModuleClass = ClassName("scala.scalajs.runtime.package$")
706706

707707
private val applySimpleMethodName = SimpleMethodName("apply")
708708

@@ -728,8 +728,8 @@ object OptimizationTest {
728728
def unapply(tree: js.Apply): Boolean = {
729729
tree.method.name.simpleName.nameString.endsWith("VarArgs") && {
730730
tree.receiver match {
731-
case js.LoadModule(ScalaRunTimeModuleClass) => true
732-
case _ => false
731+
case js.LoadModule(ScalaJSRunTimeModuleClass) => true
732+
case _ => false
733733
}
734734
}
735735
}

‎library/src/main/scala-new-collections/scala/scalajs/runtime/Compat.scala

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@
1313
package scala.scalajs.runtime
1414

1515
import scala.collection.IterableOnce
16+
import scala.collection.immutable.ArraySeq
1617

1718
import scala.scalajs.js
1819

@@ -32,4 +33,37 @@ private[runtime] object Compat {
3233
}
3334
}
3435

36+
@inline def toGenericVarArgsWasmImpl[T](xs: Array[T]): Seq[T] =
37+
ArraySeq.unsafeWrapArray(xs)
38+
39+
@inline def toRefVarArgsWasmImpl[T <: AnyRef](xs: Array[T]): Seq[T] =
40+
new ArraySeq.ofRef[T](xs)
41+
42+
@inline def toUnitVarArgsWasmImpl(xs: Array[Unit]): Seq[Unit] =
43+
new ArraySeq.ofUnit(xs)
44+
45+
@inline def toBooleanVarArgsWasmImpl(xs: Array[Boolean]): Seq[Boolean] =
46+
new ArraySeq.ofBoolean(xs)
47+
48+
@inline def toCharVarArgsWasmImpl(xs: Array[Char]): Seq[Char] =
49+
new ArraySeq.ofChar(xs)
50+
51+
@inline def toByteVarArgsWasmImpl(xs: Array[Byte]): Seq[Byte] =
52+
new ArraySeq.ofByte(xs)
53+
54+
@inline def toShortVarArgsWasmImpl(xs: Array[Short]): Seq[Short] =
55+
new ArraySeq.ofShort(xs)
56+
57+
@inline def toIntVarArgsWasmImpl(xs: Array[Int]): Seq[Int] =
58+
new ArraySeq.ofInt(xs)
59+
60+
@inline def toLongVarArgsWasmImpl(xs: Array[Long]): Seq[Long] =
61+
new ArraySeq.ofLong(xs)
62+
63+
@inline def toFloatVarArgsWasmImpl(xs: Array[Float]): Seq[Float] =
64+
new ArraySeq.ofFloat(xs)
65+
66+
@inline def toDoubleVarArgsWasmImpl(xs: Array[Double]): Seq[Double] =
67+
new ArraySeq.ofDouble(xs)
68+
3569
}

‎library/src/main/scala-old-collections/scala/scalajs/runtime/Compat.scala

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,8 @@
1313
package scala.scalajs.runtime
1414

1515
import scala.collection.GenTraversableOnce
16+
import scala.collection.mutable.WrappedArray
17+
1618
import scala.scalajs.js
1719

1820
private[runtime] object Compat {
@@ -32,4 +34,37 @@ private[runtime] object Compat {
3234
}
3335
}
3436

37+
@inline def toGenericVarArgsWasmImpl[T](xs: Array[T]): Seq[T] =
38+
WrappedArray.make(xs)
39+
40+
@inline def toRefVarArgsWasmImpl[T <: AnyRef](xs: Array[T]): Seq[T] =
41+
new WrappedArray.ofRef[T](xs)
42+
43+
@inline def toUnitVarArgsWasmImpl(xs: Array[Unit]): Seq[Unit] =
44+
new WrappedArray.ofUnit(xs)
45+
46+
@inline def toBooleanVarArgsWasmImpl(xs: Array[Boolean]): Seq[Boolean] =
47+
new WrappedArray.ofBoolean(xs)
48+
49+
@inline def toCharVarArgsWasmImpl(xs: Array[Char]): Seq[Char] =
50+
new WrappedArray.ofChar(xs)
51+
52+
@inline def toByteVarArgsWasmImpl(xs: Array[Byte]): Seq[Byte] =
53+
new WrappedArray.ofByte(xs)
54+
55+
@inline def toShortVarArgsWasmImpl(xs: Array[Short]): Seq[Short] =
56+
new WrappedArray.ofShort(xs)
57+
58+
@inline def toIntVarArgsWasmImpl(xs: Array[Int]): Seq[Int] =
59+
new WrappedArray.ofInt(xs)
60+
61+
@inline def toLongVarArgsWasmImpl(xs: Array[Long]): Seq[Long] =
62+
new WrappedArray.ofLong(xs)
63+
64+
@inline def toFloatVarArgsWasmImpl(xs: Array[Float]): Seq[Float] =
65+
new WrappedArray.ofFloat(xs)
66+
67+
@inline def toDoubleVarArgsWasmImpl(xs: Array[Double]): Seq[Double] =
68+
new WrappedArray.ofDouble(xs)
69+
3570
}

‎library/src/main/scala/scala/scalajs/runtime/package.scala

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,8 @@ package scala.scalajs
1414

1515
import scala.annotation.tailrec
1616

17+
import scala.scalajs.LinkingInfo.{isWebAssembly, linkTimeIf}
18+
1719
package object runtime {
1820

1921
import scala.scalajs.runtime.Compat._
@@ -32,6 +34,58 @@ package object runtime {
3234
@inline def toJSVarArgs[A](seq: Seq[A]): js.Array[A] =
3335
toJSVarArgsImpl(seq)
3436

37+
/* Factories for varargs seqs.
38+
*
39+
* The compiler backend introduces calls to these methods, instead of the
40+
* default {Predef,ScalaRunTime}.wrap*Array methods. They choose the best
41+
* implementation of Seq for varargs depending on the target.
42+
*
43+
* On Wasm, we use sci.ArraySeq/scm.WrappedArray, like on the JVM.
44+
* On JavaScript, we convert the Scala arrays to JS arrays and use
45+
* scala.scalajs.runtime.WrappedVarArgs/WrappedArray.
46+
*
47+
* The conversions from Scala array to JS array are intrinsified by the
48+
* optimizer, which directly creates a JS array from the start, instead of
49+
* creating a temporary Scala array.
50+
*
51+
* We use linkTimeIf's not to have any regression compared to the code
52+
* generated by Scala.js < 1.20.0, where we unconditionally generated calls
53+
* to toScalaVarArgs with JS arrays.
54+
*/
55+
56+
@inline def toGenericVarArgs[T](xs: Array[T]): Seq[T] =
57+
linkTimeIf[Seq[T]](isWebAssembly)(toGenericVarArgsWasmImpl(xs))(toScalaVarArgs(genericArrayToJSArray(xs)))
58+
59+
@inline def toRefVarArgs[T <: AnyRef](xs: Array[T]): Seq[T] =
60+
linkTimeIf[Seq[T]](isWebAssembly)(toRefVarArgsWasmImpl[T](xs))(toScalaVarArgs(refArrayToJSArray(xs)))
61+
62+
@inline def toUnitVarArgs(xs: Array[Unit]): Seq[Unit] =
63+
linkTimeIf[Seq[Unit]](isWebAssembly)(toUnitVarArgsWasmImpl(xs))(toScalaVarArgs(unitArrayToJSArray(xs)))
64+
65+
@inline def toBooleanVarArgs(xs: Array[Boolean]): Seq[Boolean] =
66+
linkTimeIf[Seq[Boolean]](isWebAssembly)(toBooleanVarArgsWasmImpl(xs))(toScalaVarArgs(booleanArrayToJSArray(xs)))
67+
68+
@inline def toCharVarArgs(xs: Array[Char]): Seq[Char] =
69+
linkTimeIf[Seq[Char]](isWebAssembly)(toCharVarArgsWasmImpl(xs))(toScalaVarArgs(charArrayToJSArray(xs)))
70+
71+
@inline def toByteVarArgs(xs: Array[Byte]): Seq[Byte] =
72+
linkTimeIf[Seq[Byte]](isWebAssembly)(toByteVarArgsWasmImpl(xs))(toScalaVarArgs(byteArrayToJSArray(xs)))
73+
74+
@inline def toShortVarArgs(xs: Array[Short]): Seq[Short] =
75+
linkTimeIf[Seq[Short]](isWebAssembly)(toShortVarArgsWasmImpl(xs))(toScalaVarArgs(shortArrayToJSArray(xs)))
76+
77+
@inline def toIntVarArgs(xs: Array[Int]): Seq[Int] =
78+
linkTimeIf[Seq[Int]](isWebAssembly)(toIntVarArgsWasmImpl(xs))(toScalaVarArgs(intArrayToJSArray(xs)))
79+
80+
@inline def toLongVarArgs(xs: Array[Long]): Seq[Long] =
81+
linkTimeIf[Seq[Long]](isWebAssembly)(toLongVarArgsWasmImpl(xs))(toScalaVarArgs(longArrayToJSArray(xs)))
82+
83+
@inline def toFloatVarArgs(xs: Array[Float]): Seq[Float] =
84+
linkTimeIf[Seq[Float]](isWebAssembly)(toFloatVarArgsWasmImpl(xs))(toScalaVarArgs(floatArrayToJSArray(xs)))
85+
86+
@inline def toDoubleVarArgs(xs: Array[Double]): Seq[Double] =
87+
linkTimeIf[Seq[Double]](isWebAssembly)(toDoubleVarArgsWasmImpl(xs))(toScalaVarArgs(doubleArrayToJSArray(xs)))
88+
3589
// Intrinsics to convert arrays to JS arrays
3690

3791
@inline

‎scalalib/overrides-2.13/scala/runtime/ScalaRunTime.scala

Lines changed: 0 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -270,58 +270,4 @@ object ScalaRunTime {
270270
def wrapShortArray(xs: Array[Short]): ArraySeq[Short] = if (xs ne null) new ArraySeq.ofShort(xs) else null
271271
def wrapBooleanArray(xs: Array[Boolean]): ArraySeq[Boolean] = if (xs ne null) new ArraySeq.ofBoolean(xs) else null
272272
def wrapUnitArray(xs: Array[Unit]): ArraySeq[Unit] = if (xs ne null) new ArraySeq.ofUnit(xs) else null
273-
274-
/* Scala.js-specific.
275-
*
276-
* The compiler backend introduces calls to these methods, instead of the
277-
* default ScalaRunTime.wrap*Array methods. They choose the best
278-
* implementation of Seq for varargs depending on the target.
279-
*
280-
* On Wasm, we use ArraySeq, like on the JVM. On JavaScript, we convert
281-
* the Scala arrays to JS arrays and use scala.scalajs.runtime.WrappedVarArgs.
282-
*
283-
* The conversion from Scala array to JS array is intrinsified by the
284-
* optimizer, which directly creates a JS array from the start, instead of
285-
* creating a temporary Scala array.
286-
*
287-
* We use linkTimeIf's not to have any regression compared to the code
288-
* generated by Scala.js < 1.20.0, where we unconditionally generated calls
289-
* to toScalaVarArgs with JS arrays.
290-
*/
291-
292-
import scala.scalajs.{runtime => jsRT}
293-
import scala.scalajs.LinkingInfo.{isWebAssembly, linkTimeIf}
294-
295-
@inline def toGenericVarArgs[T](xs: Array[T]): Seq[T] =
296-
linkTimeIf[Seq[T]](isWebAssembly)(ArraySeq.unsafeWrapArray(xs))(jsRT.toScalaVarArgs(jsRT.genericArrayToJSArray(xs)))
297-
298-
@inline def toRefVarArgs[T <: AnyRef](xs: Array[T]): Seq[T] =
299-
linkTimeIf[Seq[T]](isWebAssembly)(new ArraySeq.ofRef[T](xs))(jsRT.toScalaVarArgs(jsRT.refArrayToJSArray(xs)))
300-
301-
@inline def toUnitVarArgs(xs: Array[Unit]): Seq[Unit] =
302-
linkTimeIf[Seq[Unit]](isWebAssembly)(new ArraySeq.ofUnit(xs))(jsRT.toScalaVarArgs(jsRT.unitArrayToJSArray(xs)))
303-
304-
@inline def toBooleanVarArgs(xs: Array[Boolean]): Seq[Boolean] =
305-
linkTimeIf[Seq[Boolean]](isWebAssembly)(new ArraySeq.ofBoolean(xs))(jsRT.toScalaVarArgs(jsRT.booleanArrayToJSArray(xs)))
306-
307-
@inline def toCharVarArgs(xs: Array[Char]): Seq[Char] =
308-
linkTimeIf[Seq[Char]](isWebAssembly)(new ArraySeq.ofChar(xs))(jsRT.toScalaVarArgs(jsRT.charArrayToJSArray(xs)))
309-
310-
@inline def toByteVarArgs(xs: Array[Byte]): Seq[Byte] =
311-
linkTimeIf[Seq[Byte]](isWebAssembly)(new ArraySeq.ofByte(xs))(jsRT.toScalaVarArgs(jsRT.byteArrayToJSArray(xs)))
312-
313-
@inline def toShortVarArgs(xs: Array[Short]): Seq[Short] =
314-
linkTimeIf[Seq[Short]](isWebAssembly)(new ArraySeq.ofShort(xs))(jsRT.toScalaVarArgs(jsRT.shortArrayToJSArray(xs)))
315-
316-
@inline def toIntVarArgs(xs: Array[Int]): Seq[Int] =
317-
linkTimeIf[Seq[Int]](isWebAssembly)(new ArraySeq.ofInt(xs))(jsRT.toScalaVarArgs(jsRT.intArrayToJSArray(xs)))
318-
319-
@inline def toLongVarArgs(xs: Array[Long]): Seq[Long] =
320-
linkTimeIf[Seq[Long]](isWebAssembly)(new ArraySeq.ofLong(xs))(jsRT.toScalaVarArgs(jsRT.longArrayToJSArray(xs)))
321-
322-
@inline def toFloatVarArgs(xs: Array[Float]): Seq[Float] =
323-
linkTimeIf[Seq[Float]](isWebAssembly)(new ArraySeq.ofFloat(xs))(jsRT.toScalaVarArgs(jsRT.floatArrayToJSArray(xs)))
324-
325-
@inline def toDoubleVarArgs(xs: Array[Double]): Seq[Double] =
326-
linkTimeIf[Seq[Double]](isWebAssembly)(new ArraySeq.ofDouble(xs))(jsRT.toScalaVarArgs(jsRT.doubleArrayToJSArray(xs)))
327273
}

‎scalalib/overrides/scala/runtime/ScalaRunTime.scala

Lines changed: 0 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -261,58 +261,4 @@ object ScalaRunTime {
261261

262262
nl + s + "\n"
263263
}
264-
265-
/* Scala.js-specific.
266-
*
267-
* The compiler backend introduces calls to these methods, instead of the
268-
* default Predef.wrap*Array methods. They choose the best
269-
* implementation of Seq for varargs depending on the target.
270-
*
271-
* On Wasm, we use WrappedArray, like on the JVM. On JavaScript, we convert
272-
* the Scala arrays to JS arrays and use scala.scalajs.runtime.WrappedVarArgs.
273-
*
274-
* The conversion from Scala array to JS array is intrinsified by the
275-
* optimizer, which directly creates a JS array from the start, instead of
276-
* creating a temporary Scala array.
277-
*
278-
* We use linkTimeIf's not to have any regression compared to the code
279-
* generated by Scala.js < 1.20.0, where we unconditionally generated calls
280-
* to toScalaVarArgs with JS arrays.
281-
*/
282-
283-
import scala.scalajs.{runtime => jsRT}
284-
import scala.scalajs.LinkingInfo.{isWebAssembly, linkTimeIf}
285-
286-
@inline def toGenericVarArgs[T](xs: Array[T]): Seq[T] =
287-
linkTimeIf[Seq[T]](isWebAssembly)(WrappedArray.make(xs))(jsRT.toScalaVarArgs(jsRT.genericArrayToJSArray(xs)))
288-
289-
@inline def toRefVarArgs[T <: AnyRef](xs: Array[T]): Seq[T] =
290-
linkTimeIf[Seq[T]](isWebAssembly)(new WrappedArray.ofRef[T](xs))(jsRT.toScalaVarArgs(jsRT.refArrayToJSArray(xs)))
291-
292-
@inline def toUnitVarArgs(xs: Array[Unit]): Seq[Unit] =
293-
linkTimeIf[Seq[Unit]](isWebAssembly)(new WrappedArray.ofUnit(xs))(jsRT.toScalaVarArgs(jsRT.unitArrayToJSArray(xs)))
294-
295-
@inline def toBooleanVarArgs(xs: Array[Boolean]): Seq[Boolean] =
296-
linkTimeIf[Seq[Boolean]](isWebAssembly)(new WrappedArray.ofBoolean(xs))(jsRT.toScalaVarArgs(jsRT.booleanArrayToJSArray(xs)))
297-
298-
@inline def toCharVarArgs(xs: Array[Char]): Seq[Char] =
299-
linkTimeIf[Seq[Char]](isWebAssembly)(new WrappedArray.ofChar(xs))(jsRT.toScalaVarArgs(jsRT.charArrayToJSArray(xs)))
300-
301-
@inline def toByteVarArgs(xs: Array[Byte]): Seq[Byte] =
302-
linkTimeIf[Seq[Byte]](isWebAssembly)(new WrappedArray.ofByte(xs))(jsRT.toScalaVarArgs(jsRT.byteArrayToJSArray(xs)))
303-
304-
@inline def toShortVarArgs(xs: Array[Short]): Seq[Short] =
305-
linkTimeIf[Seq[Short]](isWebAssembly)(new WrappedArray.ofShort(xs))(jsRT.toScalaVarArgs(jsRT.shortArrayToJSArray(xs)))
306-
307-
@inline def toIntVarArgs(xs: Array[Int]): Seq[Int] =
308-
linkTimeIf[Seq[Int]](isWebAssembly)(new WrappedArray.ofInt(xs))(jsRT.toScalaVarArgs(jsRT.intArrayToJSArray(xs)))
309-
310-
@inline def toLongVarArgs(xs: Array[Long]): Seq[Long] =
311-
linkTimeIf[Seq[Long]](isWebAssembly)(new WrappedArray.ofLong(xs))(jsRT.toScalaVarArgs(jsRT.longArrayToJSArray(xs)))
312-
313-
@inline def toFloatVarArgs(xs: Array[Float]): Seq[Float] =
314-
linkTimeIf[Seq[Float]](isWebAssembly)(new WrappedArray.ofFloat(xs))(jsRT.toScalaVarArgs(jsRT.floatArrayToJSArray(xs)))
315-
316-
@inline def toDoubleVarArgs(xs: Array[Double]): Seq[Double] =
317-
linkTimeIf[Seq[Double]](isWebAssembly)(new WrappedArray.ofDouble(xs))(jsRT.toScalaVarArgs(jsRT.doubleArrayToJSArray(xs)))
318264
}

0 commit comments

Comments
 (0)