ClassTag.erasure => ClassTag.runtimeClass

This change is made to be consistent with JavaMirrors.
And, in my opinion, a technology-neutral term is better here.

1 files changed, 30 insertions, 30 deletions

diff --git a/src/library/scala/reflect/ClassTag.scala b/src/library/scala/reflect/ClassTag.scala
index ec66a42730..11fa4c8dc7 100644
--- a/src/library/scala/reflect/ClassTag.scala
+++ b/src/library/scala/reflect/ClassTag.scala
@@ -4,7 +4,7 @@ import java.lang.{ Class => jClass }
 import language.{implicitConversions, existentials}
 import scala.runtime.ScalaRunTime.arrayClass
 
-/** A `ClassTag[T]` wraps a Java class, which can be accessed via the `erasure` method.
+/** A `ClassTag[T]` wraps a runtime class, which can be accessed via the `runtimeClass` method.
  *
  *  This is useful in itself, but also enables very important use case.
  *  Having this knowledge ClassTag can instantiate `Arrays`
@@ -12,7 +12,7 @@ import scala.runtime.ScalaRunTime.arrayClass
  *  Hence, ClassTag[T] conforms to the ArrayTag[T] trait.
  *
  *  If an implicit value of type u.ClassTag[T] is required, the compiler will make one up on demand.
- *  The implicitly created value contains in its erasure field the Java class that is the result of erasing type T.
+ *  The implicitly created value contains in its `runtimeClass` field the runtime class that is the result of erasing type T.
  *  In that value, any occurrences of type parameters or abstract types U which come themselves with a ClassTag
  *  or a reflect.mirror.ConcreteTypeTag are represented by the type referenced by that tag.
  *  If the type T contains unresolved references to type parameters or abstract types, a static error results.
@@ -27,15 +27,15 @@ trait ClassTag[T] extends ArrayTag[T] with Equals with Serializable {
   // please, don't add any APIs here, like it was with `newWrappedArray` and `newArrayBuilder`
   // class tags, and all tags in general, should be as minimalistic as possible
 
-  /** Returns an erasure of type `T` */
-  def erasure: jClass[_]
+  /** Returns a runtime class of type `T` */
+  def runtimeClass: jClass[_]
 
   /** Produces a `ClassTag` that knows how to build `Array[Array[T]]` */
-  def wrap: ClassTag[Array[T]] = ClassTag[Array[T]](arrayClass(erasure))
+  def wrap: ClassTag[Array[T]] = ClassTag[Array[T]](arrayClass(runtimeClass))
 
   /** Produces a new array with element type `T` and length `len` */
   def newArray(len: Int): Array[T] =
-    erasure match {
+    runtimeClass match {
       case java.lang.Byte.TYPE      => new Array[Byte](len).asInstanceOf[Array[T]]
       case java.lang.Short.TYPE     => new Array[Short](len).asInstanceOf[Array[T]]
       case java.lang.Character.TYPE => new Array[Char](len).asInstanceOf[Array[T]]
@@ -45,14 +45,14 @@ trait ClassTag[T] extends ArrayTag[T] with Equals with Serializable {
       case java.lang.Double.TYPE    => new Array[Double](len).asInstanceOf[Array[T]]
       case java.lang.Boolean.TYPE   => new Array[Boolean](len).asInstanceOf[Array[T]]
       case java.lang.Void.TYPE      => new Array[Unit](len).asInstanceOf[Array[T]]
-      case _                        => java.lang.reflect.Array.newInstance(erasure, len).asInstanceOf[Array[T]]
+      case _                        => java.lang.reflect.Array.newInstance(runtimeClass, len).asInstanceOf[Array[T]]
     }
 
   /** case class accessories */
   override def canEqual(x: Any) = x.isInstanceOf[ClassTag[_]]
-  override def equals(x: Any) = x.isInstanceOf[ClassTag[_]] && this.erasure == x.asInstanceOf[ClassTag[_]].erasure
-  override def hashCode = scala.runtime.ScalaRunTime.hash(erasure)
-  override def toString = "ClassTag[" + erasure + "]"
+  override def equals(x: Any) = x.isInstanceOf[ClassTag[_]] && this.runtimeClass == x.asInstanceOf[ClassTag[_]].runtimeClass
+  override def hashCode = scala.runtime.ScalaRunTime.hash(runtimeClass)
+  override def toString = "ClassTag[" + runtimeClass + "]"
 }
 
 object ClassTag {
@@ -61,25 +61,25 @@ object ClassTag {
   private val ObjectTYPE = classOf[java.lang.Object]
   private val StringTYPE = classOf[java.lang.String]
 
-  val Byte    : ClassTag[scala.Byte]       = new ClassTag[scala.Byte]{ def erasure = java.lang.Byte.TYPE; private def readResolve() = ClassTag.Byte }
-  val Short   : ClassTag[scala.Short]      = new ClassTag[scala.Short]{ def erasure = java.lang.Short.TYPE; private def readResolve() = ClassTag.Short }
-  val Char    : ClassTag[scala.Char]       = new ClassTag[scala.Char]{ def erasure = java.lang.Character.TYPE; private def readResolve() = ClassTag.Char }
-  val Int     : ClassTag[scala.Int]        = new ClassTag[scala.Int]{ def erasure = java.lang.Integer.TYPE; private def readResolve() = ClassTag.Int }
-  val Long    : ClassTag[scala.Long]       = new ClassTag[scala.Long]{ def erasure = java.lang.Long.TYPE; private def readResolve() = ClassTag.Long }
-  val Float   : ClassTag[scala.Float]      = new ClassTag[scala.Float]{ def erasure = java.lang.Float.TYPE; private def readResolve() = ClassTag.Float }
-  val Double  : ClassTag[scala.Double]     = new ClassTag[scala.Double]{ def erasure = java.lang.Double.TYPE; private def readResolve() = ClassTag.Double }
-  val Boolean : ClassTag[scala.Boolean]    = new ClassTag[scala.Boolean]{ def erasure = java.lang.Boolean.TYPE; private def readResolve() = ClassTag.Boolean }
-  val Unit    : ClassTag[scala.Unit]       = new ClassTag[scala.Unit]{ def erasure = java.lang.Void.TYPE; private def readResolve() = ClassTag.Unit }
-  val Any     : ClassTag[scala.Any]        = new ClassTag[scala.Any]{ def erasure = ObjectTYPE; private def readResolve() = ClassTag.Any }
-  val Object  : ClassTag[java.lang.Object] = new ClassTag[java.lang.Object]{ def erasure = ObjectTYPE; private def readResolve() = ClassTag.Object }
-  val AnyVal  : ClassTag[scala.AnyVal]     = new ClassTag[scala.AnyVal]{ def erasure = ObjectTYPE; private def readResolve() = ClassTag.AnyVal }
-  val AnyRef  : ClassTag[scala.AnyRef]     = new ClassTag[scala.AnyRef]{ def erasure = ObjectTYPE; private def readResolve() = ClassTag.AnyRef }
-  val Nothing : ClassTag[scala.Nothing]    = new ClassTag[scala.Nothing]{ def erasure = NothingTYPE; private def readResolve() = ClassTag.Nothing }
-  val Null    : ClassTag[scala.Null]       = new ClassTag[scala.Null]{ def erasure = NullTYPE; private def readResolve() = ClassTag.Null }
-  val String  : ClassTag[java.lang.String] = new ClassTag[java.lang.String]{ def erasure = StringTYPE; private def readResolve() = ClassTag.String }
+  val Byte    : ClassTag[scala.Byte]       = new ClassTag[scala.Byte]{ def runtimeClass = java.lang.Byte.TYPE; private def readResolve() = ClassTag.Byte }
+  val Short   : ClassTag[scala.Short]      = new ClassTag[scala.Short]{ def runtimeClass = java.lang.Short.TYPE; private def readResolve() = ClassTag.Short }
+  val Char    : ClassTag[scala.Char]       = new ClassTag[scala.Char]{ def runtimeClass = java.lang.Character.TYPE; private def readResolve() = ClassTag.Char }
+  val Int     : ClassTag[scala.Int]        = new ClassTag[scala.Int]{ def runtimeClass = java.lang.Integer.TYPE; private def readResolve() = ClassTag.Int }
+  val Long    : ClassTag[scala.Long]       = new ClassTag[scala.Long]{ def runtimeClass = java.lang.Long.TYPE; private def readResolve() = ClassTag.Long }
+  val Float   : ClassTag[scala.Float]      = new ClassTag[scala.Float]{ def runtimeClass = java.lang.Float.TYPE; private def readResolve() = ClassTag.Float }
+  val Double  : ClassTag[scala.Double]     = new ClassTag[scala.Double]{ def runtimeClass = java.lang.Double.TYPE; private def readResolve() = ClassTag.Double }
+  val Boolean : ClassTag[scala.Boolean]    = new ClassTag[scala.Boolean]{ def runtimeClass = java.lang.Boolean.TYPE; private def readResolve() = ClassTag.Boolean }
+  val Unit    : ClassTag[scala.Unit]       = new ClassTag[scala.Unit]{ def runtimeClass = java.lang.Void.TYPE; private def readResolve() = ClassTag.Unit }
+  val Any     : ClassTag[scala.Any]        = new ClassTag[scala.Any]{ def runtimeClass = ObjectTYPE; private def readResolve() = ClassTag.Any }
+  val Object  : ClassTag[java.lang.Object] = new ClassTag[java.lang.Object]{ def runtimeClass = ObjectTYPE; private def readResolve() = ClassTag.Object }
+  val AnyVal  : ClassTag[scala.AnyVal]     = new ClassTag[scala.AnyVal]{ def runtimeClass = ObjectTYPE; private def readResolve() = ClassTag.AnyVal }
+  val AnyRef  : ClassTag[scala.AnyRef]     = new ClassTag[scala.AnyRef]{ def runtimeClass = ObjectTYPE; private def readResolve() = ClassTag.AnyRef }
+  val Nothing : ClassTag[scala.Nothing]    = new ClassTag[scala.Nothing]{ def runtimeClass = NothingTYPE; private def readResolve() = ClassTag.Nothing }
+  val Null    : ClassTag[scala.Null]       = new ClassTag[scala.Null]{ def runtimeClass = NullTYPE; private def readResolve() = ClassTag.Null }
+  val String  : ClassTag[java.lang.String] = new ClassTag[java.lang.String]{ def runtimeClass = StringTYPE; private def readResolve() = ClassTag.String }
 
-  def apply[T](erasure1: jClass[_]): ClassTag[T] =
-    erasure1 match {
+  def apply[T](runtimeClass1: jClass[_]): ClassTag[T] =
+    runtimeClass1 match {
       case java.lang.Byte.TYPE      => ClassTag.Byte.asInstanceOf[ClassTag[T]]
       case java.lang.Short.TYPE     => ClassTag.Short.asInstanceOf[ClassTag[T]]
       case java.lang.Character.TYPE => ClassTag.Char.asInstanceOf[ClassTag[T]]
@@ -91,8 +91,8 @@ object ClassTag {
       case java.lang.Void.TYPE      => ClassTag.Unit.asInstanceOf[ClassTag[T]]
       case ObjectTYPE               => ClassTag.Object.asInstanceOf[ClassTag[T]]
       case StringTYPE               => ClassTag.String.asInstanceOf[ClassTag[T]]
-      case _                        => new ClassTag[T]{ def erasure = erasure1 }
+      case _                        => new ClassTag[T]{ def runtimeClass = runtimeClass1 }
     }
 
-  def unapply[T](ctag: ClassTag[T]): Option[Class[_]] = Some(ctag.erasure)
+  def unapply[T](ctag: ClassTag[T]): Option[Class[_]] = Some(ctag.runtimeClass)
 }
\ No newline at end of file