Merge '0.6.x' into 'master'.

Author: sjrd

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

@@ -53,7 +53,7 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
   import jsDefinitions._
   import jsInterop.{jsNameOf, jsNativeLoadSpecOfOption, JSName}
 
-  import treeInfo.hasSynthCaseSymbol
+  import treeInfo.{hasSynthCaseSymbol, StripCast}
 
   import platform.isMaybeBoxed
 
@@ -2061,6 +2061,23 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
             }
           }
 
+        /* !!! Copy-pasted from `CleanUp.scala` upstream and simplified with
+         * our `WrapArray` extractor.
+         *
+         * Replaces `Array(Predef.wrapArray(ArrayValue(...).$asInstanceOf[...]), <tag>)`
+         * with just `ArrayValue(...).$asInstanceOf[...]`
+         *
+         * See scala/bug#6611; we must *only* do this for literal vararg arrays.
+         *
+         * This is normally done by `cleanup` but it comes later than this phase.
+         */
+        case Apply(appMeth, Apply(wrapRefArrayMeth, (arg @ StripCast(ArrayValue(_, _))) :: Nil) :: _ :: Nil)
+            if wrapRefArrayMeth.symbol == WrapArray.wrapRefArrayMethod && appMeth.symbol == ArrayModule_genericApply =>
+          genStatOrExpr(arg, isStat)
+        case Apply(appMeth, elem0 :: WrapArray(rest @ ArrayValue(elemtpt, _)) :: Nil)
+            if appMeth.symbol == ArrayModule_apply(elemtpt.tpe) =>
+          genStatOrExpr(treeCopy.ArrayValue(rest, rest.elemtpt, elem0 :: rest.elems), isStat)
+
         case app: Apply =>
           genApply(app, isStat)
 
@@ -5060,11 +5077,14 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
     }
 
     object WrapArray {
-      private val isWrapArray: Set[Symbol] = {
-        val wrapArrayModule =
-          if (hasNewCollections) ScalaRunTimeModule
-          else PredefModule
+      private val wrapArrayModule =
+        if (hasNewCollections) ScalaRunTimeModule
+        else PredefModule
 
+      val wrapRefArrayMethod: Symbol =
+        getMemberMethod(wrapArrayModule, nme.wrapRefArray)
+
+      private val isWrapArray: Set[Symbol] = {
         Seq(
             nme.wrapRefArray,
             nme.wrapByteArray,

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

@@ -21,6 +21,45 @@ import org.scalajs.ir.{Trees => js, Types => jstpe}
 class OptimizationTest extends JSASTTest {
   import OptimizationTest._
 
+  @Test
+  def testArrayApplyOptimization: Unit = {
+    /* Make sure Array(...) is optimized away completely for several kinds
+     * of data types, with both the generic overload and the ones specialized
+     * for primitives.
+     */
+    """
+    class A {
+      val a = Array(5, 7, 9, -3)
+      val b = Array("hello", "world")
+      val c = Array('a', 'b')
+      val d = Array(Nil)
+      val e = Array(5.toByte, 7.toByte, 9.toByte, -3.toByte)
+    }
+    """.
+    hasNot("any LoadModule of the scala.Array companion") {
+      case js.LoadModule(jstpe.ClassRef("s_Array$")) =>
+    }
+
+    /* Using [] with primitives produces suboptimal trees, which cannot be
+     * optimized. We should improve this in the future, if possible. This is
+     * particularly annoying for Byte and Short, as it means that we need to
+     * write `.toByte` for every single element if we want the optimization to
+     * kick in.
+     *
+     * Scala/JVM has the same limitation.
+     */
+    """
+    class A {
+      val a = Array[Int](5, 7, 9, -3)
+      val b = Array[Byte](5, 7, 9, -3)
+    }
+    """.
+    hasExactly(2, "calls to Array.apply methods") {
+      case js.Apply(_, js.LoadModule(jstpe.ClassRef("s_Array$")), js.Ident(methodName, _), _)
+          if methodName.startsWith("apply__") =>
+    }
+  }
+
   @Test
   def testJSArrayApplyOptimization: Unit = {
     /* Make sure js.Array(...) is optimized away completely for several kinds

javalanglib/src/main/scala/java/lang/Boolean.scala

@@ -41,7 +41,7 @@ final class Boolean private ()
 }
 
 object Boolean {
-  final val TYPE = classOf[scala.Boolean]
+  final val TYPE = scala.Predef.classOf[scala.Boolean]
 
   /* TRUE and FALSE are supposed to be vals. However, they are better
    * optimized as defs, because they end up being just the constant true and

javalanglib/src/main/scala/java/lang/Byte.scala

@@ -45,7 +45,7 @@ final class Byte private () extends Number with Comparable[Byte] {
 }
 
 object Byte {
-  final val TYPE = classOf[scala.Byte]
+  final val TYPE = scala.Predef.classOf[scala.Byte]
   final val SIZE = 8
   final val BYTES = 1
 

javalanglib/src/main/scala/java/lang/Character.scala

@@ -47,7 +47,7 @@ class Character private ()
 }
 
 object Character {
-  final val TYPE = classOf[scala.Char]
+  final val TYPE = scala.Predef.classOf[scala.Char]
   final val MIN_VALUE = '\u0000'
   final val MAX_VALUE = '\uffff'
   final val SIZE = 16
@@ -114,10 +114,10 @@ object Character {
   }
 
   @inline
-  private[this] def getTypeLT256(codePoint: Int): scala.Byte =
+  private[this] def getTypeLT256(codePoint: Int): Int =
     charTypesFirst256(codePoint)
 
-  private[this] def getTypeGE256(codePoint: Int): scala.Byte = {
+  private[this] def getTypeGE256(codePoint: Int): Int = {
     // the idx is increased by 1 due to the differences in indexing
     // between charTypeIndices and charType
     val idx = Arrays.binarySearch(charTypeIndices, codePoint) + 1
@@ -448,8 +448,8 @@ object Character {
   //def getDirectionality(c: scala.Char): scala.Byte
 
   /* Conversions */
-  def toUpperCase(c: scala.Char): scala.Char = c.toString.toUpperCase()(0)
-  def toLowerCase(c: scala.Char): scala.Char = c.toString.toLowerCase()(0)
+  def toUpperCase(c: scala.Char): scala.Char = c.toString.toUpperCase().charAt(0)
+  def toLowerCase(c: scala.Char): scala.Char = c.toString.toLowerCase().charAt(0)
   //def toTitleCase(c: scala.Char): scala.Char
   //def getNumericValue(c: scala.Char): Int
 
@@ -508,7 +508,7 @@ object Character {
   // Based on Unicode 7.0.0
 
   // Types of characters from 0 to 255
-  private[this] lazy val charTypesFirst256 = Array[scala.Byte](15, 15, 15, 15,
+  private[this] lazy val charTypesFirst256: Array[Int] = Array(15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 12, 24, 24, 24, 26, 24, 24, 24,
     21, 22, 24, 25, 24, 20, 24, 24, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 24, 24, 25,
@@ -541,11 +541,11 @@ object Character {
   //    .map(tup => tup._1 - tup._2)
   //  val charTypes = indicesAndTypes.map(_._2)
   //  println(charTypeIndicesDeltas.mkString(
-  //    "charTypeIndices: val deltas = Array[Int](", ", ", ")"))
-  //  println(charTypes.mkString("val charTypes = Array[scala.Byte](", ", ", ")"))
+  //    "charTypeIndices: val deltas = Array(", ", ", ")"))
+  //  println(charTypes.mkString("val charTypes = Array(", ", ", ")"))
   //
-  private[this] lazy val charTypeIndices = {
-    val deltas = Array[Int](257, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  private[this] lazy val charTypeIndices: Array[Int] = {
+    val deltas = Array(257, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
@@ -695,7 +695,7 @@ object Character {
     uncompressDeltas(deltas)
   }
 
-  private[this] lazy val charTypes = Array[scala.Byte](1, 2, 1, 2, 1, 2,
+  private[this] lazy val charTypes: Array[Int] = Array(1, 2, 1, 2, 1, 2,
     1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1,
     2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2,
     1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1,
@@ -859,8 +859,8 @@ object Character {
   //       0 :: isMirroredIndices.init).map(tup => tup._1 - tup._2)
   //  println(isMirroredIndicesDeltas.mkString(
   //     "isMirroredIndices: val deltas = Array[Int](", ", ", ")"))
-  private[this] lazy val isMirroredIndices = {
-    val deltas = Array[Int](40, 2, 18, 1, 1, 1, 28, 1, 1, 1, 29, 1, 1, 1,
+  private[this] lazy val isMirroredIndices: Array[Int] = {
+    val deltas = Array(40, 2, 18, 1, 1, 1, 28, 1, 1, 1, 29, 1, 1, 1,
       45, 1, 15, 1, 3710, 4, 1885, 2, 2460, 2, 10, 2, 54, 2, 14, 2, 177, 1,
       192, 4, 3, 6, 3, 1, 3, 2, 3, 4, 1, 4, 1, 1, 1, 1, 4, 9, 5, 1, 1, 18,
       5, 4, 9, 2, 1, 1, 1, 8, 2, 31, 2, 4, 5, 1, 9, 2, 2, 19, 5, 2, 9, 5, 2,
@@ -875,8 +875,14 @@ object Character {
   }
 
   private[this] def uncompressDeltas(deltas: Array[Int]): Array[Int] = {
-    for (i <- 1 until deltas.length)
-      deltas(i) += deltas(i - 1)
+    var acc = deltas(0)
+    var i = 1
+    val len = deltas.length
+    while (i != len) {
+      acc += deltas(i)
+      deltas(i) = acc
+      i += 1
+    }
     deltas
   }
 
@@ -887,7 +893,7 @@ object Character {
    *  point mapping to digits from 0 to 9.
    */
   private[this] lazy val nonASCIIZeroDigitCodePoints: Array[Int] = {
-    Array[Int](0x660, 0x6f0, 0x7c0, 0x966, 0x9e6, 0xa66, 0xae6, 0xb66, 0xbe6,
+    Array(0x660, 0x6f0, 0x7c0, 0x966, 0x9e6, 0xa66, 0xae6, 0xb66, 0xbe6,
         0xc66, 0xce6, 0xd66, 0xe50, 0xed0, 0xf20, 0x1040, 0x1090, 0x17e0,
         0x1810, 0x1946, 0x19d0, 0x1a80, 0x1a90, 0x1b50, 0x1bb0, 0x1c40, 0x1c50,
         0xa620, 0xa8d0, 0xa900, 0xa9d0, 0xaa50, 0xabf0, 0xff10, 0x104a0,

javalanglib/src/main/scala/java/lang/Class.scala

@@ -85,7 +85,6 @@ final class Class[A] private (data0: Object) extends Object {
   @inline // optimize for the Unchecked case, where this becomes identity()
   def cast(obj: Object): A = {
     scala.scalajs.runtime.SemanticsUtils.asInstanceOfCheck(
-        (this eq classOf[Nothing]) ||
         (obj != null && !isJSType && !isInstance(obj)),
         new ClassCastException("" + obj + " is not an instance of " + getName))
     obj.asInstanceOf[A]

javalanglib/src/main/scala/java/lang/Double.scala

@@ -66,7 +66,7 @@ final class Double private () extends Number with Comparable[Double] {
 }
 
 object Double {
-  final val TYPE = classOf[scala.Double]
+  final val TYPE = scala.Predef.classOf[scala.Double]
   final val POSITIVE_INFINITY = 1.0 / 0.0
   final val NEGATIVE_INFINITY = 1.0 / -0.0
   final val NaN = 0.0 / 0.0
@@ -186,7 +186,7 @@ object Double {
 
       val mantissa =
         js.Dynamic.global.parseInt(truncatedMantissaStr, 16).asInstanceOf[scala.Double]
-      assert(mantissa != 0.0 && mantissa != scala.Double.PositiveInfinity)
+      // Assert: mantissa != 0.0 && mantissa != scala.Double.PositiveInfinity
 
       val binaryExpDouble =
         js.Dynamic.global.parseInt(binaryExpStr, 10).asInstanceOf[scala.Double]

javalanglib/src/main/scala/java/lang/Enum.scala

@@ -30,7 +30,7 @@ abstract class Enum[E <: Enum[E]] protected (_name: String, _ordinal: Int)
   override protected final def clone(): AnyRef =
     throw new CloneNotSupportedException("Enums are not cloneable")
 
-  final def compareTo(o: E): Int = _ordinal.compareTo(o.ordinal)
+  final def compareTo(o: E): Int = Integer.compare(_ordinal, o.ordinal)
 
   // Not implemented:
   // final def getDeclaringClass(): Class[E]

javalanglib/src/main/scala/java/lang/Float.scala

@@ -50,7 +50,7 @@ final class Float private () extends Number with Comparable[Float] {
 }
 
 object Float {
-  final val TYPE = classOf[scala.Float]
+  final val TYPE = scala.Predef.classOf[scala.Float]
   final val POSITIVE_INFINITY = 1.0f / 0.0f
   final val NEGATIVE_INFINITY = 1.0f / -0.0f
   final val NaN = 0.0f / 0.0f

javalanglib/src/main/scala/java/lang/FloatingPointBits.scala

@@ -215,10 +215,10 @@ private[lang] object FloatingPointBits {
 
     val bias = (1 << (ebits-1)) - 1 // constant
 
-    if (v.isNaN) {
+    if (Double.isNaN(v)) {
       // http://dev.w3.org/2006/webapi/WebIDL/#es-type-mapping
       (false, (1 << ebits) - 1, pow(2, fbits-1))
-    } else if (v.isInfinite) {
+    } else if (Double.isInfinite(v)) {
       (v < 0, (1 << ebits) - 1, 0.0)
     } else if (v == 0.0) {
       (1 / v == scala.Double.NegativeInfinity, 0, 0.0)