Merge pull request #810 from scalamacros/pullrequest/manifests-and-ticket6005

two pullrequests from this morning, combined to merge changes to starrs

11 files changed, 122 insertions, 96 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..8d7b0858ef 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]]
@@ -65,7 +67,6 @@ object ClassTag {
   private val NothingTYPE = classOf[scala.runtime.Nothing$]
   private val NullTYPE = classOf[scala.runtime.Null$]
   private val ObjectTYPE = classOf[java.lang.Object]
-  private val StringTYPE = classOf[java.lang.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 }
@@ -82,7 +83,6 @@ object ClassTag {
   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](runtimeClass1: jClass[_]): ClassTag[T] =
     runtimeClass1 match {
@@ -96,7 +96,6 @@ object ClassTag {
       case java.lang.Boolean.TYPE   => ClassTag.Boolean.asInstanceOf[ClassTag[T]]
       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 runtimeClass = runtimeClass1 }
     }
 
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/Base.scala b/src/library/scala/reflect/base/Base.scala
index e9d963dc78..a4e6256f4d 100644
--- a/src/library/scala/reflect/base/Base.scala
+++ b/src/library/scala/reflect/base/Base.scala
@@ -101,8 +101,8 @@ class Base extends Universe { self =>
   }
   implicit val TypeTagg = ClassTag[Type](classOf[Type])
 
-  val NoType = new Type
-  val NoPrefix = new Type
+  val NoType = new Type { override def toString = "NoType" }
+  val NoPrefix = new Type { override def toString = "NoPrefix" }
 
   class SingletonType extends Type
   implicit val SingletonTypeTag = ClassTag[SingletonType](classOf[SingletonType])
@@ -425,7 +425,6 @@ class Base extends Universe { self =>
   lazy val NullTpe    = TypeRef(ScalaPrefix, NullClass, Nil)
   lazy val ObjectTpe  = TypeRef(JavaLangPrefix, ObjectClass, Nil)
   lazy val AnyRefTpe  = ObjectTpe
-  lazy val StringTpe  = TypeRef(JavaLangPrefix, StringClass, Nil)
 
   private var nodeCount = 0 // not synchronized
 
diff --git a/src/library/scala/reflect/base/StandardDefinitions.scala b/src/library/scala/reflect/base/StandardDefinitions.scala
index eff23b539e..2f270a5911 100644
--- a/src/library/scala/reflect/base/StandardDefinitions.scala
+++ b/src/library/scala/reflect/base/StandardDefinitions.scala
@@ -27,7 +27,6 @@ trait StandardTypes {
 
   val NothingTpe: Type
   val NullTpe: Type
-  val StringTpe: Type
 }
 
 trait StandardDefinitions extends StandardTypes {
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/base/TypeTags.scala b/src/library/scala/reflect/base/TypeTags.scala
index 774bc6ebea..1906118ed1 100644
--- a/src/library/scala/reflect/base/TypeTags.scala
+++ b/src/library/scala/reflect/base/TypeTags.scala
@@ -137,7 +137,6 @@ trait TypeTags { self: Universe =>
     val Object  : AbsTypeTag[java.lang.Object] = TypeTag.Object
     val Nothing : AbsTypeTag[scala.Nothing]    = TypeTag.Nothing
     val Null    : AbsTypeTag[scala.Null]       = TypeTag.Null
-    val String  : AbsTypeTag[java.lang.String] = TypeTag.String
 
     def apply[T](mirror1: MirrorOf[self.type], tpec1: TypeCreator): AbsTypeTag[T] =
       tpec1(mirror1) match {
@@ -154,7 +153,6 @@ trait TypeTags { self: Universe =>
         case ObjectTpe  => AbsTypeTag.Object.asInstanceOf[AbsTypeTag[T]]
         case NothingTpe => AbsTypeTag.Nothing.asInstanceOf[AbsTypeTag[T]]
         case NullTpe    => AbsTypeTag.Null.asInstanceOf[AbsTypeTag[T]]
-        case StringTpe  => AbsTypeTag.String.asInstanceOf[AbsTypeTag[T]]
         case _          => new AbsTypeTagImpl[T](mirror1.asInstanceOf[Mirror], tpec1)
       }
 
@@ -200,7 +198,6 @@ trait TypeTags { self: Universe =>
     val Object:  TypeTag[java.lang.Object] = new PredefTypeTag[java.lang.Object] (ObjectTpe,  _.TypeTag.Object)
     val Nothing: TypeTag[scala.Nothing]    = new PredefTypeTag[scala.Nothing]    (NothingTpe, _.TypeTag.Nothing)
     val Null:    TypeTag[scala.Null]       = new PredefTypeTag[scala.Null]       (NullTpe,    _.TypeTag.Null)
-    val String:  TypeTag[java.lang.String] = new PredefTypeTag[java.lang.String] (StringTpe,  _.TypeTag.String)
 
     def apply[T](mirror1: MirrorOf[self.type], tpec1: TypeCreator): TypeTag[T] =
       tpec1(mirror1) match {
@@ -217,7 +214,6 @@ trait TypeTags { self: Universe =>
         case ObjectTpe  => TypeTag.Object.asInstanceOf[TypeTag[T]]
         case NothingTpe => TypeTag.Nothing.asInstanceOf[TypeTag[T]]
         case NullTpe    => TypeTag.Null.asInstanceOf[TypeTag[T]]
-        case StringTpe  => TypeTag.String.asInstanceOf[TypeTag[T]]
         case _          => new TypeTagImpl[T](mirror1.asInstanceOf[Mirror], tpec1)
       }
 
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