diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 29a31375b0c9..14a36f39848c 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -626,7 +626,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           loop(from.owner, from :: froms, to :: tos)
         else {
           //println(i"change owner ${from :: froms}%, % ==> $tos of $tree")
-          new TreeTypeMap(oldOwners = from :: froms, newOwners = tos)(ctx.withMode(Mode.FutureDefsOK)).apply(tree)
+          new TreeTypeMap(oldOwners = from :: froms, newOwners = tos)(ctx.addMode(Mode.FutureDefsOK)).apply(tree)
         }
       }
       loop(from, Nil, to :: Nil)
@@ -652,7 +652,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
             traverseChildren(tree)
         }
       }
-      traverser.traverse(tree)(ctx.withMode(Mode.FutureDefsOK))
+      traverser.traverse(tree)(ctx.addMode(Mode.FutureDefsOK))
       tree
     }
 
diff --git a/src/dotty/tools/dotc/core/ConstraintHandling.scala b/src/dotty/tools/dotc/core/ConstraintHandling.scala
index 544304e8a18d..577b958c848e 100644
--- a/src/dotty/tools/dotc/core/ConstraintHandling.scala
+++ b/src/dotty/tools/dotc/core/ConstraintHandling.scala
@@ -23,6 +23,7 @@ trait ConstraintHandling {
   implicit val ctx: Context
 
   protected def isSubType(tp1: Type, tp2: Type): Boolean
+  protected def isSameType(tp1: Type, tp2: Type): Boolean
 
   val state: TyperState
   import state.constraint
@@ -104,13 +105,20 @@ trait ConstraintHandling {
     up.forall(addOneBound(_, lo, isUpper = false))
   }
 
-  protected final def isSubTypeWhenFrozen(tp1: Type, tp2: Type): Boolean = {
+  final def isSubTypeWhenFrozen(tp1: Type, tp2: Type): Boolean = {
     val saved = frozenConstraint
     frozenConstraint = true
     try isSubType(tp1, tp2)
     finally frozenConstraint = saved
   }
 
+  final def isSameTypeWhenFrozen(tp1: Type, tp2: Type): Boolean = {
+    val saved = frozenConstraint
+    frozenConstraint = true
+    try isSameType(tp1, tp2)
+    finally frozenConstraint = saved
+  }
+
   /** Test whether the lower bounds of all parameters in this
    *  constraint are a solution to the constraint.
    */
diff --git a/src/dotty/tools/dotc/core/Contexts.scala b/src/dotty/tools/dotc/core/Contexts.scala
index 206ef9d8b9d4..f9d64b2cc56f 100644
--- a/src/dotty/tools/dotc/core/Contexts.scala
+++ b/src/dotty/tools/dotc/core/Contexts.scala
@@ -439,12 +439,12 @@ object Contexts {
   }
 
   implicit class ModeChanges(val c: Context) extends AnyVal {
-    final def withMode(mode: Mode): Context =
+    final def withModeBits(mode: Mode): Context =
       if (mode != c.mode) c.fresh.setMode(mode) else c
 
-    final def addMode(mode: Mode): Context = withMode(c.mode | mode)
-    final def maskMode(mode: Mode): Context = withMode(c.mode & mode)
-    final def retractMode(mode: Mode): Context = withMode(c.mode &~ mode)
+    final def addMode(mode: Mode): Context = withModeBits(c.mode | mode)
+    final def maskMode(mode: Mode): Context = withModeBits(c.mode & mode)
+    final def retractMode(mode: Mode): Context = withModeBits(c.mode &~ mode)
   }
 
   implicit class FreshModeChanges(val c: FreshContext) extends AnyVal {
diff --git a/src/dotty/tools/dotc/core/Denotations.scala b/src/dotty/tools/dotc/core/Denotations.scala
index fff4478037a4..b223a80865e3 100644
--- a/src/dotty/tools/dotc/core/Denotations.scala
+++ b/src/dotty/tools/dotc/core/Denotations.scala
@@ -339,8 +339,8 @@ object Denotations {
           val info1 = denot1.info
           val info2 = denot2.info
           val sameSym = sym1 eq sym2
-          if (sameSym && info1 <:< info2) denot2
-          else if (sameSym && info2 <:< info1) denot1
+          if (sameSym && (info1 frozen_<:< info2)) denot2
+          else if (sameSym && (info2 frozen_<:< info1)) denot1
           else {
             val jointSym =
               if (sameSym) sym1
diff --git a/src/dotty/tools/dotc/core/OrderingConstraint.scala b/src/dotty/tools/dotc/core/OrderingConstraint.scala
index 7e27ee628174..e818862cbbad 100644
--- a/src/dotty/tools/dotc/core/OrderingConstraint.scala
+++ b/src/dotty/tools/dotc/core/OrderingConstraint.scala
@@ -129,7 +129,6 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
 
   type This = OrderingConstraint
 
-
 // ----------- Basic indices --------------------------------------------------
 
   /** The number of type parameters in the given entry array */
@@ -576,4 +575,22 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       }
     Text.lines(List(header, uninstVarsText, constrainedText, boundsText, orderingText, ")"))
   }
+
+  override def toString: String = {
+    def entryText(tp: Type): String = tp match {
+      case tp: TypeBounds => tp.toString
+      case _ =>" := " + tp
+    }
+    val constrainedText =
+      " constrained types = " + domainPolys.mkString("\n")
+    val boundsText =
+      " bounds = " + {
+        val assocs =
+          for (param <- domainParams)
+          yield
+            param.binder.paramNames(param.paramNum) + ": " + entryText(entry(param))
+        assocs.mkString("\n")
+    }
+    constrainedText + "\n" + boundsText
+  }
 }
diff --git a/src/dotty/tools/dotc/core/SymDenotations.scala b/src/dotty/tools/dotc/core/SymDenotations.scala
index 2ce2b8d20db3..d5ab09930011 100644
--- a/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -1587,6 +1587,7 @@ object SymDenotations {
               if (isCachable(tp)) baseTypeRefCache.put(tp, basetp)
               else baseTypeRefCache.remove(tp)
             } else if (basetp == NoPrefix) {
+              baseTypeRefCache.put(tp, null)
               throw CyclicReference(this)
             }
             basetp
diff --git a/src/dotty/tools/dotc/core/TypeApplications.scala b/src/dotty/tools/dotc/core/TypeApplications.scala
index 927c4fcc5522..47935f79e190 100644
--- a/src/dotty/tools/dotc/core/TypeApplications.scala
+++ b/src/dotty/tools/dotc/core/TypeApplications.scala
@@ -497,7 +497,7 @@ class TypeApplications(val self: Type) extends AnyVal {
       val boundss = new mutable.ListBuffer[TypeBounds]
       for (sym <- boundSyms) {
         val bounds = sym.info.bounds
-        if (!(TypeBounds.empty <:< bounds)) {
+        if (!(TypeBounds.empty frozen_<:< bounds)) {
           boundNames += sym.name
           boundss += bounds
         }
@@ -574,7 +574,7 @@ class TypeApplications(val self: Type) extends AnyVal {
                 // we have a binding T = Lambda$XYZ{...}.this.hk$i where hk$i names the current `tparam`.
                 val pcore = etaCore(tp.parent, otherParams)
                 val hkBounds = self.member(rname).info.bounds
-                if (TypeBounds.empty <:< hkBounds) pcore
+                if (TypeBounds.empty frozen_<:< hkBounds) pcore
                 else tp.derivedRefinedType(pcore, tp.refinedName, hkBounds)
               case _ =>
                 val pcore = etaCore(tp.parent, tparams)
diff --git a/src/dotty/tools/dotc/core/TypeComparer.scala b/src/dotty/tools/dotc/core/TypeComparer.scala
index e3e5f3960eec..5fbffe6e95ab 100644
--- a/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -154,24 +154,10 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
           case tp1: NamedType =>
             val sym1 = tp1.symbol
             (if ((sym1 ne NoSymbol) && (sym1 eq tp2.symbol))
-               ctx.erasedTypes || sym1.isStaticOwner ||
-               { // Implements: A # X  <:  B # X
-                 // if either A =:= B (i.e. A <: B and B <: A), or the following three conditions hold:
-                 //  1. X is a class type,
-                 //  2. B is a class type without abstract type members.
-                 //  3. A <: B.
-                 // Dealiasing is taken care of elsewhere.
-                 val pre1 = tp1.prefix
-                 val pre2 = tp2.prefix
-                 isSameType(pre1, pre2) ||
-                   sym1.isClass &&
-                   pre2.classSymbol.exists &&
-                   pre2.abstractTypeMembers.isEmpty &&
-                   isSubType(pre1, pre2)
-              }
+               ctx.erasedTypes || sym1.isStaticOwner || isSubType(tp1.prefix, tp2.prefix)
             else
               (tp1.name eq tp2.name) &&
-              isSameType(tp1.prefix, tp2.prefix) &&
+              isSubType(tp1.prefix, tp2.prefix) &&
               (tp1.signature == tp2.signature) &&
               !tp1.isInstanceOf[WithFixedSym] &&
               !tp2.isInstanceOf[WithFixedSym]
@@ -229,6 +215,9 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       compareSuper
     case AndType(tp21, tp22) =>
       isSubType(tp1, tp21) && isSubType(tp1, tp22)
+    case OrType(tp21, tp22) =>
+      if (tp21.stripTypeVar eq tp22.stripTypeVar) isSubType(tp1, tp21)
+      else secondTry(tp1, tp2)
     case TypeErasure.ErasedValueType(cls2, underlying2) =>
       def compareErasedValueType = tp1 match {
         case TypeErasure.ErasedValueType(cls1, underlying1) =>
@@ -291,6 +280,9 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       isSubType(tp1.ref, tp2)
     case tp1: AnnotatedType =>
       isSubType(tp1.tpe, tp2)
+    case AndType(tp11, tp12) =>
+      if (tp11.stripTypeVar eq tp12.stripTypeVar) isSubType(tp11, tp2)
+      else thirdTry(tp1, tp2)
     case OrType(tp11, tp12) =>
       isSubType(tp11, tp2) && isSubType(tp12, tp2)
     case ErrorType =>
@@ -353,6 +345,21 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       }
       compareRefined
     case OrType(tp21, tp22) =>
+      // Rewrite T1 <: (T211 & T212) | T22 to T1 <: (T211 | T22) and T1 <: (T212 | T22)
+      // and analogously for T1 <: T21 | (T221 & T222)
+      // `|' types to the right of <: are problematic, because
+      // we have to choose one constraint set or another, which might cut off
+      // solutions. The rewriting delays the point where we have to choose.
+      tp21 match {
+        case AndType(tp211, tp212) =>
+          return isSubType(tp1, OrType(tp211, tp22)) && isSubType(tp1, OrType(tp212, tp22))
+        case _ =>
+      }
+      tp22 match {
+        case AndType(tp221, tp222) =>
+          return isSubType(tp1, OrType(tp21, tp221)) && isSubType(tp1, OrType(tp21, tp222))
+        case _ =>
+      }
       eitherIsSubType(tp1, tp21, tp1, tp22) || fourthTry(tp1, tp2)
     case tp2 @ MethodType(_, formals2) =>
       def compareMethod = tp1 match {
@@ -454,6 +461,21 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
        isNewSubType(tp1.parent, tp2) ||
          needsEtaLift(tp2, tp1) && tp2.testLifted(tp1.typeParams, isSubType(tp1, _), Nil)
     case AndType(tp11, tp12) =>
+      // Rewrite (T111 | T112) & T12 <: T2 to (T111 & T12) <: T2 and (T112 | T12) <: T2
+      // and analogously for T11 & (T121 | T122) & T12 <: T2
+      // `&' types to the left of <: are problematic, because
+      // we have to choose one constraint set or another, which might cut off
+      // solutions. The rewriting delays the point where we have to choose.
+      tp11 match {
+        case OrType(tp111, tp112) =>
+          return isSubType(AndType(tp111, tp12), tp2) && isSubType(AndType(tp112, tp12), tp2)
+        case _ =>
+      }
+      tp12 match {
+        case OrType(tp121, tp122) =>
+          return isSubType(AndType(tp11, tp121), tp2) && isSubType(AndType(tp11, tp122), tp2)
+        case _ =>
+      }
       eitherIsSubType(tp11, tp2, tp12, tp2)
     case JavaArrayType(elem1) =>
       def compareJavaArray = tp2 match {
@@ -693,7 +715,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     case formal1 :: rest1 =>
       formals2 match {
         case formal2 :: rest2 =>
-          (isSameType(formal1, formal2)
+          (isSameTypeWhenFrozen(formal1, formal2)
             || isJava1 && (formal2 isRef ObjectClass) && (formal1 isRef AnyClass)
             || isJava2 && (formal1 isRef ObjectClass) && (formal2 isRef AnyClass)) &&
           matchingParams(rest1, rest2, isJava1, isJava2)
@@ -1067,7 +1089,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     case tp1: ClassInfo =>
       tp2 match {
         case tp2: ClassInfo =>
-          isSubType(tp1.prefix, tp2.prefix) || (tp1.cls.owner derivesFrom tp2.cls.owner)
+          isSubTypeWhenFrozen(tp1.prefix, tp2.prefix) || (tp1.cls.owner derivesFrom tp2.cls.owner)
         case _ =>
           false
       }
@@ -1083,7 +1105,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       tp2 match {
         case tp2: MethodType =>
           def asGoodParams(formals1: List[Type], formals2: List[Type]) =
-            (formals2 corresponds formals1)(isSubType)
+            (formals2 corresponds formals1)(isSubTypeWhenFrozen)
           asGoodParams(tp1.paramTypes, tp2.paramTypes) &&
           (!asGoodParams(tp2.paramTypes, tp1.paramTypes) ||
            isAsGood(tp1.resultType, tp2.resultType))
diff --git a/src/dotty/tools/dotc/core/Types.scala b/src/dotty/tools/dotc/core/Types.scala
index bce57ae23757..1d438daf0506 100644
--- a/src/dotty/tools/dotc/core/Types.scala
+++ b/src/dotty/tools/dotc/core/Types.scala
@@ -595,6 +595,11 @@ object Types {
       ctx.typeComparer.topLevelSubType(this, that)
     }
 
+    /** Is this type a subtype of that type? */
+    final def frozen_<:<(that: Type)(implicit ctx: Context): Boolean = track("frozen_<:<") {
+      ctx.typeComparer.isSubTypeWhenFrozen(this, that)
+    }
+
     /** Is this type the same as that type?
      *  This is the case iff `this <:< that` and `that <:< this`.
      */
@@ -625,9 +630,9 @@ object Types {
         case ExprType(_) | MethodType(Nil, _) => tp.resultType
         case _ => tp
       }
-      this <:< that || {
+      (this frozen_<:< that) || {
         val rthat = result(that)
-        (rthat ne that) && result(this) <:< rthat
+        (rthat ne that) && (result(this) frozen_<:< rthat)
       }
     }
 
@@ -801,12 +806,18 @@ object Types {
       case _ => NoType
     }
 
-    /** The chain of underlying types as long as type is a TypeProxy.
+    /** The iterator of underlying types as long as type is a TypeProxy.
      *  Useful for diagnostics
      */
-    def underlyingChain(implicit ctx: Context): List[Type] = this match {
-      case tp: TypeProxy => tp :: tp.underlying.underlyingChain
-      case _ => Nil
+    def underlyingIterator(implicit ctx: Context): Iterator[Type] = new Iterator[Type] {
+      var current = Type.this
+      var hasNext = true
+      def next = {
+        val res = current
+        hasNext = current.isInstanceOf[TypeProxy]
+        if (hasNext) current = current.asInstanceOf[TypeProxy].underlying
+        res
+      }
     }
 
     /** A prefix-less refined this or a termRef to a new skolem symbol
@@ -2652,13 +2663,13 @@ object Types {
     }
 
     def & (that: TypeBounds)(implicit ctx: Context): TypeBounds =
-      if (this.lo <:< that.lo && that.hi <:< this.hi) that
-      else if (that.lo <:< this.lo && this.hi <:< that.hi) this
+      if ((this.lo frozen_<:< that.lo) && (that.hi frozen_<:< this.hi)) that
+      else if ((that.lo frozen_<:< this.lo) && (this.hi frozen_<:< that.hi)) this
       else TypeBounds(this.lo | that.lo, this.hi & that.hi)
 
     def | (that: TypeBounds)(implicit ctx: Context): TypeBounds =
-      if (this.lo <:< that.lo && that.hi <:< this.hi) this
-      else if (that.lo <:< this.lo && this.hi <:< that.hi) that
+      if ((this.lo frozen_<:< that.lo) && (that.hi frozen_<:< this.hi)) this
+      else if ((that.lo frozen_<:< this.lo) && (this.hi frozen_<:< that.hi)) that
       else TypeBounds(this.lo & that.lo, this.hi | that.hi)
 
     override def & (that: Type)(implicit ctx: Context) = that match {
@@ -2873,13 +2884,7 @@ object Types {
       tp match {
         case tp: NamedType =>
           if (stopAtStatic && tp.symbol.isStatic) tp
-          else {
-            val saved = variance
-            variance = 0
-            val result = tp.derivedSelect(this(tp.prefix))
-            variance = saved
-            result
-          }
+          else tp.derivedSelect(this(tp.prefix))
 
         case _: ThisType
           | _: BoundType
diff --git a/src/dotty/tools/dotc/printing/PlainPrinter.scala b/src/dotty/tools/dotc/printing/PlainPrinter.scala
index 45928af4b7bd..5daef9fb8657 100644
--- a/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -166,7 +166,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
         else {
           val constr = ctx.typerState.constraint
           val bounds =
-            if (constr.contains(tp)) constr.fullBounds(tp.origin)
+            if (constr.contains(tp)) constr.fullBounds(tp.origin)(ctx.addMode(Mode.Printing))
             else TypeBounds.empty
           "(" ~ toText(tp.origin) ~ "?" ~ toText(bounds) ~ ")"
         }
diff --git a/src/dotty/tools/dotc/reporting/Reporter.scala b/src/dotty/tools/dotc/reporting/Reporter.scala
index 7adeeac1cb7c..086575fb4da0 100644
--- a/src/dotty/tools/dotc/reporting/Reporter.scala
+++ b/src/dotty/tools/dotc/reporting/Reporter.scala
@@ -149,16 +149,18 @@ trait Reporting { this: Context =>
     else traceIndented[T](s"==> $question?", (res: Any) => s"<== $question = ${resStr(res)}")(op)
   }
 
-  def traceIndented[T](leading: => String, trailing: Any => String)(op: => T): T = {
-    var finalized = false
-    var logctx = this
-    while (logctx.reporter.isInstanceOf[StoreReporter]) logctx = logctx.outer
-    def finalize(result: Any, note: String) =
-      if (!finalized) {
-        base.indent -= 1
-        logctx.log(s"${base.indentTab * base.indent}${trailing(result)}$note")
-        finalized = true
-      }
+  def traceIndented[T](leading: => String, trailing: Any => String)(op: => T): T =
+    if (ctx.mode.is(Mode.Printing)) op
+    else {
+      var finalized = false
+      var logctx = this
+      while (logctx.reporter.isInstanceOf[StoreReporter]) logctx = logctx.outer
+      def finalize(result: Any, note: String) =
+        if (!finalized) {
+          base.indent -= 1
+          logctx.log(s"${base.indentTab * base.indent}${trailing(result)}$note")
+          finalized = true
+        }
     try {
       logctx.log(s"${base.indentTab * base.indent}$leading")
       base.indent += 1
diff --git a/src/dotty/tools/dotc/transform/TreeChecker.scala b/src/dotty/tools/dotc/transform/TreeChecker.scala
index f046226d10b8..2296ae65881b 100644
--- a/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -66,7 +66,7 @@ class TreeChecker extends Phase with SymTransformer {
     val cur = symd.linkedClass
     val prev = ctx.atPhase(ctx.phase.prev) {
       ct => {
-        implicit val ctx: Context = ct.withMode(Mode.FutureDefsOK)
+        implicit val ctx: Context = ct.addMode(Mode.FutureDefsOK)
         symd.symbol.linkedClass
       }
     }
diff --git a/src/strawman/collections/CollectionStrawMan1.scala b/src/strawman/collections/CollectionStrawMan1.scala
new file mode 100644
index 000000000000..c127757ad539
--- /dev/null
+++ b/src/strawman/collections/CollectionStrawMan1.scala
@@ -0,0 +1,405 @@
+package strawman.collections
+
+import Predef.{augmentString => _, wrapString => _, _}
+import scala.reflect.ClassTag
+
+/** A strawman architecture for new collections. It contains some
+ *  example collection classes and methods with the intent to expose
+ *  some key issues. It would be good to compare this to other
+ *  implementations of the same functionality, to get an idea of the
+ *  strengths and weaknesses of different collection architectures.
+ *
+ *  For a test file, see tests/run/CollectionTests.scala.
+ */
+object CollectionStrawMan1 {
+
+  /* ------------ Base Traits -------------------------------- */
+
+  /** Replaces TraversableOnce */
+  trait CanIterate[+A] {
+    def iterator: Iterator[A]
+  }
+
+  /** Base trait for instances that can construct a collection from an iterator */
+  trait FromIterator[+C[X] <: Iterable[X]] {
+    def fromIterator[B](it: Iterator[B]): C[B]
+  }
+
+  /** Base trait for companion objects of collections */
+  trait IterableFactory[+C[X] <: Iterable[X]] extends FromIterator[C] {
+    def empty[X]: C[X] = fromIterator(Iterator.empty)
+    def apply[A](xs: A*): C[A] = fromIterator(Iterator(xs: _*))
+  }
+
+  /** Base trait for generic collections */
+  trait Iterable[+A] extends CanIterate[A] with FromIterator[Iterable]
+
+  /** Base trait for sequence collections */
+  trait Seq[+A] extends Iterable[A] with FromIterator[Seq] {
+    def apply(i: Int): A
+    def length: Int
+  }
+
+  /* ------------ Operations ----------------------------------- */
+
+  /** Operations returning types unrelated to current collection */
+  trait Ops[A] extends Any {
+    def iterator: Iterator[A]
+    def foreach(f: A => Unit): Unit = iterator.foreach(f)
+    def foldLeft[B](z: B)(op: (B, A) => B): B = iterator.foldLeft(z)(op)
+    def foldRight[B](z: B)(op: (A, B) => B): B = iterator.foldRight(z)(op)
+    def indexWhere(p: A => Boolean): Int = iterator.indexWhere(p)
+    def isEmpty: Boolean = !iterator.hasNext
+    def head: A = iterator.next
+    def view: View[A] = new View(iterator)
+    def to[C[X] <: Iterable[X]](fi: FromIterator[C]): C[A] = fi.fromIterator(iterator)
+  }
+
+  /** Transforms returning same collection type */
+  trait MonoTransforms[A, Repr] extends Any {
+    protected def iter: Iterator[A]
+    protected def fromIter(it: => Iterator[A]): Repr
+    def partition(p: A => Boolean): (Repr, Repr) = {
+      val (xs, ys) = iter.partition(p)
+      (fromIter(xs), fromIter(ys))
+    }
+    def drop(n: Int): Repr = fromIter(iter.drop(n))
+  }
+
+  /** Transforms returning same collection type constructor */
+  trait PolyTransforms[A, C[X]] extends Any {
+    protected def iter: Iterator[A]
+    protected def fromIter[B](it: => Iterator[B]): C[B]
+    def map[B](f: A => B): C[B] = fromIter(iter.map(f))
+    def flatMap[B](f: A => CanIterate[B]): C[B] = fromIter(iter.flatMap(f(_)))
+    def ++[B >: A](xs: CanIterate[B]): C[B] = fromIter(iter ++ xs)
+    def zip[B](xs: CanIterate[B]): C[(A, B)] = fromIter(iter.zip(xs.iterator))
+  }
+
+  /** Transforms that only apply to Seq */
+  trait MonoTransformsOfSeqs[A, Repr] extends Any with MonoTransforms[A, Repr] {
+    def reverse: Repr = fromIter(iter.reverse)
+  }
+
+  /** Implementation of Ops for all generic collections */
+  implicit class IterableOps[A](val c: Iterable[A])
+  extends AnyVal with Ops[A] {
+    def iterator = c.iterator
+  }
+
+  /** Implementation of MonoTransforms for all generic collections */
+  implicit class IterableMonoTransforms[A, C[X] <: Iterable[X]](val c: Iterable[A] with FromIterator[C])
+  extends AnyVal with MonoTransforms[A, C[A]] {
+    protected def iter = c.iterator
+    protected def fromIter(it: => Iterator[A]): C[A] = c.fromIterator(it)
+  }
+
+  /** Implementation of PolyTransforms for all generic collections */
+  implicit class IterablePolyTransforms[A, C[X] <: Iterable[X]](val c: Iterable[A] with FromIterator[C])
+  extends AnyVal with PolyTransforms[A, C] {
+    protected def iter = c.iterator
+    protected def fromIter[B](it: => Iterator[B]) = c.fromIterator(it)
+  }
+
+  /** Implementation of MonoTransformsForSeqs for all generic collections */
+  implicit class SeqMonoTransforms[A, C[X] <: Seq[X]](val c: Seq[A] with FromIterator[C])
+  extends AnyVal with MonoTransformsOfSeqs[A, C[A]] {
+    protected def iter = c.iterator
+    protected def fromIter(it: => Iterator[A]) = c.fromIterator(it)
+  }
+
+  /* --------- Concrete collection types ------------------------------- */
+
+  /** Concrete collection type: List */
+  sealed trait List[+A] extends Seq[A] with FromIterator[List] {
+    def isEmpty: Boolean
+    def head: A
+    def tail: List[A]
+    def iterator = new ListIterator[A](this)
+    def fromIterator[B](it: Iterator[B]): List[B] = List.fromIterator(it)
+    def apply(i: Int): A = {
+      require(!isEmpty)
+      if (i == 0) head else tail.apply(i - 1)
+    }
+    def length: Int =
+      if (isEmpty) 0 else 1 + tail.length
+  }
+
+  case class Cons[+A](x: A, xs: List[A]) extends List[A] {
+    def isEmpty = false
+    def head = x
+    def tail = xs
+  }
+
+  case object Nil extends List[Nothing] {
+    def isEmpty = true
+    def head = ???
+    def tail = ???
+  }
+
+  object List extends IterableFactory[List] {
+    def fromIterator[B](it: Iterator[B]): List[B] = it match {
+      case it: ListIterator[B] => it.toList
+      case _ => if (it.hasNext) Cons(it.next, fromIterator(it)) else Nil
+    }
+  }
+
+  class ListIterator[+A](xs: List[A]) extends Iterator[A] {
+    private[this] var current = xs
+    def hasNext = !current.isEmpty
+    def next = { val r = current.head; current = current.tail; r }
+    def toList = current
+  }
+
+  /** Concrete collection type: ArrayBuffer */
+  class ArrayBuffer[A] private (initElems: Array[AnyRef], initLength: Int) extends Seq[A] with FromIterator[ArrayBuffer] {
+    def this() = this(new Array[AnyRef](16), 0)
+    private var elems: Array[AnyRef] = initElems
+    private var start = 0
+    private var limit = initLength
+    def apply(i: Int) = elems(start + i).asInstanceOf[A]
+    def length = limit - start
+    def iterator = new ArrayBufferIterator[A](elems, start, length)
+    def fromIterator[B](it: Iterator[B]): ArrayBuffer[B] =
+      ArrayBuffer.fromIterator(it)
+    def +=(elem: A): this.type = {
+      if (limit == elems.length) {
+        if (start > 0) {
+          Array.copy(elems, start, elems, 0, length)
+          limit -= start
+          start = 0
+        }
+        else {
+          val newelems = new Array[AnyRef](limit * 2)
+          Array.copy(elems, 0, newelems, 0, limit)
+          elems = newelems
+        }
+      }
+      elems(limit) = elem.asInstanceOf[AnyRef]
+      limit += 1
+      this
+    }
+    def trimStart(n: Int): Unit = start += (n max 0)
+    override def toString = s"ArrayBuffer(${elems.slice(start, limit).mkString(", ")})"
+  }
+
+  object ArrayBuffer extends IterableFactory[ArrayBuffer] {
+    def fromIterator[B](it: Iterator[B]): ArrayBuffer[B] = it match {
+      case Iterator.Concat(fst: ArrayBufferIterator[_], snd: ArrayBufferIterator[_]) =>
+        val elems = new Array[AnyRef](fst.remaining + snd.remaining)
+        Array.copy(fst.elems, fst.start, elems, 0, fst.remaining)
+        Array.copy(snd.elems, snd.start, elems, fst.remaining, snd.remaining)
+        new ArrayBuffer(elems, elems.length)
+      case it @ Iterator.Partition(underlying, _, buf, _) =>
+        while (underlying.hasNext) it.distribute()
+        buf.asInstanceOf[ArrayBuffer[B]]
+      case it if it.remaining >= 0 =>
+        val elems = new Array[AnyRef](it.remaining)
+        for (i <- 0 until elems.length) elems(i) = it.next.asInstanceOf[AnyRef]
+        new ArrayBuffer[B](elems, elems.length)
+      case _ =>
+        val buf = new ArrayBuffer[B]
+        while (it.hasNext) buf += it.next
+        buf
+    }
+  }
+
+  class ArrayBufferIterator[A](val elems: Array[AnyRef], initStart: Int, length: Int) extends RandomAccessIterator[A] {
+    val limit = length
+    def apply(n: Int) = elems(initStart + n).asInstanceOf[A]
+  }
+
+  /** Concrete collection type: View */
+  class View[+A](it: => Iterator[A]) extends CanIterate[A] {
+    def iterator = it
+  }
+
+  implicit class ViewOps[A](val v: View[A]) extends AnyVal with Ops[A] {
+    def iterator = v.iterator
+    def cache = to(ArrayBuffer).view
+  }
+
+  implicit class ViewMonoTransforms[A](val v: View[A])
+  extends AnyVal with MonoTransforms[A, View[A]] {
+    protected def iter = v.iterator
+    protected def fromIter(it: => Iterator[A]): View[A] = new View(it)
+  }
+
+  implicit class ViewPolyTransforms[A](val v: View[A])
+  extends AnyVal with PolyTransforms[A, View] {
+    protected def iter = v.iterator
+    protected def fromIter[B](it: => Iterator[B]) = new View(it)
+  }
+
+  /** Concrete collection type: String */
+  implicit class StringOps(val s: String) extends AnyVal with Ops[Char] {
+    def iterator: Iterator[Char] = new RandomAccessIterator[Char] {
+      override val limit = s.length
+      def apply(n: Int) = s.charAt(n)
+    }
+  }
+
+  implicit class StringMonoTransforms(val s: String)
+  extends AnyVal with MonoTransformsOfSeqs[Char, String] {
+    protected def iter = StringOps(s).iterator
+    protected def fromIter(it: => Iterator[Char]) = {
+      val sb = new StringBuilder
+      for (ch <- it) sb.append(ch)
+      sb.toString
+    }
+  }
+
+  implicit class StringPolyTransforms(val s: String)
+  extends AnyVal with PolyTransforms[Char, Seq] {
+    protected def iter = StringOps(s).iterator
+    protected def fromIter[B](it: => Iterator[B]) = List.fromIterator(it)
+    def map(f: Char => Char): String = {
+      val sb = new StringBuilder
+      for (ch <- s) sb.append(f(ch))
+      sb.toString
+    }
+    def flatMap(f: Char => String) = {
+      val sb = new StringBuilder
+      for (ch <- s) sb.append(f(ch))
+      sb.toString
+    }
+    def ++(xs: CanIterate[Char]): String = {
+      val sb = new StringBuilder(s)
+      for (ch <- xs.iterator) sb.append(ch)
+      sb.toString
+    }
+    def ++(xs: String): String = s + xs
+  }
+
+/* ---------- Iterators --------------------------------------------------- */
+
+  /** A core Iterator class */
+  trait Iterator[+A] extends CanIterate[A] { self =>
+    def hasNext: Boolean
+    def next: A
+    def iterator = this
+    def foldLeft[B](z: B)(op: (B, A) => B): B =
+      if (hasNext) foldLeft(op(z, next))(op) else z
+    def foldRight[B](z: B)(op: (A, B) => B): B =
+      if (hasNext) op(next, foldRight(z)(op)) else z
+    def foreach(f: A => Unit): Unit =
+      while (hasNext) f(next)
+    def indexWhere(p: A => Boolean): Int = {
+      var i = 0
+      while (hasNext) {
+        if (p(next)) return i
+        i += 1
+      }
+      -1
+    }
+    def map[B](f: A => B): Iterator[B] = Iterator.Map(this, f)
+    def flatMap[B](f: A => CanIterate[B]): Iterator[B] = Iterator.FlatMap(this, f)
+    def ++[B >: A](xs: CanIterate[B]): Iterator[B] = Iterator.Concat(this, xs.iterator)
+    def partition(p: A => Boolean): (Iterator[A], Iterator[A]) = {
+      val lookaheadTrue, lookaheadFalse = new ArrayBuffer[A]
+      (Iterator.Partition(this, p, lookaheadTrue, lookaheadFalse),
+       Iterator.Partition[A](this, !p(_), lookaheadFalse, lookaheadTrue))
+    }
+    def drop(n: Int): Iterator[A] = Iterator.Drop(this, n)
+    def zip[B](that: CanIterate[B]): Iterator[(A, B)] = Iterator.Zip(this, that.iterator)
+    def reverse: Iterator[A] = {
+      var elems: List[A] = Nil
+      while (hasNext) elems = Cons(next, elems)
+      elems.iterator
+    }
+
+    /** If this iterator results from applying a transfomation to another iterator,
+     *  that other iterator, otherwise the iterator itself.
+     */
+    def underlying: Iterator[_] = this
+
+    /** If the number of elements still to be returned by this iterator is known,
+     *  that number, otherwise -1.
+     */
+    def remaining = -1
+  }
+
+  object Iterator {
+    val empty: Iterator[Nothing] = new Iterator[Nothing] {
+      def hasNext = false
+      def next = ???
+      override def remaining = 0
+    }
+    def apply[A](xs: A*): Iterator[A] = new RandomAccessIterator[A] {
+      override val limit = xs.length
+      def apply(n: Int) = xs(n)
+    }
+    def nextOnEmpty = throw new NoSuchElementException("next on empty iterator")
+
+    case class Map[A, B](override val underlying: Iterator[A], f: A => B) extends Iterator[B] {
+      def hasNext = underlying.hasNext
+      def next = f(underlying.next)
+      override def remaining = underlying.remaining
+    }
+    case class FlatMap[A, B](override val underlying: Iterator[A], f: A => CanIterate[B]) extends Iterator[B] {
+      private var myCurrent: Iterator[B] = Iterator.empty
+      private def current = {
+        while (!myCurrent.hasNext && underlying.hasNext)
+          myCurrent = f(underlying.next).iterator
+        myCurrent
+      }
+      def hasNext = current.hasNext
+      def next = current.next
+    }
+    case class Concat[A](override val underlying: Iterator[A], other: Iterator[A]) extends Iterator[A] {
+      private var myCurrent = underlying
+      private def current = {
+        if (!myCurrent.hasNext && myCurrent.eq(underlying)) myCurrent = other
+        myCurrent
+      }
+      def hasNext = current.hasNext
+      def next = current.next
+      override def remaining =
+        if (underlying.remaining >= 0 && other.remaining >= 0)
+          underlying.remaining + other.remaining
+        else -1
+    }
+    case class Partition[A](override val underlying: Iterator[A], p: A => Boolean, lookahead: ArrayBuffer[A], dual: ArrayBuffer[A]) extends Iterator[A] {
+      def distribute() = {
+        val elem = underlying.next
+        (if (p(elem)) lookahead else dual) += elem
+      }
+      final def hasNext: Boolean =
+        !lookahead.isEmpty || underlying.hasNext && { distribute(); hasNext }
+      final def next =
+        if (hasNext) {
+          val r = lookahead.head
+          lookahead.trimStart(1)
+          r
+        } else Iterator.nextOnEmpty
+    }
+    case class Drop[A](override val underlying: Iterator[A], n: Int) extends Iterator[A] {
+      var toSkip = n
+      def hasNext: Boolean = underlying.hasNext && (
+        toSkip == 0 || { underlying.next; toSkip -= 1; hasNext })
+      def next = if (hasNext) underlying.next else nextOnEmpty
+      override def remaining = (underlying.remaining - toSkip) max -1
+    }
+    case class Zip[A, B](override val underlying: Iterator[A], other: Iterator[B]) extends Iterator[(A, B)] {
+      def hasNext = underlying.hasNext && other.hasNext
+      def next = (underlying.next, other.next)
+      override def remaining = underlying.remaining min other.remaining
+    }
+    case class Reverse[A](override val underlying: RandomAccessIterator[A]) extends RandomAccessIterator[A] {
+      def apply(n: Int) = underlying.apply(underlying.limit - 1 - n)
+      def limit = underlying.remaining
+    }
+  }
+
+  trait RandomAccessIterator[+A] extends Iterator[A] { self =>
+    def apply(n: Int): A
+    def limit: Int
+    var start = 0
+    override def remaining = (limit - start) max 0
+    def hasNext = start < limit
+    def next: A = { val r = this(start); start += 1; r }
+    override def drop(n: Int): Iterator[A] = { start += (n max 0); this }
+    override def reverse: Iterator[A] = new Iterator.Reverse(this)
+  }
+}
+
diff --git a/test/test/DeSugarTest.scala b/test/test/DeSugarTest.scala
index 2c74abae73ad..44360d657cdc 100644
--- a/test/test/DeSugarTest.scala
+++ b/test/test/DeSugarTest.scala
@@ -35,7 +35,7 @@ class DeSugarTest extends ParserTest {
     def transform(trees: List[Tree], mode: Mode)(implicit ctx: Context): List[Tree] = withMode(mode) { transform(trees) }
 
     override def transform(tree: Tree)(implicit ctx: Context): Tree = {
-      val tree1 = desugar(tree)(ctx.withMode(curMode))
+      val tree1 = desugar(tree)(ctx.withModeBits(curMode))
       tree1 match {
         case TypedSplice(t) =>
           tree1
diff --git a/tests/pickling/i94-nada.scala b/tests/pending/pickling/i94-nada.scala
similarity index 100%
rename from tests/pickling/i94-nada.scala
rename to tests/pending/pickling/i94-nada.scala
diff --git a/tests/pos/Iter2.scala b/tests/pos/Iter2.scala
new file mode 100644
index 000000000000..b9dc5d625611
--- /dev/null
+++ b/tests/pos/Iter2.scala
@@ -0,0 +1,245 @@
+package dotty1.collections
+package immutable
+
+import annotation.unchecked.uncheckedVariance
+
+object Iter2 {
+
+  trait Iterator[+A] extends IterableOnce[A] {
+    def hasNext: Boolean
+    def next: A
+    def iterator = this
+    def foreach(f: A => Unit): Unit = ???
+    def map[B](f: A => B): Iterator[B] = ???
+    def flatMap[B](f: A => IterableOnce[B]): Iterator[B] = ???
+    def ++[B >: A](xs: IterableOnce[B]): Iterator[B] = ???
+    def drop(n: Int): Iterator[A] = ???
+    def indexWhere(p: A => Boolean): Int = {
+      var i = 0
+      while (hasNext) {
+        if (p(next)) return i
+        i += 1
+      }
+      -1
+    }
+    def zip[B](that: Iterator[B]): Iterator[(A, B)] = ???
+    def copy: Iterator[A] = ???
+  }
+/*
+  trait View[+A] { self =>
+    def iterator: Iterator[A]
+    def foreach(f: A => Unit): Unit = iterator.foreach(f)
+    def map[B](f: A => B): View[B] =
+      new View[B] { def iterator = self.iterator.map(f) }
+    def flatMap[B](f: A => IterableOnce[B]): View[B] =
+      new View[B]  { def iterator = self.iterator.flatMap(f) }
+    def ++[B >: A](xs: IterableOnce[B]): View[B] =
+      new View[B] { def iteratpr = self.iterator ++ xs }
+    def drop(n: Int): View[A] =
+      new View[A] { def iteratpr =   self.iterator.drop(n) }
+    def indexWhere(p: A => Boolean): Int = {
+      var i = 0
+      while (hasNext) {
+        if (p(next)) return i
+        i += 1
+      }
+      -1
+    }
+    def zip[B](that: Iterator[B]): Iterator[(A, B)] = ???
+  }
+*/
+
+  trait IterableOnce[+A] {
+    def iterator: Iterator[A]
+    def buildIterator: Iterator[A] = iterator
+  }
+
+  trait FromIterator[+C[X] <: Iterable[X]] {
+    def fromIterator[B](it: Iterator[B]): C[B]
+  }
+
+  trait Iterable[+IA] extends IterableOnce[IA] with FromIterator[Iterable] {
+    def view: View[IA] = new View(iterator)
+  }
+
+  trait Seq[+AA] extends Iterable[AA] with FromIterator[Seq] {
+    def apply(i: Int): AA
+    def length: Int
+  }
+
+  sealed trait List[+A] extends Seq[A] with FromIterator[List] {
+    def isEmpty: Boolean
+    def head: A
+    def tail: List[A]
+    def iterator = new ListIterator[A](this)
+    def fromIterator[B](it: Iterator[B]): List[B] = it match {
+      case ListIterator(xs) => xs
+      case _ => if (it.hasNext) Cons(it.next, fromIterator(it)) else Nil
+    }
+    def apply(i: Int): A = {
+      require(!isEmpty)
+      if (i == 0) head else tail.apply(i - 1)
+    }
+    def length: Int =
+      if (isEmpty) 0 else 1 + tail.length
+  }
+
+  class View[+A](it: Iterator[A]) extends Iterable[A] with FromIterator[View] {
+    def iterator: Iterator[A] = it.copy
+    def fromIterator[B](it: Iterator[B]): View[B] = new View(it)
+  }
+
+  case class Cons[+A](x: A, xs: List[A]) extends List[A] {
+    def isEmpty = false
+    def head = x
+    def tail = xs
+  }
+
+  case object Nil extends List[Nothing] {
+    def isEmpty = true
+    def head = ???
+    def tail = ???
+  }
+
+  class ArrayBuffer[A] private (initElems: Array[AnyRef], initLen: Int) extends Seq[A] with FromIterator[ArrayBuffer] {
+    def this() = this(new Array[AnyRef](16), 0)
+    def this(it: ArrayIterator[A]) = this(it.elems, it.len)
+    private var elems: Array[AnyRef] = initElems
+    private var len = 0
+    def iterator =
+      elems.iterator.take(len).asInstanceOf[Iterator[A]]
+    override def buildIterator =
+      new ArrayIterator(elems, len).asInstanceOf[Iterator[A]]
+    def fromIterator[B](it: Iterator[B]): ArrayBuffer[B] =
+      new ArrayBuffer(ArrayIterator.fromIterator(it))
+    def apply(i: Int) = elems(i).asInstanceOf[A]
+    def length = len
+  }
+/*
+  class SeqView[A](itf: () => Iterator) extends Seq[A] with FromIterator[SeqView] {
+    def iterator = it
+    def buildIterator = it
+    def fromIterator[B](it: Iterator[B]) = it match {
+      case ViewIterator(itf) => SeqView(itf)
+    }
+  }
+*/
+  implicit class IterableTransforms[A, C[X] <: Iterable[X]](val c: Iterable[A] with FromIterator[C]) extends AnyVal {
+    def map[B](f: A => B): C[B] = c.fromIterator(c.buildIterator.map(f))
+    def flatMap[B](f: A => IterableOnce[B]): C[B] = c.fromIterator(c.buildIterator.flatMap(f(_).buildIterator))
+    def ++[B >: A](xs: IterableOnce[B]): C[B] = c.fromIterator(c.buildIterator ++ xs.buildIterator)
+    def drop(n: Int): C[A] = c.fromIterator(c.buildIterator.drop(n))
+    def head: A = c.iterator.next
+    def zip[B](xs: IterableOnce[B]): C[(A, B)] = c.fromIterator(c.iterator.zip(xs.iterator))
+  }
+
+  implicit class SeqTransforms[SA, C[X] <: Seq[X]](val c: Seq[SA] with FromIterator[C]) extends AnyVal {
+    def reverse: C[SA] = {
+      val elems = new Array[AnyRef](c.length)
+      var i = elems.length
+      val it = c.iterator
+      while (it.hasNext) {
+        i -= 1
+        elems(i) = it.next.asInstanceOf[AnyRef]
+      }
+      val xzz = c.fromIterator(ArrayIterator[SA](elems, c.length))
+      xzz
+    }
+    def indexWhere(p: SA => Boolean): Int = c.iterator.indexWhere(p)
+  }
+/*
+  case class ViewIterator[+A](itf: () => Iterator) extends Iterator[A] {
+
+    def hasNext = it.hasNext
+    def next
+    def map(f: A => B): ViewIterator[B] = ViewIterator(() => it().map(f))
+    def
+  }
+*/
+  case class ListIterator[+A](xs: List[A]) extends Iterator[A] {
+    private[this] var current: List[A] = xs
+    def hasNext = !current.isEmpty
+    def next = { val res = current.head; current = current.tail; res }
+  }
+
+  case class ArrayIterator[+A](elems: Array[AnyRef], len: Int) extends Iterator[A] {
+    import ArrayIterator._
+
+    private def elem(i: Int) = elems(i).asInstanceOf[A]
+
+    private var cur = 0
+
+    def hasNext = cur < len
+    def next = { val res = elem(cur); cur += 1; res }
+
+    override def foreach(f: A => Unit): Unit =
+      for (i <- 0 until len) f(elem(i))
+
+    override def map[B](f: A => B): ArrayIterator[B] = {
+      var mapped = elems
+      for (i <- 0 until len) {
+        val x = elem(i)
+        val y = widen(f(x))
+        if (widen(x) ne y) {
+          if (mapped eq elems) mapped = new Array[AnyRef](len)
+          mapped(i) = y
+        }
+      }
+      if (mapped eq elems) this.asInstanceOf[ArrayIterator[B]]
+      else new ArrayIterator(mapped, len)
+    }
+
+    override def flatMap[B](f: A => IterableOnce[B]): ArrayIterator[B] =
+      flatten(map(f(_).buildIterator))
+
+    override def ++[B >: A](that: IterableOnce[B]): ArrayIterator[B] = {
+      val thatIterator @ ArrayIterator(elems2, len2) = fromIterator(that.iterator)
+      if (len == 0) thatIterator
+      else if (len2 == 0) this
+      else {
+        val resLen = len + len2
+        val resElems = new Array[AnyRef](resLen)
+        Array.copy(elems, 0, resElems, 0, len)
+        Array.copy(elems2, 0, resElems, len, len2)
+        new ArrayIterator(resElems, resLen)
+      }
+    }
+  }
+
+  object ArrayIterator {
+    private def widen(x: Any): AnyRef = x.asInstanceOf[AnyRef]
+
+    def fromIterator[A](it: Iterator[A]): ArrayIterator[A] = it match {
+      case it: ArrayIterator[A] => it
+      case _ =>
+        var elems = new Array[AnyRef](32)
+        var len = 0
+        def ensureCapacity() = {
+          while (len > elems.length) {
+            val newElems = new Array[AnyRef](elems.length * 2)
+            Array.copy(elems, 0, newElems, 0, elems.length)
+            elems = newElems
+          }
+        }
+        while (it.hasNext) {
+          len += 1
+          ensureCapacity()
+          elems(len - 1) = widen(it.next)
+        }
+        ArrayIterator(elems, len)
+    }
+
+    def flatten[A](its: ArrayIterator[Iterator[A]]): ArrayIterator[A] = {
+      var arrayIts = its.map(fromIterator)
+      var totalLen = 0
+      arrayIts.foreach(totalLen += _.len)
+      val allElems = new Array[AnyRef](totalLen)
+      var j = 0
+      arrayIts.foreach { it =>
+        Array.copy(it.elems, 0, allElems, j, it.len)
+        j += it.len
+      }
+      new ArrayIterator(allElems, totalLen)
+    }
+  }
+}
diff --git a/tests/run/CollectionTests.check b/tests/run/CollectionTests.check
new file mode 100644
index 000000000000..6c61d8821444
--- /dev/null
+++ b/tests/run/CollectionTests.check
@@ -0,0 +1,68 @@
+-------
+123
+123
+1
+1
+Cons(1,Cons(2,Cons(3,Nil)))
+Cons(2,Nil)
+Cons(1,Cons(3,Nil))
+Cons(3,Nil)
+Cons(true,Cons(true,Cons(true,Nil)))
+Cons(1,Cons(-1,Cons(2,Cons(-2,Cons(3,Cons(-3,Nil))))))
+Cons(1,Cons(2,Cons(3,Cons(1,Cons(2,Cons(3,Nil))))))
+Cons(1,Cons(2,Cons(3,Nil)))
+Cons(1,Cons(2,Cons(3,Nil)))
+Cons(1,Cons(2,Cons(3,Cons(a,Nil))))
+Cons((1,true),Cons((2,true),Cons((3,true),Nil)))
+Cons(3,Cons(2,Cons(1,Nil)))
+-------
+123
+123
+1
+1
+Cons(1,Cons(2,Cons(3,Nil)))
+ArrayBuffer(2)
+ArrayBuffer(1, 3)
+ArrayBuffer(3)
+ArrayBuffer(true, true, true)
+ArrayBuffer(1, -1, 2, -2, 3, -3)
+ArrayBuffer(1, 2, 3, 1, 2, 3)
+ArrayBuffer(1, 2, 3)
+Cons(1,Cons(2,Cons(3,Nil)))
+ArrayBuffer(1, 2, 3, a)
+ArrayBuffer((1,true), (2,true), (3,true))
+ArrayBuffer(3, 2, 1)
+-------
+123
+123
+1
+1
+Cons(1,Cons(2,Cons(3,Nil)))
+Cons(2,Nil)
+Cons(1,Cons(3,Nil))
+Cons(3,Nil)
+Cons(true,Cons(true,Cons(true,Nil)))
+Cons(1,Cons(-1,Cons(2,Cons(-2,Cons(3,Cons(-3,Nil))))))
+Cons(1,Cons(2,Cons(3,Cons(1,Cons(2,Cons(3,Nil))))))
+Cons(1,Cons(2,Cons(3,Nil)))
+Cons(1,Cons(2,Cons(3,Nil)))
+Cons(1,Cons(2,Cons(3,Cons(a,Nil))))
+Cons((1,true),Cons((2,true),Cons((3,true),Nil)))
+-------
+abc
+abc
+1
+a
+Cons(a,Cons(b,Cons(c,Nil)))
+b
+ac
+c
+Cons(98,Cons(99,Cons(100,Nil)))
+ABC
+a,ab,bc,c
+abcabc
+abcxy
+abc
+Cons(a,Cons(b,Cons(c,Nil)))
+Cons(a,Cons(b,Cons(c,Cons(xyz,Nil))))
+Cons((a,98),Cons((b,99),Cons((c,100),Nil)))
diff --git a/tests/run/CollectionTests.scala b/tests/run/CollectionTests.scala
new file mode 100644
index 000000000000..bcef547618aa
--- /dev/null
+++ b/tests/run/CollectionTests.scala
@@ -0,0 +1,170 @@
+import Predef.{augmentString => _, wrapString => _, _}
+import scala.reflect.ClassTag
+
+object Test {
+  import strawman.collections._
+  import CollectionStrawMan1._
+
+  def seqOps(xs: Seq[Int]) = {
+    val x1 = xs.foldLeft("")(_ + _)
+    val y1: String = x1
+    val x2 = xs.foldRight("")(_ + _)
+    val y2: String = x2
+    val x3 = xs.indexWhere(_ % 2 == 0)
+    val y3: Int = x3
+    val x4 = xs.head
+    val y4: Int = x4
+    val x5 = xs.to(List)
+    val y5: List[Int] = x5
+    val (xs6, xs7) = xs.partition(_ % 2 == 0)
+    val ys6: Seq[Int] = xs6
+    val ys7: Seq[Int] = xs7
+    val xs8 = xs.drop(2)
+    val ys8: Seq[Int] = xs8
+    val xs9 = xs.map(_ >= 0)
+    val ys9: Seq[Boolean] = xs9
+    val xs10 = xs.flatMap(x => Cons(x, Cons(-x, Nil)))
+    val ys10: Seq[Int] = xs10
+    val xs11 = xs ++ xs
+    val ys11: Seq[Int] = xs11
+    val xs12 = xs ++ Nil
+    val ys12: Seq[Int] = xs12
+    val xs13 = Nil ++ xs
+    val ys13: Seq[Int] = xs13
+    val xs14 = xs ++ Cons("a", Nil)
+    val ys14: Seq[Any] = xs14
+    val xs15 = xs.zip(xs9)
+    val ys15: Seq[(Int, Boolean)] = xs15
+    val xs16 = xs.reverse
+    val ys16: Seq[Int] = xs16
+    println("-------")
+    println(x1)
+    println(x2)
+    println(x3)
+    println(x4)
+    println(x5)
+    println(xs6)
+    println(xs7)
+    println(xs8)
+    println(xs9)
+    println(xs10)
+    println(xs11)
+    println(xs12)
+    println(xs13)
+    println(xs14)
+    println(xs15)
+    println(xs16)
+  }
+
+  def viewOps(xs: View[Int]) = {
+    val x1 = xs.foldLeft("")(_ + _)
+    val y1: String = x1
+    val x2 = xs.foldRight("")(_ + _)
+    val y2: String = x2
+    val x3 = xs.indexWhere(_ % 2 == 0)
+    val y3: Int = x3
+    val x4 = xs.head
+    val y4: Int = x4
+    val x5 = xs.to(List)
+    val y5: List[Int] = x5
+    val (xs6, xs7) = xs.partition(_ % 2 == 0)
+    val ys6: View[Int] = xs6
+    val ys7: View[Int] = xs7
+    val xs8 = xs.drop(2)
+    val ys8: View[Int] = xs8
+    val xs9 = xs.map(_ >= 0)
+    val ys9: View[Boolean] = xs9
+    val xs10 = xs.flatMap(x => Cons(x, Cons(-x, Nil)))
+    val ys10: View[Int] = xs10
+    val xs11 = xs ++ xs
+    val ys11: View[Int] = xs11
+    val xs12 = xs ++ Nil
+    val ys12: View[Int] = xs12
+    val xs13 = Nil ++ xs
+    val ys13: List[Int] = xs13
+    val xs14 = xs ++ Cons("a", Nil)
+    val ys14: View[Any] = xs14
+    val xs15 = xs.zip(xs9)
+    val ys15: View[(Int, Boolean)] = xs15
+    println("-------")
+    println(x1)
+    println(x2)
+    println(x3)
+    println(x4)
+    println(x5)
+    println(xs6.to(List))
+    println(xs7.to(List))
+    println(xs8.to(List))
+    println(xs9.to(List))
+    println(xs10.to(List))
+    println(xs11.to(List))
+    println(xs12.to(List))
+    println(xs13.to(List))
+    println(xs14.to(List))
+    println(xs15.to(List))
+  }
+
+  def stringOps(xs: String) = {
+    val x1 = xs.foldLeft("")(_ + _)
+    val y1: String = x1
+    val x2 = xs.foldRight("")(_ + _)
+    val y2: String = x2
+    val x3 = xs.indexWhere(_ % 2 == 0)
+    val y3: Int = x3
+    val x4 = xs.head
+    val y4: Int = x4
+    val x5 = xs.to(List)
+    val y5: List[Char] = x5
+    val (xs6, xs7) = xs.partition(_ % 2 == 0)
+    val ys6: String = xs6
+    val ys7: String = xs7
+    val xs8 = xs.drop(2)
+    val ys8: String = xs8
+    val xs9 = xs.map((_: Char) + 1)  // !!! need a language change to make this work without the : Char
+    val ys9: Seq[Int] = xs9
+    val xs9a = xs.map((_: Char).toUpper) // !!! need a language change to make this work without the : Char
+    val ys9a: String = xs9a
+    val xs10 = xs.flatMap((x: Char) => s"$x,$x")
+    val ys10: String = xs10
+    val xs11 = xs ++ xs
+    val ys11: String = xs11
+    val xs11a = xs ++ List('x', 'y')
+    val ys11a: String = xs11a
+    val xs12 = xs ++ Nil
+    val ys12: String = xs12
+    val xs13 = Nil ++ xs.iterator
+    val ys13: List[Char] = xs13
+    val xs14 = xs ++ Cons("xyz", Nil)
+    val ys14: Seq[Any] = xs14
+    val xs15 = xs.zip(xs9)
+    val ys15: Seq[(Char, Int)] = xs15
+    println("-------")
+    println(x1)
+    println(x2)
+    println(x3)
+    println(x4)
+    println(x5)
+    println(xs6)
+    println(xs7)
+    println(xs8)
+    println(xs9)
+    println(xs9a)
+    println(xs10)
+    println(xs11)
+    println(xs11a)
+    println(xs12)
+    println(xs13)
+    println(xs14)
+    println(xs15)
+  }
+
+  def main(args: Array[String]) = {
+    val ints = Cons(1, Cons(2, Cons(3, Nil)))
+    val intsBuf = ints.to(ArrayBuffer)
+    val intsView = ints.view
+    seqOps(ints)
+    seqOps(intsBuf)
+    viewOps(intsView)
+    stringOps("abc")
+  }
+}