Improves backward compatibility of manifests

1) type ClassManifest[T] = ClassTag[T] (solves a problem
with toArray[T: ClassManifest] defined on most of the collections;
if these types weren't aliases, then we won't be able to change
the signature of that method to toArray[T: ClassTag], because
that would break source compatibility for those who override
toArray in their custom collections)

2) Compiler-generated manifests no longer trigger deprecation warnings
(this is implemented by using ClassManifestFactory instead of ClassManifest
and ManifestFactory instead of Manifest)

3) Deprecation messages got improved to reflect the changes
that were introduced in 2.10.0-M4.

8 files changed, 120 insertions, 85 deletions

diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala
index 99bd7f0736..44025d5358 100644
--- a/src/library/scala/Predef.scala
+++ b/src/library/scala/Predef.scala
@@ -100,11 +100,19 @@ object Predef extends LowPriorityImplicits {
   // def AnyRef = scala.AnyRef
 
   // Manifest types, companions, and incantations for summoning
+  @annotation.implicitNotFound(msg = "No ClassManifest available for ${T}.")
+  @deprecated("Use scala.reflect.ClassTag instead", "2.10.0")
   type ClassManifest[T] = scala.reflect.ClassManifest[T]
+  @deprecated("This notion doesn't have a corresponding concept in 2.10, because scala.reflect.runtime.universe.TypeTag can capture arbitrary types. Use type tags instead of manifests, and there will be no need in opt manifests.", "2.10.0")
   type OptManifest[T]   = scala.reflect.OptManifest[T]
+  @annotation.implicitNotFound(msg = "No Manifest available for ${T}.")
+  @deprecated("Use scala.reflect.ClassTag (to capture erasures) or scala.reflect.runtime.universe.TypeTag (to capture types) or both instead", "2.10.0")
   type Manifest[T]      = scala.reflect.Manifest[T]
+  @deprecated("Use scala.reflect.ClassTag instead", "2.10.0")
   val ClassManifest     = scala.reflect.ClassManifest
+  @deprecated("Use scala.reflect.ClassTag (to capture erasures) or scala.reflect.runtime.universe.TypeTag (to capture types) or both instead", "2.10.0")
   val Manifest          = scala.reflect.Manifest
+  @deprecated("This notion doesn't have a corresponding concept in 2.10, because scala.reflect.runtime.universe.TypeTag can capture arbitrary types. Use type tags instead of manifests, and there will be no need in opt manifests.", "2.10.0")
   val NoManifest        = scala.reflect.NoManifest
 
   def manifest[T](implicit m: Manifest[T])           = m
diff --git a/src/library/scala/reflect/ClassManifest.scala b/src/library/scala/reflect/ClassManifest.scala
index d89d31f689..f143bf8712 100644
--- a/src/library/scala/reflect/ClassManifest.scala
+++ b/src/library/scala/reflect/ClassManifest.scala
@@ -11,23 +11,12 @@ package scala.reflect
 import scala.collection.mutable.{ WrappedArray, ArrayBuilder }
 import java.lang.{ Class => jClass }
 
-/** A `ClassManifest[T]` is an opaque descriptor for type `T`.
- *  It is used by the compiler to preserve information necessary
- *  for instantiating `Arrays` in those cases where the element type
- *  is unknown at compile time.
- *
- *  The type-relation operators make an effort to present a more accurate
- *  picture than can be realized with erased types, but they should not be
- *  relied upon to give correct answers. In particular they are likely to
- *  be wrong when variance is involved or when a subtype has a different
- *  number of type arguments than a supertype.
- */
-@deprecated("Use `@scala.reflect.ClassTag` instead", "2.10.0")
-trait ClassManifest[T] extends OptManifest[T] with ClassTag[T] with Equals with Serializable {
-  /** A class representing the type `U` to which `T` would be erased. Note
-    * that there is no subtyping relationship between `T` and `U`. */
-  def erasure: jClass[_]
-  override def runtimeClass: jClass[_] = erasure
+@deprecated("Use scala.reflect.ClassTag instead", "2.10.0")
+trait ClassManifestDeprecatedApis[T] extends OptManifest[T] {
+  self: ClassManifest[T] =>
+
+  @deprecated("Use runtimeClass instead", "2.10.0")
+  def erasure: jClass[_] = runtimeClass
 
   private def subtype(sub: jClass[_], sup: jClass[_]): Boolean = {
     def loop(left: Set[jClass[_]], seen: Set[jClass[_]]): Boolean = {
@@ -53,6 +42,7 @@ trait ClassManifest[T] extends OptManifest[T] with ClassTag[T] with Equals with
     * of the type represented by `that` manifest, subject to the limitations
     * described in the header.
     */
+  @deprecated("Use scala.reflect.runtime.universe.TypeTag for subtype checking instead", "2.10.0")
   def <:<(that: ClassManifest[_]): Boolean = {
     // All types which could conform to these types will override <:<.
     def cannotMatch = {
@@ -86,6 +76,7 @@ trait ClassManifest[T] extends OptManifest[T] with ClassTag[T] with Equals with
     * of the type represented by `that` manifest, subject to the limitations
     * described in the header.
     */
+  @deprecated("Use scala.reflect.runtime.universe.TypeTag for subtype checking instead", "2.10.0")
   def >:>(that: ClassManifest[_]): Boolean =
     that <:< this
 
@@ -94,49 +85,47 @@ trait ClassManifest[T] extends OptManifest[T] with ClassTag[T] with Equals with
     case _                   => false
   }
 
-  /** Tests whether the type represented by this manifest is equal to
-    * the type represented by `that` manifest, subject to the limitations
-    * described in the header.
-    */
-  override def equals(that: Any): Boolean = that match {
-    case m: ClassManifest[_] => (m canEqual this) && (this.erasure == m.erasure)
-    case _                   => false
-  }
-  override def hashCode = this.erasure.##
-
   protected def arrayClass[T](tp: jClass[_]): jClass[Array[T]] =
     java.lang.reflect.Array.newInstance(tp, 0).getClass.asInstanceOf[jClass[Array[T]]]
 
+  @deprecated("Use wrap instead", "2.10.0")
   def arrayManifest: ClassManifest[Array[T]] =
     ClassManifest.classType[Array[T]](arrayClass[T](erasure), this)
 
   override def newArray(len: Int): Array[T] =
     java.lang.reflect.Array.newInstance(erasure, len).asInstanceOf[Array[T]]
 
+  @deprecated("Use wrap.newArray instead", "2.10.0")
   def newArray2(len: Int): Array[Array[T]] =
     java.lang.reflect.Array.newInstance(arrayClass[T](erasure), len)
       .asInstanceOf[Array[Array[T]]]
 
+  @deprecated("Use wrap.wrap.newArray instead", "2.10.0")
   def newArray3(len: Int): Array[Array[Array[T]]] =
     java.lang.reflect.Array.newInstance(arrayClass[Array[T]](arrayClass[T](erasure)), len)
       .asInstanceOf[Array[Array[Array[T]]]]
 
+  @deprecated("Use wrap.wrap.wrap.newArray instead", "2.10.0")
   def newArray4(len: Int): Array[Array[Array[Array[T]]]] =
     java.lang.reflect.Array.newInstance(arrayClass[Array[Array[T]]](arrayClass[Array[T]](arrayClass[T](erasure))), len)
       .asInstanceOf[Array[Array[Array[Array[T]]]]]
 
+  @deprecated("Use wrap.wrap.wrap.wrap.newArray instead", "2.10.0")
   def newArray5(len: Int): Array[Array[Array[Array[Array[T]]]]] =
     java.lang.reflect.Array.newInstance(arrayClass[Array[Array[Array[T]]]](arrayClass[Array[Array[T]]](arrayClass[Array[T]](arrayClass[T](erasure)))), len)
       .asInstanceOf[Array[Array[Array[Array[Array[T]]]]]]
 
+  @deprecated("Create WrappedArray directly instead", "2.10.0")
   def newWrappedArray(len: Int): WrappedArray[T] =
     // it's safe to assume T <: AnyRef here because the method is overridden for all value type manifests
     new WrappedArray.ofRef[T with AnyRef](newArray(len).asInstanceOf[Array[T with AnyRef]]).asInstanceOf[WrappedArray[T]]
 
+  @deprecated("Use ArrayBuilder.make(this) instead", "2.10.0")
   def newArrayBuilder(): ArrayBuilder[T] =
     // it's safe to assume T <: AnyRef here because the method is overridden for all value type manifests
     new ArrayBuilder.ofRef[T with AnyRef]()(this.asInstanceOf[ClassManifest[T with AnyRef]]).asInstanceOf[ArrayBuilder[T]]
 
+  @deprecated("Use scala.reflect.runtime.universe.TypeTag to capture type structure instead", "2.10.0")
   def typeArguments: List[OptManifest[_]] = List()
 
   protected def argString =
@@ -145,25 +134,33 @@ trait ClassManifest[T] extends OptManifest[T] with ClassTag[T] with Equals with
     else ""
 }
 
-/** The object `ClassManifest` defines factory methods for manifests.
+/** `ClassManifestFactory` defines factory methods for manifests.
  *  It is intended for use by the compiler and should not be used in client code.
+ *
+ *  Unlike `ClassManifest`, this factory isn't annotated with a deprecation warning.
+ *  This is done to prevent avalanches of deprecation warnings in the code that calls methods with manifests.
+ *
+ *  In a perfect world, we would just remove the @deprecated annotation from `ClassManifest` the object
+ *  and then delete it in 2.11. After all, that object is explicitly marked as internal, so noone should use it.
+ *  However a lot of existing libraries disregarded the scaladoc that comes with `ClassManifest`,
+ *  so we need to somehow nudge them into migrating prior to removing stuff out of the blue.
+ *  Hence we've introduced this design decision as the lesser of two evils.
  */
-@deprecated("Use `@scala.reflect.ClassTag` instead", "2.10.0")
-object ClassManifest {
-  val Byte    = Manifest.Byte
-  val Short   = Manifest.Short
-  val Char    = Manifest.Char
-  val Int     = Manifest.Int
-  val Long    = Manifest.Long
-  val Float   = Manifest.Float
-  val Double  = Manifest.Double
-  val Boolean = Manifest.Boolean
-  val Unit    = Manifest.Unit
-  val Any     = Manifest.Any
-  val Object  = Manifest.Object
-  val AnyVal  = Manifest.AnyVal
-  val Nothing = Manifest.Nothing
-  val Null    = Manifest.Null
+object ClassManifestFactory {
+  val Byte    = ManifestFactory.Byte
+  val Short   = ManifestFactory.Short
+  val Char    = ManifestFactory.Char
+  val Int     = ManifestFactory.Int
+  val Long    = ManifestFactory.Long
+  val Float   = ManifestFactory.Float
+  val Double  = ManifestFactory.Double
+  val Boolean = ManifestFactory.Boolean
+  val Unit    = ManifestFactory.Unit
+  val Any     = ManifestFactory.Any
+  val Object  = ManifestFactory.Object
+  val AnyVal  = ManifestFactory.AnyVal
+  val Nothing = ManifestFactory.Nothing
+  val Null    = ManifestFactory.Null
 
   def fromClass[T](clazz: jClass[T]): ClassManifest[T] = clazz match {
     case java.lang.Byte.TYPE      => Byte.asInstanceOf[ClassManifest[T]]
@@ -211,7 +208,7 @@ object ClassManifest {
     * added so that erasure can be calculated without reflection. */
   def abstractType[T](prefix: OptManifest[_], name: String, clazz: jClass[_], args: OptManifest[_]*): ClassManifest[T] =
     new ClassManifest[T] {
-      def erasure = clazz
+      override def runtimeClass = clazz
       override val typeArguments = args.toList
       override def toString = prefix.toString+"#"+name+argString
     }
@@ -223,7 +220,7 @@ object ClassManifest {
     */
   def abstractType[T](prefix: OptManifest[_], name: String, upperbound: ClassManifest[_], args: OptManifest[_]*): ClassManifest[T] =
     new ClassManifest[T] {
-      def erasure = upperbound.erasure
+      override def runtimeClass = upperbound.erasure
       override val typeArguments = args.toList
       override def toString = prefix.toString+"#"+name+argString
     }
@@ -233,7 +230,7 @@ object ClassManifest {
   * a top-level or static class */
 private class ClassTypeManifest[T <: AnyRef](
   prefix: Option[OptManifest[_]],
-  val erasure: jClass[_],
+  val runtimeClass: jClass[_],
   override val typeArguments: List[OptManifest[_]]) extends ClassManifest[T]
 {
   override def toString =
diff --git a/src/library/scala/reflect/ClassTag.scala b/src/library/scala/reflect/ClassTag.scala
index 860e7bac28..eb63defeb3 100644
--- a/src/library/scala/reflect/ClassTag.scala
+++ b/src/library/scala/reflect/ClassTag.scala
@@ -19,18 +19,20 @@ import scala.runtime.ScalaRunTime.arrayClass
  * @see [[scala.reflect.base.TypeTags]]
  */
 @annotation.implicitNotFound(msg = "No ClassTag available for ${T}")
-trait ClassTag[T] extends Equals with Serializable {
+trait ClassTag[T] extends ClassManifestDeprecatedApis[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 a runtime class of type `T` */
+  /** A class representing the type `U` to which `T` would be erased.
+   *  Note that there is no subtyping relationship between `T` and `U`.
+   */
   def runtimeClass: jClass[_]
 
   /** Produces a `ClassTag` that knows how to build `Array[Array[T]]` */
   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] =
+  override def newArray(len: Int): Array[T] =
     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]]
diff --git a/src/library/scala/reflect/Manifest.scala b/src/library/scala/reflect/Manifest.scala
index 7e320b42eb..9347f5b6bb 100644
--- a/src/library/scala/reflect/Manifest.scala
+++ b/src/library/scala/reflect/Manifest.scala
@@ -39,7 +39,7 @@ import scala.collection.mutable.{ ArrayBuilder, WrappedArray }
  *
  */
 @annotation.implicitNotFound(msg = "No Manifest available for ${T}.")
-@deprecated("Use TypeTag instead", "2.10.0")
+@deprecated("Use scala.reflect.ClassTag (to capture erasures) or scala.reflect.runtime.universe.TypeTag (to capture types) or both instead", "2.10.0")
 trait Manifest[T] extends ClassManifest[T] with Equals {
   override def typeArguments: List[Manifest[_]] = Nil
 
@@ -72,17 +72,19 @@ abstract class AnyValManifest[T <: AnyVal](override val toString: String) extend
   override val hashCode = System.identityHashCode(this)
 }
 
-/** The object `Manifest` defines factory methods for manifests.
- *  It is intended for use by the compiler and should not be used
- *  in client code.
+/** `ManifestFactory` defines factory methods for manifests.
+ *  It is intended for use by the compiler and should not be used in client code.
+ *
+ *  Unlike `Manifest`, this factory isn't annotated with a deprecation warning.
+ *  This is done to prevent avalanches of deprecation warnings in the code that calls methods with manifests.
+ *  Why so complicated? Read up the comments for `ClassManifestFactory`.
  */
-@deprecated("Use TypeTag instead", "2.10.0")
-object Manifest {
+object ManifestFactory {
   def valueManifests: List[AnyValManifest[_]] =
     List(Byte, Short, Char, Int, Long, Float, Double, Boolean, Unit)
 
   val Byte: AnyValManifest[Byte] = new AnyValManifest[scala.Byte]("Byte") {
-    def erasure = java.lang.Byte.TYPE
+    def runtimeClass = java.lang.Byte.TYPE
     override def newArray(len: Int): Array[Byte] = new Array[Byte](len)
     override def newWrappedArray(len: Int): WrappedArray[Byte] = new WrappedArray.ofByte(new Array[Byte](len))
     override def newArrayBuilder(): ArrayBuilder[Byte] = new ArrayBuilder.ofByte()
@@ -90,7 +92,7 @@ object Manifest {
   }
 
   val Short: AnyValManifest[Short] = new AnyValManifest[scala.Short]("Short") {
-    def erasure = java.lang.Short.TYPE
+    def runtimeClass = java.lang.Short.TYPE
     override def newArray(len: Int): Array[Short] = new Array[Short](len)
     override def newWrappedArray(len: Int): WrappedArray[Short] = new WrappedArray.ofShort(new Array[Short](len))
     override def newArrayBuilder(): ArrayBuilder[Short] = new ArrayBuilder.ofShort()
@@ -98,7 +100,7 @@ object Manifest {
   }
 
   val Char: AnyValManifest[Char] = new AnyValManifest[scala.Char]("Char") {
-    def erasure = java.lang.Character.TYPE
+    def runtimeClass = java.lang.Character.TYPE
     override def newArray(len: Int): Array[Char] = new Array[Char](len)
     override def newWrappedArray(len: Int): WrappedArray[Char] = new WrappedArray.ofChar(new Array[Char](len))
     override def newArrayBuilder(): ArrayBuilder[Char] = new ArrayBuilder.ofChar()
@@ -106,7 +108,7 @@ object Manifest {
   }
 
   val Int: AnyValManifest[Int] = new AnyValManifest[scala.Int]("Int") {
-    def erasure = java.lang.Integer.TYPE
+    def runtimeClass = java.lang.Integer.TYPE
     override def newArray(len: Int): Array[Int] = new Array[Int](len)
     override def newWrappedArray(len: Int): WrappedArray[Int] = new WrappedArray.ofInt(new Array[Int](len))
     override def newArrayBuilder(): ArrayBuilder[Int] = new ArrayBuilder.ofInt()
@@ -114,7 +116,7 @@ object Manifest {
   }
 
   val Long: AnyValManifest[Long] = new AnyValManifest[scala.Long]("Long") {
-    def erasure = java.lang.Long.TYPE
+    def runtimeClass = java.lang.Long.TYPE
     override def newArray(len: Int): Array[Long] = new Array[Long](len)
     override def newWrappedArray(len: Int): WrappedArray[Long] = new WrappedArray.ofLong(new Array[Long](len))
     override def newArrayBuilder(): ArrayBuilder[Long] = new ArrayBuilder.ofLong()
@@ -122,7 +124,7 @@ object Manifest {
   }
 
   val Float: AnyValManifest[Float] = new AnyValManifest[scala.Float]("Float") {
-    def erasure = java.lang.Float.TYPE
+    def runtimeClass = java.lang.Float.TYPE
     override def newArray(len: Int): Array[Float] = new Array[Float](len)
     override def newWrappedArray(len: Int): WrappedArray[Float] = new WrappedArray.ofFloat(new Array[Float](len))
     override def newArrayBuilder(): ArrayBuilder[Float] = new ArrayBuilder.ofFloat()
@@ -130,7 +132,7 @@ object Manifest {
   }
 
   val Double: AnyValManifest[Double] = new AnyValManifest[scala.Double]("Double") {
-    def erasure = java.lang.Double.TYPE
+    def runtimeClass = java.lang.Double.TYPE
     override def newArray(len: Int): Array[Double] = new Array[Double](len)
     override def newWrappedArray(len: Int): WrappedArray[Double] = new WrappedArray.ofDouble(new Array[Double](len))
     override def newArrayBuilder(): ArrayBuilder[Double] = new ArrayBuilder.ofDouble()
@@ -138,7 +140,7 @@ object Manifest {
   }
 
   val Boolean: AnyValManifest[Boolean] = new AnyValManifest[scala.Boolean]("Boolean") {
-    def erasure = java.lang.Boolean.TYPE
+    def runtimeClass = java.lang.Boolean.TYPE
     override def newArray(len: Int): Array[Boolean] = new Array[Boolean](len)
     override def newWrappedArray(len: Int): WrappedArray[Boolean] = new WrappedArray.ofBoolean(new Array[Boolean](len))
     override def newArrayBuilder(): ArrayBuilder[Boolean] = new ArrayBuilder.ofBoolean()
@@ -146,7 +148,7 @@ object Manifest {
   }
 
   val Unit: AnyValManifest[Unit] = new AnyValManifest[scala.Unit]("Unit") {
-    def erasure = java.lang.Void.TYPE
+    def runtimeClass = java.lang.Void.TYPE
     override def newArray(len: Int): Array[Unit] = new Array[Unit](len)
     override def newWrappedArray(len: Int): WrappedArray[Unit] = new WrappedArray.ofUnit(new Array[Unit](len))
     override def newArrayBuilder(): ArrayBuilder[Unit] = new ArrayBuilder.ofUnit()
@@ -180,7 +182,7 @@ object Manifest {
   }
 
   private class SingletonTypeManifest[T <: AnyRef](value: AnyRef) extends Manifest[T] {
-    lazy val erasure = value.getClass
+    lazy val runtimeClass = value.getClass
     override lazy val toString = value.toString + ".type"
   }
 
@@ -217,7 +219,7 @@ object Manifest {
   /** Manifest for the class type `clazz[args]`, where `clazz` is
     * a top-level or static class. */
   private class ClassTypeManifest[T](prefix: Option[Manifest[_]],
-                                     val erasure: Predef.Class[_],
+                                     val runtimeClass: Predef.Class[_],
                                      override val typeArguments: List[Manifest[_]]) extends Manifest[T] {
     override def toString =
       (if (prefix.isEmpty) "" else prefix.get.toString+"#") +
@@ -233,7 +235,7 @@ object Manifest {
     * added so that erasure can be calculated without reflection. */
   def abstractType[T](prefix: Manifest[_], name: String, upperBound: Predef.Class[_], args: Manifest[_]*): Manifest[T] =
     new Manifest[T] {
-      def erasure = upperBound
+      def runtimeClass = upperBound
       override val typeArguments = args.toList
       override def toString = prefix.toString+"#"+name+argString
     }
@@ -242,7 +244,7 @@ object Manifest {
     */
   def wildcardType[T](lowerBound: Manifest[_], upperBound: Manifest[_]): Manifest[T] =
     new Manifest[T] {
-      def erasure = upperBound.erasure
+      def runtimeClass = upperBound.erasure
       override def toString =
         "_" +
         (if (lowerBound eq Nothing) "" else " >: "+lowerBound) +
@@ -252,7 +254,7 @@ object Manifest {
   /** Manifest for the intersection type `parents_0 with ... with parents_n'. */
   def intersectionType[T](parents: Manifest[_]*): Manifest[T] =
     new Manifest[T] {
-      def erasure = parents.head.erasure
+      def runtimeClass = parents.head.erasure
       override def toString = parents.mkString(" with ")
     }
 }
\ No newline at end of file
diff --git a/src/library/scala/reflect/NoManifest.scala b/src/library/scala/reflect/NoManifest.scala
index 7b8037272c..95b4ddca1c 100644
--- a/src/library/scala/reflect/NoManifest.scala
+++ b/src/library/scala/reflect/NoManifest.scala
@@ -10,7 +10,7 @@ package scala.reflect
 
 /** One of the branches of an [[scala.reflect.OptManifest]].
   */
-@deprecated("Use `@scala.reflect.TypeTag` instead", "2.10.0")
+@deprecated("This notion doesn't have a corresponding concept in 2.10, because scala.reflect.runtime.universe.TypeTag can capture arbitrary types. Use type tags instead of manifests, and there will be no need in opt manifests.", "2.10.0")
 object NoManifest extends OptManifest[Nothing] with Serializable {
   override def toString = "<?>"
 }
\ No newline at end of file
diff --git a/src/library/scala/reflect/OptManifest.scala b/src/library/scala/reflect/OptManifest.scala
index 46f23c4e22..0ea66cb53d 100644
--- a/src/library/scala/reflect/OptManifest.scala
+++ b/src/library/scala/reflect/OptManifest.scala
@@ -14,5 +14,5 @@ package scala.reflect
  *
  *  @author Martin Odersky
  */
-@deprecated("Use `@scala.reflect.TypeTag` instead", "2.10.0")
+@deprecated("This notion doesn't have a corresponding concept in 2.10, because scala.reflect.runtime.universe.TypeTag can capture arbitrary types. Use type tags instead of manifests, and there will be no need in opt manifests.", "2.10.0")
 trait OptManifest[+T] extends Serializable
\ No newline at end of file
diff --git a/src/library/scala/reflect/base/TagInterop.scala b/src/library/scala/reflect/base/TagInterop.scala
index 158d1979e5..a9f0b60fd2 100644
--- a/src/library/scala/reflect/base/TagInterop.scala
+++ b/src/library/scala/reflect/base/TagInterop.scala
@@ -4,17 +4,6 @@ package base
 import scala.runtime.ScalaRunTime._
 
 trait TagInterop { self: Universe =>
-  def classTagToClassManifest[T](tag: ClassTag[T]): ClassManifest[T] = {
-    val runtimeClass = tag.runtimeClass
-    if (runtimeClass.isArray) {
-      val elementClass = arrayElementClass(runtimeClass)
-      val elementManifest = classTagToClassManifest(ClassTag(elementClass))
-      ClassManifest.arrayType(elementManifest).asInstanceOf[ClassManifest[T]]
-    } else {
-      ClassManifest.fromClass(runtimeClass.asInstanceOf[Class[T]])
-    }
-  }
-
   // [Eugene++] `mirror` parameters are now of type `Any`, because I can't make these path-dependent types work
   // if you're brave enough, replace `Any` with `Mirror`, recompile and run interop_typetags_are_manifests.scala
 
diff --git a/src/library/scala/reflect/package.scala b/src/library/scala/reflect/package.scala
index 2ebc82875e..9f9d4089c4 100644
--- a/src/library/scala/reflect/package.scala
+++ b/src/library/scala/reflect/package.scala
@@ -4,14 +4,51 @@ package object reflect {
 
   lazy val basis: base.Universe = new base.Base
 
+  // in the new scheme of things ClassManifests are aliased to ClassTags
+  // this is done because we want `toArray` in collections work with ClassTags
+  // but changing it to use the ClassTag context bound without aliasing ClassManifest
+  // will break everyone who subclasses and overrides `toArray`
+  // luckily for us, aliasing doesn't hamper backward compatibility, so it's ideal in this situation
+  // I wish we could do the same for Manifests and TypeTags though
+
+  // note, by the way, that we don't touch ClassManifest the object
+  // because its Byte, Short and so on factory fields are incompatible with ClassTag's
+
+  /** A `ClassManifest[T]` is an opaque descriptor for type `T`.
+   *  It is used by the compiler to preserve information necessary
+   *  for instantiating `Arrays` in those cases where the element type
+   *  is unknown at compile time.
+   *
+   *  The type-relation operators make an effort to present a more accurate
+   *  picture than can be realized with erased types, but they should not be
+   *  relied upon to give correct answers. In particular they are likely to
+   *  be wrong when variance is involved or when a subtype has a different
+   *  number of type arguments than a supertype.
+   */
+  @deprecated("Use scala.reflect.ClassTag instead", "2.10.0")
+  @annotation.implicitNotFound(msg = "No ClassManifest available for ${T}.")
+  type ClassManifest[T]  = scala.reflect.ClassTag[T]
+
+  /** The object `ClassManifest` defines factory methods for manifests.
+   *  It is intended for use by the compiler and should not be used in client code.
+   */
+  @deprecated("Use scala.reflect.ClassTag instead", "2.10.0")
+  val ClassManifest = ClassManifestFactory
+
+  /** The object `Manifest` defines factory methods for manifests.
+   *  It is intended for use by the compiler and should not be used in client code.
+   */
+  @deprecated("Use scala.reflect.ClassTag (to capture erasures), scala.reflect.runtime.universe.TypeTag (to capture types) or both instead", "2.10.0")
+  val Manifest = ManifestFactory
+
   def classTag[T](implicit ctag: ClassTag[T]) = ctag
   // typeTag incantation is defined inside scala.reflect.basis and scala.reflect.runtime.universe
 
   // ClassTag class is defined in ClassTag.scala
-  type TypeTag[T]          = scala.reflect.basis.TypeTag[T]
+  type TypeTag[T]        = scala.reflect.basis.TypeTag[T]
 
   // ClassTag object is defined in ClassTag.scala
-  lazy val TypeTag         = scala.reflect.basis.TypeTag
+  lazy val TypeTag       = scala.reflect.basis.TypeTag
 
   @deprecated("Use `@scala.beans.BeanDescription` instead", "2.10.0")
   type BeanDescription = scala.beans.BeanDescription