reverted immutable.Vector because it gave rando...

reverted immutable.Vector because it gave random build errors on my
machine. Fixed various tickets, updated test and check files.

9 files changed, 124 insertions, 98 deletions

diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala
index 47ede4228e..6b3d24ffa2 100644
--- a/src/compiler/scala/tools/nsc/symtab/Types.scala
+++ b/src/compiler/scala/tools/nsc/symtab/Types.scala
@@ -3247,6 +3247,9 @@ A type's typeSymbol should never be inspected directly.
     }
   }
 
+  class MissingAliasException extends Exception
+  val missingAliasException = new MissingAliasException
+
   object adaptToNewRunMap extends TypeMap {
     private def adaptToNewRun(pre: Type, sym: Symbol): Symbol = {
       if (sym.isModuleClass && !phase.flatClasses) {
@@ -3256,7 +3259,9 @@ A type's typeSymbol should never be inspected directly.
       } else {
         var rebind0 = pre.findMember(sym.name, BRIDGE, 0, true)(NoSymbol)
         if (rebind0 == NoSymbol) {
-          assert(false, ""+pre+"."+sym+" does no longer exist, phase = "+phase) }
+          if (sym.isAliasType) throw missingAliasException
+          assert(false, pre+"."+sym+" does no longer exist, phase = "+phase)
+        }
         /** The two symbols have the same fully qualified name */
         def corresponds(sym1: Symbol, sym2: Symbol): Boolean =
           sym1.name == sym2.name && (sym1.isPackageClass || corresponds(sym1.owner, sym2.owner))
@@ -3294,9 +3299,14 @@ A type's typeSymbol should never be inspected directly.
         else {
           val pre1 = this(pre)
           val args1 = args mapConserve (this)
-          val sym1 = adaptToNewRun(pre1, sym)
-          if ((pre1 eq pre) && (sym1 eq sym) && (args1 eq args)/* && sym.isExternal*/) tp
-          else typeRef(pre1, sym1, args1)
+          try {
+            val sym1 = adaptToNewRun(pre1, sym)
+            if ((pre1 eq pre) && (sym1 eq sym) && (args1 eq args)/* && sym.isExternal*/) tp
+            else typeRef(pre1, sym1, args1)
+          } catch {
+            case ex: MissingAliasException =>
+              apply(tp.dealias)
+          }
         }
       case MethodType(params, restp) =>
         val restp1 = this(restp)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 133c0c1b3e..a83ce8e53b 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -735,10 +735,15 @@ self: Analyzer =>
               "classType", tp,
               (if ((pre eq NoPrefix) || pre.typeSymbol.isStaticOwner) suffix
                else findSubManifest(pre) :: suffix): _*)
-          } else if (sym.isAbstractType && !sym.isTypeParameterOrSkolem && !sym.isExistential) {
-            manifestFactoryCall(
-              "abstractType", tp,
-              findSubManifest(pre) :: Literal(sym.name.toString) :: findManifest(tp0.bounds.hi) :: (args map findSubManifest): _*)
+          } else if (sym.isAbstractType) {
+            if (sym.isExistential)
+              EmptyTree // todo: change to existential parameter manifest
+            else if (sym.isTypeParameterOrSkolem)
+              EmptyTree  // a manifest should have been found by normal searchImplicit
+            else
+              manifestFactoryCall(
+                "abstractType", tp,
+                findSubManifest(pre) :: Literal(sym.name.toString) :: findManifest(tp0.bounds.hi) :: (args map findSubManifest): _*)
           } else {
             EmptyTree  // a manifest should have been found by normal searchImplicit
           }
@@ -747,7 +752,10 @@ self: Analyzer =>
           if (parents.length == 1) findManifest(parents.head)
           else manifestFactoryCall("intersectionType", tp, parents map (findSubManifest(_)): _*)
         case ExistentialType(tparams, result) =>
-          mot(result)
+          existentialAbstraction(tparams, result) match {
+            case ExistentialType(_, _) => mot(result)
+            case t => mot(t)
+          }
         case _ =>
           EmptyTree
       }
diff --git a/src/library/scala/collection/IterableViewLike.scala b/src/library/scala/collection/IterableViewLike.scala
index 5164cf62f1..5a2db7e02f 100644
--- a/src/library/scala/collection/IterableViewLike.scala
+++ b/src/library/scala/collection/IterableViewLike.scala
@@ -14,7 +14,7 @@ package scala.collection
 import generic._
 import TraversableView.NoBuilder
 
-/** A base class for views of Iterables.
+/** A template trait for a non-strict view of an iterable.
  *
  *  @author Martin Odersky
  *  @version 2.8
@@ -64,8 +64,8 @@ extends Iterable[A] with IterableLike[A, This] with TraversableView[A, Coll] wit
 
   trait ZippedAll[A1 >: A, B] extends Transformed[(A1, B)] {
     protected[this] val other: Iterable[B]
-    val thisElem: A1
-    val thatElem: B
+    protected[this] val thisElem: A1
+    protected[this] val thatElem: B
     override def iterator: Iterator[(A1, B)] =
       self.iterator.zipAll(other.iterator, thisElem, thatElem)
   }
diff --git a/src/library/scala/collection/SeqViewLike.scala b/src/library/scala/collection/SeqViewLike.scala
index 471d447a15..38cfa7ba05 100644
--- a/src/library/scala/collection/SeqViewLike.scala
+++ b/src/library/scala/collection/SeqViewLike.scala
@@ -15,7 +15,7 @@ import generic._
 import Seq.fill
 import TraversableView.NoBuilder
 
-/** A non-strict projection of an iterable.
+/** A template trait for a non-strict view of a sequence.
  * @author Sean McDirmid
  * @author Martin Odersky
  * @version 2.8
@@ -65,7 +65,7 @@ trait SeqViewLike[+A,
   }
 
   trait Appended[B >: A] extends Transformed[B] with super.Appended[B] {
-    lazy val restSeq = rest.toSeq
+    protected[this] lazy val restSeq = rest.toSeq
     override def length = self.length + restSeq.length
     override def apply(idx: Int) =
       if (idx < self.length) self(idx) else restSeq(idx - self.length)
@@ -102,6 +102,20 @@ trait SeqViewLike[+A,
       else throw new IndexOutOfBoundsException(idx.toString)
   }
 
+  trait Zipped[B] extends Transformed[(A, B)] with super.Zipped[B] {
+    protected[this] lazy val thatSeq = other.toSeq
+    override def length: Int = self.length min thatSeq.length
+    override def apply(idx: Int) = (self.apply(idx), thatSeq.apply(idx))
+  }
+
+  trait ZippedAll[A1 >: A, B] extends Transformed[(A1, B)] with super.ZippedAll[A1, B] {
+    protected[this] lazy val thatSeq = other.toSeq
+    override def length: Int = self.length max thatSeq.length
+    override def apply(idx: Int) =
+      (if (idx < self.length) self.apply(idx) else thisElem,
+       if (idx < thatSeq.length) thatSeq.apply(idx) else thatElem)
+  }
+
   trait Reversed extends Transformed[A] {
     override def iterator: Iterator[A] = self.reverseIterator
     override def length: Int = self.length
@@ -133,10 +147,10 @@ trait SeqViewLike[+A,
   protected override def newSliced(_from: Int, _until: Int): Transformed[A] = new Sliced { val from = _from; val until = _until }
   protected override def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p }
   protected override def newTakenWhile(p: A => Boolean): Transformed[A] = new TakenWhile { val pred = p }
+  protected override def newZipped[B](that: Iterable[B]): Transformed[(A, B)] = new Zipped[B] { val other = that }
+  protected override def newZippedAll[A1 >: A, B](that: Iterable[B], _thisElem: A1, _thatElem: B): Transformed[(A1, B)] = new ZippedAll[A1, B] { val other = that; val thisElem = _thisElem; val thatElem = _thatElem }
   protected def newReversed: Transformed[A] = new Reversed { }
-  protected def newPatched[B >: A](_from: Int, _patch: Seq[B], _replaced: Int): Transformed[B] = new Patched[B] {
-    val from = _from; val patch = _patch; val replaced = _replaced
-  }
+  protected def newPatched[B >: A](_from: Int, _patch: Seq[B], _replaced: Int): Transformed[B] = new Patched[B] { val from = _from; val patch = _patch; val replaced = _replaced }
 
   override def reverse: This = newReversed.asInstanceOf[This]
 
diff --git a/src/library/scala/collection/TraversableViewLike.scala b/src/library/scala/collection/TraversableViewLike.scala
index b19c02ea35..9303e473fd 100644
--- a/src/library/scala/collection/TraversableViewLike.scala
+++ b/src/library/scala/collection/TraversableViewLike.scala
@@ -17,7 +17,7 @@ import Math.MAX_INT
 import TraversableView.NoBuilder
 
 /** <p>
- *    A base class for views of <a href="../Traversable.html"
+ *    A template trait for views of <a href="../Traversable.html"
  *    target="contentFrame"><code>Traversable</code></a>.<br/>
  *    Every subclass has to implement the <code>foreach</code> method.
  *  </p>
diff --git a/src/library/scala/collection/VectorView.scala b/src/library/scala/collection/VectorView.scala
index b679a4d04e..83705384be 100644
--- a/src/library/scala/collection/VectorView.scala
+++ b/src/library/scala/collection/VectorView.scala
@@ -26,4 +26,5 @@ trait VectorView[+A, +Coll] extends VectorViewLike[A, Coll, VectorView[A, Coll]]
 object VectorView {
   type Coll = TraversableView[_, C] forSome {type C <: Traversable[_]}
   implicit def builderFactory[A]: BuilderFactory[A, VectorView[A, Vector[_]], Coll] = new BuilderFactory[A, VectorView[A, Vector[_]], Coll] { def apply(from: Coll) = new NoBuilder }
+  implicit def arrBuilderFactory[A]: BuilderFactory[A, VectorView[A, Array[A]], TraversableView[_, Array[_]]] = new BuilderFactory[A, VectorView[A, Array[A]], TraversableView[_, Array[_]]] { def apply(from: TraversableView[_, Array[_]]) = new NoBuilder }
 }
diff --git a/src/library/scala/collection/VectorViewLike.scala b/src/library/scala/collection/VectorViewLike.scala
index dfaa0f4752..fa8b31301a 100644
--- a/src/library/scala/collection/VectorViewLike.scala
+++ b/src/library/scala/collection/VectorViewLike.scala
@@ -14,7 +14,7 @@ package scala.collection
 import generic._
 import TraversableView.NoBuilder
 
-/** A non-strict projection of an iterable.
+/** A template trait for a non-strict view of a vector.
  *
  * @author Sean McDirmid
  * @author Martin Odersky
@@ -99,17 +99,11 @@ trait VectorViewLike[+A,
   protected override def newSliced(_from: Int, _until: Int): Transformed[A] = new Sliced { val from = _from; val until = _until }
   protected override def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p }
   protected override def newTakenWhile(p: A => Boolean): Transformed[A] = new TakenWhile { val pred = p }
+  protected override def newZipped[B](that: Iterable[B]): Transformed[(A, B)] = new Zipped[B] { val other = that }
+  protected override def newZippedAll[A1 >: A, B](that: Iterable[B], _thisElem: A1, _thatElem: B): Transformed[(A1, B)] = new ZippedAll[A1, B] { val other = that; val thisElem = _thisElem; val thatElem = _thatElem }
   protected override def newReversed: Transformed[A] = new Reversed { }
   protected override def newPatched[B >: A](_from: Int, _patch: Seq[B], _replaced: Int): Transformed[B] = new Patched[B] {
     val from = _from; val patch = _patch; val replaced = _replaced
   }
-  protected override def newZipped[B](that: Iterable[B]): Transformed[(A, B)] = new Zipped[B] {
-    val other = that
-  }
-  protected override def newZippedAll[A1 >: A, B](that: Iterable[B], _thisElem: A1, _thatElem: B): Transformed[(A1, B)] = new ZippedAll[A1, B] {
-    val other: Iterable[B] = that
-    val thisElem = _thisElem
-    val thatElem = _thatElem
-  }
   override def stringPrefix = "VectorView"
 }
diff --git a/src/library/scala/collection/mutable/VectorView.scala b/src/library/scala/collection/mutable/VectorView.scala
index 1564511cab..45a21e3429 100644
--- a/src/library/scala/collection/mutable/VectorView.scala
+++ b/src/library/scala/collection/mutable/VectorView.scala
@@ -13,18 +13,85 @@ package scala.collection
 package mutable
 
 import generic._
+import Math.MAX_INT
 
 import TraversableView.NoBuilder
 
-/** A non-strict projection of an iterable.
+/** A non-strict view of a mutable vector.
+ *  This is a leaf class which mixes methods returning a plain vector view
+ *  and methods returning a mutable vector view.
+ *  There is no associated `Like' class.
  * @author Sean McDirmid
  * @author Martin Odersky
  * @version 2.8
  * @since   2.8
  */
-trait VectorView[A, +Coll] extends VectorViewLike[A, Coll, VectorView[A, Coll]]
+trait VectorView[A, +Coll] extends scala.collection.VectorView[A, Coll] {
+self =>
 
-object VectorView {
+  def update(idx: Int, elem: A)
+
+  trait Transformed[B] extends VectorView[B, Coll] with super.Transformed[B] {
+    def update(idx: Int, elem: B)
+  }
+
+  trait Sliced extends Transformed[A] with super.Sliced {
+    override def update(idx: Int, elem: A) =
+      if (idx + from < until) self.update(idx + from, elem)
+      else throw new IndexOutOfBoundsException(idx.toString)
+    override def slice(from1: Int, until1: Int): Transformed[A] =
+      newSliced(from1 max 0, until1 max 0)
+  }
+
+  trait Filtered extends Transformed[A] with super.Filtered {
+    override def update(idx: Int, elem: A) = self.update(index(idx), elem)
+  }
+
+  trait TakenWhile extends Transformed[A] with super.TakenWhile {
+    override def update(idx: Int, elem: A) =
+      if (idx < len) self.update(idx, elem)
+      else throw new IndexOutOfBoundsException(idx.toString)
+  }
+
+  trait DroppedWhile extends Transformed[A] with super.DroppedWhile {
+    override def update(idx: Int, elem: A) =
+      if (idx >= 0) self.update(idx + start, elem)
+      else throw new IndexOutOfBoundsException(idx.toString)
+  }
+
+  trait Reversed extends Transformed[A] with super.Reversed {
+    override def update(idx: Int, elem: A) = self.update(length - 1 - idx, elem)
+  }
+
+  /** Boilerplate method, to override in each subclass
+   *  This method could be eliminated if Scala had virtual classes
+   */
+  protected override def newFiltered(p: A => Boolean): Transformed[A] = new Filtered { val pred = p }
+  protected override def newSliced(_from: Int, _until: Int): Transformed[A] = new Sliced { val from = _from; val until = _until }
+  protected override def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p }
+  protected override def newTakenWhile(p: A => Boolean): Transformed[A] = new TakenWhile { val pred = p }
+  protected override def newReversed: Transformed[A] = new Reversed { }
+
+  // Todo: if we replace VectorView[A, Coll] below by
+  // private[this] type This = VectorView[A, Coll]
+  // The interpreter will display resX.This.
+  // It shouldn't.
+
+  override def filter(p: A => Boolean): VectorView[A, Coll] = newFiltered(p)
+  override def init: VectorView[A, Coll]  = newSliced(0, size - 1).asInstanceOf[VectorView[A, Coll]]
+  override def drop(n: Int): VectorView[A, Coll] = newSliced(n max 0, MAX_INT).asInstanceOf[VectorView[A, Coll]]
+  override def take(n: Int): VectorView[A, Coll] = newSliced(0, n).asInstanceOf[VectorView[A, Coll]]
+  override def slice(from: Int, until: Int): VectorView[A, Coll] = newSliced(from max 0, until).asInstanceOf[VectorView[A, Coll]]
+  override def dropWhile(p: A => Boolean): VectorView[A, Coll] = newDroppedWhile(p).asInstanceOf[VectorView[A, Coll]]
+  override def takeWhile(p: A => Boolean): VectorView[A, Coll] = newTakenWhile(p).asInstanceOf[VectorView[A, Coll]]
+  override def span(p: A => Boolean): (VectorView[A, Coll], VectorView[A, Coll]) = (takeWhile(p), dropWhile(p))
+  override def splitAt(n: Int): (VectorView[A, Coll], VectorView[A, Coll]) = (take(n), drop(n))
+  override def reverse: VectorView[A, Coll] = newReversed.asInstanceOf[VectorView[A, Coll]]
+}
+
+/*
+ * object VectorView {
   type Coll = TraversableView[_, C] forSome { type C <: scala.collection.Traversable[_] }
   implicit def builderFactory[A]: BuilderFactory[A, VectorView[A, Vector[_]], Coll] = new BuilderFactory[A, VectorView[A, mutable.Vector[_]], Coll] { def apply(from: Coll) = new NoBuilder }
 }
+*/
diff --git a/src/library/scala/collection/mutable/VectorViewLike.scala b/src/library/scala/collection/mutable/VectorViewLike.scala
deleted file mode 100644
index dbde90c024..0000000000
--- a/src/library/scala/collection/mutable/VectorViewLike.scala
+++ /dev/null
@@ -1,68 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2009, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-// $Id$
-
-
-package scala.collection
-package mutable
-
-import TraversableView.NoBuilder
-
-/** A non-strict projection of an iterable.
- * @author Sean McDirmid
- * @author Martin Odersky
- * @version 2.8
- * @since   2.8
- */
-trait VectorViewLike[A,
-                     +Coll,
-                     +This <: VectorView[A, Coll] with VectorViewLike[A, Coll, This]]
-  extends Vector[A] with VectorLike[A, This] with scala.collection.VectorView[A, Coll] with scala.collection.VectorViewLike[A, Coll, This]
-{ self =>
-
-  trait Transformed[B] extends VectorView[B, Coll] with super.Transformed[B] {
-    def update(idx: Int, elem: B)
-  }
-
-  trait Sliced extends Transformed[A] with super.Sliced {
-    override def update(idx: Int, elem: A) =
-      if (idx + from < until) self.update(idx + from, elem)
-      else throw new IndexOutOfBoundsException(idx.toString)
-  }
-
-  trait Filtered extends Transformed[A] with super.Filtered {
-    override def update(idx: Int, elem: A) = self.update(index(idx), elem)
-  }
-
-  trait TakenWhile extends Transformed[A] with super.TakenWhile {
-    override def update(idx: Int, elem: A) =
-      if (idx < len) self.update(idx, elem)
-      else throw new IndexOutOfBoundsException(idx.toString)
-  }
-
-  trait DroppedWhile extends Transformed[A] with super.DroppedWhile {
-    override def update(idx: Int, elem: A) =
-      if (idx >= 0) self.update(idx + start, elem)
-      else throw new IndexOutOfBoundsException(idx.toString)
-  }
-
-  trait Reversed extends Transformed[A] with super.Reversed {
-    override def update(idx: Int, elem: A) = self.update(length - 1 - idx, elem)
-  }
-
-  /** Boilerplate method, to override in each subclass
-   *  This method could be eliminated if Scala had virtual classes
-   */
-  protected override def newFiltered(p: A => Boolean): Transformed[A] = new Filtered { val pred = p }
-  protected override def newSliced(_from: Int, _until: Int): Transformed[A] = new Sliced { val from = _from; val until = _until }
-  protected override def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p }
-  protected override def newTakenWhile(p: A => Boolean): Transformed[A] = new TakenWhile { val pred = p }
-  protected override def newReversed: Transformed[A] = new Reversed { }
-}
-