Merge pull request scala-js#3717 from sjrd/independent-javalanglib

Make the IR of the javalanglib independent of the Scala library.

Author: gzm0

ir/src/main/scala/org/scalajs/ir/Definitions.scala

@@ -138,6 +138,25 @@ object Definitions {
   private val decompressedPrefixes: Seq[(String, String)] =
     compressedPrefixes map { case (a, b) => (b, a) }
 
+  /** Encodes a method name from its full signature. */
+  def encodeMethodName(baseName: String, paramTypes: List[TypeRef],
+      resultType: Option[TypeRef]): String = {
+
+    val paramTypesString = paramTypes.map(encodeTypeRef).mkString("__")
+
+    if (baseName == "<clinit>") {
+      assert(paramTypes.isEmpty && resultType.isEmpty)
+      StaticInitializerName
+    } else if (baseName == "<init>") {
+      assert(resultType.isEmpty)
+      paramTypes.map(encodeTypeRef).mkString("init___", "__", "")
+    } else {
+      val resultTypeString = resultType.fold("")(encodeTypeRef)
+      (paramTypes.map(encodeTypeRef) :+ resultTypeString).mkString(
+          baseName + "__", "__", "")
+    }
+  }
+
   /** Decodes a method name into its full signature. */
   def decodeMethodName(
       encodedName: String): (String, List[TypeRef], Option[TypeRef]) = {
@@ -154,11 +173,7 @@ object Definitions {
     }
 
     // -1 preserves trailing empty strings
-    val parts = privateAndSigString.split("__", -1).toSeq
-    val paramsAndResultStrings =
-      if (parts.headOption.exists(_.startsWith("p"))) parts.tail
-      else parts
-
+    val paramsAndResultStrings = privateAndSigString.split("__", -1).toSeq
     val paramStrings :+ resultString = paramsAndResultStrings
 
     val paramTypes = paramStrings.map(decodeTypeRef).toList
@@ -169,6 +184,18 @@ object Definitions {
     (simpleName, paramTypes, resultType)
   }
 
+  /** Encodes a [[Types.TypeRef]] to be used for example in an encoded method
+   *  signature.
+   */
+  def encodeTypeRef(typeRef: TypeRef): String = {
+    typeRef match {
+      case ClassRef(className) =>
+        className
+      case ArrayTypeRef(baseClassName, dimensions) =>
+        "A" * dimensions + baseClassName
+    }
+  }
+
   /** Decodes a [[Types.TypeRef]], such as in an encoded method signature.
    */
   def decodeTypeRef(encodedName: String): TypeRef = {

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

@@ -76,7 +76,7 @@ object Byte {
   def parseByte(s: String, radix: Int): scala.Byte = {
     val r = Integer.parseInt(s, radix)
     if (r < MIN_VALUE || r > MAX_VALUE)
-      throw new NumberFormatException(s"""For input string: "$s"""")
+      throw new NumberFormatException("For input string: \"" + s + "\"")
     else
       r.toByte
   }

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

@@ -84,9 +84,11 @@ 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(
-        (obj != null && !isJSType && !isInstance(obj)),
-        new ClassCastException("" + obj + " is not an instance of " + getName))
+    SemanticsUtils.asInstanceOfCheck({ () =>
+      (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

@@ -112,7 +112,7 @@ object Double {
 
   def parseDouble(s: String): scala.Double = {
     def fail(): Nothing =
-      throw new NumberFormatException(s"""For input string: "$s"""")
+      throw new NumberFormatException("For input string: \"" + s + "\"")
 
     // (Very) slow path for hexadecimal notation
     def parseHexDoubleImpl(match2: js.RegExp.ExecResult): scala.Double = {
@@ -184,12 +184,16 @@ object Double {
        * `binaryExp` (see below) did not stray too far from that range itself.
        */
 
-      val mantissa =
-        js.Dynamic.global.parseInt(truncatedMantissaStr, 16).asInstanceOf[scala.Double]
+      @inline def nativeParseInt(s: String, radix: Int): scala.Double = {
+        js.Dynamic.global
+          .parseInt(s.asInstanceOf[js.Any], radix.asInstanceOf[js.Any])
+          .asInstanceOf[scala.Double]
+      }
+
+      val mantissa = nativeParseInt(truncatedMantissaStr, 16)
       // Assert: mantissa != 0.0 && mantissa != scala.Double.PositiveInfinity
 
-      val binaryExpDouble =
-        js.Dynamic.global.parseInt(binaryExpStr, 10).asInstanceOf[scala.Double]
+      val binaryExpDouble = nativeParseInt(binaryExpStr, 10)
       val binaryExp = binaryExpDouble.toInt // caps to [MinValue, MaxValue]
 
       val binExpAndCorrection = binaryExp + fullCorrection
@@ -221,7 +225,7 @@ object Double {
 
     val match1 = doubleStrPat.exec(s)
     if (match1 != null) {
-      js.Dynamic.global.parseFloat(match1(1)).asInstanceOf[scala.Double]
+      js.Dynamic.global.parseFloat(match1(1).asInstanceOf[js.Any]).asInstanceOf[scala.Double]
     } else {
       val match2 = doubleStrHexPat.exec(s)
       if (match2 != null)

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

@@ -19,11 +19,11 @@ import js.typedarray
 /** Manipulating the bits of floating point numbers. */
 private[lang] object FloatingPointBits {
 
-  import scala.scalajs.LinkingInfo.assumingES6
+  import scala.scalajs.runtime.linkingInfo
 
   private[this] val _areTypedArraysSupported = {
     // Here we use `assumingES6` to dce the 4 subsequent tests
-    assumingES6 || {
+    linkingInfo.assumingES6 || {
       js.typeOf(global.ArrayBuffer) != "undefined" &&
       js.typeOf(global.Int32Array) != "undefined" &&
       js.typeOf(global.Float32Array) != "undefined" &&
@@ -41,7 +41,7 @@ private[lang] object FloatingPointBits {
      * * If we emit ES5, replace `areTypedArraysSupported` by
      *   `_areTypedArraysSupported` so we do not calculate it multiple times.
      */
-    assumingES6 || _areTypedArraysSupported
+    linkingInfo.assumingES6 || _areTypedArraysSupported
   }
 
   private val arrayBuffer =
@@ -153,18 +153,16 @@ private[lang] object FloatingPointBits {
   private def floatToIntBitsPolyfill(value: scala.Double): Int = {
     val ebits = 8
     val fbits = 23
-    val (s, e, f) = encodeIEEE754(ebits, fbits, value)
-    (if (s) 0x80000000 else 0) | (e << fbits) | rawToInt(f)
+    val sef = encodeIEEE754(ebits, fbits, value)
+    (if (sef.s) 0x80000000 else 0) | (sef.e << fbits) | rawToInt(sef.f)
   }
 
   private def longBitsToDoublePolyfill(bits: scala.Long): scala.Double = {
-    import js.JSNumberOps._
-
     val ebits = 11
     val fbits = 52
     val hifbits = fbits-32
     val hi = (bits >>> 32).toInt
-    val lo = bits.toInt.toUint
+    val lo = Utils.toUint(bits.toInt)
     val s = hi < 0
     val e = (hi >> hifbits) & ((1 << ebits) - 1)
     val f = (hi & ((1 << hifbits) - 1)).toDouble * 0x100000000L.toDouble + lo
@@ -175,10 +173,10 @@ private[lang] object FloatingPointBits {
     val ebits = 11
     val fbits = 52
     val hifbits = fbits-32
-    val (s, e, f) = encodeIEEE754(ebits, fbits, value)
-    val hif = rawToInt(f / 0x100000000L.toDouble)
-    val hi = (if (s) 0x80000000 else 0) | (e << hifbits) | hif
-    val lo = rawToInt(f)
+    val sef = encodeIEEE754(ebits, fbits, value)
+    val hif = rawToInt(sef.f / 0x100000000L.toDouble)
+    val hi = (if (sef.s) 0x80000000 else 0) | (sef.e << hifbits) | hif
+    val lo = rawToInt(sef.f)
     (hi.toLong << 32) | (lo.toLong & 0xffffffffL)
   }
 
@@ -209,19 +207,19 @@ private[lang] object FloatingPointBits {
   }
 
   @inline private def encodeIEEE754(ebits: Int, fbits: Int,
-      v: scala.Double): (scala.Boolean, Int, scala.Double) = {
+      v: scala.Double): EncodeIEEE754Result = {
 
-    import Math._
+    import js.Math.{floor, log, pow}
 
     val bias = (1 << (ebits-1)) - 1 // constant
 
     if (Double.isNaN(v)) {
       // http://dev.w3.org/2006/webapi/WebIDL/#es-type-mapping
-      (false, (1 << ebits) - 1, pow(2, fbits-1))
+      new EncodeIEEE754Result(false, (1 << ebits) - 1, pow(2, fbits-1))
     } else if (Double.isInfinite(v)) {
-      (v < 0, (1 << ebits) - 1, 0.0)
+      new EncodeIEEE754Result(v < 0, (1 << ebits) - 1, 0.0)
     } else if (v == 0.0) {
-      (1 / v == scala.Double.NegativeInfinity, 0, 0.0)
+      new EncodeIEEE754Result(1 / v == scala.Double.NegativeInfinity, 0, 0.0)
     } else {
       val LN2 = 0.6931471805599453
 
@@ -231,7 +229,9 @@ private[lang] object FloatingPointBits {
       if (av >= pow(2, 1-bias)) {
         val twoPowFbits = pow(2, fbits)
 
-        var e = min(rawToInt(floor(log(av) / LN2)), 1023)
+        var e = rawToInt(floor(log(av) / LN2))
+        if (e > 1023)
+          e = 1023
         var twoPowE = pow(2, e)
 
         /* #2911: When av is very close under a power of 2 (e.g.,
@@ -259,10 +259,10 @@ private[lang] object FloatingPointBits {
           e = e + bias
           f = f - twoPowFbits
         }
-        (s, e, f)
+        new EncodeIEEE754Result(s, e, f)
       } else {
         // Subnormal
-        (s, 0, roundToEven(av / pow(2, 1-bias-fbits)))
+        new EncodeIEEE754Result(s, 0, roundToEven(av / pow(2, 1-bias-fbits)))
       }
     }
   }
@@ -271,12 +271,17 @@ private[lang] object FloatingPointBits {
     (x.asInstanceOf[js.Dynamic] | 0.asInstanceOf[js.Dynamic]).asInstanceOf[Int]
 
   @inline private def roundToEven(n: scala.Double): scala.Double = {
-    val w = Math.floor(n)
+    val w = js.Math.floor(n)
     val f = n - w
     if (f < 0.5) w
     else if (f > 0.5) w + 1
     else if (w % 2 != 0) w + 1
     else w
   }
 
+  // Cannot use tuples in the javalanglib
+  @inline
+  private final class EncodeIEEE754Result(val s: scala.Boolean, val e: Int,
+      val f: scala.Double)
+
 }

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

@@ -77,7 +77,7 @@ object Integer {
       signed: scala.Boolean): scala.Int = {
 
     def fail(): Nothing =
-      throw new NumberFormatException(s"""For input string: "$s"""")
+      throw new NumberFormatException("For input string: \"" + s + "\"")
 
     val len = if (s == null) 0 else s.length
 
@@ -123,9 +123,9 @@ object Integer {
     if (x == y) 0 else if (x < y) -1 else 1
 
   @inline def compareUnsigned(x: scala.Int, y: scala.Int): scala.Int = {
-    import js.JSNumberOps._
+    import Utils.toUint
     if (x == y) 0
-    else if (x.toUint > y.toUint) 1
+    else if (toUint(x) > toUint(y)) 1
     else -1
   }
 
@@ -235,7 +235,7 @@ object Integer {
     if (radix == 10 || radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
       Integer.toString(i)
     } else {
-      import js.JSNumberOps.enableJSNumberOps
+      import Utils.Implicits.enableJSNumberOps
       i.toString(radix)
     }
   }

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

@@ -71,7 +71,7 @@ object Long {
     var radix = 0
 
     while (radix < Character.MIN_RADIX) {
-      r += null
+      r.push(null)
       radix += 1
     }
 
@@ -96,8 +96,8 @@ object Long {
       }
       val radixPowLengthLong = radixPowLength.toLong
       val overflowBarrier = Long.divideUnsigned(-1L, radixPowLengthLong)
-      r += new StringRadixInfo(chunkLength, radixPowLengthLong,
-          paddingZeros, overflowBarrier)
+      r.push(new StringRadixInfo(chunkLength, radixPowLengthLong,
+          paddingZeros, overflowBarrier))
       radix += 1
     }
 
@@ -138,7 +138,7 @@ object Long {
     val hi = (i >>> 32).toInt
     if (lo >> 31 == hi) {
       // It's a signed int32
-      import js.JSNumberOps.enableJSNumberOps
+      import Utils.Implicits.enableJSNumberOps
       lo.toString(radix)
     } else if (hi < 0) {
       "-" + toUnsignedStringInternalLarge(-i, radix)
@@ -151,17 +151,16 @@ object Long {
   private def toUnsignedStringImpl(i: scala.Long, radix: Int): String = {
     if ((i >>> 32).toInt == 0) {
       // It's an unsigned int32
-      import js.JSNumberOps._
-      i.toInt.toUint.toString(radix)
+      import Utils.Implicits.enableJSNumberOps
+      Utils.toUint(i.toInt).toString(radix)
     } else {
       toUnsignedStringInternalLarge(i, radix)
     }
   }
 
   // Must be called only with valid radix
   private def toUnsignedStringInternalLarge(i: scala.Long, radix: Int): String = {
-    import js.JSNumberOps._
-    import js.JSStringOps._
+    import Utils.Implicits._
 
     val radixInfo = StringRadixInfos(radix)
     val divisor = radixInfo.radixPowLength
@@ -312,7 +311,7 @@ object Long {
   }
 
   private def parseLongError(s: String): Nothing =
-    throw new NumberFormatException(s"""For input string: "$s"""")
+    throw new NumberFormatException("For input string: \"" + s + "\"")
 
   @inline def `new`(value: scala.Long): Long = valueOf(value)