SI-7814 Updates the instrumented version of ScalaRuntime.

Some tests for specialization use a modified version of
the standard library that count boxing, array lookups etc.

These sources are updated manually with the script:

    % test/instrumented/mkinstrumented.sh build

Looks that that wasn't done for a while, though.

This commit brings it up to date, and adjusts a few braces in
ScalaRuntime.scala so the patch srt.scala (used by that script)
is shorter.

We should really avoid checking in the products of that script and
run it as part of the build, or, better, use the bytecode
instrumentation framework instead of a modified standard library.
But I have to leave that for another day.

5 files changed, 70 insertions, 156 deletions

diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala
index 4fee6d75a3..dcd323961e 100644
--- a/src/library/scala/runtime/ScalaRunTime.scala
+++ b/src/library/scala/runtime/ScalaRunTime.scala
@@ -67,33 +67,37 @@ object ScalaRunTime {
     classTag[T].runtimeClass.asInstanceOf[jClass[T]]
 
   /** Retrieve generic array element */
-  def array_apply(xs: AnyRef, idx: Int): Any = xs match {
-    case x: Array[AnyRef]  => x(idx).asInstanceOf[Any]
-    case x: Array[Int]     => x(idx).asInstanceOf[Any]
-    case x: Array[Double]  => x(idx).asInstanceOf[Any]
-    case x: Array[Long]    => x(idx).asInstanceOf[Any]
-    case x: Array[Float]   => x(idx).asInstanceOf[Any]
-    case x: Array[Char]    => x(idx).asInstanceOf[Any]
-    case x: Array[Byte]    => x(idx).asInstanceOf[Any]
-    case x: Array[Short]   => x(idx).asInstanceOf[Any]
-    case x: Array[Boolean] => x(idx).asInstanceOf[Any]
-    case x: Array[Unit]    => x(idx).asInstanceOf[Any]
-    case null => throw new NullPointerException
+  def array_apply(xs: AnyRef, idx: Int): Any = {
+    xs match {
+      case x: Array[AnyRef]  => x(idx).asInstanceOf[Any]
+      case x: Array[Int]     => x(idx).asInstanceOf[Any]
+      case x: Array[Double]  => x(idx).asInstanceOf[Any]
+      case x: Array[Long]    => x(idx).asInstanceOf[Any]
+      case x: Array[Float]   => x(idx).asInstanceOf[Any]
+      case x: Array[Char]    => x(idx).asInstanceOf[Any]
+      case x: Array[Byte]    => x(idx).asInstanceOf[Any]
+      case x: Array[Short]   => x(idx).asInstanceOf[Any]
+      case x: Array[Boolean] => x(idx).asInstanceOf[Any]
+      case x: Array[Unit]    => x(idx).asInstanceOf[Any]
+      case null => throw new NullPointerException
+    }
   }
 
   /** update generic array element */
-  def array_update(xs: AnyRef, idx: Int, value: Any): Unit = xs match {
-    case x: Array[AnyRef]  => x(idx) = value.asInstanceOf[AnyRef]
-    case x: Array[Int]     => x(idx) = value.asInstanceOf[Int]
-    case x: Array[Double]  => x(idx) = value.asInstanceOf[Double]
-    case x: Array[Long]    => x(idx) = value.asInstanceOf[Long]
-    case x: Array[Float]   => x(idx) = value.asInstanceOf[Float]
-    case x: Array[Char]    => x(idx) = value.asInstanceOf[Char]
-    case x: Array[Byte]    => x(idx) = value.asInstanceOf[Byte]
-    case x: Array[Short]   => x(idx) = value.asInstanceOf[Short]
-    case x: Array[Boolean] => x(idx) = value.asInstanceOf[Boolean]
-    case x: Array[Unit]    => x(idx) = value.asInstanceOf[Unit]
-    case null => throw new NullPointerException
+  def array_update(xs: AnyRef, idx: Int, value: Any): Unit = {
+    xs match {
+      case x: Array[AnyRef]  => x(idx) = value.asInstanceOf[AnyRef]
+      case x: Array[Int]     => x(idx) = value.asInstanceOf[Int]
+      case x: Array[Double]  => x(idx) = value.asInstanceOf[Double]
+      case x: Array[Long]    => x(idx) = value.asInstanceOf[Long]
+      case x: Array[Float]   => x(idx) = value.asInstanceOf[Float]
+      case x: Array[Char]    => x(idx) = value.asInstanceOf[Char]
+      case x: Array[Byte]    => x(idx) = value.asInstanceOf[Byte]
+      case x: Array[Short]   => x(idx) = value.asInstanceOf[Short]
+      case x: Array[Boolean] => x(idx) = value.asInstanceOf[Boolean]
+      case x: Array[Unit]    => x(idx) = value.asInstanceOf[Unit]
+      case null => throw new NullPointerException
+    }
   }
 
   /** Get generic array length */
diff --git a/test/instrumented/boxes.patch b/test/instrumented/boxes.patch
index 6c5ff23f9f..2bb3243221 100644
--- a/test/instrumented/boxes.patch
+++ b/test/instrumented/boxes.patch
@@ -1,5 +1,5 @@
 9c9
-<
+< 
 ---
 > /* INSTRUMENTED VERSION */
 51a52,59
diff --git a/test/instrumented/library/scala/runtime/BoxesRunTime.java b/test/instrumented/library/scala/runtime/BoxesRunTime.java
index 172ed8ee14..57799bd9b1 100644
--- a/test/instrumented/library/scala/runtime/BoxesRunTime.java
+++ b/test/instrumented/library/scala/runtime/BoxesRunTime.java
@@ -1,6 +1,6 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2006-2011, LAMP/EPFL             **
+**    / __/ __// _ | / /  / _ |    (c) 2006-2013, LAMP/EPFL             **
 **  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
@@ -244,7 +244,7 @@ public final class BoxesRunTime
      *  as yet have not.
      *
      *  Note: Among primitives, Float.NaN != Float.NaN, but the boxed
-     *  verisons are equal.  This still needs reconciliation.
+     *  versions are equal.  This still needs reconciliation.
      */
     public static int hashFromLong(java.lang.Long n) {
         int iv = n.intValue();
@@ -258,6 +258,9 @@ public final class BoxesRunTime
 
         long lv = n.longValue();
         if (lv == dv) return java.lang.Long.valueOf(lv).hashCode();
+
+        float fv = n.floatValue();
+        if (fv == dv) return java.lang.Float.valueOf(fv).hashCode();
         else return n.hashCode();
     }
     public static int hashFromFloat(java.lang.Float n) {
diff --git a/test/instrumented/library/scala/runtime/ScalaRunTime.scala b/test/instrumented/library/scala/runtime/ScalaRunTime.scala
index 5a3f83015f..e474ae737c 100644
--- a/test/instrumented/library/scala/runtime/ScalaRunTime.scala
+++ b/test/instrumented/library/scala/runtime/ScalaRunTime.scala
@@ -1,6 +1,6 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2002-2011, LAMP/EPFL             **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
 **  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
@@ -8,7 +8,8 @@
 
 /* INSTRUMENTED VERSION */
 
-package scala.runtime
+package scala
+package runtime
 
 import scala.collection.{ Seq, IndexedSeq, TraversableView, AbstractIterator }
 import scala.collection.mutable.WrappedArray
@@ -17,6 +18,7 @@ import scala.collection.generic.{ Sorted }
 import scala.reflect.{ ClassTag, classTag }
 import scala.util.control.ControlThrowable
 import scala.xml.{ Node, MetaData }
+import java.lang.{ Class => jClass }
 
 import java.lang.Double.doubleToLongBits
 import java.lang.reflect.{ Modifier, Method => JMethod }
@@ -30,29 +32,21 @@ object ScalaRunTime {
   def isArray(x: Any, atLevel: Int): Boolean =
     x != null && isArrayClass(x.getClass, atLevel)
 
-  private def isArrayClass(clazz: Class[_], atLevel: Int): Boolean =
+  private def isArrayClass(clazz: jClass[_], atLevel: Int): Boolean =
     clazz.isArray && (atLevel == 1 || isArrayClass(clazz.getComponentType, atLevel - 1))
 
-  def isValueClass(clazz: Class[_]) = clazz.isPrimitive()
-  def isTuple(x: Any) = x != null && tupleNames(x.getClass.getName)
+  def isValueClass(clazz: jClass[_]) = clazz.isPrimitive()
+
+  // includes specialized subclasses and future proofed against hypothetical TupleN (for N > 22)
+  def isTuple(x: Any) = x != null && x.getClass.getName.startsWith("scala.Tuple")
   def isAnyVal(x: Any) = x match {
     case _: Byte | _: Short | _: Char | _: Int | _: Long | _: Float | _: Double | _: Boolean | _: Unit => true
     case _                                                                                             => false
   }
-  // Avoiding boxing which messes up the specialized tests.  Don't ask.
-  private val tupleNames = {
-    var i = 22
-    var names: List[String] = Nil
-    while (i >= 1) {
-      names ::= ("scala.Tuple" + String.valueOf(i))
-      i -= 1
-    }
-    names.toSet
-  }
 
   /** Return the class object representing an array with element class `clazz`.
    */
-  def arrayClass(clazz: Class[_]): Class[_] = {
+  def arrayClass(clazz: jClass[_]): jClass[_] = {
     // newInstance throws an exception if the erasure is Void.TYPE. see SI-5680
     if (clazz == java.lang.Void.TYPE) classOf[Array[Unit]]
     else java.lang.reflect.Array.newInstance(clazz, 0).getClass
@@ -60,18 +54,19 @@ object ScalaRunTime {
 
   /** Return the class object representing elements in arrays described by a given schematic.
    */
-  def arrayElementClass(schematic: Any): Class[_] = schematic match {
-    case cls: Class[_] => cls.getComponentType
+  def arrayElementClass(schematic: Any): jClass[_] = schematic match {
+    case cls: jClass[_]   => cls.getComponentType
     case tag: ClassTag[_] => tag.runtimeClass
-    case _ => throw new UnsupportedOperationException("unsupported schematic %s (%s)".format(schematic, if (schematic == null) "null" else schematic.getClass))
+    case _                =>
+      throw new UnsupportedOperationException(s"unsupported schematic $schematic (${schematic.getClass})")
   }
 
   /** Return the class object representing an unboxed value type,
    *  e.g. classOf[int], not classOf[java.lang.Integer].  The compiler
    *  rewrites expressions like 5.getClass to come here.
    */
-  def anyValClass[T <: AnyVal : ClassTag](value: T): Class[T] =
-    classTag[T].runtimeClass.asInstanceOf[Class[T]]
+  def anyValClass[T <: AnyVal : ClassTag](value: T): jClass[T] =
+    classTag[T].runtimeClass.asInstanceOf[jClass[T]]
 
   var arrayApplyCount = 0
 
@@ -93,11 +88,9 @@ object ScalaRunTime {
     }
   }
 
-  var arrayUpdateCount = 0
-
   /** update generic array element */
   def array_update(xs: AnyRef, idx: Int, value: Any): Unit = {
-    arrayUpdateCount += 1
+    arrayApplyCount += 1
     xs match {
       case x: Array[AnyRef]  => x(idx) = value.asInstanceOf[AnyRef]
       case x: Array[Int]     => x(idx) = value.asInstanceOf[Int]
@@ -156,7 +149,7 @@ object ScalaRunTime {
       dest
   }
 
-  def toArray[T](xs: collection.Seq[T]) = {
+  def toArray[T](xs: scala.collection.Seq[T]) = {
     val arr = new Array[AnyRef](xs.length)
     var i = 0
     for (x <- xs) {
@@ -179,39 +172,10 @@ object ScalaRunTime {
   def checkInitialized[T <: AnyRef](x: T): T =
     if (x == null) throw new UninitializedError else x
 
-  abstract class Try[+A] {
-    def Catch[B >: A](handler: PartialFunction[Throwable, B]): B
-    def Finally(fin: => Unit): A
-  }
-
-  def Try[A](block: => A): Try[A] = new Try[A] with Runnable {
-    private var result: A = _
-    private var exception: Throwable =
-      try   { run() ; null }
-      catch {
-        case e: ControlThrowable  => throw e  // don't catch non-local returns etc
-        case e: Throwable         => e
-      }
-
-    def run() { result = block }
-
-    def Catch[B >: A](handler: PartialFunction[Throwable, B]): B =
-      if (exception == null) result
-      else if (handler isDefinedAt exception) handler(exception)
-      else throw exception
-
-    def Finally(fin: => Unit): A = {
-      fin
-
-      if (exception == null) result
-      else throw exception
-    }
-  }
-
   def _toString(x: Product): String =
     x.productIterator.mkString(x.productPrefix + "(", ",", ")")
 
-  def _hashCode(x: Product): Int = scala.util.MurmurHash3.productHash(x)
+  def _hashCode(x: Product): Int = scala.util.hashing.MurmurHash3.productHash(x)
 
   /** A helper for case classes. */
   def typedProductIterator[T](x: Product): Iterator[T] = {
@@ -246,12 +210,12 @@ object ScalaRunTime {
   // Note that these are the implementations called by ##, so they
   // must not call ## themselves.
 
-  @inline def hash(x: Any): Int =
+  def hash(x: Any): Int =
     if (x == null) 0
     else if (x.isInstanceOf[java.lang.Number]) BoxesRunTime.hashFromNumber(x.asInstanceOf[java.lang.Number])
     else x.hashCode
 
-  @inline def hash(dv: Double): Int = {
+  def hash(dv: Double): Int = {
     val iv = dv.toInt
     if (iv == dv) return iv
 
@@ -261,7 +225,7 @@ object ScalaRunTime {
     val fv = dv.toFloat
     if (fv == dv) fv.hashCode else dv.hashCode
   }
-  @inline def hash(fv: Float): Int = {
+  def hash(fv: Float): Int = {
     val iv = fv.toInt
     if (iv == fv) return iv
 
@@ -269,29 +233,29 @@ object ScalaRunTime {
     if (lv == fv) return hash(lv)
     else fv.hashCode
   }
-  @inline def hash(lv: Long): Int = {
+  def hash(lv: Long): Int = {
     val low = lv.toInt
     val lowSign = low >>> 31
     val high = (lv >>> 32).toInt
     low ^ (high + lowSign)
   }
-  @inline def hash(x: Number): Int  = runtime.BoxesRunTime.hashFromNumber(x)
+  def hash(x: Number): Int  = runtime.BoxesRunTime.hashFromNumber(x)
 
   // The remaining overloads are here for completeness, but the compiler
   // inlines these definitions directly so they're not generally used.
-  @inline def hash(x: Int): Int = x
-  @inline def hash(x: Short): Int = x.toInt
-  @inline def hash(x: Byte): Int = x.toInt
-  @inline def hash(x: Char): Int = x.toInt
-  @inline def hash(x: Boolean): Int = if (x) true.hashCode else false.hashCode
-  @inline def hash(x: Unit): Int = 0
+  def hash(x: Int): Int = x
+  def hash(x: Short): Int = x.toInt
+  def hash(x: Byte): Int = x.toInt
+  def hash(x: Char): Int = x.toInt
+  def hash(x: Boolean): Int = if (x) true.hashCode else false.hashCode
+  def hash(x: Unit): Int = 0
 
   /** A helper method for constructing case class equality methods,
    *  because existential types get in the way of a clean outcome and
    *  it's performing a series of Any/Any equals comparisons anyway.
    *  See ticket #2867 for specifics.
    */
-  def sameElements(xs1: collection.Seq[Any], xs2: collection.Seq[Any]) = xs1 sameElements xs2
+  def sameElements(xs1: scala.collection.Seq[Any], xs2: scala.collection.Seq[Any]) = xs1 sameElements xs2
 
   /** Given any Scala value, convert it to a String.
    *
@@ -358,7 +322,7 @@ object ScalaRunTime {
       case x: String                    => if (x.head.isWhitespace || x.last.isWhitespace) "\"" + x + "\"" else x
       case x if useOwnToString(x)       => x.toString
       case x: AnyRef if isArray(x)      => arrayToString(x)
-      case x: collection.Map[_, _]      => x.iterator take maxElements map mapInner mkString (x.stringPrefix + "(", ", ", ")")
+      case x: scala.collection.Map[_, _]      => x.iterator take maxElements map mapInner mkString (x.stringPrefix + "(", ", ", ")")
       case x: Iterable[_]               => x.iterator take maxElements map inner mkString (x.stringPrefix + "(", ", ", ")")
       case x: Traversable[_]            => x take maxElements map inner mkString (x.stringPrefix + "(", ", ", ")")
       case x: Product1[_] if isTuple(x) => "(" + inner(x._1) + ",)" // that special trailing comma
diff --git a/test/instrumented/srt.patch b/test/instrumented/srt.patch
index 47dcfa2197..ee619b2ecb 100644
--- a/test/instrumented/srt.patch
+++ b/test/instrumented/srt.patch
@@ -1,67 +1,10 @@
 8a9,10
 > /* INSTRUMENTED VERSION */
 > 
-73a76,77
+68a71,72
 >   var arrayApplyCount = 0
 > 
-75,86c79,93
-<   def array_apply(xs: AnyRef, idx: Int): Any = xs match {
-<     case x: Array[AnyRef]  => x(idx).asInstanceOf[Any]
-<     case x: Array[Int]     => x(idx).asInstanceOf[Any]
-<     case x: Array[Double]  => x(idx).asInstanceOf[Any]
-<     case x: Array[Long]    => x(idx).asInstanceOf[Any]
-<     case x: Array[Float]   => x(idx).asInstanceOf[Any]
-<     case x: Array[Char]    => x(idx).asInstanceOf[Any]
-<     case x: Array[Byte]    => x(idx).asInstanceOf[Any]
-<     case x: Array[Short]   => x(idx).asInstanceOf[Any]
-<     case x: Array[Boolean] => x(idx).asInstanceOf[Any]
-<     case x: Array[Unit]    => x(idx).asInstanceOf[Any]
-<     case null => throw new NullPointerException
----
->   def array_apply(xs: AnyRef, idx: Int): Any = {
+70a75
+>     arrayApplyCount += 1
+87a93
 >     arrayApplyCount += 1
->     xs match {
->       case x: Array[AnyRef]  => x(idx).asInstanceOf[Any]
->       case x: Array[Int]     => x(idx).asInstanceOf[Any]
->       case x: Array[Double]  => x(idx).asInstanceOf[Any]
->       case x: Array[Long]    => x(idx).asInstanceOf[Any]
->       case x: Array[Float]   => x(idx).asInstanceOf[Any]
->       case x: Array[Char]    => x(idx).asInstanceOf[Any]
->       case x: Array[Byte]    => x(idx).asInstanceOf[Any]
->       case x: Array[Short]   => x(idx).asInstanceOf[Any]
->       case x: Array[Boolean] => x(idx).asInstanceOf[Any]
->       case x: Array[Unit]    => x(idx).asInstanceOf[Any]
->       case null => throw new NullPointerException
->     }
-88a96,97
->   var arrayUpdateCount = 0
-> 
-90,101c99,113
-<   def array_update(xs: AnyRef, idx: Int, value: Any): Unit = xs match {
-<     case x: Array[AnyRef]  => x(idx) = value.asInstanceOf[AnyRef]
-<     case x: Array[Int]     => x(idx) = value.asInstanceOf[Int]
-<     case x: Array[Double]  => x(idx) = value.asInstanceOf[Double]
-<     case x: Array[Long]    => x(idx) = value.asInstanceOf[Long]
-<     case x: Array[Float]   => x(idx) = value.asInstanceOf[Float]
-<     case x: Array[Char]    => x(idx) = value.asInstanceOf[Char]
-<     case x: Array[Byte]    => x(idx) = value.asInstanceOf[Byte]
-<     case x: Array[Short]   => x(idx) = value.asInstanceOf[Short]
-<     case x: Array[Boolean] => x(idx) = value.asInstanceOf[Boolean]
-<     case x: Array[Unit]    => x(idx) = value.asInstanceOf[Unit]
-<     case null => throw new NullPointerException
----
->   def array_update(xs: AnyRef, idx: Int, value: Any): Unit = {
->     arrayUpdateCount += 1
->     xs match {
->       case x: Array[AnyRef]  => x(idx) = value.asInstanceOf[AnyRef]
->       case x: Array[Int]     => x(idx) = value.asInstanceOf[Int]
->       case x: Array[Double]  => x(idx) = value.asInstanceOf[Double]
->       case x: Array[Long]    => x(idx) = value.asInstanceOf[Long]
->       case x: Array[Float]   => x(idx) = value.asInstanceOf[Float]
->       case x: Array[Char]    => x(idx) = value.asInstanceOf[Char]
->       case x: Array[Byte]    => x(idx) = value.asInstanceOf[Byte]
->       case x: Array[Short]   => x(idx) = value.asInstanceOf[Short]
->       case x: Array[Boolean] => x(idx) = value.asInstanceOf[Boolean]
->       case x: Array[Unit]    => x(idx) = value.asInstanceOf[Unit]
->       case null => throw new NullPointerException
->     }