resurrects manifests in their pre-2.10 glory

67 files changed, 3913 insertions, 25 deletions

diff --git a/src/compiler/scala/reflect/internal/Definitions.scala b/src/compiler/scala/reflect/internal/Definitions.scala
index 29eb573b64..6cb935edad 100644
--- a/src/compiler/scala/reflect/internal/Definitions.scala
+++ b/src/compiler/scala/reflect/internal/Definitions.scala
@@ -485,6 +485,13 @@ trait Definitions extends reflect.api.StandardDefinitions {
       // [Eugene] is this a good place for ReflectMirrorPrefix?
       def ReflectMirrorPrefix = gen.mkAttributedRef(ReflectMirror) setType singleType(ReflectMirror.owner.thisPrefix, ReflectMirror)
 
+    lazy val PartialManifestClass  = getRequiredClass("scala.reflect.ClassManifest")
+    lazy val PartialManifestModule = getRequiredModule("scala.reflect.ClassManifest")
+    lazy val FullManifestClass     = getRequiredClass("scala.reflect.Manifest")
+    lazy val FullManifestModule    = getRequiredModule("scala.reflect.Manifest")
+    lazy val OptManifestClass      = getRequiredClass("scala.reflect.OptManifest")
+    lazy val NoManifest            = getRequiredModule("scala.reflect.NoManifest")
+
     lazy val ExprClass     = getMember(getRequiredClass("scala.reflect.api.Exprs"), tpnme.Expr)
          def ExprTree      = getMemberClass(ExprClass, nme.tree)
          def ExprTpe       = getMemberClass(ExprClass, nme.tpe)
diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
index d3e64811d3..978d83616b 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
@@ -177,6 +177,22 @@ abstract class TreeGen extends reflect.internal.TreeGen with TreeDSL {
   def mkSysErrorCall(message: String): Tree =
     mkMethodCall(Sys_error, List(Literal(Constant(message))))
 
+  /** A creator for a call to a scala.reflect.Manifest or ClassManifest factory method.
+   *
+   *  @param    full          full or partial manifest (target will be Manifest or ClassManifest)
+   *  @param    constructor   name of the factory method (e.g. "classType")
+   *  @param    tparg         the type argument
+   *  @param    args          value arguments
+   *  @return   the tree
+   */
+  def mkManifestFactoryCall(full: Boolean, constructor: String, tparg: Type, args: List[Tree]): Tree =
+    mkMethodCall(
+      if (full) FullManifestModule else PartialManifestModule,
+      newTermName(constructor),
+      List(tparg),
+      args
+    )
+
   /** Make a synchronized block on 'monitor'. */
   def mkSynchronized(monitor: Tree, body: Tree): Tree =
     Apply(Select(monitor, Object_synchronized), List(body))
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 3f4e941ec6..fadb691cb6 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -1129,7 +1129,10 @@ trait Implicits {
       ConcreteTypeTagClass -> MacroInternal_materializeConcreteTypeTag
     )
 
-    def tagOfType(pre: Type, tp: Type, tagClass: Symbol): SearchResult = {
+    /** Creates a tree will produce a tag of the requested flavor.
+      * An EmptyTree is returned if materialization fails.
+      */
+    private def tagOfType(pre: Type, tp: Type, tagClass: Symbol): SearchResult = {
       def success(arg: Tree) =
         try {
           val tree1 = typed(atPos(pos.focus)(arg))
@@ -1171,9 +1174,111 @@ trait Implicits {
       else failure(materializer, "macros are disabled")
     }
 
+    private val ManifestSymbols = Set[Symbol](PartialManifestClass, FullManifestClass, OptManifestClass)
+
+    /** Creates a tree that calls the relevant factory method in object
+      * reflect.Manifest for type 'tp'. An EmptyTree is returned if
+      * no manifest is found. todo: make this instantiate take type params as well?
+      */
+    private def manifestOfType(tp: Type, full: Boolean): SearchResult = {
+
+      /** Creates a tree that calls the factory method called constructor in object reflect.Manifest */
+      def manifestFactoryCall(constructor: String, tparg: Type, args: Tree*): Tree =
+        if (args contains EmptyTree) EmptyTree
+        else typedPos(tree.pos.focus) {
+          val mani = gen.mkManifestFactoryCall(full, constructor, tparg, args.toList)
+          if (settings.debug.value) println("generated manifest: "+mani) // DEBUG
+          mani
+        }
+
+      /** Creates a tree representing one of the singleton manifests.*/
+      def findSingletonManifest(name: String) = typedPos(tree.pos.focus) {
+        Select(gen.mkAttributedRef(FullManifestModule), name)
+      }
+
+      /** Re-wraps a type in a manifest before calling inferImplicit on the result */
+      def findManifest(tp: Type, manifestClass: Symbol = if (full) FullManifestClass else PartialManifestClass) =
+        inferImplicit(tree, appliedType(manifestClass, tp), true, false, context).tree
+
+      def findSubManifest(tp: Type) = findManifest(tp, if (full) FullManifestClass else OptManifestClass)
+      def mot(tp0: Type, from: List[Symbol], to: List[Type]): SearchResult = {
+        implicit def wrapResult(tree: Tree): SearchResult =
+          if (tree == EmptyTree) SearchFailure else new SearchResult(tree, if (from.isEmpty) EmptyTreeTypeSubstituter else new TreeTypeSubstituter(from, to))
+
+        val tp1 = tp0.normalize
+        tp1 match {
+          case ThisType(_) | SingleType(_, _) =>
+            // can't generate a reference to a value that's abstracted over by an existential
+            if (containsExistential(tp1)) EmptyTree
+            else manifestFactoryCall("singleType", tp, gen.mkAttributedQualifier(tp1))
+          case ConstantType(value) =>
+            manifestOfType(tp1.deconst, full)
+          case TypeRef(pre, sym, args) =>
+            if (isPrimitiveValueClass(sym) || isPhantomClass(sym)) {
+              findSingletonManifest(sym.name.toString)
+            } else if (sym == ObjectClass || sym == AnyRefClass) {
+              findSingletonManifest("Object")
+            } else if (sym == RepeatedParamClass || sym == ByNameParamClass) {
+              EmptyTree
+            } else if (sym == ArrayClass && args.length == 1) {
+              manifestFactoryCall("arrayType", args.head, findManifest(args.head))
+            } else if (sym.isClass) {
+              val classarg0 = gen.mkClassOf(tp1)
+              val classarg = tp match {
+                case _: ExistentialType => gen.mkCast(classarg0, ClassType(tp))
+                case _                  => classarg0
+              }
+              val suffix = classarg :: (args map findSubManifest)
+              manifestFactoryCall(
+                "classType", tp,
+                (if ((pre eq NoPrefix) || pre.typeSymbol.isStaticOwner) suffix
+                 else findSubManifest(pre) :: suffix): _*)
+            } else if (sym.isExistentiallyBound && full) {
+              manifestFactoryCall("wildcardType", tp,
+                                  findManifest(tp.bounds.lo), findManifest(tp.bounds.hi))
+            }
+            // looking for a manifest of a type parameter that hasn't been inferred by now,
+            // can't do much, but let's not fail
+            else if (undetParams contains sym) {
+              // #3859: need to include the mapping from sym -> NothingClass.tpe in the SearchResult
+              mot(NothingClass.tpe, sym :: from, NothingClass.tpe :: to)
+            } else {
+              // a manifest should have been found by normal searchImplicit
+              EmptyTree
+            }
+          case RefinedType(parents, decls) => // !!! not yet: if !full || decls.isEmpty =>
+            // refinement is not generated yet
+            if (hasLength(parents, 1)) findManifest(parents.head)
+            else if (full) manifestFactoryCall("intersectionType", tp, parents map findSubManifest: _*)
+            else mot(erasure.intersectionDominator(parents), from, to)
+          case ExistentialType(tparams, result) =>
+            mot(tp1.skolemizeExistential, from, to)
+          case _ =>
+            EmptyTree
+/*          !!! the following is almost right, but we have to splice nested manifest
+ *          !!! types into this type. This requires a substantial extension of
+ *          !!! reifiers.
+            val reifier = new Reifier()
+            val rtree = reifier.reifyTopLevel(tp1)
+            manifestFactoryCall("apply", tp, rtree)
+*/
+          }
+      }
+
+      mot(tp, Nil, Nil)
+    }
+
+    def wrapResult(tree: Tree): SearchResult =
+      if (tree == EmptyTree) SearchFailure else new SearchResult(tree, EmptyTreeTypeSubstituter)
+
     /** The tag corresponding to type `pt`, provided `pt` is a flavor of a tag.
      */
     private def implicitTagOrOfExpectedType(pt: Type): SearchResult = pt.dealias match {
+      case TypeRef(pre, sym, arg :: Nil) if ManifestSymbols(sym) =>
+        manifestOfType(arg, sym == FullManifestClass) match {
+          case SearchFailure if sym == OptManifestClass => wrapResult(gen.mkAttributedRef(NoManifest))
+          case result                                   => result
+        }
       case TypeRef(pre, sym, arg :: Nil) if TagSymbols(sym) =>
         tagOfType(pre, arg, sym)
       case tp@TypeRef(_, sym, _) if sym.isAbstractType =>
diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala
index 093f972f72..d2aa3a8b34 100644
--- a/src/library/scala/Predef.scala
+++ b/src/library/scala/Predef.scala
@@ -100,19 +100,12 @@ object Predef extends LowPriorityImplicits {
   // def AnyRef = scala.AnyRef
 
   // Manifest types, companions, and incantations for summoning
-  @deprecated("Use `@scala.reflect.ClassTag` instead", "2.10.0")
   type ClassManifest[T] = scala.reflect.ClassManifest[T]
-  @deprecated("OptManifest is no longer supported and using it may lead to incorrect results, use `@scala.reflect.TypeTag` instead", "2.10.0")
   type OptManifest[T]   = scala.reflect.OptManifest[T]
-  @deprecated("Use `@scala.reflect.ConcreteTypeTag` 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
-  // [Paul to Eugene] No lazy vals in Predef.  Too expensive.  Have to work harder on breaking initialization dependencies.
-  @deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0")
-  lazy val Manifest     = scala.reflect.Manifest // needs to be lazy, because requires scala.reflect.mirror instance
-  @deprecated("NoManifest is no longer supported and using it may lead to incorrect results, use `@scala.reflect.TypeTag` instead", "2.10.0")
-  lazy val NoManifest   = scala.reflect.NoManifest // needs to be lazy, because requires scala.reflect.mirror instance
+  val Manifest          = scala.reflect.Manifest
+  val NoManifest        = scala.reflect.NoManifest
 
   def manifest[T](implicit m: Manifest[T])           = m
   def classManifest[T](implicit m: ClassManifest[T]) = m
diff --git a/src/library/scala/collection/mutable/WrappedArray.scala b/src/library/scala/collection/mutable/WrappedArray.scala
index 5e20f4ec61..9d170b2832 100644
--- a/src/library/scala/collection/mutable/WrappedArray.scala
+++ b/src/library/scala/collection/mutable/WrappedArray.scala
@@ -45,7 +45,7 @@ extends AbstractSeq[T]
   def elemTag: ArrayTag[T]
 
   @deprecated("use elemTag instead", "2.10.0")
-  def elemManifest: ClassManifest[T] = ClassManifest[T](arrayElementClass(elemTag))
+  def elemManifest: ClassManifest[T] = ClassManifest.fromClass[T](arrayElementClass(elemTag).asInstanceOf[Class[T]])
 
   /** The length of the array */
   def length: Int
diff --git a/src/library/scala/reflect/ClassManifest.scala b/src/library/scala/reflect/ClassManifest.scala
new file mode 100644
index 0000000000..43e043fd40
--- /dev/null
+++ b/src/library/scala/reflect/ClassManifest.scala
@@ -0,0 +1,242 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2007-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+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[_]
+
+  private def subtype(sub: jClass[_], sup: jClass[_]): Boolean = {
+    def loop(left: Set[jClass[_]], seen: Set[jClass[_]]): Boolean = {
+      left.nonEmpty && {
+        val next = left.head
+        val supers = next.getInterfaces.toSet ++ Option(next.getSuperclass)
+        supers(sup) || {
+          val xs = left ++ supers filterNot seen
+          loop(xs - next, seen + next)
+        }
+      }
+    }
+    loop(Set(sub), Set())
+  }
+
+  private def subargs(args1: List[OptManifest[_]], args2: List[OptManifest[_]]) = (args1 corresponds args2) {
+    // !!! [Martin] this is wrong, need to take variance into account
+    case (x: ClassManifest[_], y: ClassManifest[_]) => x <:< y
+    case (x, y)                                     => (x eq NoManifest) && (y eq NoManifest)
+  }
+
+  /** Tests whether the type represented by this manifest is a subtype
+    * of the type represented by `that` manifest, subject to the limitations
+    * described in the header.
+    */
+  def <:<(that: ClassManifest[_]): Boolean = {
+    // All types which could conform to these types will override <:<.
+    def cannotMatch = {
+      import Manifest._
+      that.isInstanceOf[AnyValManifest[_]] || (that eq AnyVal) || (that eq Nothing) || (that eq Null)
+    }
+
+    // This is wrong, and I don't know how it can be made right
+    // without more development of Manifests, due to arity-defying
+    // relationships like:
+    //
+    //   List[String] <: AnyRef
+    //   Map[Int, Int] <: Iterable[(Int, Int)]
+    //
+    // Given the manifest for Map[A, B] how do I determine that a
+    // supertype has single type argument (A, B) ? I don't see how we
+    // can say whether X <:< Y when type arguments are involved except
+    // when the erasure is the same, even before considering variance.
+    !cannotMatch && {
+      // this part is wrong for not considering variance
+      if (this.erasure == that.erasure)
+        subargs(this.typeArguments, that.typeArguments)
+      // this part is wrong for punting unless the rhs has no type
+      // arguments, but it's better than a blindfolded pinata swing.
+      else
+        that.typeArguments.isEmpty && subtype(this.erasure, that.erasure)
+    }
+  }
+
+  /** Tests whether the type represented by this manifest is a supertype
+    * of the type represented by `that` manifest, subject to the limitations
+    * described in the header.
+    */
+  def >:>(that: ClassManifest[_]): Boolean =
+    that <:< this
+
+  override def canEqual(other: Any) = other match {
+    case _: ClassManifest[_] => true
+    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]]]
+
+  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]]
+
+  def newArray2(len: Int): Array[Array[T]] =
+    java.lang.reflect.Array.newInstance(arrayClass[T](erasure), len)
+      .asInstanceOf[Array[Array[T]]]
+
+  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]]]]
+
+  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]]]]]
+
+  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]]]]]]
+
+  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]]
+
+  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]]
+
+  def typeArguments: List[OptManifest[_]] = List()
+
+  protected def argString =
+    if (typeArguments.nonEmpty) typeArguments.mkString("[", ", ", "]")
+    else if (erasure.isArray) "["+ClassManifest.fromClass(erasure.getComponentType)+"]"
+    else ""
+}
+
+/** 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")
+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
+
+  def fromClass[T](clazz: jClass[T]): ClassManifest[T] = clazz match {
+    case java.lang.Byte.TYPE      => Byte.asInstanceOf[ClassManifest[T]]
+    case java.lang.Short.TYPE     => Short.asInstanceOf[ClassManifest[T]]
+    case java.lang.Character.TYPE => Char.asInstanceOf[ClassManifest[T]]
+    case java.lang.Integer.TYPE   => Int.asInstanceOf[ClassManifest[T]]
+    case java.lang.Long.TYPE      => Long.asInstanceOf[ClassManifest[T]]
+    case java.lang.Float.TYPE     => Float.asInstanceOf[ClassManifest[T]]
+    case java.lang.Double.TYPE    => Double.asInstanceOf[ClassManifest[T]]
+    case java.lang.Boolean.TYPE   => Boolean.asInstanceOf[ClassManifest[T]]
+    case java.lang.Void.TYPE      => Unit.asInstanceOf[ClassManifest[T]]
+    case _                        => classType[T with AnyRef](clazz).asInstanceOf[ClassManifest[T]]
+  }
+
+  def singleType[T <: AnyRef](value: AnyRef): Manifest[T] = Manifest.singleType(value)
+
+  /** ClassManifest for the class type `clazz`, where `clazz` is
+    * a top-level or static class.
+    * @note This no-prefix, no-arguments case is separate because we
+    *       it's called from ScalaRunTime.boxArray itself. If we
+    *       pass varargs as arrays into this, we get an infinitely recursive call
+    *       to boxArray. (Besides, having a separate case is more efficient)
+    */
+  def classType[T <: AnyRef](clazz: jClass[_]): ClassManifest[T] =
+    new ClassTypeManifest[T](None, clazz, Nil)
+
+  /** ClassManifest for the class type `clazz[args]`, where `clazz` is
+    * a top-level or static class and `args` are its type arguments */
+  def classType[T <: AnyRef](clazz: jClass[_], arg1: OptManifest[_], args: OptManifest[_]*): ClassManifest[T] =
+    new ClassTypeManifest[T](None, clazz, arg1 :: args.toList)
+
+  /** ClassManifest for the class type `clazz[args]`, where `clazz` is
+    * a class with non-package prefix type `prefix` and type arguments `args`.
+    */
+  def classType[T <: AnyRef](prefix: OptManifest[_], clazz: jClass[_], args: OptManifest[_]*): ClassManifest[T] =
+    new ClassTypeManifest[T](Some(prefix), clazz, args.toList)
+
+  def arrayType[T](arg: OptManifest[_]): ClassManifest[Array[T]] = arg match {
+    case NoManifest          => Object.asInstanceOf[ClassManifest[Array[T]]]
+    case m: ClassManifest[_] => m.asInstanceOf[ClassManifest[T]].arrayManifest
+  }
+
+  /** ClassManifest for the abstract type `prefix # name`. `upperBound` is not
+    * strictly necessary as it could be obtained by reflection. It was
+    * 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 val typeArguments = args.toList
+      override def toString = prefix.toString+"#"+name+argString
+    }
+
+  /** ClassManifest for the abstract type `prefix # name`. `upperBound` is not
+    * strictly necessary as it could be obtained by reflection. It was
+    * added so that erasure can be calculated without reflection.
+    * todo: remove after next boostrap
+    */
+  def abstractType[T](prefix: OptManifest[_], name: String, upperbound: ClassManifest[_], args: OptManifest[_]*): ClassManifest[T] =
+    new ClassManifest[T] {
+      def erasure = upperbound.erasure
+      override val typeArguments = args.toList
+      override def toString = prefix.toString+"#"+name+argString
+    }
+}
+
+/** Manifest for the class type `clazz[args]`, where `clazz` is
+  * a top-level or static class */
+private class ClassTypeManifest[T <: AnyRef](
+  prefix: Option[OptManifest[_]],
+  val erasure: jClass[_],
+  override val typeArguments: List[OptManifest[_]]) extends ClassManifest[T]
+{
+  override def toString =
+    (if (prefix.isEmpty) "" else prefix.get.toString+"#") +
+    (if (erasure.isArray) "Array" else erasure.getName) +
+    argString
+}
\ No newline at end of file
diff --git a/src/library/scala/reflect/Manifest.scala b/src/library/scala/reflect/Manifest.scala
new file mode 100644
index 0000000000..da029f046d
--- /dev/null
+++ b/src/library/scala/reflect/Manifest.scala
@@ -0,0 +1,259 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2007-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.reflect
+
+import scala.collection.mutable.{ ArrayBuilder, WrappedArray }
+import mirror._
+
+/** A `Manifest[T]` is an opaque descriptor for type T.  Its supported use
+ *  is to give access to the erasure of the type as a `Class` instance, as
+ *  is necessary for the creation of native `Arrays` if the class is not
+ *  known at compile time.
+ *
+ *  The type-relation operators `<:<` and `=:=` should be considered
+ *  approximations only, as there are numerous aspects of type conformance
+ *  which are not yet adequately represented in manifests.
+ *
+ *  Example usages:
+{{{
+  def arr[T] = new Array[T](0)                          // does not compile
+  def arr[T](implicit m: Manifest[T]) = new Array[T](0) // compiles
+  def arr[T: Manifest] = new Array[T](0)                // shorthand for the preceding
+
+  // Methods manifest, classManifest, and optManifest are in [[scala.Predef]].
+  def isApproxSubType[T: Manifest, U: Manifest] = manifest[T] <:< manifest[U]
+  isApproxSubType[List[String], List[AnyRef]] // true
+  isApproxSubType[List[String], List[Int]]    // false
+
+  def methods[T: ClassManifest] = classManifest[T].erasure.getMethods
+  def retType[T: ClassManifest](name: String) =
+    methods[T] find (_.getName == name) map (_.getGenericReturnType)
+
+  retType[Map[_, _]]("values")  // Some(scala.collection.Iterable<B>)
+}}}
+ *
+ */
+@annotation.implicitNotFound(msg = "No Manifest available for ${T}.")
+@deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0")
+trait Manifest[T] extends ClassManifest[T] with Equals {
+  override def typeArguments: List[Manifest[_]] = Nil
+
+  override def arrayManifest: Manifest[Array[T]] =
+    Manifest.classType[Array[T]](arrayClass[T](erasure), this)
+
+  override def canEqual(that: Any): Boolean = that match {
+    case _: Manifest[_]   => true
+    case _                => false
+  }
+  /** Note: testing for erasure here is important, as it is many times
+   *  faster than <:< and rules out most comparisons.
+   */
+  override def equals(that: Any): Boolean = that match {
+    case m: Manifest[_] => (m canEqual this) && (this.erasure == m.erasure) && (this <:< m) && (m <:< this)
+    case _              => false
+  }
+  override def hashCode = this.erasure.##
+}
+
+@deprecated("Use type tags and manually check the corresponding class or type instead", "2.10.0")
+abstract class AnyValManifest[T <: AnyVal](override val toString: String) extends Manifest[T] with Equals {
+  override def <:<(that: ClassManifest[_]): Boolean =
+    (that eq this) || (that eq Manifest.Any) || (that eq Manifest.AnyVal)
+  override def canEqual(other: Any) = other match {
+    case _: AnyValManifest[_] => true
+    case _                    => false
+  }
+  override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef]
+  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.
+ */
+@deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0")
+object Manifest {
+  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
+    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()
+    private def readResolve(): Any = Manifest.Byte
+  }
+
+  val Short: AnyValManifest[Short] = new AnyValManifest[scala.Short]("Short") {
+    def erasure = 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()
+    private def readResolve(): Any = Manifest.Short
+  }
+
+  val Char: AnyValManifest[Char] = new AnyValManifest[scala.Char]("Char") {
+    def erasure = 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()
+    private def readResolve(): Any = Manifest.Char
+  }
+
+  val Int: AnyValManifest[Int] = new AnyValManifest[scala.Int]("Int") {
+    def erasure = 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()
+    private def readResolve(): Any = Manifest.Int
+  }
+
+  val Long: AnyValManifest[Long] = new AnyValManifest[scala.Long]("Long") {
+    def erasure = 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()
+    private def readResolve(): Any = Manifest.Long
+  }
+
+  val Float: AnyValManifest[Float] = new AnyValManifest[scala.Float]("Float") {
+    def erasure = 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()
+    private def readResolve(): Any = Manifest.Float
+  }
+
+  val Double: AnyValManifest[Double] = new AnyValManifest[scala.Double]("Double") {
+    def erasure = 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()
+    private def readResolve(): Any = Manifest.Double
+  }
+
+  val Boolean: AnyValManifest[Boolean] = new AnyValManifest[scala.Boolean]("Boolean") {
+    def erasure = 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()
+    private def readResolve(): Any = Manifest.Boolean
+  }
+
+  val Unit: AnyValManifest[Unit] = new AnyValManifest[scala.Unit]("Unit") {
+    def erasure = 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()
+    private def readResolve(): Any = Manifest.Unit
+  }
+
+  val Any: Manifest[scala.Any] = new PhantomManifest[scala.Any]("Any") {
+    override def <:<(that: ClassManifest[_]): Boolean = (that eq this)
+    private def readResolve(): Any = Manifest.Any
+  }
+
+  val Object: Manifest[java.lang.Object] = new PhantomManifest[java.lang.Object]("Object") {
+    override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any)
+    private def readResolve(): Any = Manifest.Object
+  }
+
+  val AnyVal: Manifest[scala.AnyVal] = new PhantomManifest[scala.AnyVal]("AnyVal") {
+    override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any)
+    private def readResolve(): Any = Manifest.AnyVal
+  }
+
+  val Null: Manifest[scala.Null] = new PhantomManifest[scala.Null]("Null") {
+    override def <:<(that: ClassManifest[_]): Boolean =
+      (that ne null) && (that ne Nothing) && !(that <:< AnyVal)
+    private def readResolve(): Any = Manifest.Null
+  }
+
+  val Nothing: Manifest[scala.Nothing] = new PhantomManifest[scala.Nothing]("Nothing") {
+    override def <:<(that: ClassManifest[_]): Boolean = (that ne null)
+    private def readResolve(): Any = Manifest.Nothing
+  }
+
+  private class SingletonTypeManifest[T <: AnyRef](value: AnyRef) extends Manifest[T] {
+    lazy val erasure = value.getClass
+    override lazy val toString = value.toString + ".type"
+  }
+
+  /** Manifest for the singleton type `value.type`. */
+  def singleType[T <: AnyRef](value: AnyRef): Manifest[T] =
+    new SingletonTypeManifest[T](value)
+
+  /** Manifest for the class type `clazz[args]`, where `clazz` is
+    * a top-level or static class.
+    * @note This no-prefix, no-arguments case is separate because we
+    *       it's called from ScalaRunTime.boxArray itself. If we
+    *       pass varargs as arrays into this, we get an infinitely recursive call
+    *       to boxArray. (Besides, having a separate case is more efficient)
+    */
+  def classType[T](clazz: Predef.Class[_]): Manifest[T] =
+    new ClassTypeManifest[T](None, clazz, Nil)
+
+  /** Manifest for the class type `clazz`, where `clazz` is
+    * a top-level or static class and args are its type arguments. */
+  def classType[T](clazz: Predef.Class[T], arg1: Manifest[_], args: Manifest[_]*): Manifest[T] =
+    new ClassTypeManifest[T](None, clazz, arg1 :: args.toList)
+
+  /** Manifest for the class type `clazz[args]`, where `clazz` is
+    * a class with non-package prefix type `prefix` and type arguments `args`.
+    */
+  def classType[T](prefix: Manifest[_], clazz: Predef.Class[_], args: Manifest[_]*): Manifest[T] =
+    new ClassTypeManifest[T](Some(prefix), clazz, args.toList)
+
+  private abstract class PhantomManifest[T](override val toString: String) extends ClassTypeManifest[T](None, classOf[java.lang.Object], Nil) {
+    override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef]
+    override val hashCode = System.identityHashCode(this)
+  }
+
+  /** 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[_],
+                                     override val typeArguments: List[Manifest[_]]) extends Manifest[T] {
+    override def toString =
+      (if (prefix.isEmpty) "" else prefix.get.toString+"#") +
+      (if (erasure.isArray) "Array" else erasure.getName) +
+      argString
+   }
+
+  def arrayType[T](arg: Manifest[_]): Manifest[Array[T]] =
+    arg.asInstanceOf[Manifest[T]].arrayManifest
+
+  /** Manifest for the abstract type `prefix # name'. `upperBound` is not
+    * strictly necessary as it could be obtained by reflection. It was
+    * 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
+      override val typeArguments = args.toList
+      override def toString = prefix.toString+"#"+name+argString
+    }
+
+  /** Manifest for the unknown type `_ >: L <: U` in an existential.
+    */
+  def wildcardType[T](lowerBound: Manifest[_], upperBound: Manifest[_]): Manifest[T] =
+    new Manifest[T] {
+      def erasure = upperBound.erasure
+      override def toString =
+        "_" +
+        (if (lowerBound eq Nothing) "" else " >: "+lowerBound) +
+        (if (upperBound eq Nothing) "" else " <: "+upperBound)
+    }
+
+  /** 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
+      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
new file mode 100644
index 0000000000..7b8037272c
--- /dev/null
+++ b/src/library/scala/reflect/NoManifest.scala
@@ -0,0 +1,16 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2007-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.reflect
+
+/** One of the branches of an [[scala.reflect.OptManifest]].
+  */
+@deprecated("Use `@scala.reflect.TypeTag` instead", "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
new file mode 100644
index 0000000000..46f23c4e22
--- /dev/null
+++ b/src/library/scala/reflect/OptManifest.scala
@@ -0,0 +1,18 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2007-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.reflect
+
+/** A `OptManifest[T]` is an optional [[scala.reflect.Manifest]].
+ *
+ *  It is either a `Manifest` or the value `NoManifest`.
+ *
+ *  @author Martin Odersky
+ */
+@deprecated("Use `@scala.reflect.TypeTag` instead", "2.10.0")
+trait OptManifest[+T] extends Serializable
\ No newline at end of file
diff --git a/src/library/scala/reflect/package.scala b/src/library/scala/reflect/package.scala
index 640cad6c21..0e6350183f 100644
--- a/src/library/scala/reflect/package.scala
+++ b/src/library/scala/reflect/package.scala
@@ -53,20 +53,6 @@ package object reflect {
   @deprecated("Use `@scala.beans.ScalaBeanInfo` instead", "2.10.0")
   type ScalaBeanInfo = scala.beans.ScalaBeanInfo
 
-  @deprecated("Use `@scala.reflect.ClassTag` instead", "2.10.0")
-  type ClassManifest[T] = ClassTag[T]
-  @deprecated("OptManifest is no longer supported, and using it may lead to incorrect results, Use `@scala.reflect.TypeTag` instead", "2.10.0")
-  type OptManifest[T]   = TypeTag[T]
-  @deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0")
-  type Manifest[T]      = ConcreteTypeTag[T]
-
-  @deprecated("Use `@scala.reflect.ClassTag` instead", "2.10.0")
-  val ClassManifest     = ClassTag
-  @deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0")
-  lazy val Manifest     = ConcreteTypeTag
-  @deprecated("NoManifest is no longer supported, and using it may lead to incorrect results, Use `@scala.reflect.TypeTag` instead", "2.10.0")
-  lazy val NoManifest   = TypeTag.Nothing
-
   // ArrayTag trait is defined separately from the mirror
   // ErasureTag trait is defined separately from the mirror
   // ConcreteErasureTag trait is defined separately from the mirror
diff --git a/test/files/jvm/manifests-old.check b/test/files/jvm/manifests-old.check
new file mode 100644
index 0000000000..54f504b929
--- /dev/null
+++ b/test/files/jvm/manifests-old.check
@@ -0,0 +1,55 @@
+x=(), m=Unit
+x=true, m=Boolean
+x=a, m=Char
+x=1, m=Int
+x=abc, m=java.lang.String
+x='abc, m=scala.Symbol
+
+x=List(()), m=scala.collection.immutable.List[Unit]
+x=List(true), m=scala.collection.immutable.List[Boolean]
+x=List(1), m=scala.collection.immutable.List[Int]
+x=List(abc), m=scala.collection.immutable.List[java.lang.String]
+x=List('abc), m=scala.collection.immutable.List[scala.Symbol]
+
+x=[Z, m=Array[Boolean]
+x=[C, m=Array[Char]
+x=[I, m=Array[Int]
+x=[Ljava.lang.String;, m=Array[java.lang.String]
+x=[Lscala.Symbol;, m=Array[scala.Symbol]
+
+x=((),()), m=scala.Tuple2[Unit, Unit]
+x=(true,false), m=scala.Tuple2[Boolean, Boolean]
+x=(1,2), m=scala.Tuple2[Int, Int]
+x=(abc,xyz), m=scala.Tuple2[java.lang.String, java.lang.String]
+x=('abc,'xyz), m=scala.Tuple2[scala.Symbol, scala.Symbol]
+
+
+x=Foo, m=Foo[Int]
+x=Foo, m=Foo[scala.collection.immutable.List[Int]]
+x=Foo, m=Foo[Foo[Int]]
+x=Foo, m=Foo[scala.collection.immutable.List[Foo[Int]]]
+
+x=Test1$$anon$1, m=Object with Bar[java.lang.String]
+
+()=()
+true=true
+a=a
+1=1
+'abc='abc
+
+List(())=List(())
+List(true)=List(true)
+List('abc)=List('abc)
+
+Array()=Array()
+Array(true)=Array(true)
+Array(a)=Array(a)
+Array(1)=Array(1)
+
+((),())=((),())
+(true,false)=(true,false)
+
+List(List(1), List(2))=List(List(1), List(2))
+
+Array(Array(1), Array(2))=Array(Array(1), Array(2))
+
diff --git a/test/files/jvm/manifests-old.scala b/test/files/jvm/manifests-old.scala
new file mode 100644
index 0000000000..241966fd9d
--- /dev/null
+++ b/test/files/jvm/manifests-old.scala
@@ -0,0 +1,109 @@
+object Test extends App {
+  Test1
+  Test2
+}
+
+class Foo[T](x: T)
+trait Bar[T] { def f: T }
+
+object Test1 extends TestUtil {
+  print(())
+  print(true)
+  print('a')
+  print(1)
+  print("abc")
+  print('abc)
+  println()
+
+  print(List(()))
+  print(List(true))
+  print(List(1))
+  print(List("abc"))
+  print(List('abc))
+  println()
+
+  //print(Array(()))  //Illegal class name "[V" in class file Test$
+  print(Array(true))
+  print(Array('a'))
+  print(Array(1))
+  print(Array("abc"))
+  print(Array('abc))
+  println()
+
+  print(((), ()))
+  print((true, false))
+  print((1, 2))
+  print(("abc", "xyz"))
+  print(('abc, 'xyz))
+  println()
+
+  // Disabled: should these work? changing the inference for objects from
+  // "object Test" to "Test.type" drags in a singleton manifest which for
+  // some reason leads to serialization failure.
+  // print(Test)
+  // print(List)
+  println()
+
+  print(new Foo(2))
+  print(new Foo(List(2)))
+  print(new Foo(new Foo(2)))
+  print(new Foo(List(new Foo(2))))
+  println()
+
+  print(new Bar[String] { def f = "abc" })
+  println()
+}
+
+object Test2 {
+  import scala.util.Marshal._
+  println("()="+load[Unit](dump(())))
+  println("true="+load[Boolean](dump(true)))
+  println("a="+load[Char](dump('a')))
+  println("1="+load[Int](dump(1)))
+  println("'abc="+load[Symbol](dump('abc)))
+  println()
+
+  println("List(())="+load[List[Unit]](dump(List(()))))
+  println("List(true)="+load[List[Boolean]](dump(List(true))))
+  println("List('abc)="+load[List[Symbol]](dump(List('abc))))
+  println()
+
+  def loadArray[T](x: Array[Byte])(implicit m: reflect.Manifest[Array[T]]) =
+    load[Array[T]](x)(m).deep.toString
+  println("Array()="+loadArray[Int](dump(Array(): Array[Int])))
+  println("Array(true)="+loadArray[Boolean](dump(Array(true))))
+  println("Array(a)="+loadArray[Char](dump(Array('a'))))
+  println("Array(1)="+loadArray[Int](dump(Array(1))))
+  println()
+
+  println("((),())="+load[(Unit, Unit)](dump(((), ()))))
+  println("(true,false)="+load[(Boolean, Boolean)](dump((true, false))))
+  println()
+
+  println("List(List(1), List(2))="+load[List[List[Int]]](dump(List(List(1), List(2)))))
+  println()
+
+  println("Array(Array(1), Array(2))="+loadArray[Array[Int]](dump(Array(Array(1), Array(2)))))
+  println()
+}
+
+trait TestUtil {
+  import java.io._
+  def write[A](o: A): Array[Byte] = {
+    val ba = new ByteArrayOutputStream(512)
+    val out = new ObjectOutputStream(ba)
+    out.writeObject(o)
+    out.close()
+    ba.toByteArray()
+  }
+  def read[A](buffer: Array[Byte]): A = {
+    val in = new ObjectInputStream(new ByteArrayInputStream(buffer))
+    in.readObject().asInstanceOf[A]
+  }
+  import scala.reflect._
+  def print[T](x: T)(implicit m: Manifest[T]) {
+    val m1: Manifest[T] = read(write(m))
+    val x1 = x.toString.replaceAll("@[0-9a-z]+$", "")
+    println("x="+x1+", m="+m1)
+  }
+}
diff --git a/test/files/jvm/serialization.check b/test/files/jvm/serialization.check
new file mode 100644
index 0000000000..fa51c6a879
--- /dev/null
+++ b/test/files/jvm/serialization.check
@@ -0,0 +1,313 @@
+a1 = Array[1,2,3]
+_a1 = Array[1,2,3]
+arrayEquals(a1, _a1): true
+
+e1 = Left(1)
+_e1 = Left(1)
+e1 eq _e1: false, _e1 eq e1: false
+e1 equals _e1: true, _e1 equals e1: true
+
+x7 = RoundingMode
+y7 = RoundingMode
+x7 eq y7: true, y7 eq x7: true
+x7 equals y7: true, y7 equals x7: true
+
+x8 = WeekDay
+y8 = WeekDay
+x8 eq y8: true, y8 eq x8: true
+x8 equals y8: true, y8 equals x8: true
+
+x9 = UP
+y9 = UP
+x9 eq y9: true, y9 eq x9: true
+x9 equals y9: true, y9 equals x9: true
+
+x10 = Monday
+y10 = Monday
+x10 eq y10: true, y10 eq x10: true
+x10 equals y10: true, y10 equals x10: true
+
+x9 eq x10: false, x10 eq x9: false
+x9 equals x10: false, x10 equals x9: false
+x9 eq y10: false, y10 eq x9: false
+x9 equals y10: false, y10 equals x9: false
+
+f1 = <na>
+_f1 = <na>
+f1(2): 4, _f1(2): 4
+
+xs0 = List(1, 2, 3)
+_xs0 = List(1, 2, 3)
+xs0 eq _xs0: false, _xs0 eq xs0: false
+xs0 equals _xs0: true, _xs0 equals xs0: true
+
+xs1 = List()
+_xs1 = List()
+xs1 eq _xs1: true, _xs1 eq xs1: true
+
+o1 = None
+_o1 = None
+o1 eq _o1: true, _o1 eq o1: true
+
+o2 = Some(1)
+_o2 = Some(1)
+o2 eq _o2: false, _o2 eq o2: false
+o2 equals _o2: true, _o2 equals o2: true
+
+s1 = 'hello
+_s1 = 'hello
+s1 eq _s1: true, _s1 eq s1: true
+s1 equals _s1: true, _s1 equals s1: true
+
+t1 = (BannerLimit,12345)
+_t1 = (BannerLimit,12345)
+t1 eq _t1: false, _t1 eq t1: false
+t1 equals _t1: true, _t1 equals t1: true
+
+x = BitSet(1, 2)
+y = BitSet(1, 2)
+x equals y: true, y equals x: true
+
+x = BitSet(2, 3)
+y = BitSet(2, 3)
+x equals y: true, y equals x: true
+
+x = Map(1 -> A, 2 -> B, 3 -> C)
+y = Map(1 -> A, 2 -> B, 3 -> C)
+x equals y: true, y equals x: true
+
+x = Set(1, 2)
+y = Set(1, 2)
+x equals y: true, y equals x: true
+
+x = List((buffers,20), (layers,2), (title,3))
+y = List((buffers,20), (layers,2), (title,3))
+x equals y: true, y equals x: true
+
+x = Map(buffers -> 20, layers -> 2, title -> 3)
+y = Map(buffers -> 20, layers -> 2, title -> 3)
+x equals y: true, y equals x: true
+
+x = ListSet(5, 3)
+y = ListSet(5, 3)
+x equals y: true, y equals x: true
+
+x = Queue(a, b, c)
+y = Queue(a, b, c)
+x equals y: true, y equals x: true
+
+x = Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
+y = Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
+x equals y: true, y equals x: true
+
+x = NumericRange(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
+y = NumericRange(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
+x equals y: true, y equals x: true
+
+x = Map(1 -> A, 2 -> B, 3 -> C)
+y = Map(1 -> A, 2 -> B, 3 -> C)
+x equals y: true, y equals x: true
+
+x = TreeSet(1, 2, 3)
+y = TreeSet(1, 2, 3)
+x equals y: true, y equals x: true
+
+x = Stack(c, b, a)
+y = Stack(c, b, a)
+x equals y: true, y equals x: true
+
+x = Stream(0, ?)
+y = Stream(0, ?)
+x equals y: true, y equals x: true
+
+x = Map(42 -> FortyTwo)
+y = Map(42 -> FortyTwo)
+x equals y: true, y equals x: true
+
+x = TreeSet(0, 2)
+y = TreeSet(0, 2)
+x equals y: true, y equals x: true
+
+x = Vector('a, 'b, 'c)
+y = Vector('a, 'b, 'c)
+x equals y: true, y equals x: true
+
+x = ArrayBuffer(one, two)
+y = ArrayBuffer(one, two)
+x equals y: true, y equals x: true
+
+x = ArrayBuilder.ofLong
+y = ArrayBuilder.ofLong
+x equals y: true, y equals x: true
+
+x = ArrayBuilder.ofFloat
+y = ArrayBuilder.ofFloat
+x equals y: true, y equals x: true
+
+x = ArraySeq(1, 2, 3)
+y = ArraySeq(1, 2, 3)
+x equals y: true, y equals x: true
+
+x = ArrayStack(3, 2, 20)
+y = ArrayStack(3, 2, 20)
+x equals y: true, y equals x: true
+
+x = BitSet(0, 8, 9)
+y = BitSet(0, 8, 9)
+x equals y: true, y equals x: true
+
+x = Map(A -> 1, C -> 3, B -> 2)
+y = Map(A -> 1, C -> 3, B -> 2)
+x equals y: true, y equals x: true
+
+x = Set(buffers, title, layers)
+y = Set(buffers, title, layers)
+x equals y: true, y equals x: true
+
+x = History()
+y = History()
+x equals y: true, y equals x: true
+
+x = ListBuffer(white, black)
+y = ListBuffer(white, black)
+x equals y: true, y equals x: true
+
+x = Queue(20, 2, 3)
+y = Queue(20, 2, 3)
+x equals y: true, y equals x: true
+
+x = Stack(3, 2, 20)
+y = Stack(3, 2, 20)
+x equals y: true, y equals x: true
+
+x = abc
+y = abc
+x equals y: true, y equals x: true
+
+x = WrappedArray(1, 2, 3)
+y = WrappedArray(1, 2, 3)
+x equals y: true, y equals x: true
+
+x = TreeSet(1, 2, 3)
+y = TreeSet(1, 2, 3)
+x equals y: true, y equals x: true
+
+x = TrieMap(1 -> one, 2 -> two, 3 -> three)
+y = TrieMap(1 -> one, 2 -> two, 3 -> three)
+x equals y: true, y equals x: true
+
+x =  xml:src="hello"
+y =  xml:src="hello"
+x equals y: true, y equals x: true
+
+x = <title></title>
+y = <title></title>
+x equals y: true, y equals x: true
+
+x = <html><title>title</title><body></body></html>
+y = <html><title>title</title><body></body></html>
+x equals y: true, y equals x: true
+
+x = <html>
+      <body>
+        <table cellpadding="2" cellspacing="0">
+        <tr>
+          <th>Last Name</th>
+          <th>First Name</th>
+        </tr>
+        <tr>
+          <td> Tom </td>
+          <td> 20 </td>
+        </tr><tr>
+          <td> Bob </td>
+          <td> 22 </td>
+        </tr><tr>
+          <td> James </td>
+          <td> 19 </td>
+        </tr>
+      </table>
+      </body>
+      </html>
+y = <html>
+      <body>
+        <table cellpadding="2" cellspacing="0">
+        <tr>
+          <th>Last Name</th>
+          <th>First Name</th>
+        </tr>
+        <tr>
+          <td> Tom </td>
+          <td> 20 </td>
+        </tr><tr>
+          <td> Bob </td>
+          <td> 22 </td>
+        </tr><tr>
+          <td> James </td>
+          <td> 19 </td>
+        </tr>
+      </table>
+      </body>
+      </html>
+x equals y: true, y equals x: true
+
+x = Tim
+y = Tim
+x equals y: true, y equals x: true
+
+x = Bob
+y = Bob
+x equals y: true, y equals x: true
+
+x = John
+y = John
+x equals y: true, y equals x: true
+
+x = Bill
+y = Bill
+x equals y: true, y equals x: true
+
+x = Paul
+y = Paul
+x equals y: true, y equals x: true
+
+1
+2
+1
+2
+
+x = UnrolledBuffer(one, two)
+y = UnrolledBuffer(one, two)
+x equals y: true, y equals x: true
+
+x = ParArray(abc, def, etc)
+y = ParArray(abc, def, etc)
+x equals y: true, y equals x: true
+
+x = ParHashMap(2 -> 4, 1 -> 2)
+y = ParHashMap(2 -> 4, 1 -> 2)
+x equals y: true, y equals x: true
+
+x = ParTrieMap(1 -> 2, 2 -> 4)
+y = ParTrieMap(1 -> 2, 2 -> 4)
+x equals y: true, y equals x: true
+
+x = ParHashSet(1, 2, 3)
+y = ParHashSet(1, 2, 3)
+x equals y: true, y equals x: true
+
+x = ParRange(0, 1, 2, 3, 4)
+y = ParRange(0, 1, 2, 3, 4)
+x equals y: true, y equals x: true
+
+x = ParRange(0, 1, 2, 3)
+y = ParRange(0, 1, 2, 3)
+x equals y: true, y equals x: true
+
+x = ParMap(5 -> 1, 10 -> 2)
+y = ParMap(5 -> 1, 10 -> 2)
+x equals y: true, y equals x: true
+
+x = ParSet(two, one)
+y = ParSet(two, one)
+x equals y: true, y equals x: true
+
diff --git a/test/files/jvm/serialization.scala b/test/files/jvm/serialization.scala
new file mode 100644
index 0000000000..9c2f2acdbf
--- /dev/null
+++ b/test/files/jvm/serialization.scala
@@ -0,0 +1,651 @@
+//############################################################################
+// Serialization
+//############################################################################
+
+object Serialize {
+  @throws(classOf[java.io.IOException])
+  def write[A](o: A): Array[Byte] = {
+    val ba = new java.io.ByteArrayOutputStream(512)
+    val out = new java.io.ObjectOutputStream(ba)
+    out.writeObject(o)
+    out.close()
+    ba.toByteArray()
+  }
+  @throws(classOf[java.io.IOException])
+  @throws(classOf[ClassNotFoundException])
+  def read[A](buffer: Array[Byte]): A = {
+    val in =
+      new java.io.ObjectInputStream(new java.io.ByteArrayInputStream(buffer))
+    in.readObject().asInstanceOf[A]
+  }
+  def check[A, B](x: A, y: B) {
+    println("x = " + x)
+    println("y = " + y)
+    println("x equals y: " + (x equals y) + ", y equals x: " + (y equals x))
+    assert((x equals y) && (y equals x))
+    println()
+  }
+}
+import Serialize._
+
+//############################################################################
+// Test classes in package "scala"
+
+object Test1_scala {
+
+  private def arrayToString[A](arr: Array[A]): String =
+    arr.mkString("Array[",",","]")
+
+  private def arrayEquals[A, B](a1: Array[A], a2: Array[B]): Boolean =
+    (a1.length == a2.length) &&
+    (Iterator.range(0, a1.length) forall { i => a1(i) == a2(i) })
+
+  object WeekDay extends Enumeration {
+    type WeekDay = Value
+    val Monday, Tuesday, Wednesday, Thusday, Friday, Saturday, Sunday = Value
+  }
+  import WeekDay._, BigDecimal._, RoundingMode._
+
+  // in alphabetic order
+  try {
+    // Array
+    val a1 = Array(1, 2, 3)
+    val _a1: Array[Int] = read(write(a1))
+    println("a1 = " + arrayToString(a1))
+    println("_a1 = " + arrayToString(_a1))
+    println("arrayEquals(a1, _a1): " + arrayEquals(a1, _a1))
+    println()
+
+    // Either
+    val e1 = Left(1)
+    val _e1: Either[Int, String] = read(write(e1))
+    println("e1 = " + e1)
+    println("_e1 = " + _e1)
+    println("e1 eq _e1: " + (e1 eq _e1) + ", _e1 eq e1: " + (_e1 eq e1))
+    println("e1 equals _e1: " + (e1 equals _e1) + ", _e1 equals e1: " + (_e1 equals e1))
+    println()
+
+    // Enumeration
+    val x7 = BigDecimal.RoundingMode
+    val y7: RoundingMode.type = read(write(x7))
+    println("x7 = " + x7)
+    println("y7 = " + y7)
+    println("x7 eq y7: " + (x7 eq y7) + ", y7 eq x7: " + (y7 eq x7))
+    println("x7 equals y7: " + (x7 equals y7) + ", y7 equals x7: " + (y7 equals x7))
+    println()
+
+    val x8 = WeekDay
+    val y8: WeekDay.type = read(write(x8))
+    println("x8 = " + x8)
+    println("y8 = " + y8)
+    println("x8 eq y8: " + (x8 eq y8) + ", y8 eq x8: " + (y8 eq x8))
+    println("x8 equals y8: " + (x8 equals y8) + ", y8 equals x8: " + (y8 equals x8))
+    println()
+
+    val x9 = UP
+    val y9: RoundingMode = read(write(x9))
+    println("x9 = " + x9)
+    println("y9 = " + y9)
+    println("x9 eq y9: " + (x9 eq y9) + ", y9 eq x9: " + (y9 eq x9))
+    println("x9 equals y9: " + (x9 equals y9) + ", y9 equals x9: " + (y9 equals x9))
+    println()
+
+    val x10 = Monday
+    val y10: WeekDay = read(write(x10))
+    println("x10 = " + x10)
+    println("y10 = " + y10)
+    println("x10 eq y10: " + (x10 eq y10) + ", y10 eq x10: " + (y10 eq x10))
+    println("x10 equals y10: " + (x10 equals y10) + ", y10 equals x10: " + (y10 equals x10))
+    println()
+
+    println("x9 eq x10: " + (x9 eq x10) + ", x10 eq x9: " + (x10 eq x9))
+    println("x9 equals x10: " + (x9 equals x10) + ", x10 equals x9: " + (x10 equals x9))
+    println("x9 eq y10: " + (x9 eq y10) + ", y10 eq x9: " + (y10 eq x9))
+    println("x9 equals y10: " + (x9 equals y10) + ", y10 equals x9: " + (y10 equals x9))
+    println()
+
+    // Function
+    val f1 = { x: Int => 2 * x }
+    val _f1: Function[Int, Int] = read(write(f1))
+    println("f1 = <na>")
+    println("_f1 = <na>")
+    println("f1(2): " + f1(2) + ", _f1(2): " + _f1(2))
+    println()
+
+    // List
+    val xs0 = List(1, 2, 3)
+    val _xs0: List[Int] = read(write(xs0))
+    println("xs0 = " + xs0)
+    println("_xs0 = " + _xs0)
+    println("xs0 eq _xs0: " + (xs0 eq _xs0) + ", _xs0 eq xs0: " + (_xs0 eq xs0))
+    println("xs0 equals _xs0: " + (xs0 equals _xs0) + ", _xs0 equals xs0: " + (_xs0 equals xs0))
+    println()
+
+    val xs1 = Nil
+    val _xs1: List[Nothing] = read(write(xs1))
+    println("xs1 = " + xs1)
+    println("_xs1 = " + _xs1)
+    println("xs1 eq _xs1: " + (xs1 eq _xs1) + ", _xs1 eq xs1: " + (_xs1 eq xs1))
+    println()
+
+    // Option
+    val o1 = None
+    val _o1: Option[Nothing] = read(write(o1))
+    println("o1 = " + o1)
+    println("_o1 = " + _o1)
+    println("o1 eq _o1: " + (o1 eq _o1) + ", _o1 eq o1: " + (_o1 eq o1))
+    println()
+
+    val o2 = Some(1)
+    val _o2: Option[Int] = read(write(o2))
+    println("o2 = " + o2)
+    println("_o2 = " + _o2)
+    println("o2 eq _o2: " + (o2 eq _o2) + ", _o2 eq o2: " + (_o2 eq o2))
+    println("o2 equals _o2: " + (o2 equals _o2) + ", _o2 equals o2: " + (_o2 equals o2))
+    println()
+/*
+    // Responder
+    val r1 = Responder.constant("xyz")
+    val _r1: Responder[String] = read(write(r1))
+    check(r1, _r1)
+*/
+    // Symbol
+    val s1 = 'hello
+    val _s1: Symbol = read(write(s1))
+    println("s1 = " + s1)
+    println("_s1 = " + _s1)
+    println("s1 eq _s1: " + (s1 eq _s1) + ", _s1 eq s1: " + (_s1 eq s1))
+    println("s1 equals _s1: " + (s1 equals _s1) + ", _s1 equals s1: " + (_s1 equals s1))
+    println()
+
+    // Tuple
+    val t1 = ("BannerLimit", 12345)
+    val _t1: (String, Int) = read(write(t1))
+    println("t1 = " + t1)
+    println("_t1 = " + _t1)
+    println("t1 eq _t1: " + (t1 eq _t1) + ", _t1 eq t1: " + (_t1 eq t1))
+    println("t1 equals _t1: " + (t1 equals _t1) + ", _t1 equals t1: " + (_t1 equals t1))
+    println()
+  }
+  catch {
+    case e: Exception =>
+      println("Error in Test1_scala: " + e)
+      throw e
+  }
+}
+
+//############################################################################
+// Test classes in package "scala.collection.immutable"
+
+object Test2_immutable {
+  import scala.collection.immutable.{
+    BitSet, HashMap, HashSet, ListMap, ListSet, Queue, Range, SortedMap,
+    SortedSet, Stack, Stream, TreeMap, TreeSet, Vector}
+
+  // in alphabetic order
+  try {
+    // BitSet
+    val bs1 = BitSet.empty + 1 + 2
+    val _bs1: BitSet = read(write(bs1))
+    check(bs1, _bs1)
+
+    val bs2 = {
+      val bs = new collection.mutable.BitSet()
+      bs += 2; bs += 3
+      bs.toImmutable
+    }
+    val _bs2: BitSet = read(write(bs2))
+    check(bs2, _bs2)
+
+    // HashMap
+    val hm1 = new HashMap[Int, String] + (1 -> "A", 2 -> "B", 3 -> "C")
+    val _hm1: HashMap[Int, String] = read(write(hm1))
+    check(hm1, _hm1)
+
+    // HashSet
+    val hs1 = new HashSet[Int] + 1 + 2
+    val _hs1: HashSet[Int] = read(write(hs1))
+    check(hs1, _hs1)
+
+    // List
+    val xs1 = List(("buffers", 20), ("layers", 2), ("title", 3))
+    val _xs1: List[(String, Int)] = read(write(xs1))
+    check(xs1, _xs1)
+
+    // ListMap
+    val lm1 = new ListMap[String, Int] + ("buffers" -> 20, "layers" -> 2, "title" -> 3)
+    val _lm1: ListMap[String, Int] = read(write(lm1))
+    check(lm1, _lm1)
+
+    // ListSet
+    val ls1 = new ListSet[Int] + 3 + 5
+    val _ls1: ListSet[Int] = read(write(ls1))
+    check(ls1, _ls1)
+
+    // Queue
+    val q1 = Queue("a", "b", "c")
+    val _q1: Queue[String] = read(write(q1))
+    check(q1, _q1)
+
+    // Range
+    val r1 = 0 until 10
+    val _r1: Range = read(write(r1))
+    check(r1, _r1)
+
+    val r2 = Range.Long(0L, 10L, 1)
+    val _r2: r2.type = read(write(r2))
+    check(r2, _r2)
+
+    // SortedMap
+    val sm1 = SortedMap.empty[Int, String] + (2 -> "B", 3 -> "C", 1 -> "A")
+    val _sm1: SortedMap[Int, String] = read(write(sm1))
+    check(sm1, _sm1)
+
+    // SortedSet
+    val ss1 = SortedSet.empty[Int] + 2 + 3 + 1
+    val _ss1: SortedSet[Int] = read(write(ss1))
+    check(ss1, _ss1)
+
+    // Stack
+    val s1 = new Stack().push("a", "b", "c")
+    val _s1: Stack[String] = read(write(s1))
+    check(s1, _s1)
+
+    // Stream
+    val st1 = Stream.range(0, 10)
+    val _st1: Stream[Int] = read(write(st1))
+    check(st1, _st1)
+
+    // TreeMap
+    val tm1 = new TreeMap[Int, String] + (42 -> "FortyTwo")
+    val _tm1: TreeMap[Int, String] = read(write(tm1))
+    check(tm1, _tm1)
+
+    // TreeSet
+    val ts1 = new TreeSet[Int]() + 2 + 0
+    val _ts1: TreeSet[Int] = read(write(ts1))
+    check(ts1, _ts1)
+
+    // Vector
+    val v1 = Vector('a, 'b, 'c)
+    val _v1: Vector[Symbol] = read(write(v1))
+    check(v1, _v1)
+  }
+  catch {
+    case e: Exception =>
+      println("Error in Test2_immutable: " + e)
+      throw e
+  }
+}
+
+//############################################################################
+// Test classes in package "scala.collection.mutable"
+
+object Test3_mutable {
+  import scala.reflect.ClassManifest
+  import scala.collection.mutable.{
+    ArrayBuffer, ArrayBuilder, ArraySeq, ArrayStack, BitSet, DoubleLinkedList,
+    HashMap, HashSet, History, LinkedList, ListBuffer, Publisher, Queue,
+    Stack, StringBuilder, WrappedArray, TreeSet}
+  import scala.collection.concurrent.TrieMap
+
+  // in alphabetic order
+  try {
+    // ArrayBuffer
+    val ab1 = new ArrayBuffer[String]
+    ab1 ++= List("one", "two")
+    val _ab1: ArrayBuffer[String] = read(write(ab1))
+    check(ab1, _ab1)
+    
+    // ArrayBuilder
+    val abu1 = ArrayBuilder.make[Long]
+    val _abu1: ArrayBuilder[ClassManifest[Long]] = read(write(abu1))
+    check(abu1, _abu1)
+
+    val abu2 = ArrayBuilder.make[Float]
+    val _abu2: ArrayBuilder[ClassManifest[Float]] = read(write(abu2))
+    check(abu2, _abu2)
+    
+    // ArraySeq
+    val aq1 = ArraySeq(1, 2, 3)
+    val _aq1: ArraySeq[Int] = read(write(aq1))
+    check(aq1, _aq1)
+    
+    // ArrayStack
+    val as1 = new ArrayStack[Int]
+    as1 ++= List(20, 2, 3).iterator
+    val _as1: ArrayStack[Int] = read(write(as1))
+    check(as1, _as1)
+
+    // BitSet
+    val bs1 = new BitSet()
+    bs1 += 0
+    bs1 += 8
+    bs1 += 9
+    val _bs1: BitSet = read(write(bs1))
+    check(bs1, _bs1)
+/*
+    // DoubleLinkedList
+    val dl1 = new DoubleLinkedList[Int](2, null)
+    dl1.append(new DoubleLinkedList(3, null))
+    val _dl1: DoubleLinkedList[Int] = read(write(dl1))
+    check(dl1, _dl1)
+*/
+    // HashMap
+    val hm1 = new HashMap[String, Int]
+    hm1 ++= List(("A", 1), ("B", 2), ("C", 3)).iterator
+    val _hm1: HashMap[String, Int] = read(write(hm1))
+    check(hm1, _hm1)
+
+    // HashSet
+    val hs1 = new HashSet[String]
+    hs1 ++= List("layers", "buffers", "title").iterator
+    val _hs1: HashSet[String] = read(write(hs1))
+    check(hs1, _hs1)
+
+    val h1 = new History[String, Int]
+    val _h1: History[String, Int] = read(write(h1))
+    check(h1, _h1)
+/*
+    // LinkedList
+    val ll1 = new LinkedList[Int](2, null)
+    ll1.append(new LinkedList(3, null))
+    val _ll1: LinkedList[Int] = read(write(ll1))
+    check(ll1, _ll1)
+*/
+    // ListBuffer
+    val lb1 = new ListBuffer[String]
+    lb1 ++= List("white", "black")
+    val _lb1: ListBuffer[String] = read(write(lb1))
+    check(lb1, _lb1)
+
+    // Queue
+    val q1 = new Queue[Int]
+    q1 ++= List(20, 2, 3).iterator
+    val _q1: Queue[Int] = read(write(q1))
+    check(q1, _q1)
+
+    // Stack
+    val s1 = new Stack[Int]
+    s1 pushAll q1
+    val _s1: Stack[Int] = read(write(s1))
+    check(s1, _s1)
+
+    // StringBuilder
+    val sb1 = new StringBuilder
+    sb1 append "abc"
+    val _sb1: StringBuilder = read(write(sb1))
+    check(sb1, _sb1)
+
+    // WrappedArray
+    val wa1 = WrappedArray.make(Array(1, 2, 3))
+    val _wa1: WrappedArray[Int] = read(write(wa1))
+    check(wa1, _wa1)
+    
+    // TreeSet
+    val ts1 = TreeSet[Int]() ++= Array(1, 2, 3)
+    val _ts1: TreeSet[Int] = read(write(ts1))
+    check(ts1, _ts1)
+    
+    // concurrent.TrieMap
+    val ct1 = TrieMap[Int, String]() ++= Array(1 -> "one", 2 -> "two", 3 -> "three")
+    val _ct1: TrieMap[Int, String] = read(write(ct1))
+    check(ct1, _ct1)
+  }
+  catch {
+    case e: Exception =>
+      println("Error in Test3_mutable: " + e)
+      throw e
+  }
+}
+
+
+//############################################################################
+// Test classes in package "scala.xml"
+
+object Test4_xml {
+  import scala.xml.{Attribute, Document, Elem, Null, PrefixedAttribute, Text}
+
+  case class Person(name: String, age: Int)
+
+  try {
+    // Attribute
+    val a1 = new PrefixedAttribute("xml", "src", Text("hello"), Null)
+    val _a1: Attribute = read(write(a1))
+    check(a1, _a1)
+
+    // Document
+    val d1 = new Document
+    d1.docElem = <title></title>
+    d1.encoding = Some("UTF-8")
+    val _d1: Document = read(write(d1))
+    check(d1, _d1)
+
+    // Elem
+    val e1 = <html><title>title</title><body></body></html>;
+    val _e1: Elem = read(write(e1))
+    check(e1, _e1)
+
+    class AddressBook(a: Person*) {
+      private val people: List[Person] = a.toList
+      def toXHTML =
+      <table cellpadding="2" cellspacing="0">
+        <tr>
+          <th>Last Name</th>
+          <th>First Name</th>
+        </tr>
+        { for (p <- people) yield
+        <tr>
+          <td> { p.name } </td>
+          <td> { p.age.toString() } </td>
+        </tr> }
+      </table>;
+    }
+
+    val people = new AddressBook(
+      Person("Tom", 20),
+      Person("Bob", 22),
+      Person("James", 19))
+
+    val e2 =
+      <html>
+      <body>
+        { people.toXHTML }
+      </body>
+      </html>;
+    val _e2: Elem = read(write(e2))
+    check(e2, _e2)
+  }
+  catch {
+    case e: Exception =>
+      println("Error in Test4_xml: " + e)
+      throw e
+  }
+}
+
+//############################################################################
+// Test user-defined classes WITHOUT nesting
+
+class Person(_name: String) extends Serializable {
+  private var name = _name
+  override def toString() = name
+  override def equals(that: Any): Boolean =
+    that.isInstanceOf[Person] &&
+    (name == that.asInstanceOf[Person].name)
+}
+
+class Employee(_name: String) extends Serializable {
+  private var name = _name
+  override def toString() = name
+}
+
+object bob extends Employee("Bob")
+
+object Test5 {
+  val x1 = new Person("Tim")
+  val x2 = bob
+
+  try {
+    val y1: Person   = read(write(x1))
+    val y2: Employee = read(write(x2))
+
+    check(x1, y1)
+    check(x2, y2)
+  }
+  catch {
+    case e: Exception =>
+      println("Error in Test5: " + e)
+  }
+}
+
+//############################################################################
+// Test user-defined classes WITH nesting
+
+object Test6 {
+  object bill extends Employee("Bill") {
+    val x = paul
+  }
+  object paul extends Person("Paul") {
+    val x = 4  //  bill; => StackOverflowException !!!
+  }
+  val x1 = new Person("John")
+  val x2 = bill
+  val x3 = paul
+
+  try {
+    val y1: Person   = read(write(x1))
+    val y2: Employee = read(write(x2))
+    val y3: Person   = read(write(x3))
+
+    check(x1, y1)
+    check(x2, y2)
+    check(x3, y3)
+  }
+  catch {
+    case e: Exception =>
+      println("Error in Test6: " + e)
+  }
+}
+
+//############################################################################
+// Nested objects cannot get readresolve automatically because after deserialization
+// they would be null (they are treated as lazy vals)
+class Outer extends Serializable {
+    object Inner extends Serializable
+}
+
+object Test7 {
+  val x = new Outer
+  x.Inner // initialize
+  val y:Outer = read(write(x))
+  if (y.Inner == null)
+    println("Inner object is null")
+}
+
+// Verify that transient lazy vals don't get serialized
+class WithTransient extends Serializable {
+  @transient lazy val a1 = 1
+  @transient private lazy val a2 = 2
+  @transient object B extends Serializable
+  @transient private object C extends Serializable
+    
+  def test = {
+    println(a1)
+    println(a2)
+    if (B == null || C == null)
+     println("Transient nested object failed to serialize properly")
+  }
+}
+
+object Test8 {
+    val x = new WithTransient
+    x.test
+  try {
+    val y:WithTransient = read(write(x))
+    y.test
+  }
+  catch {
+  case e: Exception =>
+    println("Error in Test8: " + e)
+  }
+}
+
+//############################################################################
+// Test code
+
+object Test {
+  def main(args: Array[String]) {
+    Test1_scala
+    Test2_immutable
+    Test3_mutable
+    Test4_xml
+    Test5
+    Test6
+    Test7
+    Test8
+    Test9_parallel
+  }
+}
+
+//############################################################################
+
+
+//############################################################################
+// Test classes in package "scala.collection.parallel" and subpackages
+object Test9_parallel {
+  import scala.collection.parallel._
+  
+  try {
+    println()
+    
+    // UnrolledBuffer
+    val ub = new collection.mutable.UnrolledBuffer[String]
+    ub ++= List("one", "two")
+    val _ub: collection.mutable.UnrolledBuffer[String] = read(write(ub))
+    check(ub, _ub)
+    
+    // mutable.ParArray
+    val pa = mutable.ParArray("abc", "def", "etc")
+    val _pa: mutable.ParArray[String] = read(write(pa))
+    check(pa, _pa)
+    
+    // mutable.ParHashMap
+    val mpm = mutable.ParHashMap(1 -> 2, 2 -> 4)
+    val _mpm: mutable.ParHashMap[Int, Int] = read(write(mpm))
+    check(mpm, _mpm)
+    
+    // mutable.ParTrieMap
+    val mpc = mutable.ParTrieMap(1 -> 2, 2 -> 4)
+    val _mpc: mutable.ParTrieMap[Int, Int] = read(write(mpc))
+    check(mpc, _mpc)
+    
+    // mutable.ParHashSet
+    val mps = mutable.ParHashSet(1, 2, 3)
+    val _mps: mutable.ParHashSet[Int] = read(write(mps))
+    check(mps, _mps)
+    
+    // immutable.ParRange
+    val pr1 = immutable.ParRange(0, 4, 1, true)
+    val _pr1: immutable.ParRange = read(write(pr1))
+    check(pr1, _pr1)
+    
+    val pr2 = immutable.ParRange(0, 4, 1, false)
+    val _pr2: immutable.ParRange = read(write(pr2))
+    check(pr2, _pr2)
+    
+    // immutable.ParHashMap
+    val ipm = immutable.ParHashMap(5 -> 1, 10 -> 2)
+    val _ipm: immutable.ParHashMap[Int, Int] = read(write(ipm))
+    check(ipm, _ipm)
+    
+    // immutable.ParHashSet
+    val ips = immutable.ParHashSet("one", "two")
+    val _ips: immutable.ParHashSet[String] = read(write(ips))
+    check(ips, _ips)
+    
+  } catch {
+    case e: Exception =>
+      println("Error in Test5_parallel: " + e)
+      throw e
+  }
+}
diff --git a/test/files/neg/t3507-old.check b/test/files/neg/t3507-old.check
new file mode 100644
index 0000000000..5c58444cb3
--- /dev/null
+++ b/test/files/neg/t3507-old.check
@@ -0,0 +1,4 @@
+t3507-old.scala:13: error: No Manifest available for _1.b.c.type.

+  mani/*[object _1.b.c]*/(c) // kaboom in manifestOfType / TreeGen.mkAttributedQualifier

+                         ^

+one error found

diff --git a/test/files/neg/t3507-old.scala b/test/files/neg/t3507-old.scala
new file mode 100644
index 0000000000..32688d3934
--- /dev/null
+++ b/test/files/neg/t3507-old.scala
@@ -0,0 +1,15 @@
+class A {
+  object b {
+    object c
+  }
+  def m = b.c
+}
+
+object Test {
+  var a: A = new A // mutable
+  val c /*: object _1.b.c forSome { val _1: A } */ = a.m // widening using existential
+  
+  def mani[T: Manifest](x: T) = ()
+  mani/*[object _1.b.c]*/(c) // kaboom in manifestOfType / TreeGen.mkAttributedQualifier
+  // --> _1 is not in scope here
+}
\ No newline at end of file
diff --git a/test/files/neg/t3692-old.check b/test/files/neg/t3692-old.check
new file mode 100644
index 0000000000..9da7033239
--- /dev/null
+++ b/test/files/neg/t3692-old.check
@@ -0,0 +1,8 @@
+t3692-old.scala:6: warning: object Manifest in package reflect is deprecated: Use `@scala.reflect.ConcreteTypeTag` instead

+    new ManifestTester().toJavaMap(map)

+                                  ^

+t3692-old.scala:15: error: unreachable code

+      case m2: Map[T, Int] => new java.util.HashMap[T, Integer]

+                              ^

+one warning found

+one error found

diff --git a/test/files/neg/t3692-old.flags b/test/files/neg/t3692-old.flags
new file mode 100644
index 0000000000..82becdfbfd
--- /dev/null
+++ b/test/files/neg/t3692-old.flags
@@ -0,0 +1 @@
+ -Xoldpatmat
\ No newline at end of file
diff --git a/test/files/neg/t3692-old.scala b/test/files/neg/t3692-old.scala
new file mode 100644
index 0000000000..151535ae94
--- /dev/null
+++ b/test/files/neg/t3692-old.scala
@@ -0,0 +1,19 @@
+import java.lang.Integer
+
+object ManifestTester {
+  def main(args: Array[String]) = {
+    val map = Map("John" -> 1, "Josh" -> 2)
+    new ManifestTester().toJavaMap(map)
+  }
+}
+
+class ManifestTester {
+  private final def toJavaMap[T, V](map: Map[T, V])(implicit m1: Manifest[T], m2: Manifest[V]): java.util.Map[_, _] = {
+    map match {
+      case m0: Map[Int, Int] => new java.util.HashMap[Integer, Integer]
+      case m1: Map[Int, V] => new java.util.HashMap[Integer, V]
+      case m2: Map[T, Int] => new java.util.HashMap[T, Integer]
+      case _ => new java.util.HashMap[T, V]
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/files/neg/t5452-old.check b/test/files/neg/t5452-old.check
new file mode 100644
index 0000000000..e5872a5759
--- /dev/null
+++ b/test/files/neg/t5452-old.check
@@ -0,0 +1,8 @@
+t5452-old.scala:28: error: overloaded method value apply with alternatives:

+  ()Queryable[CoffeesTable] <and>

+  (t: Tree)(implicit evidence$2: Manifest[CoffeesTable])Nothing <and>

+  (implicit evidence$1: Manifest[CoffeesTable])Nothing

+ cannot be applied to (Queryable[CoffeesTable])

+  Queryable[CoffeesTable](  q.treeFilter(null)  )

+           ^

+one error found

diff --git a/test/files/neg/t5452-old.scala b/test/files/neg/t5452-old.scala
new file mode 100644
index 0000000000..1032db7a4b
--- /dev/null
+++ b/test/files/neg/t5452-old.scala
@@ -0,0 +1,29 @@
+// /scala/trac/5452/a.scala
+// Mon Feb 13 22:52:36 PST 2012
+
+// import scala.reflect.mirror._
+
+trait Tree
+
+object Bip {
+  def ??? = sys.error("")
+}
+import Bip._
+
+case class Queryable[T]() {
+  def treeFilter( t:Tree ) : Queryable[T] = ???
+}
+
+object Queryable {
+  def apply[T:Manifest] = ???
+  def apply[T:Manifest]( t:Tree ) = ???
+}
+
+trait CoffeesTable{
+  def sales : Int
+}
+
+object Test extends App{
+  val q = new Queryable[CoffeesTable]
+  Queryable[CoffeesTable](  q.treeFilter(null)  )
+}
diff --git a/test/files/pos/contextbounds-implicits-old.scala b/test/files/pos/contextbounds-implicits-old.scala
new file mode 100644
index 0000000000..f9113ee320
--- /dev/null
+++ b/test/files/pos/contextbounds-implicits-old.scala
@@ -0,0 +1,8 @@
+/* Tests implicit parameters in the presence of context bounds.
+ * See Section 7.4 of the Scala Language Specification.
+ */
+class C {
+
+  def f[T: Manifest, S: Manifest](x: T, y: S)(implicit p: C) { }
+
+}
diff --git a/test/files/pos/implicits-old.scala b/test/files/pos/implicits-old.scala
new file mode 100644
index 0000000000..2c01dd0ba8
--- /dev/null
+++ b/test/files/pos/implicits-old.scala
@@ -0,0 +1,89 @@
+// #1435
+object t1435 {
+  implicit def a(s:String):String = error("")
+  implicit def a(i:Int):String = error("")
+  implicit def b(i:Int):String = error("")
+}
+
+class C1435 {
+  val v:String = {
+    import t1435.a
+    2
+  }
+}
+
+// #1492
+class C1492 {
+
+  class X
+
+  def foo(x: X => X) {}
+
+  foo ( implicit x => implicitly[X] )
+  foo { implicit x => implicitly[X] }
+}
+
+// #1579
+object Test1579 {
+  class Column
+  class Query[E](val value: E)
+  class Invoker(q: Any) { val foo = null }
+
+  implicit def unwrap[C](q: Query[C]) = q.value
+  implicit def invoker(q: Query[Column]) = new Invoker(q)
+
+  val q = new Query(new Column)
+  q.foo
+}
+// #1625
+object Test1625 {
+
+  class Wrapped(x:Any) {
+    def unwrap() = x
+  }
+
+  implicit def byName[A](x: =>A) = new Wrapped(x)
+
+  implicit def byVal[A](x: A) = x
+  
+  def main(args: Array[String]) = {
+
+//    val res:Wrapped = 7 // works
+
+    val res = 7.unwrap() // doesn't work
+
+    println("=> result: " + res)
+  }
+}
+
+object Test2188 {
+  implicit def toJavaList[A: ClassManifest](t:collection.Seq[A]):java.util.List[A] = java.util.Arrays.asList(t.toArray:_*)   
+
+  val x: java.util.List[String] = List("foo")
+}
+
+object TestNumericWidening {
+  val y = 1
+  val x: java.lang.Long = y
+}
+
+// #2709 
+package foo2709 { 
+  class A 
+  class B 
+ 
+  package object bar { 
+    implicit def a2b(a: A): B = new B 
+  } 
+ 
+  package bar { 
+    object test { 
+      new A: B 
+    } 
+  } 
+} 
+
+// Problem with specs
+object specsProblem {
+  println(implicitly[Manifest[Class[_]]])
+}
diff --git a/test/files/pos/manifest1-old.scala b/test/files/pos/manifest1-old.scala
new file mode 100644
index 0000000000..8901aa7437
--- /dev/null
+++ b/test/files/pos/manifest1-old.scala
@@ -0,0 +1,21 @@
+import scala.reflect.Manifest
+
+object Test {
+  def foo[T](x: T)(implicit m: Manifest[T]) {
+    foo(List(x))
+  }
+  foo(1)
+  foo("abc")
+  foo(List(1, 2, 3))
+  val x: List[Int] with Ordered[List[Int]] = null
+  foo(x)
+  foo[x.type](x)
+  abstract class C { type T = String; val x: T }
+  val c = new C { val x = "abc" }
+  foo(c.x)
+  abstract class D { type T; implicit val m: Manifest[T]; val x: T }
+  val stringm = implicitly[Manifest[String]]
+  val d: D = new D { type T = String; val m = stringm; val x = "x" }
+  import d.m
+  foo(d.x)
+}
diff --git a/test/files/pos/nothing_manifest_disambig-old.scala b/test/files/pos/nothing_manifest_disambig-old.scala
new file mode 100644
index 0000000000..076742033f
--- /dev/null
+++ b/test/files/pos/nothing_manifest_disambig-old.scala
@@ -0,0 +1,10 @@
+object Test {
+  def mani[T: Manifest](xs: T) = xs
+  mani(List())
+ 
+  def listElMani[T: Manifest](xs: List[T]) = xs
+  listElMani(List())
+ 
+  def foo[A, C](m : C)(implicit ev: C <:< Traversable[A], mani: Manifest[A]): (C, A, Manifest[A]) = (m, m.head, mani)
+  foo(List(1,2,3)) 
+}
\ No newline at end of file
diff --git a/test/files/pos/spec-constr-old.scala b/test/files/pos/spec-constr-old.scala
new file mode 100644
index 0000000000..e908b65a41
--- /dev/null
+++ b/test/files/pos/spec-constr-old.scala
@@ -0,0 +1,7 @@
+class SparseArray2[@specialized(Int) T:ClassManifest](val maxSize: Int, initialLength:Int = 3) {
+  private var data = new Array[T](initialLength);
+  private var index = new Array[Int](initialLength);
+
+  // comment out to compile correctly
+  data.length + 3;
+}
diff --git a/test/files/pos/spec-doubledef-old.scala b/test/files/pos/spec-doubledef-old.scala
new file mode 100644
index 0000000000..86b0d857d3
--- /dev/null
+++ b/test/files/pos/spec-doubledef-old.scala
@@ -0,0 +1,28 @@
+object Test {
+  def fn[@specialized T, @specialized U](t : T => Int, u : U => Int) : T =
+    null.asInstanceOf[T]
+}
+
+trait A[@specialized(Int) T] {
+  var value: T
+  def getWith[@specialized(Int) Z](f: T => Z) = f(value)
+}
+
+class C extends A[Int] {
+  var value = 10
+  override def getWith[@specialized(Int) Z](f: Int => Z) = f(value)
+}
+
+abstract class B[T, @specialized(scala.Int) U : Manifest, @specialized(scala.Int) V <% Ordered[V]] {
+    val u: U
+    val v: V
+
+    def f(t: T, v2: V): Pair[U, V] = {
+        val m: Array[U] = null
+        if (m.isEmpty) {
+            Pair(u, v)
+        } else {
+            Pair(u, v2)
+        }
+    }
+}
diff --git a/test/files/pos/spec-fields-old.scala b/test/files/pos/spec-fields-old.scala
new file mode 100644
index 0000000000..26a8c4ffbd
--- /dev/null
+++ b/test/files/pos/spec-fields-old.scala
@@ -0,0 +1,10 @@
+abstract class Foo[@specialized T: ClassManifest, U <: Ordered[U]](x: T, size: Int) {
+  var y: T
+  var z: T = x
+
+  def initialSize = 16
+  val array = new Array[T](initialSize + size)
+
+  def getZ = z
+  def setZ(zz: T) = z = zz
+}
diff --git a/test/files/pos/spec-params-old.scala b/test/files/pos/spec-params-old.scala
new file mode 100644
index 0000000000..f522512846
--- /dev/null
+++ b/test/files/pos/spec-params-old.scala
@@ -0,0 +1,32 @@
+class Foo[@specialized A: ClassManifest] {
+
+  // conflicting in bounds, expect a normalized member calling m
+  // and bridge + implementation in specialized subclasses
+  // and overloads here according to specialization on A
+  def m1[@specialized B <: A](x: B, y: A) =
+    goal(x)
+
+  // conflicting, unsolvable, expect a warning
+  def m2[@specialized B <: String](x: B) = x.concat("a")
+
+  // conflicting in bounds, no mention of other spec members
+  // expect an overload here plus implementation in 
+  // compatible specialized subclasses
+  def m3[@specialized B >: A](x: B) = ()
+
+  // non-conflicting, expect a normalized overload implementation here
+  def m4[@specialized T, U <: Ordered[T]](x: T, y: U) = ()
+
+  // non-conflicting, expect a normalized overload implementation here
+  def m5[@specialized B](x: B) = x
+  
+  // non-conflicting, expect a normalized implementation here
+  // and specialized implementations for all expansions in specialized subclasses
+  def m6[@specialized B](x: B, y: A) = 
+    goal(y)
+
+  def goal(x: A) = {
+    val xs = new Array[A](1)
+    xs(0) = x
+  }
+}
diff --git a/test/files/pos/spec-sparsearray-old.scala b/test/files/pos/spec-sparsearray-old.scala
new file mode 100644
index 0000000000..ea7710a785
--- /dev/null
+++ b/test/files/pos/spec-sparsearray-old.scala
@@ -0,0 +1,24 @@
+import scala.collection.mutable.MapLike
+
+class SparseArray[@specialized(Int) T:ClassManifest] extends collection.mutable.Map[Int,T] with collection.mutable.MapLike[Int,T,SparseArray[T]] {
+  override def get(x: Int) = {
+    val ind = findOffset(x)
+    if(ind < 0) None else Some(error("ignore"))
+  }
+
+  /**
+   * Returns the offset into index and data for the requested vector
+   * index.  If the requested index is not found, the return value is
+   * negative and can be converted into an insertion point with -(rv+1).
+   */
+  private def findOffset(i : Int) : Int = {
+    error("impl doesn't matter")
+  }
+
+  override def apply(i : Int) : T = { error("ignore") }
+  override def update(i : Int, value : T) = error("ignore")
+  override def empty = new SparseArray[T]
+  def -=(ind: Int) = error("ignore")
+  def +=(kv: (Int,T)) = error("ignore")
+  override final def iterator = error("ignore")
+}
diff --git a/test/files/pos/t1381-old.scala b/test/files/pos/t1381-old.scala
new file mode 100644
index 0000000000..0762891898
--- /dev/null
+++ b/test/files/pos/t1381-old.scala
@@ -0,0 +1,31 @@
+import scala.reflect.Manifest
+
+class D[V <: Variable]
+
+class ID[V<:IV] extends D[V] {
+  type E = V#ValueType
+  def index(value:E) : Int = 0
+  // Comment this out to eliminate crash.  Or see below
+  def index(values:E*) : Iterable[Int] = null
+}
+
+abstract class Variable {
+  type VT <: Variable
+  def d : D[VT] = null
+}
+
+abstract class PV[T](initval:T) extends Variable  {
+  type VT <: PV[T]
+  type ValueType = T
+}
+
+trait IV extends Variable  {
+  type ValueType
+}
+
+abstract class EV[T](initval:T) extends PV[T](initval) with IV {
+  type VT <: EV[T]
+  override def d : ID[VT] = null
+  // Comment this out to eliminate crash
+  protected var indx = d.index(initval)
+}
diff --git a/test/files/pos/t2795-old.scala b/test/files/pos/t2795-old.scala
new file mode 100644
index 0000000000..935cb1f444
--- /dev/null
+++ b/test/files/pos/t2795-old.scala
@@ -0,0 +1,17 @@
+package t1
+
+trait Element[T] {
+}
+
+trait Config {
+  type T <: Element[T]
+  implicit val m: ClassManifest[T]
+  // XXX Following works fine:
+  // type T <: Element[_]
+}
+
+trait Transform { self: Config =>
+  def processBlock(block: Array[T]): Unit = {
+    var X = new Array[T](1)
+  }
+}
diff --git a/test/files/pos/t3363-old.scala b/test/files/pos/t3363-old.scala
new file mode 100644
index 0000000000..bae54084ea
--- /dev/null
+++ b/test/files/pos/t3363-old.scala
@@ -0,0 +1,18 @@
+object TestCase {
+
+        //now matter if you put (abstract) class or trait it will fail in all cases
+        trait MapOps[T]
+
+        //if fs was reduced to List (generic type with one parameter) then the code compiles
+        //if you inherit from MapOps[T] instead of MapOps[F] then code compiles fine
+        implicit def map2ops[T,F](fs: Map[T,F]) = new MapOps[F] {
+          //if you remove this line, then code compiles
+	    lazy val m: Manifest[T] = error("just something to make it compile")
+	    def is(xs: List[T]) = List(xs)
+	  }
+
+	  def main(args: Array[String]) {
+	    println(Map(1 -> "2") is List(2))
+	  }
+
+	}
diff --git a/test/files/pos/t3498-old.scala b/test/files/pos/t3498-old.scala
new file mode 100644
index 0000000000..bcc90ca64c
--- /dev/null
+++ b/test/files/pos/t3498-old.scala
@@ -0,0 +1,15 @@
+abstract class A[T, @specialized(scala.Int) U : Manifest] {
+    def f(state: T): Array[U]
+}
+
+abstract class B extends A[ Array[Byte], Int ] {
+    type T = Array[Byte]
+    type U = Int
+
+    val N = 0
+
+    def f(state: T): Array[U] =
+    {
+        new Array[U](N + state(N))
+    }
+}
\ No newline at end of file
diff --git a/test/files/run/arrayclone-old.scala b/test/files/run/arrayclone-old.scala
new file mode 100644
index 0000000000..c9f7556b47
--- /dev/null
+++ b/test/files/run/arrayclone-old.scala
@@ -0,0 +1,106 @@
+object Test extends App{
+  BooleanArrayClone;
+  ByteArrayClone;
+  ShortArrayClone;
+  CharArrayClone;
+  IntArrayClone;
+  LongArrayClone;
+  FloatArrayClone;
+  DoubleArrayClone;
+  ObjectArrayClone;
+  PolymorphicArrayClone;
+}
+
+object BooleanArrayClone{
+  val it : Array[Boolean] = Array(true, false);
+  val cloned = it.clone();
+  assert(cloned.sameElements(it));
+  cloned(0) = false;
+  assert(it(0) == true) 
+}
+
+object ByteArrayClone{
+  val it : Array[Byte] = Array(1, 0);
+  val cloned = it.clone();
+  assert(cloned.sameElements(it));
+  cloned(0) = 0;
+  assert(it(0) == 1) 
+}
+
+object ShortArrayClone{
+  val it : Array[Short] = Array(1, 0);
+  val cloned = it.clone();
+  assert(cloned.sameElements(it));
+  cloned(0) = 0;
+  assert(it(0) == 1) 
+}
+
+object CharArrayClone{
+  val it : Array[Char] = Array(1, 0);
+  val cloned = it.clone();
+  assert(cloned.sameElements(it));
+  cloned(0) = 0;
+  assert(it(0) == 1) 
+}
+
+object IntArrayClone{
+  val it : Array[Int] = Array(1, 0);
+  val cloned = it.clone();
+  assert(cloned.sameElements(it));
+  cloned(0) = 0;
+  assert(it(0) == 1) 
+}
+
+object LongArrayClone{
+  val it : Array[Long] = Array(1, 0);
+  val cloned = it.clone();
+  assert(cloned.sameElements(it));
+  cloned(0) = 0;
+  assert(it(0) == 1) 
+}
+
+object FloatArrayClone{
+  val it : Array[Float] = Array(1, 0);
+  val cloned = it.clone();
+  assert(cloned.sameElements(it));
+  cloned(0) = 0;
+  assert(it(0) == 1) 
+}
+
+object DoubleArrayClone{
+  val it : Array[Double] = Array(1, 0);
+  val cloned = it.clone();
+  assert(cloned.sameElements(it));
+  cloned(0) = 0;
+  assert(it(0) == 1) 
+}
+
+object ObjectArrayClone{
+  val it : Array[String] = Array("1", "0");
+  val cloned = it.clone();
+  assert(cloned.sameElements(it));
+  cloned(0) = "0";
+  assert(it(0) == "1") 
+}
+
+object PolymorphicArrayClone{
+  def testIt[T](it : Array[T], one : T, zero : T) = {
+    val cloned = it.clone();
+    assert(cloned.sameElements(it));
+    cloned(0) = zero;
+    assert(it(0) == one) 
+  }  
+
+  testIt(Array("one", "two"), "one", "two");
+
+  class Mangler[T: Manifest](ts : T*){
+    // this will always be a BoxedAnyArray even after we've unboxed its contents.
+    val it = ts.toArray[T]; 
+  }
+
+  val mangled = new Mangler[Int](0, 1);
+
+  val y : Array[Int] = mangled.it; // make sure it's unboxed
+
+  testIt(mangled.it, 0, 1);
+}
diff --git a/test/files/run/ctries-old/DumbHash.scala b/test/files/run/ctries-old/DumbHash.scala
new file mode 100644
index 0000000000..8ef325b67c
--- /dev/null
+++ b/test/files/run/ctries-old/DumbHash.scala
@@ -0,0 +1,14 @@
+
+
+
+
+
+
+class DumbHash(val i: Int) {
+  override def equals(other: Any) = other match {
+    case that: DumbHash => that.i == this.i
+    case _ => false
+  }
+  override def hashCode = i % 5
+  override def toString = "DH(%s)".format(i)
+}
diff --git a/test/files/run/ctries-old/Wrap.scala b/test/files/run/ctries-old/Wrap.scala
new file mode 100644
index 0000000000..7b645c1612
--- /dev/null
+++ b/test/files/run/ctries-old/Wrap.scala
@@ -0,0 +1,9 @@
+
+
+
+
+
+
+case class Wrap(i: Int) {
+  override def hashCode = i * 0x9e3775cd
+}
diff --git a/test/files/run/ctries-old/concmap.scala b/test/files/run/ctries-old/concmap.scala
new file mode 100644
index 0000000000..3ec0256afb
--- /dev/null
+++ b/test/files/run/ctries-old/concmap.scala
@@ -0,0 +1,188 @@
+
+
+
+import collection.concurrent.TrieMap
+
+
+object ConcurrentMapSpec extends Spec {
+  
+  val initsz = 500
+  val secondsz = 750
+  
+  def test() {
+    "support put" in {
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until initsz) assert(ct.put(new Wrap(i), i) == None)
+      for (i <- 0 until initsz) assert(ct.put(new Wrap(i), -i) == Some(i))
+    }
+    
+    "support put if absent" in {
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until initsz) ct.update(new Wrap(i), i)
+      for (i <- 0 until initsz) assert(ct.putIfAbsent(new Wrap(i), -i) == Some(i))
+      for (i <- 0 until initsz) assert(ct.putIfAbsent(new Wrap(i), -i) == Some(i))
+      for (i <- initsz until secondsz) assert(ct.putIfAbsent(new Wrap(i), -i) == None)
+      for (i <- initsz until secondsz) assert(ct.putIfAbsent(new Wrap(i), i) == Some(-i))
+    }
+    
+    "support remove if mapped to a specific value" in {
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until initsz) ct.update(new Wrap(i), i)
+      for (i <- 0 until initsz) assert(ct.remove(new Wrap(i), -i - 1) == false)
+      for (i <- 0 until initsz) assert(ct.remove(new Wrap(i), i) == true)
+      for (i <- 0 until initsz) assert(ct.remove(new Wrap(i), i) == false)
+    }
+    
+    "support replace if mapped to a specific value" in {
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until initsz) ct.update(new Wrap(i), i)
+      for (i <- 0 until initsz) assert(ct.replace(new Wrap(i), -i - 1, -i - 2) == false)
+      for (i <- 0 until initsz) assert(ct.replace(new Wrap(i), i, -i - 2) == true)
+      for (i <- 0 until initsz) assert(ct.replace(new Wrap(i), i, -i - 2) == false)
+      for (i <- initsz until secondsz) assert(ct.replace(new Wrap(i), i, 0) == false)
+    }
+    
+    "support replace if present" in {
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until initsz) ct.update(new Wrap(i), i)
+      for (i <- 0 until initsz) assert(ct.replace(new Wrap(i), -i) == Some(i))
+      for (i <- 0 until initsz) assert(ct.replace(new Wrap(i), i) == Some(-i))
+      for (i <- initsz until secondsz) assert(ct.replace(new Wrap(i), i) == None)
+    }
+    
+    def assertEqual(a: Any, b: Any) = {
+      if (a != b) println(a, b)
+      assert(a == b)
+    }
+    
+    "support replace if mapped to a specific value, using several threads" in {
+      val ct = new TrieMap[Wrap, Int]
+      val sz = 55000
+      for (i <- 0 until sz) ct.update(new Wrap(i), i)
+      
+      class Updater(index: Int, offs: Int) extends Thread {
+        override def run() {
+          var repeats = 0
+          for (i <- 0 until sz) {
+            val j = (offs + i) % sz
+            var k = Int.MaxValue
+            do {
+              if (k != Int.MaxValue) repeats += 1
+              k = ct.lookup(new Wrap(j))
+            } while (!ct.replace(new Wrap(j), k, -k))
+          }
+          //println("Thread %d repeats: %d".format(index, repeats))
+        }
+      }
+      
+      val threads = for (i <- 0 until 16) yield new Updater(i, sz / 32 * i)
+      threads.foreach(_.start())
+      threads.foreach(_.join())
+      
+      for (i <- 0 until sz) assertEqual(ct(new Wrap(i)), i)
+      
+      val threads2 = for (i <- 0 until 15) yield new Updater(i, sz / 32 * i)
+      threads2.foreach(_.start())
+      threads2.foreach(_.join())
+      
+      for (i <- 0 until sz) assertEqual(ct(new Wrap(i)), -i)
+    }
+    
+    "support put if absent, several threads" in {
+      val ct = new TrieMap[Wrap, Int]
+      val sz = 110000
+      
+      class Updater(offs: Int) extends Thread {
+        override def run() {
+          for (i <- 0 until sz) {
+            val j = (offs + i) % sz
+            ct.putIfAbsent(new Wrap(j), j)
+            assert(ct.lookup(new Wrap(j)) == j)
+          }
+        }
+      }
+      
+      val threads = for (i <- 0 until 16) yield new Updater(sz / 32 * i)
+      threads.foreach(_.start())
+      threads.foreach(_.join())
+      
+      for (i <- 0 until sz) assert(ct(new Wrap(i)) == i)
+    }
+    
+    "support remove if mapped to a specific value, several threads" in {
+      val ct = new TrieMap[Wrap, Int]
+      val sz = 55000
+      for (i <- 0 until sz) ct.update(new Wrap(i), i)
+      
+      class Remover(offs: Int) extends Thread {
+        override def run() {
+          for (i <- 0 until sz) {
+            val j = (offs + i) % sz
+            ct.remove(new Wrap(j), j)
+            assert(ct.get(new Wrap(j)) == None)
+          }
+        }
+      }
+      
+      val threads = for (i <- 0 until 16) yield new Remover(sz / 32 * i)
+      threads.foreach(_.start())
+      threads.foreach(_.join())
+      
+      for (i <- 0 until sz) assert(ct.get(new Wrap(i)) == None)
+    }
+    
+    "have all or none of the elements depending on the oddity" in {
+      val ct = new TrieMap[Wrap, Int]
+      val sz = 65000
+      for (i <- 0 until sz) ct(new Wrap(i)) = i
+      
+      class Modifier(index: Int, offs: Int) extends Thread {
+        override def run() {
+          for (j <- 0 until sz) {
+            val i = (offs + j) % sz
+            var success = false
+            do {
+              if (ct.contains(new Wrap(i))) {
+                success = ct.remove(new Wrap(i)) != None
+              } else {
+                success = ct.putIfAbsent(new Wrap(i), i) == None
+              }
+            } while (!success)
+          }
+        }
+      }
+      
+      def modify(n: Int) = {
+        val threads = for (i <- 0 until n) yield new Modifier(i, sz / n * i)
+        threads.foreach(_.start())
+        threads.foreach(_.join())
+      }
+      
+      modify(16)
+      for (i <- 0 until sz) assertEqual(ct.get(new Wrap(i)), Some(i))
+      modify(15)
+      for (i <- 0 until sz) assertEqual(ct.get(new Wrap(i)), None)
+    }
+    
+    "compute size correctly" in {
+      val ct = new TrieMap[Wrap, Int]
+      val sz = 36450
+      for (i <- 0 until sz) ct(new Wrap(i)) = i
+      
+      assertEqual(ct.size, sz)
+      assertEqual(ct.size, sz)
+    }
+    
+    "compute size correctly in parallel" in {
+      val ct = new TrieMap[Wrap, Int]
+      val sz = 36450
+      for (i <- 0 until sz) ct(new Wrap(i)) = i
+      val pct = ct.par
+      
+      assertEqual(pct.size, sz)
+      assertEqual(pct.size, sz)
+    }
+    
+  }
+  
+}
diff --git a/test/files/run/ctries-old/iterator.scala b/test/files/run/ctries-old/iterator.scala
new file mode 100644
index 0000000000..b953a40e00
--- /dev/null
+++ b/test/files/run/ctries-old/iterator.scala
@@ -0,0 +1,289 @@
+
+
+
+
+import collection._
+import collection.concurrent.TrieMap
+
+
+
+object IteratorSpec extends Spec {
+  
+  def test() {
+    "work for an empty trie" in {
+      val ct = new TrieMap
+      val it = ct.iterator
+      
+      it.hasNext shouldEqual (false)
+      evaluating { it.next() }.shouldProduce [NoSuchElementException]
+    }
+    
+    def nonEmptyIteratorCheck(sz: Int) {
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until sz) ct.put(new Wrap(i), i)
+      
+      val it = ct.iterator
+      val tracker = mutable.Map[Wrap, Int]()
+      for (i <- 0 until sz) {
+        assert(it.hasNext == true)
+        tracker += it.next
+      }
+      
+      it.hasNext shouldEqual (false)
+      evaluating { it.next() }.shouldProduce [NoSuchElementException]
+      tracker.size shouldEqual (sz)
+      tracker shouldEqual (ct)
+    }
+    
+    "work for a 1 element trie" in {
+      nonEmptyIteratorCheck(1)
+    }
+    
+    "work for a 2 element trie" in {
+      nonEmptyIteratorCheck(2)
+    }
+    
+    "work for a 3 element trie" in {
+      nonEmptyIteratorCheck(3)
+    }
+    
+    "work for a 5 element trie" in {
+      nonEmptyIteratorCheck(5)
+    }
+    
+    "work for a 10 element trie" in {
+      nonEmptyIteratorCheck(10)
+    }
+    
+    "work for a 20 element trie" in {
+      nonEmptyIteratorCheck(20)
+    }
+    
+    "work for a 50 element trie" in {
+      nonEmptyIteratorCheck(50)
+    }
+     
+    "work for a 100 element trie" in {
+      nonEmptyIteratorCheck(100)
+    }
+    
+    "work for a 1k element trie" in {
+      nonEmptyIteratorCheck(1000)
+    }
+    
+    "work for a 5k element trie" in {
+      nonEmptyIteratorCheck(5000)
+    }
+    
+    "work for a 75k element trie" in {
+      nonEmptyIteratorCheck(75000)
+    }
+    
+    "work for a 250k element trie" in {
+      nonEmptyIteratorCheck(500000)
+    }
+    
+    def nonEmptyCollideCheck(sz: Int) {
+      val ct = new TrieMap[DumbHash, Int]
+      for (i <- 0 until sz) ct.put(new DumbHash(i), i)
+      
+      val it = ct.iterator
+      val tracker = mutable.Map[DumbHash, Int]()
+      for (i <- 0 until sz) {
+        assert(it.hasNext == true)
+        tracker += it.next
+      }
+      
+      it.hasNext shouldEqual (false)
+      evaluating { it.next() }.shouldProduce [NoSuchElementException]
+      tracker.size shouldEqual (sz)
+      tracker shouldEqual (ct)
+    }
+    
+    "work for colliding hashcodes, 2 element trie" in {
+      nonEmptyCollideCheck(2)
+    }
+    
+    "work for colliding hashcodes, 3 element trie" in {
+      nonEmptyCollideCheck(3)
+    }
+    
+    "work for colliding hashcodes, 5 element trie" in {
+      nonEmptyCollideCheck(5)
+    }
+    
+    "work for colliding hashcodes, 10 element trie" in {
+      nonEmptyCollideCheck(10)
+    }
+    
+    "work for colliding hashcodes, 100 element trie" in {
+      nonEmptyCollideCheck(100)
+    }
+    
+    "work for colliding hashcodes, 500 element trie" in {
+      nonEmptyCollideCheck(500)
+    }
+    
+    "work for colliding hashcodes, 5k element trie" in {
+      nonEmptyCollideCheck(5000)
+    }
+    
+    def assertEqual(a: Map[Wrap, Int], b: Map[Wrap, Int]) {
+      if (a != b) {
+        println(a.size + " vs " + b.size)
+        // println(a)
+        // println(b)
+        // println(a.toSeq.sortBy((x: (Wrap, Int)) => x._1.i))
+        // println(b.toSeq.sortBy((x: (Wrap, Int)) => x._1.i))
+      }
+      assert(a == b)
+    }
+    
+    "be consistent when taken with concurrent modifications" in {
+      val sz = 25000
+      val W = 15
+      val S = 5
+      val checks = 5
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until sz) ct.put(new Wrap(i), i)
+      
+      class Modifier extends Thread {
+        override def run() {
+          for (i <- 0 until sz) ct.putIfAbsent(new Wrap(i), i) match {
+            case Some(_) => ct.remove(new Wrap(i))
+            case None => 
+          }
+        }
+      }
+      
+      def consistentIteration(ct: TrieMap[Wrap, Int], checks: Int) {
+        class Iter extends Thread {
+          override def run() {
+            val snap = ct.readOnlySnapshot()
+            val initial = mutable.Map[Wrap, Int]()
+            for (kv <- snap) initial += kv
+            
+            for (i <- 0 until checks) {
+              assertEqual(snap.iterator.toMap, initial)
+            }
+          }
+        }
+        
+        val iter = new Iter
+        iter.start()
+        iter.join()
+      }
+      
+      val threads = for (_ <- 0 until W) yield new Modifier
+      threads.foreach(_.start())
+      for (_ <- 0 until S) consistentIteration(ct, checks)
+      threads.foreach(_.join())
+    }
+    
+    "be consistent with a concurrent removal with a well defined order" in {
+      val sz = 150000
+      val sgroupsize = 10
+      val sgroupnum = 5
+      val removerslowdown = 50
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until sz) ct.put(new Wrap(i), i)
+      
+      class Remover extends Thread {
+        override def run() {
+          for (i <- 0 until sz) {
+            assert(ct.remove(new Wrap(i)) == Some(i))
+            for (i <- 0 until removerslowdown) ct.get(new Wrap(i)) // slow down, mate
+          }
+          //println("done removing")
+        }
+      }
+      
+      def consistentIteration(it: Iterator[(Wrap, Int)]) = {
+        class Iter extends Thread {
+          override def run() {
+            val elems = it.toBuffer
+            if (elems.nonEmpty) {
+              val minelem = elems.minBy((x: (Wrap, Int)) => x._1.i)._1.i
+              assert(elems.forall(_._1.i >= minelem))
+            }
+          }
+        }
+        new Iter
+      }
+      
+      val remover = new Remover
+      remover.start()
+      for (_ <- 0 until sgroupnum) {
+        val iters = for (_ <- 0 until sgroupsize) yield consistentIteration(ct.iterator)
+        iters.foreach(_.start())
+        iters.foreach(_.join())
+      }
+      //println("done with iterators")
+      remover.join()
+    }
+    
+    "be consistent with a concurrent insertion with a well defined order" in {
+      val sz = 150000
+      val sgroupsize = 10
+      val sgroupnum = 10
+      val inserterslowdown = 50
+      val ct = new TrieMap[Wrap, Int]
+      
+      class Inserter extends Thread {
+        override def run() {
+          for (i <- 0 until sz) {
+            assert(ct.put(new Wrap(i), i) == None)
+            for (i <- 0 until inserterslowdown) ct.get(new Wrap(i)) // slow down, mate
+          }
+          //println("done inserting")
+        }
+      }
+      
+      def consistentIteration(it: Iterator[(Wrap, Int)]) = {
+        class Iter extends Thread {
+          override def run() {
+            val elems = it.toSeq
+            if (elems.nonEmpty) {
+              val maxelem = elems.maxBy((x: (Wrap, Int)) => x._1.i)._1.i
+              assert(elems.forall(_._1.i <= maxelem))
+            }
+          }
+        }
+        new Iter
+      }
+      
+      val inserter = new Inserter
+      inserter.start()
+      for (_ <- 0 until sgroupnum) {
+        val iters = for (_ <- 0 until sgroupsize) yield consistentIteration(ct.iterator)
+        iters.foreach(_.start())
+        iters.foreach(_.join())
+      }
+      //println("done with iterators")
+      inserter.join()
+    }
+    
+    "work on a yet unevaluated snapshot" in {
+      val sz = 50000
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until sz) ct.update(new Wrap(i), i)
+      
+      val snap = ct.snapshot()
+      val it = snap.iterator
+      
+      while (it.hasNext) it.next()
+    }
+    
+    "be duplicated" in {
+      val sz = 50
+      val ct = collection.parallel.mutable.ParTrieMap((0 until sz) zip (0 until sz): _*)
+      val it = ct.splitter
+      for (_ <- 0 until (sz / 2)) it.next()
+      val dupit = it.dup
+      
+      it.toList shouldEqual dupit.toList
+    }
+    
+  }
+  
+}
diff --git a/test/files/run/ctries-old/lnode.scala b/test/files/run/ctries-old/lnode.scala
new file mode 100644
index 0000000000..92a31088e5
--- /dev/null
+++ b/test/files/run/ctries-old/lnode.scala
@@ -0,0 +1,61 @@
+
+
+
+import collection.concurrent.TrieMap
+
+
+object LNodeSpec extends Spec {
+  
+  val initsz = 1500
+  val secondsz = 1750
+  
+  def test() {
+    "accept elements with the same hash codes" in {
+      val ct = new TrieMap[DumbHash, Int]
+      for (i <- 0 until initsz) ct.update(new DumbHash(i), i)
+    }
+    
+    "lookup elements with the same hash codes" in {
+      val ct = new TrieMap[DumbHash, Int]
+      for (i <- 0 until initsz) ct.update(new DumbHash(i), i)
+      for (i <- 0 until initsz) assert(ct.get(new DumbHash(i)) == Some(i))
+      for (i <- initsz until secondsz) assert(ct.get(new DumbHash(i)) == None)
+    }
+    
+    "remove elements with the same hash codes" in {
+      val ct = new TrieMap[DumbHash, Int]
+      for (i <- 0 until initsz) ct.update(new DumbHash(i), i)
+      for (i <- 0 until initsz) {
+        val remelem = ct.remove(new DumbHash(i))
+        assert(remelem == Some(i), "removing " + i + " yields " + remelem)
+      }
+      for (i <- 0 until initsz) assert(ct.get(new DumbHash(i)) == None)
+    }
+    
+    "put elements with the same hash codes if absent" in {
+      val ct = new TrieMap[DumbHash, Int]
+      for (i <- 0 until initsz) ct.put(new DumbHash(i), i)
+      for (i <- 0 until initsz) assert(ct.lookup(new DumbHash(i)) == i)
+      for (i <- 0 until initsz) assert(ct.putIfAbsent(new DumbHash(i), i) == Some(i))
+      for (i <- initsz until secondsz) assert(ct.putIfAbsent(new DumbHash(i), i) == None)
+      for (i <- initsz until secondsz) assert(ct.lookup(new DumbHash(i)) == i)
+    }
+    
+    "replace elements with the same hash codes" in {
+      val ct = new TrieMap[DumbHash, Int]
+      for (i <- 0 until initsz) assert(ct.put(new DumbHash(i), i) == None)
+      for (i <- 0 until initsz) assert(ct.lookup(new DumbHash(i)) == i)
+      for (i <- 0 until initsz) assert(ct.replace(new DumbHash(i), -i) == Some(i))
+      for (i <- 0 until initsz) assert(ct.lookup(new DumbHash(i)) == -i)
+      for (i <- 0 until initsz) assert(ct.replace(new DumbHash(i), -i, i) == true)
+    }
+    
+    "remove elements with the same hash codes if mapped to a specific value" in {
+      val ct = new TrieMap[DumbHash, Int]
+      for (i <- 0 until initsz) assert(ct.put(new DumbHash(i), i) == None)
+      for (i <- 0 until initsz) assert(ct.remove(new DumbHash(i), i) == true)
+    }
+    
+  }
+  
+}
diff --git a/test/files/run/ctries-old/main.scala b/test/files/run/ctries-old/main.scala
new file mode 100644
index 0000000000..8db7fcef54
--- /dev/null
+++ b/test/files/run/ctries-old/main.scala
@@ -0,0 +1,45 @@
+
+
+
+
+
+
+
+object Test {
+  
+  def main(args: Array[String]) {
+    ConcurrentMapSpec.test()
+    IteratorSpec.test()
+    LNodeSpec.test()
+    SnapshotSpec.test()
+  }
+  
+}
+
+
+trait Spec {
+  
+  implicit def str2ops(s: String) = new {
+    def in[U](body: =>U) {
+      // just execute body
+      body
+    }
+  }
+  
+  implicit def any2ops(a: Any) = new {
+    def shouldEqual(other: Any) = assert(a == other)
+  }
+  
+  def evaluating[U](body: =>U) = new {
+    def shouldProduce[T <: Throwable: ClassManifest]() = {
+      var produced = false
+      try body
+      catch {
+        case e => if (e.getClass == implicitly[ClassManifest[T]].erasure) produced = true
+      } finally {
+        assert(produced, "Did not produce exception of type: " + implicitly[ClassManifest[T]])
+      }
+    }
+  }
+  
+}
diff --git a/test/files/run/ctries-old/snapshot.scala b/test/files/run/ctries-old/snapshot.scala
new file mode 100644
index 0000000000..5fe77d445b
--- /dev/null
+++ b/test/files/run/ctries-old/snapshot.scala
@@ -0,0 +1,267 @@
+
+
+
+
+import collection._
+import collection.concurrent.TrieMap
+
+
+
+object SnapshotSpec extends Spec {
+  
+  def test() {
+    "support snapshots" in {
+      val ctn = new TrieMap
+      ctn.snapshot()
+      ctn.readOnlySnapshot()
+      
+      val ct = new TrieMap[Int, Int]
+      for (i <- 0 until 100) ct.put(i, i)
+      ct.snapshot()
+      ct.readOnlySnapshot()
+    }
+    
+    "empty 2 quiescent snapshots in isolation" in {
+      val sz = 4000
+      
+      class Worker(trie: TrieMap[Wrap, Int]) extends Thread {
+        override def run() {
+          for (i <- 0 until sz) {
+            assert(trie.remove(new Wrap(i)) == Some(i))
+            for (j <- 0 until sz)
+              if (j <= i) assert(trie.get(new Wrap(j)) == None)
+              else assert(trie.get(new Wrap(j)) == Some(j))
+          }
+        }
+      }
+      
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until sz) ct.put(new Wrap(i), i)
+      val snapt = ct.snapshot()
+      
+      val original = new Worker(ct)
+      val snapshot = new Worker(snapt)
+      original.start()
+      snapshot.start()
+      original.join()
+      snapshot.join()
+      
+      for (i <- 0 until sz) {
+        assert(ct.get(new Wrap(i)) == None)
+        assert(snapt.get(new Wrap(i)) == None)
+      }
+    }
+    
+    def consistentReadOnly(name: String, readonly: Map[Wrap, Int], sz: Int, N: Int) {
+      @volatile var e: Exception = null
+      
+      // reads possible entries once and stores them
+      // then reads all these N more times to check if the
+      // state stayed the same
+      class Reader(trie: Map[Wrap, Int]) extends Thread {
+        setName("Reader " + name)
+        
+        override def run() =
+          try check()
+          catch {
+            case ex: Exception => e = ex
+          }
+        
+        def check() {
+          val initial = mutable.Map[Wrap, Int]()
+          for (i <- 0 until sz) trie.get(new Wrap(i)) match {
+            case Some(i) => initial.put(new Wrap(i), i)
+            case None => // do nothing
+          }
+          
+          for (k <- 0 until N) {
+            for (i <- 0 until sz) {
+              val tres = trie.get(new Wrap(i))
+              val ires = initial.get(new Wrap(i))
+              if (tres != ires) println(i, "initially: " + ires, "traversal %d: %s".format(k, tres))
+              assert(tres == ires)
+            }
+          }
+        }
+      }
+      
+      val reader = new Reader(readonly)
+      reader.start()
+      reader.join()
+      
+      if (e ne null) {
+        e.printStackTrace()
+        throw e
+      }
+    }
+    
+    // traverses the trie `rep` times and modifies each entry
+    class Modifier(trie: TrieMap[Wrap, Int], index: Int, rep: Int, sz: Int) extends Thread {
+      setName("Modifier %d".format(index))
+      
+      override def run() {
+        for (k <- 0 until rep) {
+          for (i <- 0 until sz) trie.putIfAbsent(new Wrap(i), i) match {
+            case Some(_) => trie.remove(new Wrap(i))
+            case None => // do nothing
+          }
+        }
+      }
+    }
+    
+    // removes all the elements from the trie
+    class Remover(trie: TrieMap[Wrap, Int], index: Int, totremovers: Int, sz: Int) extends Thread {
+      setName("Remover %d".format(index))
+      
+      override def run() {
+        for (i <- 0 until sz) trie.remove(new Wrap((i + sz / totremovers * index) % sz))
+      }
+    }
+    
+    "have a consistent quiescent read-only snapshot" in {
+      val sz = 10000
+      val N = 100
+      val W = 10
+      
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until sz) ct(new Wrap(i)) = i
+      val readonly = ct.readOnlySnapshot()
+      val threads = for (i <- 0 until W) yield new Modifier(ct, i, N, sz)
+      
+      threads.foreach(_.start())
+      consistentReadOnly("qm", readonly, sz, N)
+      threads.foreach(_.join())
+    }
+    
+    // now, we check non-quiescent snapshots, as these permit situations
+    // where a thread is caught in the middle of the update when a snapshot is taken
+    
+    "have a consistent non-quiescent read-only snapshot, concurrent with removes only" in {
+      val sz = 1250
+      val W = 100
+      val S = 5000
+      
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until sz) ct(new Wrap(i)) = i
+      val threads = for (i <- 0 until W) yield new Remover(ct, i, W, sz)
+      
+      threads.foreach(_.start())
+      for (i <- 0 until S) consistentReadOnly("non-qr", ct.readOnlySnapshot(), sz, 5)
+      threads.foreach(_.join())
+    }
+    
+    "have a consistent non-quiescent read-only snapshot, concurrent with modifications" in {
+      val sz = 1000
+      val N = 7000
+      val W = 10
+      val S = 7000
+      
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until sz) ct(new Wrap(i)) = i
+      val threads = for (i <- 0 until W) yield new Modifier(ct, i, N, sz)
+      
+      threads.foreach(_.start())
+      for (i <- 0 until S) consistentReadOnly("non-qm", ct.readOnlySnapshot(), sz, 5)
+      threads.foreach(_.join())
+    }
+    
+    def consistentNonReadOnly(name: String, trie: TrieMap[Wrap, Int], sz: Int, N: Int) {
+      @volatile var e: Exception = null
+      
+      // reads possible entries once and stores them
+      // then reads all these N more times to check if the
+      // state stayed the same
+      class Worker extends Thread {
+        setName("Worker " + name)
+        
+        override def run() =
+          try check()
+          catch {
+            case ex: Exception => e = ex
+          }
+        
+        def check() {
+          val initial = mutable.Map[Wrap, Int]()
+          for (i <- 0 until sz) trie.get(new Wrap(i)) match {
+            case Some(i) => initial.put(new Wrap(i), i)
+            case None => // do nothing
+          }
+          
+          for (k <- 0 until N) {
+            // modify
+            for ((key, value) <- initial) {
+              val oldv = if (k % 2 == 0) value else -value
+              val newv = -oldv
+              trie.replace(key, oldv, newv)
+            }
+            
+            // check
+            for (i <- 0 until sz) if (initial.contains(new Wrap(i))) {
+              val expected = if (k % 2 == 0) -i else i
+              //println(trie.get(new Wrap(i)))
+              assert(trie.get(new Wrap(i)) == Some(expected))
+            } else {
+              assert(trie.get(new Wrap(i)) == None)
+            }
+          }
+        }
+      }
+      
+      val worker = new Worker
+      worker.start()
+      worker.join()
+      
+      if (e ne null) {
+        e.printStackTrace()
+        throw e
+      }
+    }
+    
+    "have a consistent non-quiescent snapshot, concurrent with modifications" in {
+      val sz = 9000
+      val N = 1000
+      val W = 10
+      val S = 400
+      
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until sz) ct(new Wrap(i)) = i
+      val threads = for (i <- 0 until W) yield new Modifier(ct, i, N, sz)
+      
+      threads.foreach(_.start())
+      for (i <- 0 until S) {
+        consistentReadOnly("non-qm", ct.snapshot(), sz, 5)
+        consistentNonReadOnly("non-qsnap", ct.snapshot(), sz, 5)
+      }
+      threads.foreach(_.join())
+    }
+    
+    "work when many concurrent snapshots are taken, concurrent with modifications" in {
+      val sz = 12000
+      val W = 10
+      val S = 10
+      val modifytimes = 1200
+      val snaptimes = 600
+      val ct = new TrieMap[Wrap, Int]
+      for (i <- 0 until sz) ct(new Wrap(i)) = i
+      
+      class Snapshooter extends Thread {
+        setName("Snapshooter")
+        override def run() {
+          for (k <- 0 until snaptimes) {
+            val snap = ct.snapshot()
+            for (i <- 0 until sz) snap.remove(new Wrap(i))
+            for (i <- 0 until sz) assert(!snap.contains(new Wrap(i)))
+          }
+        }
+      }
+      
+      val mods = for (i <- 0 until W) yield new Modifier(ct, i, modifytimes, sz)
+      val shooters = for (i <- 0 until S) yield new Snapshooter
+      val threads = mods ++ shooters
+      threads.foreach(_.start())
+      threads.foreach(_.join())
+    }
+    
+  }
+  
+}
diff --git a/test/files/run/existentials3-old.check b/test/files/run/existentials3-old.check
new file mode 100644
index 0000000000..e166e53ba8
--- /dev/null
+++ b/test/files/run/existentials3-old.check
@@ -0,0 +1,22 @@
+_ <: scala.runtime.AbstractFunction0[_ <: Object with Test$ToS with scala.Product with scala.Serializable] with scala.Serializable with java.lang.Object

+_ <: Object with Test$ToS with scala.Product with scala.Serializable

+Object with Test$ToS

+Object with Test$ToS

+Object with Test$ToS

+scala.Function0[Object with Test$ToS]

+scala.Function0[Object with Test$ToS]

+_ <: Object with _ <: Object with Object with Test$ToS

+_ <: Object with _ <: Object with _ <: Object with Test$ToS

+scala.collection.immutable.List[Object with scala.collection.Seq[Int]]

+scala.collection.immutable.List[Object with scala.collection.Seq[_ <: Int]]

+_ <: scala.runtime.AbstractFunction0[_ <: Object with Test$ToS with scala.Product with scala.Serializable] with scala.Serializable with java.lang.Object

+_ <: Object with Test$ToS with scala.Product with scala.Serializable

+Object with Test$ToS

+Object with Test$ToS

+Object with Test$ToS

+scala.Function0[Object with Test$ToS]

+scala.Function0[Object with Test$ToS]

+_ <: Object with _ <: Object with Object with Test$ToS

+_ <: Object with _ <: Object with _ <: Object with Test$ToS

+scala.collection.immutable.List[Object with scala.collection.Seq[Int]]

+scala.collection.immutable.List[Object with scala.collection.Seq[_ <: Int]]

diff --git a/test/files/run/existentials3-old.scala b/test/files/run/existentials3-old.scala
new file mode 100644
index 0000000000..944160ff12
--- /dev/null
+++ b/test/files/run/existentials3-old.scala
@@ -0,0 +1,73 @@
+object Test {
+  trait ToS { final override def toString = getClass.getName }
+
+  def f1 = { case class Bar() extends ToS; Bar }
+  def f2 = { case class Bar() extends ToS; Bar() }
+  def f3 = { class Bar() extends ToS; object Bar extends ToS; Bar }
+  def f4 = { class Bar() extends ToS; new Bar() }
+  def f5 = { object Bar extends ToS; Bar }
+  def f6 = { () => { object Bar extends ToS ; Bar } }
+  def f7 = { val f = { () => { object Bar extends ToS ; Bar } } ; f }
+
+  def f8 = { trait A ; trait B extends A ; class C extends B with ToS; new C { } }
+  def f9 = { trait A ; trait B ; class C extends B with A with ToS; new C { } }
+
+  def f10 = { class A { type T1 } ; List[A#T1]() }
+  def f11 = { abstract class A extends Seq[Int] ; List[A]() }
+  def f12 = { abstract class A extends Seq[U forSome { type U <: Int }] ; List[A]() }
+
+  val g1 = { case class Bar() extends ToS; Bar }
+  val g2 = { case class Bar() extends ToS; Bar() }
+  val g3 = { class Bar() extends ToS; object Bar extends ToS; Bar }
+  val g4 = { class Bar() extends ToS; new Bar() }
+  val g5 = { object Bar extends ToS; Bar }
+  val g6 = { () => { object Bar extends ToS ; Bar } }
+  val g7 = { val f = { () => { object Bar extends ToS ; Bar } } ; f }
+
+  val g8 = { trait A ; trait B extends A ; class C extends B with ToS; new C { } }
+  val g9 = { trait A ; trait B ; class C extends B with A with ToS; new C { } }
+
+  val g10 = { class A { type T1 } ; List[A#T1]() }
+  val g11 = { abstract class A extends Seq[Int] ; List[A]() }
+  val g12 = { abstract class A extends Seq[U forSome { type U <: Int }] ; List[A]() }
+
+  def m[T: Manifest](x: T) = println(manifest[T])
+
+  // manifests don't work for f10/g10
+  def main(args: Array[String]): Unit = {
+    m(f1)
+    m(f2)
+    m(f3)
+    m(f4)
+    m(f5)
+    m(f6)
+    m(f7)
+    m(f8)
+    m(f9)
+    // m(f10)
+    m(f11)
+    m(f12)
+    m(g1)
+    m(g2)
+    m(g3)
+    m(g4)
+    m(g5)
+    m(g6)
+    m(g7)
+    m(g8)
+    m(g9)
+    // m(g10)
+    m(g11)
+    m(g12)
+  }
+}
+
+object Misc {
+  trait Bippy { def bippy = "I'm Bippy!" }
+  object o1 {
+    def f1 = { trait A extends Seq[U forSome { type U <: Bippy }] ; abstract class B extends A ; trait C extends B ; (null: C) }
+    def f2 = f1.head.bippy
+  }
+  def g1 = o1.f1 _
+  def g2 = o1.f2 _
+}
diff --git a/test/files/run/getClassTest-old.check b/test/files/run/getClassTest-old.check
new file mode 100644
index 0000000000..94e86c3889
--- /dev/null
+++ b/test/files/run/getClassTest-old.check
@@ -0,0 +1,18 @@
+f1: java.lang.Class<?>
+f2: java.lang.Class<?>
+f3: java.lang.Class<java.lang.Object>
+f4: java.lang.Class<? extends java.lang.Integer>
+f5: java.lang.Class<?>
+f0: T
+f1: class java.lang.Object
+f2: class java.lang.Object
+f3: class AnyRefs$A
+f4: class AnyRefs$B
+f5: class java.lang.Object
+f6: class java.lang.Object
+f7: class AnyRefs$A
+f8: class AnyRefs$B
+f1: java.lang.Class<? extends MoreAnyRefs$A>
+f2: java.lang.Class<? extends MoreAnyRefs$B>
+f3: java.lang.Class<?>
+f4: java.lang.Class<? extends MoreAnyRefs$A>
diff --git a/test/files/run/getClassTest-old.scala b/test/files/run/getClassTest-old.scala
new file mode 100644
index 0000000000..951cc8d931
--- /dev/null
+++ b/test/files/run/getClassTest-old.scala
@@ -0,0 +1,66 @@
+class AnyVals {
+  def f1 = (5: Any).getClass
+  def f2 = (5: AnyVal).getClass
+  def f3 = 5.getClass
+  def f4 = (5: java.lang.Integer).getClass
+  def f5 = (5.asInstanceOf[AnyRef]).getClass
+
+  // scalap says:
+  //
+  // def f1 : java.lang.Class[?0] forSome {type ?0} = { /* compiled code */ }
+  // def f2 : java.lang.Class[?0] forSome {type ?0} = { /* compiled code */ }
+  // def f3 : java.lang.Class[scala.Int] = { /* compiled code */ }
+  // def f4 : java.lang.Class[?0] forSome {type ?0 <: java.lang.Integer} = { /* compiled code */ }
+  // def f5 : java.lang.Class[?0] forSome {type ?0 <: scala.AnyRef} = { /* compiled code */ }
+  //
+  // java generic signature says:
+  //
+  // f1: java.lang.Class<?>
+  // f2: java.lang.Class<?>
+  // f3: java.lang.Class<java.lang.Object>
+  // f4: java.lang.Class<? extends java.lang.Integer>
+  // f5: java.lang.Class<?>
+}
+
+class AnyRefs {
+  class A
+  class B extends A
+
+  def f1 = (new B: Any).getClass().newInstance()
+  def f2 = (new B: AnyRef).getClass().newInstance()
+  def f3 = (new B: A).getClass().newInstance()
+  def f4 = (new B: B).getClass().newInstance()
+
+  def f0[T >: B] = (new B: T).getClass().newInstance()
+
+  def f5 = f0[Any]
+  def f6 = f0[AnyRef]
+  def f7 = f0[A]
+  def f8 = f0[B]
+}
+
+class MoreAnyRefs {
+  trait A
+  trait B
+
+  // don't leak anon/refinements
+  def f1 = (new A with B { }).getClass()
+  def f2 = (new B with A { }).getClass()
+  def f3 = (new { def bippy() = 5 }).getClass()
+  def f4 = (new A { def bippy() = 5 }).getClass()
+}
+
+object Test {
+  def returnTypes[T: Manifest] = (
+    manifest[T].erasure.getMethods.toList
+      filter (_.getName startsWith "f")
+      sortBy (_.getName)
+      map (m => m.getName + ": " + m.getGenericReturnType.toString)
+  )
+
+  def main(args: Array[String]): Unit = {
+    returnTypes[AnyVals] foreach println
+    returnTypes[AnyRefs] foreach println
+    returnTypes[MoreAnyRefs] foreach println
+  }
+}
diff --git a/test/files/run/manifests-old.scala b/test/files/run/manifests-old.scala
new file mode 100644
index 0000000000..621689a254
--- /dev/null
+++ b/test/files/run/manifests-old.scala
@@ -0,0 +1,147 @@
+object Test
+{
+  object Variances extends Enumeration {
+    val CO, IN, CONTRA = Value
+  }
+  import Variances.{ CO, IN, CONTRA }
+
+  object SubtypeRelationship extends Enumeration {
+    val NONE, SAME, SUB, SUPER = Value
+  }
+  import SubtypeRelationship.{ NONE, SAME, SUB, SUPER }
+
+  class VarianceTester[T, U, CC[_]](expected: Variances.Value)(
+            implicit ev1: Manifest[T], ev2: Manifest[U], ev3: Manifest[CC[T]], ev4: Manifest[CC[U]]) {
+
+    def elements = List(ev1 <:< ev2, ev2 <:< ev1)
+    def containers = List(ev3 <:< ev4, ev4 <:< ev3)
+
+    def isUnrelated = typeCompare[T, U] == NONE
+    def isSame = typeCompare[T, U] == SAME
+    def isSub = typeCompare[T, U] == SUB
+    def isSuper = typeCompare[T, U] == SUPER
+
+    def showsCovariance = (elements == containers)
+    def showsContravariance = (elements == containers.reverse)
+    def showsInvariance = containers forall (_ == isSame)
+
+    def allContainerVariances = List(showsCovariance, showsInvariance, showsContravariance)
+
+    def showsExpectedVariance =
+      if (isUnrelated) allContainerVariances forall (_ == false)
+      else if (isSame) allContainerVariances forall (_ == true)
+      else expected match {
+        case CO     => showsCovariance && !showsContravariance && !showsInvariance
+        case IN     => showsInvariance && !showsCovariance && !showsContravariance
+        case CONTRA => showsContravariance && !showsCovariance && !showsInvariance
+      }
+  }
+
+  def showsCovariance[T, U, CC[_]](implicit ev1: Manifest[T], ev2: Manifest[U], ev3: Manifest[CC[T]], ev4: Manifest[CC[U]]) =
+    new VarianceTester[T, U, CC](CO) showsExpectedVariance
+
+  def showsInvariance[T, U, CC[_]](implicit ev1: Manifest[T], ev2: Manifest[U], ev3: Manifest[CC[T]], ev4: Manifest[CC[U]]) =
+    new VarianceTester[T, U, CC](IN) showsExpectedVariance
+
+  def showsContravariance[T, U, CC[_]](implicit ev1: Manifest[T], ev2: Manifest[U], ev3: Manifest[CC[T]], ev4: Manifest[CC[U]]) =
+    new VarianceTester[T, U, CC](CONTRA) showsExpectedVariance
+
+  def typeCompare[T, U](implicit ev1: Manifest[T], ev2: Manifest[U]) = (ev1 <:< ev2, ev2 <:< ev1) match {
+    case (true, true)   => SAME
+    case (true, false)  => SUB
+    case (false, true)  => SUPER
+    case (false, false) => NONE
+  }
+
+  def assertAnyRef[T: Manifest] = List(
+    manifest[T] <:< manifest[Any],
+    manifest[T] <:< manifest[AnyRef],
+    !(manifest[T] <:< manifest[AnyVal])
+  ) foreach (assert(_, "assertAnyRef"))
+
+  def assertAnyVal[T: Manifest] = List(
+    manifest[T] <:< manifest[Any],
+    !(manifest[T] <:< manifest[AnyRef]),
+    manifest[T] <:< manifest[AnyVal]
+  ) foreach (assert(_, "assertAnyVal"))
+
+  def assertSameType[T: Manifest, U: Manifest] = assert(typeCompare[T, U] == SAME, "assertSameType")
+  def assertSuperType[T: Manifest, U: Manifest] = assert(typeCompare[T, U] == SUPER, "assertSuperType")
+  def assertSubType[T: Manifest, U: Manifest] = assert(typeCompare[T, U] == SUB, "assertSubType")
+  def assertNoRelationship[T: Manifest, U: Manifest] = assert(typeCompare[T, U] == NONE, "assertNoRelationship")
+
+  def testVariancesVia[T: Manifest, U: Manifest] = assert(
+    typeCompare[T, U] == SUB &&
+    showsCovariance[T, U, List] &&
+    showsInvariance[T, U, Set],
+    "testVariancesVia"
+  )
+
+  def runAllTests = {
+    assertAnyVal[AnyVal]
+    assertAnyVal[Unit]
+    assertAnyVal[Int]
+    assertAnyVal[Double]
+    assertAnyVal[Boolean]
+    assertAnyVal[Char]
+
+    assertAnyRef[AnyRef]
+    assertAnyRef[java.lang.Object]
+    assertAnyRef[java.lang.Integer]
+    assertAnyRef[java.lang.Double]
+    assertAnyRef[java.lang.Boolean]
+    assertAnyRef[java.lang.Character]
+    assertAnyRef[String]
+    assertAnyRef[scala.List[String]]
+    assertAnyRef[scala.List[_]]
+
+    // variance doesn't work yet
+    // testVariancesVia[String, Any]
+    // testVariancesVia[String, AnyRef]
+
+    assertSubType[List[String], List[Any]]
+    assertSubType[List[String], List[AnyRef]]
+    assertNoRelationship[List[String], List[AnyVal]]
+
+    assertSubType[List[Int], List[Any]]
+    assertSubType[List[Int], List[AnyVal]]
+    assertNoRelationship[List[Int], List[AnyRef]]
+
+    // Nothing
+    assertSubType[Nothing, Any]
+    assertSubType[Nothing, AnyVal]
+    assertSubType[Nothing, AnyRef]
+    assertSubType[Nothing, String]
+    assertSubType[Nothing, List[String]]
+    assertSubType[Nothing, Null]
+    assertSameType[Nothing, Nothing]
+
+    // Null
+    assertSubType[Null, Any]
+    assertNoRelationship[Null, AnyVal]
+    assertSubType[Null, AnyRef]
+    assertSubType[Null, String]
+    assertSubType[Null, List[String]]
+    assertSameType[Null, Null]
+    assertSuperType[Null, Nothing]
+
+    // Any
+    assertSameType[Any, Any]
+    assertSuperType[Any, AnyVal]
+    assertSuperType[Any, AnyRef]
+    assertSuperType[Any, String]
+    assertSuperType[Any, List[String]]
+    assertSuperType[Any, Null]
+    assertSuperType[Any, Nothing]
+
+    // Misc unrelated types
+    assertNoRelationship[Unit, AnyRef]
+    assertNoRelationship[Unit, Int]
+    assertNoRelationship[Int, Long]
+    assertNoRelationship[Boolean, String]
+    assertNoRelationship[List[Boolean], List[String]]
+    assertNoRelationship[Set[Boolean], Set[String]]
+  }
+
+  def main(args: Array[String]): Unit = runAllTests
+}
\ No newline at end of file
diff --git a/test/files/run/patmat_unapp_abstype-old.check b/test/files/run/patmat_unapp_abstype-old.check
new file mode 100644
index 0000000000..72239d16cd
--- /dev/null
+++ b/test/files/run/patmat_unapp_abstype-old.check
@@ -0,0 +1,4 @@
+TypeRef
+none of the above
+Bar
+Foo
diff --git a/test/files/run/patmat_unapp_abstype-old.flags b/test/files/run/patmat_unapp_abstype-old.flags
new file mode 100644
index 0000000000..ba80cad69b
--- /dev/null
+++ b/test/files/run/patmat_unapp_abstype-old.flags
@@ -0,0 +1 @@
+-Xoldpatmat
diff --git a/test/files/run/patmat_unapp_abstype-old.scala b/test/files/run/patmat_unapp_abstype-old.scala
new file mode 100644
index 0000000000..45496f08a2
--- /dev/null
+++ b/test/files/run/patmat_unapp_abstype-old.scala
@@ -0,0 +1,83 @@
+// abstract types and extractors, oh my!
+trait TypesAPI {
+  trait Type
+
+  // an alternative fix (implemented in the virtual pattern matcher, is to replace the isInstanceOf by a manifest-based run-time test)
+  // that's what typeRefMani is for
+  type TypeRef <: Type //; implicit def typeRefMani: Manifest[TypeRef]
+  val TypeRef: TypeRefExtractor; trait TypeRefExtractor {
+    def apply(x: Int): TypeRef
+    def unapply(x: TypeRef): Option[(Int)]
+  }
+
+  // just for illustration, should follow the same pattern as TypeRef
+  case class MethodType(n: Int) extends Type
+}
+
+// user should not be exposed to the implementation
+trait TypesUser extends TypesAPI {
+  def shouldNotCrash(tp: Type): Unit = {
+    tp match {
+      case TypeRef(x) => println("TypeRef") 
+      // the above checks tp.isInstanceOf[TypeRef], which is erased to tp.isInstanceOf[Type]
+      //   before calling TypeRef.unapply(tp), which will then crash unless tp.isInstanceOf[TypesImpl#TypeRef] (which is not implied by tp.isInstanceOf[Type])
+      // tp.isInstanceOf[TypesImpl#TypeRef] is equivalent to classOf[TypesImpl#TypeRef].isAssignableFrom(tp.getClass)
+      // this is equivalent to manifest
+      // it is NOT equivalent to manifest[Type] <:< typeRefMani
+      case MethodType(x) => println("MethodType")
+      case _ => println("none of the above")
+    }
+  }
+}
+
+trait TypesImpl extends TypesAPI {
+  object TypeRef extends TypeRefExtractor  // this will have a bridged unapply(x: Type) = unapply(x.asInstanceOf[TypeRef])
+  case class TypeRef(n: Int) extends Type // this has a bridge from TypesAPI#Type to TypesImpl#TypeRef 
+  // --> the cast in the bridge will fail because the pattern matcher can't type test against the abstract types in TypesUser
+  //lazy val typeRefMani = manifest[TypeRef]
+}
+
+trait Foos {
+ trait Bar
+ type Foo <: Bar
+ trait FooExtractor {
+   def unapply(foo: Foo): Option[Int]
+ }
+ val Foo: FooExtractor
+}
+
+trait RealFoos extends Foos {
+ class Foo(val x: Int) extends Bar
+ object Foo extends FooExtractor {
+   def unapply(foo: Foo): Option[Int] = Some(foo.x)
+ }
+}
+
+trait Intermed extends Foos {
+ def crash(bar: Bar): Unit =
+   bar match {
+     case Foo(x) => println("Foo")
+     case _ => println("Bar")
+   }
+}
+
+object TestUnappStaticallyKnownSynthetic extends TypesImpl with TypesUser {
+  def test() = {
+    shouldNotCrash(TypeRef(10)) // should and does print "TypeRef"
+    // once  #1697/#2337 are fixed, this should generate the correct output
+    shouldNotCrash(MethodType(10)) // should print "MethodType" but prints "none of the above" -- good one, pattern matcher!
+  }
+}
+
+object TestUnappDynamicSynth extends RealFoos with Intermed {
+ case class FooToo(n: Int) extends Bar
+ def test() = {
+   crash(FooToo(10))
+   crash(new Foo(5))
+ }
+}
+
+object Test extends App {
+  TestUnappStaticallyKnownSynthetic.test()
+  TestUnappDynamicSynth.test()
+}
diff --git a/test/files/run/primitive-sigs-2-old.check b/test/files/run/primitive-sigs-2-old.check
new file mode 100644
index 0000000000..9132b4d8ae
--- /dev/null
+++ b/test/files/run/primitive-sigs-2-old.check
@@ -0,0 +1,7 @@
+T<java.lang.Object>

+List(A, char, class java.lang.Object)

+a

+public <T> java.lang.Object Arr.arr4(java.lang.Object[],scala.reflect.Manifest<T>)

+public float[] Arr.arr3(float[][])

+public scala.collection.immutable.List<java.lang.Character> Arr.arr2(java.lang.Character[])

+public scala.collection.immutable.List<java.lang.Object> Arr.arr1(int[])

diff --git a/test/files/run/primitive-sigs-2-old.scala b/test/files/run/primitive-sigs-2-old.scala
new file mode 100644
index 0000000000..b7152f7e3d
--- /dev/null
+++ b/test/files/run/primitive-sigs-2-old.scala
@@ -0,0 +1,39 @@
+import java.{ lang => jl }
+
+trait T[A] {
+  def f(): A
+}
+class C extends T[Char] {
+  def f(): Char = 'a'
+}
+class Arr {
+  def arr1(xs: Array[Int]): List[Int] = xs.toList
+  def arr2(xs: Array[jl.Character]): List[jl.Character] = xs.toList
+  def arr3(xss: Array[Array[Float]]): Array[Float] = xss map (_.sum)
+  // This gets a signature like
+  // public <T> java.lang.Object Arr.arr4(java.lang.Object[],scala.reflect.Manifest<T>)
+  //
+  // instead of the more appealing version from the past
+  // public <T> T[] Arr.arr4(T[][],scala.reflect.Manifest<T>)
+  //
+  // because java inflict's its reference-only generic-arrays on us.
+  //
+  def arr4[T: Manifest](xss: Array[Array[T]]): Array[T] = xss map (_.head)
+}
+
+object Test {
+  val c1: Class[_] = classOf[T[_]]
+  val c2: Class[_] = classOf[C]
+  val c3: Class[_] = classOf[Arr]
+  
+  val c1m = c1.getMethods.toList filter (_.getName == "f") map (_.getGenericReturnType.toString)
+  val c2m = c2.getMethods.toList filter (_.getName == "f") map (_.getGenericReturnType.toString)
+  val c3m = c3.getDeclaredMethods.toList map (_.toGenericString)
+
+  def main(args: Array[String]): Unit = {
+    println(c2.getGenericInterfaces.map(_.toString).sorted mkString " ")
+    println(c1m ++ c2m sorted)
+    println(new C f)
+    c3m.sorted foreach println
+  }
+}
diff --git a/test/files/run/reflection-implClass-old.scala b/test/files/run/reflection-implClass-old.scala
new file mode 100644
index 0000000000..6583624d8b
--- /dev/null
+++ b/test/files/run/reflection-implClass-old.scala
@@ -0,0 +1,38 @@
+/**
+ * Tries to load a symbol for the `Foo$class` using Scala reflection.
+ * Since trait implementation classes do not get pickling information
+ * symbol for them should be created using fallback mechanism
+ * that exposes Java reflection information dressed up in
+ * a Scala symbol.
+ */
+object Test extends App with Outer {
+  import scala.reflect.mirror
+
+  assert(mirror.classToSymbol(manifest[Foo].erasure).typeSignature.declaration(mirror.newTermName("bar")).typeSignature ==
+    mirror.classToSymbol(manifest[Bar].erasure).typeSignature.declaration(mirror.newTermName("foo")).typeSignature)
+
+  val s1 = implClass(manifest[Foo].erasure)
+  assert(s1 != mirror.NoSymbol)
+  assert(s1.typeSignature != mirror.NoType)
+  assert(s1.companionSymbol.typeSignature != mirror.NoType)
+  assert(s1.companionSymbol.typeSignature.declaration(mirror.newTermName("bar")) != mirror.NoSymbol)
+  val s2 = implClass(manifest[Bar].erasure)
+  assert(s2 != mirror.NoSymbol)
+  assert(s2.typeSignature != mirror.NoType)
+  assert(s2.companionSymbol.typeSignature != mirror.NoType)
+  assert(s2.companionSymbol.typeSignature.declaration(mirror.newTermName("foo")) != mirror.NoSymbol)
+  def implClass(clazz: Class[_]) = {
+    val implClass = Class.forName(clazz.getName + "$class")
+    mirror.classToSymbol(implClass)
+  }
+}
+
+trait Foo {
+  def bar = 1
+}
+
+trait Outer {
+  trait Bar {
+    def foo = 1
+  }
+}
diff --git a/test/files/run/reify_implicits-old.check b/test/files/run/reify_implicits-old.check
new file mode 100644
index 0000000000..e3aeb20f6b
--- /dev/null
+++ b/test/files/run/reify_implicits-old.check
@@ -0,0 +1 @@
+x = List(1, 2, 3, 4)
diff --git a/test/files/run/reify_implicits-old.scala b/test/files/run/reify_implicits-old.scala
new file mode 100644
index 0000000000..60971c3cfb
--- /dev/null
+++ b/test/files/run/reify_implicits-old.scala
@@ -0,0 +1,14 @@
+import scala.reflect.mirror._
+
+object Test extends App {
+  reify {
+    implicit def arrayWrapper[A : ClassManifest](x: Array[A]) =
+      new {
+        def sort(p: (A, A) => Boolean) = {
+          util.Sorting.stableSort(x, p); x
+        }
+      }
+    val x = Array(2, 3, 1, 4)
+    println("x = "+ x.sort((x: Int, y: Int) => x < y).toList)
+  }.eval
+}
diff --git a/test/files/run/t0421-old.check b/test/files/run/t0421-old.check
new file mode 100644
index 0000000000..cdcf042f19
--- /dev/null
+++ b/test/files/run/t0421-old.check
@@ -0,0 +1,3 @@
+[Array(0, 1),Array(2, 3),Array(4, 5)]
+[Array(31.0)]
+[Array(24.0, 32.0)]
diff --git a/test/files/run/t0421-old.scala b/test/files/run/t0421-old.scala
new file mode 100644
index 0000000000..8d51013924
--- /dev/null
+++ b/test/files/run/t0421-old.scala
@@ -0,0 +1,30 @@
+// ticket #421
+object Test extends App {
+
+  def transpose[A: ClassManifest](xss: Array[Array[A]]) = {
+    for (i <- Array.range(0, xss(0).length)) yield
+      for (xs <- xss) yield xs(i)
+  }
+
+  def scalprod(xs: Array[Double], ys: Array[Double]) = {
+    var acc = 0.0 
+    for ((x, y) <- xs zip ys) acc = acc + x * y  
+    acc
+  }
+
+  def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = {
+    val ysst = transpose(yss) 
+    val ysst1: Array[Array[Double]] = yss.transpose
+    assert(ysst.deep == ysst1.deep)
+    for (xs <- xss) yield
+      for (yst <- ysst) yield 
+        scalprod(xs, yst)
+  }
+
+  val a1 = Array(Array(0, 2, 4), Array(1, 3, 5))
+  println(transpose(a1).deep.mkString("[", ",", "]"))
+
+  println(matmul(Array(Array(2, 3)), Array(Array(5), Array(7))).deep.mkString("[", ",", "]"))
+  
+  println(matmul(Array(Array(4)), Array(Array(6, 8))).deep.mkString("[", ",", "]"))
+}
diff --git a/test/files/run/t0677-old.scala b/test/files/run/t0677-old.scala
new file mode 100644
index 0000000000..6c8a3a7e99
--- /dev/null
+++ b/test/files/run/t0677-old.scala
@@ -0,0 +1,8 @@
+object Test extends App {
+  class X[T: ClassManifest] { 
+    val a = Array.ofDim[T](3, 4)
+  }
+  val x = new X[String]
+  x.a(1)(2) = "hello"
+  assert(x.a(1)(2) == "hello")
+}
diff --git a/test/files/run/t1195-old.check b/test/files/run/t1195-old.check
new file mode 100644
index 0000000000..eb60eceb17
--- /dev/null
+++ b/test/files/run/t1195-old.check
@@ -0,0 +1,6 @@
+_ <: scala.runtime.AbstractFunction1[Int, _ <: Object with scala.Product with scala.Serializable] with scala.Serializable with java.lang.Object

+_ <: Object with scala.Product with scala.Serializable

+Object with scala.Product with scala.Serializable

+_ <: scala.runtime.AbstractFunction1[Int, _ <: Object with scala.Product with scala.Serializable] with scala.Serializable with java.lang.Object

+_ <: Object with scala.Product with scala.Serializable

+Object with scala.Product with scala.Serializable

diff --git a/test/files/run/t1195-old.scala b/test/files/run/t1195-old.scala
new file mode 100644
index 0000000000..b46a3b70f5
--- /dev/null
+++ b/test/files/run/t1195-old.scala
@@ -0,0 +1,26 @@
+object Test {
+  def f() = { case class Bar(x: Int); Bar }
+  def g() = { case class Bar(x: Int); Bar(5) }
+  def h() = { case object Bar ; Bar }
+
+  val f1 = f()
+  val g1 = g()
+  val h1 = h()
+
+  def m[T: Manifest](x: T) = println(manifest[T])
+
+  def main(args: Array[String]): Unit = {
+    m(f)
+    m(g)
+    m(h)
+    m(f1)
+    m(g1)
+    m(h1)
+  }
+}
+
+class A1[T] {
+  class B1[U] {
+    def f = { case class D(x: Int) extends A1[String] ; new D(5) }
+  }
+}
diff --git a/test/files/run/t2236-old.scala b/test/files/run/t2236-old.scala
new file mode 100644
index 0000000000..64ed18c805
--- /dev/null
+++ b/test/files/run/t2236-old.scala
@@ -0,0 +1,17 @@
+class T[A](implicit val m:Manifest[A])
+class Foo
+class Bar extends T[Foo]
+object Test extends App {
+  new Bar
+}
+
+object EvidenceTest {
+  trait E[T]
+  trait A[T] { implicit val e: E[T] = null }
+  class B[T : E] extends A[T] { override val e = null }
+
+  def f[T] {
+    implicit val e: E[T] = null
+    new B[T]{}
+  }
+}
diff --git a/test/files/run/t3758-old.scala b/test/files/run/t3758-old.scala
new file mode 100644
index 0000000000..f00254afee
--- /dev/null
+++ b/test/files/run/t3758-old.scala
@@ -0,0 +1,10 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    assert(classManifest[Array[String]].typeArguments contains classManifest[String])
+    assert(classManifest[Array[Int]].typeArguments contains classManifest[Int])
+    assert(classManifest[Array[Float]].typeArguments contains classManifest[Float])
+    assert(manifest[Array[String]].typeArguments contains manifest[String])
+    assert(manifest[Array[Int]].typeArguments contains manifest[Int])
+    assert(manifest[Array[Float]].typeArguments contains manifest[Float])
+  }
+}
\ No newline at end of file
diff --git a/test/files/run/t4110-old.check b/test/files/run/t4110-old.check
new file mode 100644
index 0000000000..8b005989de
--- /dev/null
+++ b/test/files/run/t4110-old.check
@@ -0,0 +1,2 @@
+Object with Test$A with Test$B
+Object with Test$A with Test$B
diff --git a/test/files/run/t4110-old.scala b/test/files/run/t4110-old.scala
new file mode 100644
index 0000000000..a42646ce52
--- /dev/null
+++ b/test/files/run/t4110-old.scala
@@ -0,0 +1,11 @@
+object Test extends App {
+  def inferredType[T : Manifest](v : T) = println(manifest[T])
+
+  trait A
+  trait B
+
+  inferredType(new A with B)
+
+  val name = new A with B
+  inferredType(name)
+}
\ No newline at end of file
diff --git a/test/files/scalacheck/array-old.scala b/test/files/scalacheck/array-old.scala
new file mode 100644
index 0000000000..f262bc6320
--- /dev/null
+++ b/test/files/scalacheck/array-old.scala
@@ -0,0 +1,37 @@
+import org.scalacheck._
+import Prop._
+import Gen._
+import Arbitrary._
+import util._
+import Buildable._
+import scala.collection.mutable.ArraySeq
+
+object Test extends Properties("Array") {
+  /** At this moment the authentic scalacheck Array Builder/Arb bits are commented out.
+   */
+  implicit def arbArray[T](implicit a: Arbitrary[T], m: Manifest[T]): Arbitrary[Array[T]] =
+    Arbitrary(containerOf[List,T](arbitrary[T]) map (_.toArray))
+  
+  val arrGen: Gen[Array[_]] = oneOf(
+    arbitrary[Array[Int]],
+    arbitrary[Array[Array[Int]]],
+    arbitrary[Array[List[String]]],
+    arbitrary[Array[String]],
+    arbitrary[Array[Boolean]],
+    arbitrary[Array[AnyVal]]
+  )
+  
+  // inspired by #1857 and #2352
+  property("eq/ne") = forAll(arrGen, arrGen) { (c1, c2) =>
+    (c1 eq c2) || (c1 ne c2)
+  }
+
+  // inspired by #2299
+  def smallInt = choose(1, 10)
+  property("ofDim") = forAll(smallInt, smallInt, smallInt) { (i1, i2, i3) =>
+    val arr = Array.ofDim[String](i1, i2, i3)
+    val flattened = arr flatMap (x => x) flatMap (x => x)
+    flattened.length == i1 * i2 * i3
+  }                                                                             
+}
+
diff --git a/test/files/specialized/spec-matrix-old.check b/test/files/specialized/spec-matrix-old.check
new file mode 100644
index 0000000000..5ec3e84597
--- /dev/null
+++ b/test/files/specialized/spec-matrix-old.check
@@ -0,0 +1,2 @@
+251437.0
+Boxed doubles: 1
diff --git a/test/files/specialized/spec-matrix-old.scala b/test/files/specialized/spec-matrix-old.scala
new file mode 100644
index 0000000000..98735c8c03
--- /dev/null
+++ b/test/files/specialized/spec-matrix-old.scala
@@ -0,0 +1,80 @@
+/** Test matrix multiplication with specialization.
+ */
+
+class Matrix[@specialized A: ClassManifest](val rows: Int, val cols: Int) {
+  private val arr: Array[Array[A]] = Array.ofDim[A](rows, cols)
+  
+  def apply(i: Int, j: Int): A = {
+    if (i < 0 || i >= rows || j < 0 || j >= cols)
+      throw new NoSuchElementException("Indexes out of bounds: " + (i, j))
+
+    arr(i)(j)
+  }
+
+  def update(i: Int, j: Int, e: A) {
+    arr(i)(j) = e
+  }
+
+  def rowsIterator: Iterator[Array[A]] = new Iterator[Array[A]] {
+    var idx = 0;
+    def hasNext = idx < rows
+    def next = {
+      idx += 1
+      arr(idx - 1)
+    }
+  }
+}
+
+object Test {
+  def main(args: Array[String]) {
+    val m = randomMatrix(200, 100)
+    val n = randomMatrix(100, 200)
+    
+    val p = mult(m, n)
+    println(p(0, 0))
+    println("Boxed doubles: " + runtime.BoxesRunTime.doubleBoxCount)
+//    println("Boxed integers: " + runtime.BoxesRunTime.integerBoxCount)
+  }
+
+  def randomMatrix(n: Int, m: Int) = {
+    val r = new util.Random(10)
+    val x = new Matrix[Double](n, m) 
+    for (i <- 0 until n; j <- 0 until m)
+      x(i, j) = (r.nextInt % 1000).toDouble
+    x
+  }
+
+  def printMatrix[Double](m: Matrix[Double]) {
+    for (i <- 0 until m.rows) {
+      for (j <- 0 until m.cols) 
+        print("%5.3f ".format(m(i, j)))
+      println
+    }
+  }
+
+  def multManifest[@specialized(Int) T](m: Matrix[T], n: Matrix[T])(implicit cm: ClassManifest[T], num: Numeric[T]) {
+    val p = new Matrix[T](m.rows, n.cols)
+    import num._
+
+    for (i <- 0 until m.rows) 
+      for (j <- 0 until n.cols) {
+        var sum = num.zero
+        for (k <- 0 until n.rows)
+          sum += m(i, k) * n(k, j)
+        p(i, j) = sum
+      }
+  }
+
+  def mult(m: Matrix[Double], n: Matrix[Double]) = {
+    val p = new Matrix[Double](m.rows, n.cols)
+
+    for (i <- 0 until m.rows) 
+      for (j <- 0 until n.cols) {
+        var sum = 0.0
+        for (k <- 0 until n.rows)
+          sum += m(i, k) * n(k, j)
+        p(i, j) = sum
+      }
+    p
+  }
+}