Merge pull request scala#5098 from sjrd/simplify-scala-runtime

Simplify scala.runtime

Author: lrytz

src/compiler/scala/reflect/reify/phases/Reify.scala

@@ -1,7 +1,6 @@
 package scala.reflect.reify
 package phases
 
-import scala.runtime.ScalaRunTime.isAnyVal
 import scala.reflect.reify.codegen._
 
 trait Reify extends GenSymbols
@@ -57,4 +56,9 @@ trait Reify extends GenSymbols
     case _                        =>
       throw new Error("reifee %s of type %s is not supported".format(reifee, reifee.getClass))
   })
+
+  private def isAnyVal(x: Any) = x match {
+    case _: Byte | _: Short | _: Char | _: Int | _: Long | _: Float | _: Double | _: Boolean | _: Unit => true
+    case _                                                                                             => false
+  }
 }

src/compiler/scala/tools/nsc/typechecker/Macros.scala

@@ -12,7 +12,6 @@ import scala.reflect.internal.util.ListOfNil
 import scala.reflect.macros.runtime.{AbortMacroException, MacroRuntimes}
 import scala.reflect.macros.compiler.DefaultMacroCompiler
 import scala.tools.reflect.FastTrack
-import scala.runtime.ScalaRunTime
 import Fingerprint._
 
 /**
@@ -239,7 +238,7 @@ trait Macros extends MacroRuntimes with Traces with Helpers {
         if (!payload.contains(field)) failField("is supposed to be there")
         val raw: Any = payload(field)
         if (raw == null) failField(s"is not supposed to be null")
-        val expected = ScalaRunTime.box(clazz)
+        val expected = box(clazz)
         val actual = raw.getClass
         if (!expected.isAssignableFrom(actual)) failField(s"has wrong type: expected $expected, actual $actual")
         raw.asInstanceOf[T]
@@ -256,6 +255,19 @@ trait Macros extends MacroRuntimes with Traces with Helpers {
       val signature = unpickle("signature", classOf[List[List[Fingerprint]]])
       MacroImplBinding(isBundle, isBlackbox, className, methodName, signature, targs)
     }
+
+    private def box[T](clazz: Class[T]): Class[_] = clazz match {
+      case java.lang.Byte.TYPE => classOf[java.lang.Byte]
+      case java.lang.Short.TYPE => classOf[java.lang.Short]
+      case java.lang.Character.TYPE => classOf[java.lang.Character]
+      case java.lang.Integer.TYPE => classOf[java.lang.Integer]
+      case java.lang.Long.TYPE => classOf[java.lang.Long]
+      case java.lang.Float.TYPE => classOf[java.lang.Float]
+      case java.lang.Double.TYPE => classOf[java.lang.Double]
+      case java.lang.Void.TYPE => classOf[scala.runtime.BoxedUnit]
+      case java.lang.Boolean.TYPE => classOf[java.lang.Boolean]
+      case _ => clazz
+    }
   }
 
   def bindMacroImpl(macroDef: Symbol, macroImplRef: Tree): Unit = {

src/library/scala/collection/mutable/ArrayOps.scala

@@ -11,7 +11,6 @@ package collection
 package mutable
 
 import scala.reflect.ClassTag
-import scala.runtime.ScalaRunTime._
 import parallel.mutable.ParArray
 
 /** This class serves as a wrapper for `Array`s with all the operations found in
@@ -35,15 +34,15 @@ import parallel.mutable.ParArray
 sealed trait ArrayOps[T] extends Any with ArrayLike[T, Array[T]] with CustomParallelizable[T, ParArray[T]] {
 
   private def elementClass: Class[_] =
-    arrayElementClass(repr.getClass)
+    repr.getClass.getComponentType
 
   override def copyToArray[U >: T](xs: Array[U], start: Int, len: Int) {
     val l = len min repr.length min (xs.length - start)
     if (l > 0) Array.copy(repr, 0, xs, start, l)
   }
 
   override def toArray[U >: T : ClassTag]: Array[U] = {
-    val thatElementClass = arrayElementClass(implicitly[ClassTag[U]])
+    val thatElementClass = implicitly[ClassTag[U]].runtimeClass
     if (elementClass eq thatElementClass)
       repr.asInstanceOf[Array[U]]
     else
@@ -91,7 +90,7 @@ sealed trait ArrayOps[T] extends Any with ArrayLike[T, Array[T]] with CustomPara
     val bb: Builder[Array[U], Array[Array[U]]] = Array.newBuilder(ClassTag[Array[U]](elementClass))
     if (isEmpty) bb.result()
     else {
-      def mkRowBuilder() = Array.newBuilder(ClassTag[U](arrayElementClass(elementClass)))
+      def mkRowBuilder() = Array.newBuilder(ClassTag[U](elementClass.getComponentType))
       val bs = asArray(head) map (_ => mkRowBuilder())
       for (xs <- this) {
         var i = 0
@@ -184,7 +183,7 @@ object ArrayOps {
 
     override protected[this] def thisCollection: WrappedArray[T] = new WrappedArray.ofRef[T](repr)
     override protected[this] def toCollection(repr: Array[T]): WrappedArray[T] = new WrappedArray.ofRef[T](repr)
-    override protected[this] def newBuilder = new ArrayBuilder.ofRef[T]()(ClassTag[T](arrayElementClass(repr.getClass)))
+    override protected[this] def newBuilder = new ArrayBuilder.ofRef[T]()(ClassTag[T](repr.getClass.getComponentType))
 
     def length: Int = repr.length
     def apply(index: Int): T = repr(index)

src/library/scala/collection/mutable/WrappedArray.scala

@@ -13,7 +13,6 @@ package collection
 package mutable
 
 import scala.reflect.ClassTag
-import scala.runtime.ScalaRunTime._
 import scala.collection.generic._
 import scala.collection.parallel.mutable.ParArray
 
@@ -46,7 +45,7 @@ extends AbstractSeq[T]
   def elemTag: ClassTag[T]
 
   @deprecated("use elemTag instead", "2.10.0")
-  def elemManifest: ClassManifest[T] = ClassManifest.fromClass[T](arrayElementClass(elemTag).asInstanceOf[Class[T]])
+  def elemManifest: ClassManifest[T] = ClassManifest.fromClass[T](elemTag.runtimeClass.asInstanceOf[Class[T]])
 
   /** The length of the array */
   def length: Int
@@ -63,10 +62,10 @@ extends AbstractSeq[T]
   override def par = ParArray.handoff(array)
 
   private def elementClass: Class[_] =
-    arrayElementClass(array.getClass)
+    array.getClass.getComponentType
 
   override def toArray[U >: T : ClassTag]: Array[U] = {
-    val thatElementClass = arrayElementClass(implicitly[ClassTag[U]])
+    val thatElementClass = implicitly[ClassTag[U]].runtimeClass
     if (elementClass eq thatElementClass)
       array.asInstanceOf[Array[U]]
     else
@@ -122,7 +121,7 @@ object WrappedArray {
   def newBuilder[A]: Builder[A, IndexedSeq[A]] = new ArrayBuffer
 
   final class ofRef[T <: AnyRef](val array: Array[T]) extends WrappedArray[T] with Serializable {
-    lazy val elemTag = ClassTag[T](arrayElementClass(array.getClass))
+    lazy val elemTag = ClassTag[T](array.getClass.getComponentType)
     def length: Int = array.length
     def apply(index: Int): T = array(index).asInstanceOf[T]
     def update(index: Int, elem: T) { array(index) = elem }

src/library/scala/collection/mutable/WrappedArrayBuilder.scala

@@ -13,7 +13,6 @@ package collection
 package mutable
 
 import scala.reflect.ClassTag
-import scala.runtime.ScalaRunTime._
 
 /** A builder class for arrays.
  *
@@ -34,7 +33,7 @@ class WrappedArrayBuilder[A](tag: ClassTag[A]) extends ReusableBuilder[A, Wrappe
   private var size: Int = 0
 
   private def mkArray(size: Int): WrappedArray[A] = {
-    val runtimeClass = arrayElementClass(tag)
+    val runtimeClass = tag.runtimeClass
     val newelems = runtimeClass match {
       case java.lang.Byte.TYPE      => new WrappedArray.ofByte(new Array[Byte](size)).asInstanceOf[WrappedArray[A]]
       case java.lang.Short.TYPE     => new WrappedArray.ofShort(new Array[Short](size)).asInstanceOf[WrappedArray[A]]

src/library/scala/reflect/ClassTag.scala

@@ -2,7 +2,6 @@ package scala
 package reflect
 
 import java.lang.{ Class => jClass }
-import scala.runtime.ScalaRunTime.arrayElementClass
 
 /**
  *
@@ -105,7 +104,7 @@ trait ClassTag[T] extends ClassManifestDeprecatedApis[T] with Equals with Serial
   override def hashCode = scala.runtime.ScalaRunTime.hash(runtimeClass)
   override def toString = {
     def prettyprint(clazz: jClass[_]): String =
-      if (clazz.isArray) s"Array[${prettyprint(arrayElementClass(clazz))}]" else
+      if (clazz.isArray) s"Array[${prettyprint(clazz.getComponentType)}]" else
       clazz.getName
     prettyprint(runtimeClass)
   }

src/library/scala/runtime/ArrayRuntime.java

@@ -257,10 +257,6 @@ public static int hashFromNumber(java.lang.Number n) {
       else if (n instanceof java.lang.Float) return hashFromFloat((java.lang.Float)n);
       else return n.hashCode();
     }
-    public static int hashFromObject(Object a) {
-      if (a instanceof Number) return hashFromNumber((Number)a);
-      else return a.hashCode();
-    }
 
     private static int unboxCharOrInt(Object arg1, int code) {
       if (code == CHAR)

src/library/scala/runtime/Boxed.scala

@@ -29,15 +29,6 @@ object ScalaRunTime {
   private def isArrayClass(clazz: jClass[_], atLevel: Int): Boolean =
     clazz.isArray && (atLevel == 1 || isArrayClass(clazz.getComponentType, atLevel - 1))
 
-  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
-  }
-
   // A helper method to make my life in the pattern matcher a lot easier.
   def drop[Repr](coll: Repr, num: Int)(implicit traversable: IsTraversableLike[Repr]): Repr =
     traversable conversion coll drop num
@@ -50,15 +41,6 @@ object ScalaRunTime {
     else java.lang.reflect.Array.newInstance(clazz, 0).getClass
   }
 
-  /** Return the class object representing elements in arrays described by a given schematic.
-   */
-  def arrayElementClass(schematic: Any): jClass[_] = schematic match {
-    case cls: jClass[_]   => cls.getComponentType
-    case tag: ClassTag[_] => tag.runtimeClass
-    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.
@@ -116,15 +98,15 @@ object ScalaRunTime {
   }
 
   def array_clone(xs: AnyRef): AnyRef = xs match {
-    case x: Array[AnyRef]  => ArrayRuntime.cloneArray(x)
-    case x: Array[Int]     => ArrayRuntime.cloneArray(x)
-    case x: Array[Double]  => ArrayRuntime.cloneArray(x)
-    case x: Array[Long]    => ArrayRuntime.cloneArray(x)
-    case x: Array[Float]   => ArrayRuntime.cloneArray(x)
-    case x: Array[Char]    => ArrayRuntime.cloneArray(x)
-    case x: Array[Byte]    => ArrayRuntime.cloneArray(x)
-    case x: Array[Short]   => ArrayRuntime.cloneArray(x)
-    case x: Array[Boolean] => ArrayRuntime.cloneArray(x)
+    case x: Array[AnyRef]  => x.clone()
+    case x: Array[Int]     => x.clone()
+    case x: Array[Double]  => x.clone()
+    case x: Array[Long]    => x.clone()
+    case x: Array[Float]   => x.clone()
+    case x: Array[Char]    => x.clone()
+    case x: Array[Byte]    => x.clone()
+    case x: Array[Short]   => x.clone()
+    case x: Array[Boolean] => x.clone()
     case x: Array[Unit]    => x
     case null => throw new NullPointerException
   }
@@ -157,9 +139,6 @@ object ScalaRunTime {
   // More background at ticket #2318.
   def ensureAccessible(m: JMethod): JMethod = scala.reflect.ensureAccessible(m)
 
-  def checkInitialized[T <: AnyRef](x: T): T =
-    if (x == null) throw new UninitializedError else x
-
   def _toString(x: Product): String =
     x.productIterator.mkString(x.productPrefix + "(", ",", ")")
 
@@ -179,72 +158,12 @@ object ScalaRunTime {
     }
   }
 
-  /** Fast path equality method for inlining; used when -optimise is set.
-   */
-  @inline def inlinedEquals(x: Object, y: Object): Boolean =
-    if (x eq y) true
-    else if (x eq null) false
-    else if (x.isInstanceOf[java.lang.Number]) BoxesRunTime.equalsNumObject(x.asInstanceOf[java.lang.Number], y)
-    else if (x.isInstanceOf[java.lang.Character]) BoxesRunTime.equalsCharObject(x.asInstanceOf[java.lang.Character], y)
-    else x.equals(y)
-
-  def _equals(x: Product, y: Any): Boolean = y match {
-    case y: Product if x.productArity == y.productArity => x.productIterator sameElements y.productIterator
-    case _                                              => false
-  }
-
-  // hashcode -----------------------------------------------------------
-  //
-  // Note that these are the implementations called by ##, so they
-  // must not call ## themselves.
-
+  /** Implementation of `##`. */
   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
 
-  def hash(dv: Double): Int = {
-    val iv = dv.toInt
-    if (iv == dv) return iv
-
-    val lv = dv.toLong
-    if (lv == dv) return lv.hashCode
-
-    val fv = dv.toFloat
-    if (fv == dv) fv.hashCode else dv.hashCode
-  }
-  def hash(fv: Float): Int = {
-    val iv = fv.toInt
-    if (iv == fv) return iv
-
-    val lv = fv.toLong
-    if (lv == fv) hash(lv)
-    else fv.hashCode
-  }
-  def hash(lv: Long): Int = {
-    val low = lv.toInt
-    val lowSign = low >>> 31
-    val high = (lv >>> 32).toInt
-    low ^ (high + lowSign)
-  }
-  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.
-  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: scala.collection.Seq[Any], xs2: scala.collection.Seq[Any]) = xs1 sameElements xs2
-
   /** Given any Scala value, convert it to a String.
    *
    * The primary motivation for this method is to provide a means for
@@ -266,6 +185,9 @@ object ScalaRunTime {
     def isScalaClass(x: AnyRef)         = packageOf(x) startsWith "scala."
     def isScalaCompilerClass(x: AnyRef) = packageOf(x) startsWith "scala.tools.nsc."
 
+    // includes specialized subclasses and future proofed against hypothetical TupleN (for N > 22)
+    def isTuple(x: Any) = x != null && x.getClass.getName.startsWith("scala.Tuple")
+
     // We use reflection because the scala.xml package might not be available
     def isSubClassOf(potentialSubClass: Class[_], ofClass: String) =
       try {
@@ -345,17 +267,4 @@ object ScalaRunTime {
 
     nl + s + "\n"
   }
-
-  def box[T](clazz: jClass[T]): jClass[_] = clazz match {
-    case java.lang.Byte.TYPE => classOf[java.lang.Byte]
-    case java.lang.Short.TYPE => classOf[java.lang.Short]
-    case java.lang.Character.TYPE => classOf[java.lang.Character]
-    case java.lang.Integer.TYPE => classOf[java.lang.Integer]
-    case java.lang.Long.TYPE => classOf[java.lang.Long]
-    case java.lang.Float.TYPE => classOf[java.lang.Float]
-    case java.lang.Double.TYPE => classOf[java.lang.Double]
-    case java.lang.Void.TYPE => classOf[scala.runtime.BoxedUnit]
-    case java.lang.Boolean.TYPE => classOf[java.lang.Boolean]
-    case _ => clazz
-  }
 }