diff --git a/project/TastyMiMaFilters.scala b/project/TastyMiMaFilters.scala
index d0533c6e464e..9f2582be54f1 100644
--- a/project/TastyMiMaFilters.scala
+++ b/project/TastyMiMaFilters.scala
@@ -34,8 +34,6 @@ object TastyMiMaFilters {
 
     // Problem: Class[T] or ClassTag[T] with `T` equal to wildcard `_ >: Nothing <: AnyVal` instead of a specific primitive type `T`
     ProblemMatcher.make(ProblemKind.IncompatibleTypeChange, "scala.*.getClass"),
-    ProblemMatcher.make(ProblemKind.IncompatibleTypeChange, "scala.reflect.ManifestFactory.*.runtimeClass"),
-    ProblemMatcher.make(ProblemKind.IncompatibleTypeChange, "scala.collection.*.elemTag"),
     ProblemMatcher.make(ProblemKind.IncompatibleTypeChange, "scala.collection.mutable.UnrolledBuffer.Unrolled.<init>$default$4"),
 
     // Problem: Case class with private constructor
diff --git a/stdlib-bootstrapped/src/scala/collection/immutable/ArraySeq.scala b/stdlib-bootstrapped/src/scala/collection/immutable/ArraySeq.scala
new file mode 100644
index 000000000000..c27d3c579c63
--- /dev/null
+++ b/stdlib-bootstrapped/src/scala/collection/immutable/ArraySeq.scala
@@ -0,0 +1,685 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala.collection
+package immutable
+
+import java.util.Arrays
+
+import scala.annotation.unchecked.uncheckedVariance
+import scala.collection.Stepper.EfficientSplit
+import scala.collection.mutable.{ArrayBuffer, ArrayBuilder, Builder, ArraySeq => MutableArraySeq}
+import scala.collection.convert.impl._
+import scala.reflect.ClassTag
+import scala.runtime.ScalaRunTime
+import scala.util.Sorting
+import scala.util.hashing.MurmurHash3
+
+/**
+  * An immutable array.
+  *
+  * Supports efficient indexed access and has a small memory footprint.
+  *
+  * @define coll immutable array
+  * @define Coll `ArraySeq`
+  */
+sealed abstract class ArraySeq[+A]
+  extends AbstractSeq[A]
+    with IndexedSeq[A]
+    with IndexedSeqOps[A, ArraySeq, ArraySeq[A]]
+    with StrictOptimizedSeqOps[A, ArraySeq, ArraySeq[A]]
+    with EvidenceIterableFactoryDefaults[A, ArraySeq, ClassTag]
+    with Serializable {
+
+  /** The tag of the element type. This does not have to be equal to the element type of this ArraySeq. A primitive
+    * ArraySeq can be backed by an array of boxed values and a reference ArraySeq can be backed by an array of a supertype
+    * or subtype of the element type. */
+  protected def elemTag: ClassTag[_]
+
+  override def iterableFactory: SeqFactory[ArraySeq] = ArraySeq.untagged
+
+  /** The wrapped mutable `Array` that backs this `ArraySeq`. Any changes to this array will break
+    * the expected immutability. Its element type does not have to be equal to the element type of this ArraySeq.
+    * A primitive ArraySeq can be backed by an array of boxed values and a reference ArraySeq can be backed by an
+    * array of a supertype or subtype of the element type. */
+  def unsafeArray: Array[_]
+
+  protected def evidenceIterableFactory: ArraySeq.type = ArraySeq
+  protected def iterableEvidence: ClassTag[A @uncheckedVariance] = elemTag.asInstanceOf[ClassTag[A]]
+
+  def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S with EfficientSplit
+
+  @throws[ArrayIndexOutOfBoundsException]
+  def apply(i: Int): A
+
+  override def updated[B >: A](index: Int, elem: B): ArraySeq[B] = {
+    val dest = new Array[Any](length)
+    Array.copy(unsafeArray, 0, dest, 0, length)
+    dest(index) = elem
+    ArraySeq.unsafeWrapArray(dest).asInstanceOf[ArraySeq[B]]
+  }
+
+  override def map[B](f: A => B): ArraySeq[B] = {
+    val a = new Array[Any](size)
+    var i = 0
+    while (i < a.length){
+      a(i) = f(apply(i))
+      i += 1
+    }
+    ArraySeq.unsafeWrapArray(a).asInstanceOf[ArraySeq[B]]
+  }
+
+  override def prepended[B >: A](elem: B): ArraySeq[B] =
+    ArraySeq.unsafeWrapArray(unsafeArray.prepended[Any](elem)).asInstanceOf[ArraySeq[B]]
+
+  override def appended[B >: A](elem: B): ArraySeq[B] =
+    ArraySeq.unsafeWrapArray(unsafeArray.appended[Any](elem)).asInstanceOf[ArraySeq[B]]
+
+  /** Fast concatenation of two [[ArraySeq]]s.
+    *
+    * @return null if optimisation not possible.
+    */
+  private def appendedAllArraySeq[B >: A](that: ArraySeq[B]): ArraySeq[B] = {
+    // Optimise concatenation of two ArraySeqs
+    // For ArraySeqs with sizes of [100, 1000, 10000] this is [3.5, 4.1, 5.2]x as fast
+    if (isEmpty)
+      that
+    else if (that.isEmpty)
+      this
+    else {
+      val thisIsObj = this.unsafeArray.isInstanceOf[Array[AnyRef]]
+      val thatIsObj = that.unsafeArray.isInstanceOf[Array[AnyRef]]
+      val mismatch = thisIsObj != thatIsObj
+      if (mismatch)
+        // Combining primatives and objects: abort
+        null
+      else if (thisIsObj) {
+        // A and B are objects
+        val ax = this.unsafeArray.asInstanceOf[Array[A]]
+        val ay = that.unsafeArray.asInstanceOf[Array[B]]
+        val len = ax.length + ay.length
+        val a = new Array[AnyRef](len)
+        System.arraycopy(ax, 0, a, 0, ax.length)
+        System.arraycopy(ay, 0, a, ax.length, ay.length)
+        ArraySeq.unsafeWrapArray(a).asInstanceOf[ArraySeq[B]]
+      } else {
+        // A is a primative and B = A. Use this instance's protected ClassTag.
+        val ax = this.unsafeArray.asInstanceOf[Array[A]]
+        val ay = that.unsafeArray.asInstanceOf[Array[A]]
+        val len = ax.length + ay.length
+        val a = iterableEvidence.newArray(len)
+        System.arraycopy(ax, 0, a, 0, ax.length)
+        System.arraycopy(ay, 0, a, ax.length, ay.length)
+        ArraySeq.unsafeWrapArray(a).asInstanceOf[ArraySeq[B]]
+      }
+    }
+  }
+
+  override def appendedAll[B >: A](suffix: collection.IterableOnce[B]): ArraySeq[B] = {
+    def genericResult = {
+      val k = suffix.knownSize
+      if (k == 0) this
+      else {
+        val b = ArrayBuilder.make[Any]
+        if(k >= 0) b.sizeHint(k + unsafeArray.length)
+        b.addAll(unsafeArray)
+        b.addAll(suffix)
+        ArraySeq.unsafeWrapArray(b.result()).asInstanceOf[ArraySeq[B]]
+      }
+    }
+
+    suffix match {
+      case that: ArraySeq[_] =>
+        val result = appendedAllArraySeq(that.asInstanceOf[ArraySeq[B]])
+        if (result == null) genericResult
+        else result
+      case _ =>
+        genericResult
+    }
+  }
+
+  override def prependedAll[B >: A](prefix: collection.IterableOnce[B]): ArraySeq[B] = {
+    def genericResult = {
+      val k = prefix.knownSize
+      if (k == 0) this
+      else {
+        val b = ArrayBuilder.make[Any]
+        if(k >= 0) b.sizeHint(k + unsafeArray.length)
+        b.addAll(prefix)
+        if(k < 0) b.sizeHint(b.length + unsafeArray.length)
+        b.addAll(unsafeArray)
+        ArraySeq.unsafeWrapArray(b.result()).asInstanceOf[ArraySeq[B]]
+      }
+    }
+
+    prefix match {
+      case that: ArraySeq[_] =>
+        val result = that.asInstanceOf[ArraySeq[B]].appendedAllArraySeq(this)
+        if (result == null) genericResult
+        else result
+      case _ =>
+        genericResult
+    }
+  }
+
+  override def zip[B](that: collection.IterableOnce[B]): ArraySeq[(A, B)] =
+    that match {
+      case bs: ArraySeq[B] =>
+        ArraySeq.tabulate(length min bs.length) { i =>
+          (apply(i), bs(i))
+        }
+      case _ =>
+        strictOptimizedZip[B, ArraySeq[(A, B)]](that, iterableFactory.newBuilder)
+    }
+
+  override def take(n: Int): ArraySeq[A] =
+    if (unsafeArray.length <= n)
+      this
+    else
+      ArraySeq.unsafeWrapArray(new ArrayOps(unsafeArray).take(n)).asInstanceOf[ArraySeq[A]]
+
+  override def takeRight(n: Int): ArraySeq[A] =
+    if (unsafeArray.length <= n)
+      this
+    else
+      ArraySeq.unsafeWrapArray(new ArrayOps(unsafeArray).takeRight(n)).asInstanceOf[ArraySeq[A]]
+
+  override def drop(n: Int): ArraySeq[A] =
+    if (n <= 0)
+      this
+    else
+      ArraySeq.unsafeWrapArray(new ArrayOps(unsafeArray).drop(n)).asInstanceOf[ArraySeq[A]]
+
+  override def dropRight(n: Int): ArraySeq[A] =
+    if (n <= 0)
+      this
+    else
+      ArraySeq.unsafeWrapArray(new ArrayOps(unsafeArray).dropRight(n)).asInstanceOf[ArraySeq[A]]
+
+  override def slice(from: Int, until: Int): ArraySeq[A] =
+    if (from <= 0 && unsafeArray.length <= until)
+      this
+    else
+      ArraySeq.unsafeWrapArray(new ArrayOps(unsafeArray).slice(from, until)).asInstanceOf[ArraySeq[A]]
+
+  override def foldLeft[B](z: B)(f: (B, A) => B): B = {
+    // For ArraySeqs with sizes of [100, 1000, 10000] this is [1.3, 1.8, 1.8]x as fast
+    // as the same while-loop over this instead of unsafeArray.
+    val array = unsafeArray
+    var b = z
+    var i = 0
+    while (i < array.length) {
+      val a = array(i).asInstanceOf[A]
+      b = f(b, a)
+      i += 1
+    }
+    b
+  }
+
+  override def foldRight[B](z: B)(f: (A, B) => B): B = {
+    // For ArraySeqs with sizes of [100, 1000, 10000] this is [1.6, 1.8, 2.7]x as fast
+    // as the same while-loop over this instead of unsafeArray.
+    val array = unsafeArray
+    var b = z
+    var i = array.length
+    while (i > 0) {
+      i -= 1
+      val a = array(i).asInstanceOf[A]
+      b = f(a, b)
+    }
+    b
+  }
+
+  override def tail: ArraySeq[A] = ArraySeq.unsafeWrapArray(new ArrayOps(unsafeArray).tail).asInstanceOf[ArraySeq[A]]
+
+  override def reverse: ArraySeq[A] = ArraySeq.unsafeWrapArray(new ArrayOps(unsafeArray).reverse).asInstanceOf[ArraySeq[A]]
+
+  override protected[this] def className = "ArraySeq"
+
+  override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int = {
+    val copied = IterableOnce.elemsToCopyToArray(length, xs.length, start, len)
+    if(copied > 0) {
+      Array.copy(unsafeArray, 0, xs, start, copied)
+    }
+    copied
+  }
+
+  override protected final def applyPreferredMaxLength: Int = Int.MaxValue
+
+  override def sorted[B >: A](implicit ord: Ordering[B]): ArraySeq[A] =
+    if(unsafeArray.length <= 1) this
+    else {
+      val a = Array.copyAs[AnyRef](unsafeArray, length)(ClassTag.AnyRef)
+      Arrays.sort(a, ord.asInstanceOf[Ordering[AnyRef]])
+      new ArraySeq.ofRef[AnyRef](a).asInstanceOf[ArraySeq[A]]
+    }
+}
+
+/**
+  * $factoryInfo
+  * @define coll immutable array
+  * @define Coll `ArraySeq`
+  */
+@SerialVersionUID(3L)
+object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
+  val untagged: SeqFactory[ArraySeq] = new ClassTagSeqFactory.AnySeqDelegate(self)
+
+  private[this] lazy val emptyImpl = new ArraySeq.ofRef[Nothing](new Array[Nothing](0))
+
+  def empty[A : ClassTag]: ArraySeq[A] = emptyImpl
+
+  def from[A](it: scala.collection.IterableOnce[A])(implicit tag: ClassTag[A]): ArraySeq[A] = it match {
+    case as: ArraySeq[A] => as
+    case _ => unsafeWrapArray(Array.from[A](it))
+  }
+
+  def newBuilder[A : ClassTag]: Builder[A, ArraySeq[A]] =
+    ArrayBuffer.newBuilder[A].mapResult(b => unsafeWrapArray[A](b.toArray))
+
+  override def fill[A : ClassTag](n: Int)(elem: => A): ArraySeq[A] = tabulate(n)(_ => elem)
+
+  override def tabulate[A : ClassTag](n: Int)(f: Int => A): ArraySeq[A] = {
+    val elements = Array.ofDim[A](scala.math.max(n, 0))
+    var i = 0
+    while (i < n) {
+      ScalaRunTime.array_update(elements, i, f(i))
+      i = i + 1
+    }
+    ArraySeq.unsafeWrapArray(elements)
+  }
+
+  /**
+   * Wrap an existing `Array` into an `ArraySeq` of the proper primitive specialization type
+   * without copying. Any changes to wrapped array will break the expected immutability.
+   *
+   * Note that an array containing boxed primitives can be wrapped in an `ArraySeq` without
+   * copying. For example, `val a: Array[Any] = Array(1)` is an array of `Object` at runtime,
+   * containing `Integer`s. An `ArraySeq[Int]` can be obtained with a cast:
+   * `ArraySeq.unsafeWrapArray(a).asInstanceOf[ArraySeq[Int]]`. The values are still
+   * boxed, the resulting instance is an [[ArraySeq.ofRef]]. Writing
+   * `ArraySeq.unsafeWrapArray(a.asInstanceOf[Array[Int]])` does not work, it throws a
+   * `ClassCastException` at runtime.
+   */
+  def unsafeWrapArray[T](x: Array[T]): ArraySeq[T] = ((x: @unchecked) match {
+    case null              => null
+    case x: Array[AnyRef]  => new ofRef[AnyRef](x)
+    case x: Array[Int]     => new ofInt(x)
+    case x: Array[Double]  => new ofDouble(x)
+    case x: Array[Long]    => new ofLong(x)
+    case x: Array[Float]   => new ofFloat(x)
+    case x: Array[Char]    => new ofChar(x)
+    case x: Array[Byte]    => new ofByte(x)
+    case x: Array[Short]   => new ofShort(x)
+    case x: Array[Boolean] => new ofBoolean(x)
+    case x: Array[Unit]    => new ofUnit(x)
+  }).asInstanceOf[ArraySeq[T]]
+
+  @SerialVersionUID(3L)
+  final class ofRef[T <: AnyRef](val unsafeArray: Array[T]) extends ArraySeq[T] {
+    def elemTag: ClassTag[T] = ClassTag[T](unsafeArray.getClass.getComponentType)
+    def length: Int = unsafeArray.length
+    @throws[ArrayIndexOutOfBoundsException]
+    def apply(i: Int): T = unsafeArray(i)
+    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def equals(that: Any): Boolean = that match {
+      case that: ofRef[_] =>
+        Array.equals(
+          this.unsafeArray.asInstanceOf[Array[AnyRef]],
+          that.unsafeArray.asInstanceOf[Array[AnyRef]])
+      case _ => super.equals(that)
+    }
+    override def sorted[B >: T](implicit ord: Ordering[B]): ArraySeq.ofRef[T] = {
+      if(unsafeArray.length <= 1) this
+      else {
+        val a = unsafeArray.clone()
+        Arrays.sort(a, ord.asInstanceOf[Ordering[T]])
+        new ArraySeq.ofRef(a)
+      }
+    }
+    override def iterator: Iterator[T] = new ArrayOps.ArrayIterator[T](unsafeArray)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        new ObjectArrayStepper(unsafeArray, 0, unsafeArray.length)
+      else shape.parUnbox(new ObjectArrayStepper(unsafeArray, 0, unsafeArray.length).asInstanceOf[AnyStepper[T] with EfficientSplit])
+    ).asInstanceOf[S with EfficientSplit]
+  }
+
+  @SerialVersionUID(3L)
+  final class ofByte(val unsafeArray: Array[Byte]) extends ArraySeq[Byte] {
+    protected def elemTag = ClassTag.Byte
+    def length: Int = unsafeArray.length
+    @throws[ArrayIndexOutOfBoundsException]
+    def apply(i: Int): Byte = unsafeArray(i)
+    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofByte => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+    override def sorted[B >: Byte](implicit ord: Ordering[B]): ArraySeq[Byte] =
+      if(length <= 1) this
+      else if(ord eq Ordering.Byte) {
+        val a = unsafeArray.clone()
+        Arrays.sort(a)
+        new ArraySeq.ofByte(a)
+      } else super.sorted[B]
+    override def iterator: Iterator[Byte] = new ArrayOps.ArrayIterator[Byte](unsafeArray)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Byte, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParIntStepper(new WidenedByteArrayStepper(unsafeArray, 0, unsafeArray.length))
+      else new WidenedByteArrayStepper(unsafeArray, 0, unsafeArray.length)
+    ).asInstanceOf[S with EfficientSplit]
+    override def updated[B >: Byte](index: Int, elem: B): ArraySeq[B] =
+      elem match {
+        case b: Byte => new ArraySeq.ofByte(unsafeArray.updated(index, b))
+        case _ => super.updated(index, elem)
+      }
+    override def appended[B >: Byte](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Byte => new ArraySeq.ofByte(unsafeArray.appended(b))
+        case _ => super.appended(elem)
+      }
+    override def prepended[B >: Byte](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Byte => new ArraySeq.ofByte(unsafeArray.prepended(b))
+        case _ => super.prepended(elem)
+      }
+  }
+
+  @SerialVersionUID(3L)
+  final class ofShort(val unsafeArray: Array[Short]) extends ArraySeq[Short] {
+    protected def elemTag = ClassTag.Short
+    def length: Int = unsafeArray.length
+    @throws[ArrayIndexOutOfBoundsException]
+    def apply(i: Int): Short = unsafeArray(i)
+    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofShort => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+    override def sorted[B >: Short](implicit ord: Ordering[B]): ArraySeq[Short] =
+      if(length <= 1) this
+      else if(ord eq Ordering.Short) {
+        val a = unsafeArray.clone()
+        Arrays.sort(a)
+        new ArraySeq.ofShort(a)
+      } else super.sorted[B]
+    override def iterator: Iterator[Short] = new ArrayOps.ArrayIterator[Short](unsafeArray)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Short, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParIntStepper(new WidenedShortArrayStepper(unsafeArray, 0, unsafeArray.length))
+      else new WidenedShortArrayStepper(unsafeArray, 0, unsafeArray.length)
+    ).asInstanceOf[S with EfficientSplit]
+    override def updated[B >: Short](index: Int, elem: B): ArraySeq[B] =
+      elem match {
+        case b: Short => new ArraySeq.ofShort(unsafeArray.updated(index, b))
+        case _ => super.updated(index, elem)
+      }
+    override def appended[B >: Short](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Short => new ArraySeq.ofShort(unsafeArray.appended(b))
+        case _ => super.appended(elem)
+      }
+    override def prepended[B >: Short](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Short => new ArraySeq.ofShort(unsafeArray.prepended(b))
+        case _ => super.prepended(elem)
+      }
+  }
+
+  @SerialVersionUID(3L)
+  final class ofChar(val unsafeArray: Array[Char]) extends ArraySeq[Char] {
+    protected def elemTag = ClassTag.Char
+    def length: Int = unsafeArray.length
+    @throws[ArrayIndexOutOfBoundsException]
+    def apply(i: Int): Char = unsafeArray(i)
+    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofChar => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+    override def sorted[B >: Char](implicit ord: Ordering[B]): ArraySeq[Char] =
+      if(length <= 1) this
+      else if(ord eq Ordering.Char) {
+        val a = unsafeArray.clone()
+        Arrays.sort(a)
+        new ArraySeq.ofChar(a)
+      } else super.sorted[B]
+    override def iterator: Iterator[Char] = new ArrayOps.ArrayIterator[Char](unsafeArray)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Char, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParIntStepper(new WidenedCharArrayStepper(unsafeArray, 0, unsafeArray.length))
+      else new WidenedCharArrayStepper(unsafeArray, 0, unsafeArray.length)
+    ).asInstanceOf[S with EfficientSplit]
+    override def updated[B >: Char](index: Int, elem: B): ArraySeq[B] =
+      elem match {
+        case b: Char => new ArraySeq.ofChar(unsafeArray.updated(index, b))
+        case _ => super.updated(index, elem)
+      }
+    override def appended[B >: Char](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Char => new ArraySeq.ofChar(unsafeArray.appended(b))
+        case _ => super.appended(elem)
+      }
+    override def prepended[B >: Char](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Char => new ArraySeq.ofChar(unsafeArray.prepended(b))
+        case _ => super.prepended(elem)
+      }
+
+    override def addString(sb: StringBuilder, start: String, sep: String, end: String): sb.type =
+      (new MutableArraySeq.ofChar(unsafeArray)).addString(sb, start, sep, end)
+  }
+
+  @SerialVersionUID(3L)
+  final class ofInt(val unsafeArray: Array[Int]) extends ArraySeq[Int] {
+    protected def elemTag = ClassTag.Int
+    def length: Int = unsafeArray.length
+    @throws[ArrayIndexOutOfBoundsException]
+    def apply(i: Int): Int = unsafeArray(i)
+    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofInt => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+    override def sorted[B >: Int](implicit ord: Ordering[B]): ArraySeq[Int] =
+      if(length <= 1) this
+      else if(ord eq Ordering.Int) {
+        val a = unsafeArray.clone()
+        Arrays.sort(a)
+        new ArraySeq.ofInt(a)
+      } else super.sorted[B]
+    override def iterator: Iterator[Int] = new ArrayOps.ArrayIterator[Int](unsafeArray)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Int, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParIntStepper(new IntArrayStepper(unsafeArray, 0, unsafeArray.length))
+      else new IntArrayStepper(unsafeArray, 0, unsafeArray.length)
+    ).asInstanceOf[S with EfficientSplit]
+    override def updated[B >: Int](index: Int, elem: B): ArraySeq[B] =
+      elem match {
+        case b: Int => new ArraySeq.ofInt(unsafeArray.updated(index, b))
+        case _ => super.updated(index, elem)
+      }
+    override def appended[B >: Int](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Int => new ArraySeq.ofInt(unsafeArray.appended(b))
+        case _ => super.appended(elem)
+      }
+    override def prepended[B >: Int](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Int => new ArraySeq.ofInt(unsafeArray.prepended(b))
+        case _ => super.prepended(elem)
+      }
+  }
+
+  @SerialVersionUID(3L)
+  final class ofLong(val unsafeArray: Array[Long]) extends ArraySeq[Long] {
+    protected def elemTag = ClassTag.Long
+    def length: Int = unsafeArray.length
+    @throws[ArrayIndexOutOfBoundsException]
+    def apply(i: Int): Long = unsafeArray(i)
+    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofLong => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+    override def sorted[B >: Long](implicit ord: Ordering[B]): ArraySeq[Long] =
+      if(length <= 1) this
+      else if(ord eq Ordering.Long) {
+        val a = unsafeArray.clone()
+        Arrays.sort(a)
+        new ArraySeq.ofLong(a)
+      } else super.sorted[B]
+    override def iterator: Iterator[Long] = new ArrayOps.ArrayIterator[Long](unsafeArray)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Long, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParLongStepper(new LongArrayStepper(unsafeArray, 0, unsafeArray.length))
+      else new LongArrayStepper(unsafeArray, 0, unsafeArray.length)
+    ).asInstanceOf[S with EfficientSplit]
+    override def updated[B >: Long](index: Int, elem: B): ArraySeq[B] =
+      elem match {
+        case b: Long => new ArraySeq.ofLong(unsafeArray.updated(index, b))
+        case _ => super.updated(index, elem)
+      }
+    override def appended[B >: Long](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Long => new ArraySeq.ofLong(unsafeArray.appended(b))
+        case _ => super.appended(elem)
+      }
+    override def prepended[B >: Long](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Long => new ArraySeq.ofLong(unsafeArray.prepended(b))
+        case _ => super.prepended(elem)
+      }
+  }
+
+  @SerialVersionUID(3L)
+  final class ofFloat(val unsafeArray: Array[Float]) extends ArraySeq[Float] {
+    protected def elemTag = ClassTag.Float
+    def length: Int = unsafeArray.length
+    @throws[ArrayIndexOutOfBoundsException]
+    def apply(i: Int): Float = unsafeArray(i)
+    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofFloat => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+    override def iterator: Iterator[Float] = new ArrayOps.ArrayIterator[Float](unsafeArray)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Float, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParDoubleStepper(new WidenedFloatArrayStepper(unsafeArray, 0, unsafeArray.length))
+      else new WidenedFloatArrayStepper(unsafeArray, 0, unsafeArray.length)
+    ).asInstanceOf[S with EfficientSplit]
+    override def updated[B >: Float](index: Int, elem: B): ArraySeq[B] =
+      elem match {
+        case b: Float => new ArraySeq.ofFloat(unsafeArray.updated(index, b))
+        case _ => super.updated(index, elem)
+      }
+    override def appended[B >: Float](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Float => new ArraySeq.ofFloat(unsafeArray.appended(b))
+        case _ => super.appended(elem)
+      }
+    override def prepended[B >: Float](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Float => new ArraySeq.ofFloat(unsafeArray.prepended(b))
+        case _ => super.prepended(elem)
+      }
+  }
+
+  @SerialVersionUID(3L)
+  final class ofDouble(val unsafeArray: Array[Double]) extends ArraySeq[Double] {
+    protected def elemTag = ClassTag.Double
+    def length: Int = unsafeArray.length
+    @throws[ArrayIndexOutOfBoundsException]
+    def apply(i: Int): Double = unsafeArray(i)
+    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofDouble => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+    override def iterator: Iterator[Double] = new ArrayOps.ArrayIterator[Double](unsafeArray)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Double, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParDoubleStepper(new DoubleArrayStepper(unsafeArray, 0, unsafeArray.length))
+      else new DoubleArrayStepper(unsafeArray, 0, unsafeArray.length)
+    ).asInstanceOf[S with EfficientSplit]
+    override def updated[B >: Double](index: Int, elem: B): ArraySeq[B] =
+      elem match {
+        case b: Double => new ArraySeq.ofDouble(unsafeArray.updated(index, b))
+        case _ => super.updated(index, elem)
+      }
+    override def appended[B >: Double](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Double => new ArraySeq.ofDouble(unsafeArray.appended(b))
+        case _ => super.appended(elem)
+      }
+    override def prepended[B >: Double](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Double => new ArraySeq.ofDouble(unsafeArray.prepended(b))
+        case _ => super.prepended(elem)
+      }
+  }
+
+  @SerialVersionUID(3L)
+  final class ofBoolean(val unsafeArray: Array[Boolean]) extends ArraySeq[Boolean] {
+    protected def elemTag = ClassTag.Boolean
+    def length: Int = unsafeArray.length
+    @throws[ArrayIndexOutOfBoundsException]
+    def apply(i: Int): Boolean = unsafeArray(i)
+    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofBoolean => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+    override def sorted[B >: Boolean](implicit ord: Ordering[B]): ArraySeq[Boolean] =
+      if(length <= 1) this
+      else if(ord eq Ordering.Boolean) {
+        val a = unsafeArray.clone()
+        Sorting.stableSort(a)
+        new ArraySeq.ofBoolean(a)
+      } else super.sorted[B]
+    override def iterator: Iterator[Boolean] = new ArrayOps.ArrayIterator[Boolean](unsafeArray)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Boolean, S]): S with EfficientSplit =
+      new BoxedBooleanArrayStepper(unsafeArray, 0, unsafeArray.length).asInstanceOf[S with EfficientSplit]
+    override def updated[B >: Boolean](index: Int, elem: B): ArraySeq[B] =
+      elem match {
+        case b: Boolean => new ArraySeq.ofBoolean(unsafeArray.updated(index, b))
+        case _ => super.updated(index, elem)
+      }
+    override def appended[B >: Boolean](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Boolean => new ArraySeq.ofBoolean(unsafeArray.appended(b))
+        case _ => super.appended(elem)
+      }
+    override def prepended[B >: Boolean](elem: B): ArraySeq[B] =
+      elem match {
+        case b: Boolean => new ArraySeq.ofBoolean(unsafeArray.prepended(b))
+        case _ => super.prepended(elem)
+      }
+  }
+
+  @SerialVersionUID(3L)
+  final class ofUnit(val unsafeArray: Array[Unit]) extends ArraySeq[Unit] {
+    protected def elemTag = ClassTag.Unit
+    def length: Int = unsafeArray.length
+    @throws[ArrayIndexOutOfBoundsException]
+    def apply(i: Int): Unit = unsafeArray(i)
+    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofUnit => unsafeArray.length == that.unsafeArray.length
+      case _ => super.equals(that)
+    }
+    override def iterator: Iterator[Unit] = new ArrayOps.ArrayIterator[Unit](unsafeArray)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Unit, S]): S with EfficientSplit =
+      new ObjectArrayStepper[AnyRef](unsafeArray.asInstanceOf[Array[AnyRef]], 0, unsafeArray.length).asInstanceOf[S with EfficientSplit]
+  }
+}
diff --git a/stdlib-bootstrapped/src/scala/collection/mutable/ArraySeq.scala b/stdlib-bootstrapped/src/scala/collection/mutable/ArraySeq.scala
new file mode 100644
index 000000000000..cfa80b6633d5
--- /dev/null
+++ b/stdlib-bootstrapped/src/scala/collection/mutable/ArraySeq.scala
@@ -0,0 +1,347 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala.collection
+package mutable
+
+import java.util.Arrays
+
+import scala.collection.Stepper.EfficientSplit
+import scala.collection.convert.impl._
+import scala.reflect.ClassTag
+import scala.util.hashing.MurmurHash3
+
+/**
+  *  A collection representing `Array[T]`. Unlike `ArrayBuffer` it is always backed by the same
+  *  underlying `Array`, therefore it is not growable or shrinkable.
+  *
+  *  @tparam T    type of the elements in this wrapped array.
+  *
+  *  @define Coll `ArraySeq`
+  *  @define coll wrapped array
+  *  @define orderDependent
+  *  @define orderDependentFold
+  *  @define mayNotTerminateInf
+  *  @define willNotTerminateInf
+  */
+@SerialVersionUID(3L)
+sealed abstract class ArraySeq[T]
+  extends AbstractSeq[T]
+    with IndexedSeq[T]
+    with IndexedSeqOps[T, ArraySeq, ArraySeq[T]]
+    with StrictOptimizedSeqOps[T, ArraySeq, ArraySeq[T]]
+    with Serializable {
+
+  override def iterableFactory: scala.collection.SeqFactory[ArraySeq] = ArraySeq.untagged
+
+  override protected def fromSpecific(coll: scala.collection.IterableOnce[T]): ArraySeq[T] = {
+    val b = ArrayBuilder.make(elemTag).asInstanceOf[ArrayBuilder[T]]
+    val s = coll.knownSize
+    if(s > 0) b.sizeHint(s)
+    b ++= coll
+    ArraySeq.make(b.result())
+  }
+  override protected def newSpecificBuilder: Builder[T, ArraySeq[T]] = ArraySeq.newBuilder(elemTag).asInstanceOf[Builder[T, ArraySeq[T]]]
+  override def empty: ArraySeq[T] = ArraySeq.empty(elemTag.asInstanceOf[ClassTag[T]])
+
+  /** The tag of the element type. This does not have to be equal to the element type of this ArraySeq. A primitive
+    * ArraySeq can be backed by an array of boxed values and a reference ArraySeq can be backed by an array of a supertype
+    * or subtype of the element type. */
+  def elemTag: ClassTag[_]
+
+  /** Update element at given index */
+  def update(@deprecatedName("idx", "2.13.0") index: Int, elem: T): Unit
+
+  /** The underlying array. Its element type does not have to be equal to the element type of this ArraySeq. A primitive
+    * ArraySeq can be backed by an array of boxed values and a reference ArraySeq can be backed by an array of a supertype
+    * or subtype of the element type. */
+  def array: Array[_]
+
+  override def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S with EfficientSplit
+
+  override protected[this] def className = "ArraySeq"
+
+  /** Clones this object, including the underlying Array. */
+  override def clone(): ArraySeq[T] = ArraySeq.make(array.clone()).asInstanceOf[ArraySeq[T]]
+
+  override def copyToArray[B >: T](xs: Array[B], start: Int, len: Int): Int = {
+    val copied = IterableOnce.elemsToCopyToArray(length, xs.length, start, len)
+    if(copied > 0) {
+      Array.copy(array, 0, xs, start, copied)
+    }
+    copied
+  }
+
+  override def equals(other: Any): Boolean = other match {
+    case that: ArraySeq[_] if this.array.length != that.array.length =>
+      false
+    case _ =>
+      super.equals(other)
+  }
+
+  override def sorted[B >: T](implicit ord: Ordering[B]): ArraySeq[T] =
+    ArraySeq.make(array.sorted(ord.asInstanceOf[Ordering[Any]])).asInstanceOf[ArraySeq[T]]
+
+  override def sortInPlace[B >: T]()(implicit ord: Ordering[B]): this.type = {
+    if (length > 1) scala.util.Sorting.stableSort(array.asInstanceOf[Array[B]])
+    this
+  }
+}
+
+/** A companion object used to create instances of `ArraySeq`.
+  */
+@SerialVersionUID(3L)
+object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
+  val untagged: SeqFactory[ArraySeq] = new ClassTagSeqFactory.AnySeqDelegate(self)
+
+  // This is reused for all calls to empty.
+  private[this] val EmptyArraySeq  = new ofRef[AnyRef](new Array[AnyRef](0))
+  def empty[T : ClassTag]: ArraySeq[T] = EmptyArraySeq.asInstanceOf[ArraySeq[T]]
+
+  def from[A : ClassTag](it: scala.collection.IterableOnce[A]): ArraySeq[A] = make(Array.from[A](it))
+
+  def newBuilder[A : ClassTag]: Builder[A, ArraySeq[A]] = ArrayBuilder.make[A].mapResult(make)
+
+  /**
+   * Wrap an existing `Array` into a `ArraySeq` of the proper primitive specialization type
+   * without copying.
+   *
+   * Note that an array containing boxed primitives can be converted to a `ArraySeq` without
+   * copying. For example, `val a: Array[Any] = Array(1)` is an array of `Object` at runtime,
+   * containing `Integer`s. An `ArraySeq[Int]` can be obtained with a cast:
+   * `ArraySeq.make(a).asInstanceOf[ArraySeq[Int]]`. The values are still
+   * boxed, the resulting instance is an [[ArraySeq.ofRef]]. Writing
+   * `ArraySeq.make(a.asInstanceOf[Array[Int]])` does not work, it throws a `ClassCastException`
+   * at runtime.
+   */
+  def make[T](x: Array[T]): ArraySeq[T] = ((x.asInstanceOf[Array[_]]: @unchecked) match {
+    case null              => null
+    case x: Array[AnyRef]  => new ofRef[AnyRef](x)
+    case x: Array[Int]     => new ofInt(x)
+    case x: Array[Double]  => new ofDouble(x)
+    case x: Array[Long]    => new ofLong(x)
+    case x: Array[Float]   => new ofFloat(x)
+    case x: Array[Char]    => new ofChar(x)
+    case x: Array[Byte]    => new ofByte(x)
+    case x: Array[Short]   => new ofShort(x)
+    case x: Array[Boolean] => new ofBoolean(x)
+    case x: Array[Unit]    => new ofUnit(x)
+  }).asInstanceOf[ArraySeq[T]]
+
+  @SerialVersionUID(3L)
+  final class ofRef[T <: AnyRef](val array: Array[T]) extends ArraySeq[T] {
+    def elemTag: ClassTag[T] = ClassTag[T](array.getClass.getComponentType)
+    def length: Int = array.length
+    def apply(index: Int): T = array(index)
+    def update(index: Int, elem: T): Unit = { array(index) = elem }
+    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def equals(that: Any) = that match {
+      case that: ofRef[_] =>
+        Array.equals(
+          this.array.asInstanceOf[Array[AnyRef]],
+          that.array.asInstanceOf[Array[AnyRef]])
+      case _ => super.equals(that)
+    }
+    override def iterator: Iterator[T] = new ArrayOps.ArrayIterator[T](array)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        new ObjectArrayStepper(array, 0, array.length)
+      else shape.parUnbox(new ObjectArrayStepper(array, 0, array.length).asInstanceOf[AnyStepper[T] with EfficientSplit])
+      ).asInstanceOf[S with EfficientSplit]
+  }
+
+  @SerialVersionUID(3L)
+  final class ofByte(val array: Array[Byte]) extends ArraySeq[Byte] {
+    def elemTag: ClassTag.Byte.type = ClassTag.Byte
+    def length: Int = array.length
+    def apply(index: Int): Byte = array(index)
+    def update(index: Int, elem: Byte): Unit = { array(index) = elem }
+    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def equals(that: Any) = that match {
+      case that: ofByte => Arrays.equals(array, that.array)
+      case _ => super.equals(that)
+    }
+    override def iterator: Iterator[Byte] = new ArrayOps.ArrayIterator[Byte](array)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Byte, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParIntStepper(new WidenedByteArrayStepper(array, 0, array.length))
+      else new WidenedByteArrayStepper(array, 0, array.length)
+      ).asInstanceOf[S with EfficientSplit]
+  }
+
+  @SerialVersionUID(3L)
+  final class ofShort(val array: Array[Short]) extends ArraySeq[Short] {
+    def elemTag: ClassTag.Short.type = ClassTag.Short
+    def length: Int = array.length
+    def apply(index: Int): Short = array(index)
+    def update(index: Int, elem: Short): Unit = { array(index) = elem }
+    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def equals(that: Any) = that match {
+      case that: ofShort => Arrays.equals(array, that.array)
+      case _ => super.equals(that)
+    }
+    override def iterator: Iterator[Short] = new ArrayOps.ArrayIterator[Short](array)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Short, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParIntStepper(new WidenedShortArrayStepper(array, 0, array.length))
+      else new WidenedShortArrayStepper(array, 0, array.length)
+      ).asInstanceOf[S with EfficientSplit]
+  }
+
+  @SerialVersionUID(3L)
+  final class ofChar(val array: Array[Char]) extends ArraySeq[Char] {
+    def elemTag: ClassTag.Char.type = ClassTag.Char
+    def length: Int = array.length
+    def apply(index: Int): Char = array(index)
+    def update(index: Int, elem: Char): Unit = { array(index) = elem }
+    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def equals(that: Any) = that match {
+      case that: ofChar => Arrays.equals(array, that.array)
+      case _ => super.equals(that)
+    }
+    override def iterator: Iterator[Char] = new ArrayOps.ArrayIterator[Char](array)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Char, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParIntStepper(new WidenedCharArrayStepper(array, 0, array.length))
+      else new WidenedCharArrayStepper(array, 0, array.length)
+      ).asInstanceOf[S with EfficientSplit]
+
+    override def addString(sb: StringBuilder, start: String, sep: String, end: String): sb.type = {
+      val jsb = sb.underlying
+      if (start.length != 0) jsb.append(start)
+      val len = array.length
+      if (len != 0) {
+        if (sep.isEmpty) jsb.append(array)
+        else {
+          jsb.ensureCapacity(jsb.length + len + end.length + (len - 1) * sep.length)
+          jsb.append(array(0))
+          var i = 1
+          while (i < len) {
+            jsb.append(sep)
+            jsb.append(array(i))
+            i += 1
+          }
+        }
+      }
+      if (end.length != 0) jsb.append(end)
+      sb
+    }
+  }
+
+  @SerialVersionUID(3L)
+  final class ofInt(val array: Array[Int]) extends ArraySeq[Int] {
+    def elemTag: ClassTag.Int.type = ClassTag.Int
+    def length: Int = array.length
+    def apply(index: Int): Int = array(index)
+    def update(index: Int, elem: Int): Unit = { array(index) = elem }
+    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def equals(that: Any) = that match {
+      case that: ofInt => Arrays.equals(array, that.array)
+      case _ => super.equals(that)
+    }
+    override def iterator: Iterator[Int] = new ArrayOps.ArrayIterator[Int](array)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Int, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParIntStepper(new IntArrayStepper(array, 0, array.length))
+      else new IntArrayStepper(array, 0, array.length)
+      ).asInstanceOf[S with EfficientSplit]
+  }
+
+  @SerialVersionUID(3L)
+  final class ofLong(val array: Array[Long]) extends ArraySeq[Long] {
+    def elemTag: ClassTag.Long.type = ClassTag.Long
+    def length: Int = array.length
+    def apply(index: Int): Long = array(index)
+    def update(index: Int, elem: Long): Unit = { array(index) = elem }
+    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def equals(that: Any) = that match {
+      case that: ofLong => Arrays.equals(array, that.array)
+      case _ => super.equals(that)
+    }
+    override def iterator: Iterator[Long] = new ArrayOps.ArrayIterator[Long](array)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Long, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParLongStepper(new LongArrayStepper(array, 0, array.length))
+      else new LongArrayStepper(array, 0, array.length)
+      ).asInstanceOf[S with EfficientSplit]
+  }
+
+  @SerialVersionUID(3L)
+  final class ofFloat(val array: Array[Float]) extends ArraySeq[Float] {
+    def elemTag: ClassTag.Float.type = ClassTag.Float
+    def length: Int = array.length
+    def apply(index: Int): Float = array(index)
+    def update(index: Int, elem: Float): Unit = { array(index) = elem }
+    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def equals(that: Any) = that match {
+      case that: ofFloat => Arrays.equals(array, that.array)
+      case _ => super.equals(that)
+    }
+    override def iterator: Iterator[Float] = new ArrayOps.ArrayIterator[Float](array)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Float, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParDoubleStepper(new WidenedFloatArrayStepper(array, 0, array.length))
+      else new WidenedFloatArrayStepper(array, 0, array.length)
+      ).asInstanceOf[S with EfficientSplit]
+  }
+
+  @SerialVersionUID(3L)
+  final class ofDouble(val array: Array[Double]) extends ArraySeq[Double] {
+    def elemTag: ClassTag.Double.type = ClassTag.Double
+    def length: Int = array.length
+    def apply(index: Int): Double = array(index)
+    def update(index: Int, elem: Double): Unit = { array(index) = elem }
+    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def equals(that: Any) = that match {
+      case that: ofDouble => Arrays.equals(array, that.array)
+      case _ => super.equals(that)
+    }
+    override def iterator: Iterator[Double] = new ArrayOps.ArrayIterator[Double](array)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Double, S]): S with EfficientSplit = (
+      if(shape.shape == StepperShape.ReferenceShape)
+        AnyStepper.ofParDoubleStepper(new DoubleArrayStepper(array, 0, array.length))
+      else new DoubleArrayStepper(array, 0, array.length)
+      ).asInstanceOf[S with EfficientSplit]
+  }
+
+  @SerialVersionUID(3L)
+  final class ofBoolean(val array: Array[Boolean]) extends ArraySeq[Boolean] {
+    def elemTag: ClassTag.Boolean.type = ClassTag.Boolean
+    def length: Int = array.length
+    def apply(index: Int): Boolean = array(index)
+    def update(index: Int, elem: Boolean): Unit = { array(index) = elem }
+    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def equals(that: Any) = that match {
+      case that: ofBoolean => Arrays.equals(array, that.array)
+      case _ => super.equals(that)
+    }
+    override def iterator: Iterator[Boolean] = new ArrayOps.ArrayIterator[Boolean](array)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Boolean, S]): S with EfficientSplit =
+      new BoxedBooleanArrayStepper(array, 0, array.length).asInstanceOf[S with EfficientSplit]
+  }
+
+  @SerialVersionUID(3L)
+  final class ofUnit(val array: Array[Unit]) extends ArraySeq[Unit] {
+    def elemTag: ClassTag.Unit.type = ClassTag.Unit
+    def length: Int = array.length
+    def apply(index: Int): Unit = array(index)
+    def update(index: Int, elem: Unit): Unit = { array(index) = elem }
+    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def equals(that: Any) = that match {
+      case that: ofUnit => array.length == that.array.length
+      case _ => super.equals(that)
+    }
+    override def iterator: Iterator[Unit] = new ArrayOps.ArrayIterator[Unit](array)
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Unit, S]): S with EfficientSplit =
+      new ObjectArrayStepper[AnyRef](array.asInstanceOf[Array[AnyRef]], 0, array.length).asInstanceOf[S with EfficientSplit]
+  }
+}
diff --git a/stdlib-bootstrapped/src/scala/reflect/Manifest.scala b/stdlib-bootstrapped/src/scala/reflect/Manifest.scala
new file mode 100644
index 000000000000..d46fa1039bfc
--- /dev/null
+++ b/stdlib-bootstrapped/src/scala/reflect/Manifest.scala
@@ -0,0 +1,461 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala
+package reflect
+
+import scala.annotation.{implicitNotFound, nowarn}
+import scala.collection.mutable.{ArrayBuilder, ArraySeq}
+
+/** 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 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: Manifest] = manifest[T].runtimeClass.getMethods
+ *    def retType[T: Manifest](name: String) =
+ *      methods[T] find (_.getName == name) map (_.getGenericReturnType)
+ *
+ *    retType[Map[_, _]]("values")  // Some(scala.collection.Iterable<B>)
+ *  }}}
+ */
+@nowarn("""cat=deprecation&origin=scala\.reflect\.ClassManifest(DeprecatedApis.*)?""")
+@implicitNotFound(msg = "No Manifest available for ${T}.")
+// TODO undeprecated until Scala reflection becomes non-experimental
+// @deprecated("use scala.reflect.ClassTag (to capture erasures) or scala.reflect.runtime.universe.TypeTag (to capture types) or both instead", "2.10.0")
+trait Manifest[T] extends ClassManifest[T] with Equals {
+  override def typeArguments: List[Manifest[_]] = Nil
+
+  override def arrayManifest: Manifest[Array[T]] =
+    Manifest.classType[Array[T]](arrayClass[T](runtimeClass), 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.runtimeClass == m.runtimeClass) && (this <:< m) && (m <:< this)
+    case _              => false
+  }
+  override def hashCode = this.runtimeClass.##
+}
+
+/** The object `Manifest` defines factory methods for manifests.
+ *  It is intended for use by the compiler and should not be used in client code.
+ */
+// TODO undeprecated until Scala reflection becomes non-experimental
+// @deprecated("use scala.reflect.ClassTag (to capture erasures), scala.reflect.runtime.universe.TypeTag (to capture types) or both instead", "2.10.0")
+object Manifest {
+  /* Forward all the public members of ManifestFactory, since this object used
+   * to be a `private val Manifest = ManifestFactory` in the package object. It
+   * was moved here because it needs to be in the same file as `trait Manifest`
+   * defined above.
+   */
+
+  def valueManifests: List[AnyValManifest[_]] =
+    ManifestFactory.valueManifests
+
+  val Byte: ManifestFactory.ByteManifest = ManifestFactory.Byte
+  val Short: ManifestFactory.ShortManifest = ManifestFactory.Short
+  val Char: ManifestFactory.CharManifest = ManifestFactory.Char
+  val Int: ManifestFactory.IntManifest = ManifestFactory.Int
+  val Long: ManifestFactory.LongManifest = ManifestFactory.Long
+  val Float: ManifestFactory.FloatManifest = ManifestFactory.Float
+  val Double: ManifestFactory.DoubleManifest = ManifestFactory.Double
+  val Boolean: ManifestFactory.BooleanManifest = ManifestFactory.Boolean
+  val Unit: ManifestFactory.UnitManifest = ManifestFactory.Unit
+
+  val Any: Manifest[scala.Any] = ManifestFactory.Any
+  val Object: Manifest[java.lang.Object] = ManifestFactory.Object
+  val AnyRef: Manifest[scala.AnyRef] = ManifestFactory.AnyRef
+  val AnyVal: Manifest[scala.AnyVal] = ManifestFactory.AnyVal
+  val Null: Manifest[scala.Null] = ManifestFactory.Null
+  val Nothing: Manifest[scala.Nothing] = ManifestFactory.Nothing
+
+  /** Manifest for the singleton type `value.type`. */
+  def singleType[T <: AnyRef](value: AnyRef): Manifest[T] =
+    ManifestFactory.singleType[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] =
+    ManifestFactory.classType[T](clazz)
+
+  /** 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] =
+    ManifestFactory.classType[T](clazz, arg1, args: _*)
+
+  /** 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] =
+    ManifestFactory.classType[T](prefix, clazz, args: _*)
+
+  def arrayType[T](arg: Manifest[_]): Manifest[Array[T]] =
+    ManifestFactory.arrayType[T](arg)
+
+  /** 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] =
+    ManifestFactory.abstractType[T](prefix, name, upperBound, args: _*)
+
+  /** Manifest for the unknown type `_ >: L <: U` in an existential. */
+  def wildcardType[T](lowerBound: Manifest[_], upperBound: Manifest[_]): Manifest[T] =
+    ManifestFactory.wildcardType[T](lowerBound, upperBound)
+
+  /** Manifest for the intersection type `parents_0 with ... with parents_n`. */
+  def intersectionType[T](parents: Manifest[_]*): Manifest[T] =
+    ManifestFactory.intersectionType[T](parents: _*)
+
+}
+
+// TODO undeprecated until Scala reflection becomes non-experimental
+// @deprecated("use type tags and manually check the corresponding class or type instead", "2.10.0")
+@nowarn("""cat=deprecation&origin=scala\.reflect\.ClassManifest(DeprecatedApis.*)?""")
+@SerialVersionUID(1L)
+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]
+  @transient
+  override val hashCode = System.identityHashCode(this)
+}
+
+/** `ManifestFactory` defines factory methods for manifests.
+ *  It is intended for use by the compiler and should not be used in client code.
+ *
+ *  Unlike `Manifest`, this factory isn't annotated with a deprecation warning.
+ *  This is done to prevent avalanches of deprecation warnings in the code that calls methods with manifests.
+ *  Why so complicated? Read up the comments for `ClassManifestFactory`.
+ */
+@nowarn("""cat=deprecation&origin=scala\.reflect\.ClassManifest(DeprecatedApis.*)?""")
+object ManifestFactory {
+  def valueManifests: List[AnyValManifest[_]] =
+    List(Byte, Short, Char, Int, Long, Float, Double, Boolean, Unit)
+
+  @SerialVersionUID(1L)
+  final private[reflect] class ByteManifest extends AnyValManifest[scala.Byte]("Byte") {
+    def runtimeClass: Class[java.lang.Byte] = java.lang.Byte.TYPE
+    @inline override def newArray(len: Int): Array[Byte] = new Array[Byte](len)
+    override def newWrappedArray(len: Int): ArraySeq[Byte] = new ArraySeq.ofByte(new Array[Byte](len))
+    override def newArrayBuilder(): ArrayBuilder[Byte] = new ArrayBuilder.ofByte()
+    override def unapply(x: Any): Option[Byte] = {
+      x match {
+        case d: Byte => Some(d)
+        case _ => None
+      }
+    }
+    private def readResolve(): Any = Manifest.Byte
+  }
+  val Byte: ByteManifest = new ByteManifest
+
+  @SerialVersionUID(1L)
+  final private[reflect] class ShortManifest extends AnyValManifest[scala.Short]("Short") {
+    def runtimeClass: Class[java.lang.Short] = java.lang.Short.TYPE
+    @inline override def newArray(len: Int): Array[Short] = new Array[Short](len)
+    override def newWrappedArray(len: Int): ArraySeq[Short] = new ArraySeq.ofShort(new Array[Short](len))
+    override def newArrayBuilder(): ArrayBuilder[Short] = new ArrayBuilder.ofShort()
+    override def unapply(x: Any): Option[Short] = {
+      x match {
+        case d: Short => Some(d)
+        case _ => None
+      }
+    }
+    private def readResolve(): Any = Manifest.Short
+  }
+  val Short: ShortManifest = new ShortManifest
+
+  @SerialVersionUID(1L)
+  final private[reflect] class CharManifest extends AnyValManifest[scala.Char]("Char") {
+    def runtimeClass: Class[java.lang.Character] = java.lang.Character.TYPE
+    @inline override def newArray(len: Int): Array[Char] = new Array[Char](len)
+    override def newWrappedArray(len: Int): ArraySeq[Char] = new ArraySeq.ofChar(new Array[Char](len))
+    override def newArrayBuilder(): ArrayBuilder[Char] = new ArrayBuilder.ofChar()
+    override def unapply(x: Any): Option[Char] = {
+      x match {
+        case d: Char => Some(d)
+        case _ => None
+      }
+    }
+    private def readResolve(): Any = Manifest.Char
+  }
+  val Char: CharManifest = new CharManifest
+
+  @SerialVersionUID(1L)
+  final private[reflect] class IntManifest extends AnyValManifest[scala.Int]("Int") {
+    def runtimeClass: Class[java.lang.Integer] = java.lang.Integer.TYPE
+    @inline override def newArray(len: Int): Array[Int] = new Array[Int](len)
+    override def newWrappedArray(len: Int): ArraySeq[Int] = new ArraySeq.ofInt(new Array[Int](len))
+    override def newArrayBuilder(): ArrayBuilder[Int] = new ArrayBuilder.ofInt()
+    override def unapply(x: Any): Option[Int] = {
+      x match {
+        case d: Int => Some(d)
+        case _ => None
+      }
+    }
+    private def readResolve(): Any = Manifest.Int
+  }
+  val Int: IntManifest = new IntManifest
+
+  @SerialVersionUID(1L)
+  final private[reflect] class LongManifest extends AnyValManifest[scala.Long]("Long") {
+    def runtimeClass: Class[java.lang.Long] = java.lang.Long.TYPE
+    @inline override def newArray(len: Int): Array[Long] = new Array[Long](len)
+    override def newWrappedArray(len: Int): ArraySeq[Long] = new ArraySeq.ofLong(new Array[Long](len))
+    override def newArrayBuilder(): ArrayBuilder[Long] = new ArrayBuilder.ofLong()
+    override def unapply(x: Any): Option[Long] = {
+      x match {
+        case d: Long => Some(d)
+        case _ => None
+      }
+    }
+    private def readResolve(): Any = Manifest.Long
+  }
+  val Long: LongManifest = new LongManifest
+
+  @SerialVersionUID(1L)
+  final private[reflect] class FloatManifest extends AnyValManifest[scala.Float]("Float") {
+    def runtimeClass: Class[java.lang.Float] = java.lang.Float.TYPE
+    @inline override def newArray(len: Int): Array[Float] = new Array[Float](len)
+    override def newWrappedArray(len: Int): ArraySeq[Float] = new ArraySeq.ofFloat(new Array[Float](len))
+    override def newArrayBuilder(): ArrayBuilder[Float] = new ArrayBuilder.ofFloat()
+    override def unapply(x: Any): Option[Float] = {
+      x match {
+        case d: Float => Some(d)
+        case _ => None
+      }
+    }
+    private def readResolve(): Any = Manifest.Float
+  }
+  val Float: FloatManifest = new FloatManifest
+
+  @SerialVersionUID(1L)
+  final private[reflect] class DoubleManifest extends AnyValManifest[scala.Double]("Double") {
+    def runtimeClass: Class[java.lang.Double] = java.lang.Double.TYPE
+    @inline override def newArray(len: Int): Array[Double] = new Array[Double](len)
+    override def newWrappedArray(len: Int): ArraySeq[Double] = new ArraySeq.ofDouble(new Array[Double](len))
+    override def newArrayBuilder(): ArrayBuilder[Double] = new ArrayBuilder.ofDouble()
+
+    override def unapply(x: Any): Option[Double] = {
+      x match {
+        case d: Double => Some(d)
+        case _ => None
+      }
+    }
+    private def readResolve(): Any = Manifest.Double
+  }
+  val Double: DoubleManifest = new DoubleManifest
+
+  @SerialVersionUID(1L)
+  final private[reflect] class BooleanManifest extends AnyValManifest[scala.Boolean]("Boolean") {
+    def runtimeClass: Class[java.lang.Boolean] = java.lang.Boolean.TYPE
+    @inline override def newArray(len: Int): Array[Boolean] = new Array[Boolean](len)
+    override def newWrappedArray(len: Int): ArraySeq[Boolean] = new ArraySeq.ofBoolean(new Array[Boolean](len))
+    override def newArrayBuilder(): ArrayBuilder[Boolean] = new ArrayBuilder.ofBoolean()
+    override def unapply(x: Any): Option[Boolean] = {
+      x match {
+        case d: Boolean => Some(d)
+        case _ => None
+      }
+    }
+    private def readResolve(): Any = Manifest.Boolean
+  }
+  val Boolean: BooleanManifest = new BooleanManifest
+
+  @SerialVersionUID(1L)
+  final private[reflect] class UnitManifest extends AnyValManifest[scala.Unit]("Unit") {
+    def runtimeClass: Class[java.lang.Void] = java.lang.Void.TYPE
+    @inline override def newArray(len: Int): Array[Unit] = new Array[Unit](len)
+    override def newWrappedArray(len: Int): ArraySeq[Unit] = new ArraySeq.ofUnit(new Array[Unit](len))
+    override def newArrayBuilder(): ArrayBuilder[Unit] = new ArrayBuilder.ofUnit()
+    override protected def arrayClass[T](tp: Class[_]): Class[Array[T]] =
+      if (tp eq runtimeClass) classOf[Array[scala.runtime.BoxedUnit]].asInstanceOf[Class[Array[T]]]
+      else super.arrayClass(tp)
+    override def unapply(x: Any): Option[Unit] = {
+      x match {
+        case d: Unit => Some(d)
+        case _ => None
+      }
+    }
+    private def readResolve(): Any = Manifest.Unit
+  }
+  val Unit: UnitManifest = new UnitManifest
+
+  private[this] val ObjectTYPE = classOf[java.lang.Object]
+  private[this] val NothingTYPE = classOf[scala.runtime.Nothing$]
+  private[this] val NullTYPE = classOf[scala.runtime.Null$]
+
+  @SerialVersionUID(1L)
+  final private class AnyManifest extends PhantomManifest[scala.Any](ObjectTYPE, "Any") {
+    override def newArray(len: Int) = new Array[scala.Any](len)
+    override def <:<(that: ClassManifest[_]): Boolean = (that eq this)
+    private def readResolve(): Any = Manifest.Any
+  }
+  val Any: Manifest[scala.Any] = new AnyManifest
+
+  @SerialVersionUID(1L)
+  final private class ObjectManifest extends PhantomManifest[java.lang.Object](ObjectTYPE, "Object") {
+    override def newArray(len: Int) = new Array[java.lang.Object](len)
+    override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any)
+    private def readResolve(): Any = Manifest.Object
+  }
+  val Object: Manifest[java.lang.Object] = new ObjectManifest
+
+  val AnyRef: Manifest[scala.AnyRef] = Object.asInstanceOf[Manifest[scala.AnyRef]]
+
+  @SerialVersionUID(1L)
+  final private class AnyValPhantomManifest extends PhantomManifest[scala.AnyVal](ObjectTYPE, "AnyVal") {
+    override def newArray(len: Int) = new Array[scala.AnyVal](len)
+    override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any)
+    private def readResolve(): Any = Manifest.AnyVal
+  }
+  val AnyVal: Manifest[scala.AnyVal] = new AnyValPhantomManifest
+
+  @SerialVersionUID(1L)
+  final private class NullManifest extends PhantomManifest[scala.Null](NullTYPE, "Null") {
+    override def newArray(len: Int) = new Array[scala.Null](len)
+    override def <:<(that: ClassManifest[_]): Boolean =
+      (that ne null) && (that ne Nothing) && !(that <:< AnyVal)
+    private def readResolve(): Any = Manifest.Null
+  }
+  val Null: Manifest[scala.Null] = new NullManifest
+
+  @SerialVersionUID(1L)
+  final private class NothingManifest extends PhantomManifest[scala.Nothing](NothingTYPE, "Nothing") {
+    override def newArray(len: Int) = new Array[scala.Nothing](len)
+    override def <:<(that: ClassManifest[_]): Boolean = (that ne null)
+    private def readResolve(): Any = Manifest.Nothing
+  }
+  val Nothing: Manifest[scala.Nothing] = new NothingManifest
+
+  @SerialVersionUID(1L)
+  final private class SingletonTypeManifest[T <: AnyRef](value: AnyRef) extends Manifest[T] {
+    lazy val runtimeClass = 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)
+
+  @SerialVersionUID(1L)
+  private abstract class PhantomManifest[T](_runtimeClass: Predef.Class[_],
+                                            override val toString: String) extends ClassTypeManifest[T](None, _runtimeClass, Nil) {
+    override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef]
+    @transient
+    override val hashCode = System.identityHashCode(this)
+  }
+
+  /** Manifest for the class type `clazz[args]`, where `clazz` is
+    * a top-level or static class. */
+  @SerialVersionUID(1L)
+  private class ClassTypeManifest[T](prefix: Option[Manifest[_]],
+                                     val runtimeClass: Predef.Class[_],
+                                     override val typeArguments: List[Manifest[_]]) extends Manifest[T] {
+    override def toString =
+      (if (prefix.isEmpty) "" else prefix.get.toString+"#") +
+      (if (runtimeClass.isArray) "Array" else runtimeClass.getName) +
+      argString
+   }
+
+  def arrayType[T](arg: Manifest[_]): Manifest[Array[T]] =
+    arg.asInstanceOf[Manifest[T]].arrayManifest
+
+  @SerialVersionUID(1L)
+  private class AbstractTypeManifest[T](prefix: Manifest[_], name: String, upperBound: Predef.Class[_], args: scala.collection.Seq[Manifest[_]]) extends Manifest[T] {
+    def runtimeClass = upperBound
+    override val typeArguments = args.toList
+    override def toString = prefix.toString+"#"+name+argString
+  }
+
+  /** 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 AbstractTypeManifest[T](prefix, name, upperBound, args)
+
+  @SerialVersionUID(1L)
+  private class WildcardManifest[T](lowerBound: Manifest[_], upperBound: Manifest[_]) extends Manifest[T] {
+    def runtimeClass = upperBound.runtimeClass
+    override def toString =
+      "_" +
+        (if (lowerBound eq Nothing) "" else " >: "+lowerBound) +
+        (if (upperBound eq Nothing) "" else " <: "+upperBound)
+  }
+
+  /** Manifest for the unknown type `_ >: L <: U` in an existential.
+    */
+  def wildcardType[T](lowerBound: Manifest[_], upperBound: Manifest[_]): Manifest[T] =
+    new WildcardManifest[T](lowerBound, upperBound)
+
+  @SerialVersionUID(1L)
+  private class IntersectionTypeManifest[T](parents: Array[Manifest[_]]) extends Manifest[T] {
+    // We use an `Array` instead of a `Seq` for `parents` to avoid cyclic dependencies during deserialization
+    // which can cause serialization proxies to leak and cause a ClassCastException.
+    def runtimeClass = parents(0).runtimeClass
+    override def toString = parents.mkString(" with ")
+  }
+
+  /** Manifest for the intersection type `parents_0 with ... with parents_n`. */
+  def intersectionType[T](parents: Manifest[_]*): Manifest[T] =
+    new IntersectionTypeManifest[T](parents.toArray)
+}