Merged revisions 24881,24956,24962,24966-24968,...

Merged revisions 24881,24956,24962,24966-24968,24991-24993 via svnmerge
from https://lampsvn.epfl.ch/svn-repos/scala/scala/trunk

........
  r24881 | odersky | 2011-05-03 16:44:33 +0200 (Tue, 03 May 2011) | 1 line

  Closes #4537. No review.
........
  r24956 | extempore | 2011-05-14 18:54:42 +0200 (Sat, 14 May 2011) | 1 line

  Fix for view+groupBy closes #4558, no review.
........
  r24962 | extempore | 2011-05-15 01:00:05 +0200 (Sun, 15 May 2011) | 7 lines

  Fix for Iterator flattening regression. Not sure what happened, but
  my theory is that ++ takes a by name argument, but doing a foldLeft
  and using ++ to join creates a closure which loses the by-nameness. If
  this theory is correct that's an ugly trap.

  Not sure how I write a test against this sort of thing? Will take
pointers. For now, closes #4582, no review. ........ r24966 | odersky |
2011-05-16 14:51:54 +0200 (Mon, 16 May 2011) | 1 line

  Removed ill-fated bridge method. Review by extempore. ........ r24967
| odersky | 2011-05-16 14:57:15 +0200 (Mon, 16 May 2011) | 1 line

  Removing two more @bridge methods because they do not make sense
anymore. Review by extempore. ........ r24968 | odersky | 2011-05-16
16:37:10 +0200 (Mon, 16 May 2011) | 1 line

  Closes 4560. Review by dragos.
........
  r24991 | prokopec | 2011-05-19 16:04:13 +0200 (Thu, 19 May 2011) | 3 lines

  Fixes and closes #4608.

  No review.
........
  r24992 | extempore | 2011-05-19 20:07:57 +0200 (Thu, 19 May 2011) | 2 lines

  Specialized keySets for immutable and sorted maps are supposed to
be views, not actual sets. Closes #4616, no review. ........ r24993 |
extempore | 2011-05-19 20:08:15 +0200 (Thu, 19 May 2011) | 3 lines

  Apparent assumption that Literal(0) would be adapted to Literal(0.0f)
as necessary mercilessly invalidated. Fixed mkZero to account for all
types explicitly. Closes #4617, no review. ........

15 files changed, 104 insertions, 22 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
index 41faf00a04..aa829d61ab 100644
--- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala
+++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
@@ -34,14 +34,14 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
      *  the enclosing implementation class instead.
      */
     def safeREF(sym: Symbol) = {
-      def fix(tree: Tree): Tree = tree match {
-        case Select(qual, name) => treeCopy.Select(tree, fix(qual), name)
-        case This(_) if tree.symbol.isInterface && tree.symbol.name + "$class" == currentClass.name.toString =>
-          tree.setSymbol(currentClass).setType(currentClass.tpe)
-        case _ => tree
+      def fix(tree: Tree): Unit = tree match {
+        case Select(qual @ This(_), name) if qual.symbol != currentClass =>
+          qual.setSymbol(currentClass).setType(currentClass.tpe)
+        case _ =>
       }
       val tree = REF(sym)
-      if (currentClass.isImplClass) fix(tree) else tree
+      if (currentClass.isImplClass && sym.owner == currentClass) fix(tree)
+      tree
     }
 
     //private val classConstantMeth = new HashMap[String, Symbol]
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 8e49626df6..b35a23ed50 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -943,7 +943,7 @@ trait Typers extends Modes {
                   //
                   //   val x: T forSome { ts } = expr
                   //
-                  // would typechek. Or one can simply leave out the type of the `val':
+                  // would typecheck. Or one can simply leave out the type of the `val':
                   //
                   //   val x = expr
                   context.unit.warning(tree.pos, "recovering from existential Skolem type error in tree \n"+tree+"\nwith type "+tree.tpe+"\n expected type = "+pt+"\n context = "+context.tree)
@@ -3776,7 +3776,10 @@ trait Typers extends Modes {
                     // atPos necessary because qualifier might come from startContext
           val (tree2, pre2) = makeAccessible(tree1, defSym, pre, qual)
           // assert(pre.typeArgs isEmpty) // no need to add #2416-style check here, right?
-          stabilize(tree2, pre2, mode, pt)
+          stabilize(tree2, pre2, mode, pt) match {
+            case accErr: Inferencer#AccessError => accErr.emit()
+            case result => result
+          }
         }
       }
 
diff --git a/src/library/scala/collection/TraversableOnce.scala b/src/library/scala/collection/TraversableOnce.scala
index 90f1583c58..84fe4bdf4c 100644
--- a/src/library/scala/collection/TraversableOnce.scala
+++ b/src/library/scala/collection/TraversableOnce.scala
@@ -346,7 +346,12 @@ object TraversableOnce {
   }
 
   class FlattenOps[A](travs: TraversableOnce[TraversableOnce[A]]) {
-    def flatten: Iterator[A] = travs.foldLeft(Iterator.empty: Iterator[A])(_ ++ _)
+    def flatten: Iterator[A] = new Iterator[A] {
+      val its = travs.toIterator
+      private var it: Iterator[A] = Iterator.empty
+      def hasNext: Boolean = it.hasNext || its.hasNext && { it = its.next.toIterator; hasNext }
+      def next(): A = if (hasNext) it.next() else Iterator.empty.next()
+    }
   }
 
   class MonadOps[+A](trav: TraversableOnce[A]) {
diff --git a/src/library/scala/collection/TraversableViewLike.scala b/src/library/scala/collection/TraversableViewLike.scala
index 6dc0936c61..23e967aea0 100644
--- a/src/library/scala/collection/TraversableViewLike.scala
+++ b/src/library/scala/collection/TraversableViewLike.scala
@@ -16,6 +16,8 @@ import annotation.migration
 trait ViewMkString[+A] {
   self: Traversable[A] =>
 
+  // It is necessary to use thisSeq rather than toSeq to avoid cycles in the
+  // eager evaluation of vals in transformed view subclasses, see #4558.
   protected[this] def thisSeq: Seq[A] = new ArrayBuffer[A] ++= self result
 
   // Have to overload all three to work around #4299.  The overload
@@ -157,17 +159,17 @@ trait TraversableViewLike[+A,
   override def splitAt(n: Int): (This, This) = (newTaken(n), newDropped(n))
 
   override def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[This, B, That]): That =
-    newForced(self.toSeq.scanLeft(z)(op)).asInstanceOf[That]
+    newForced(thisSeq.scanLeft(z)(op)).asInstanceOf[That]
 
   @migration(2, 9,
     "This scanRight definition has changed in 2.9.\n" +
     "The previous behavior can be reproduced with scanRight.reverse."
   )
   override def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[This, B, That]): That =
-    newForced(self.toSeq.scanRight(z)(op)).asInstanceOf[That]
+    newForced(thisSeq.scanRight(z)(op)).asInstanceOf[That]
 
   override def groupBy[K](f: A => K): immutable.Map[K, This] =
-    self.toSeq.groupBy(f).mapValues(xs => newForced(xs).asInstanceOf[This])
+    thisSeq.groupBy(f).mapValues(xs => newForced(thisSeq))
 
   override def toString = viewToString
 }
diff --git a/src/library/scala/collection/generic/GenericTraversableTemplate.scala b/src/library/scala/collection/generic/GenericTraversableTemplate.scala
index 37d86a0aa9..805009be77 100644
--- a/src/library/scala/collection/generic/GenericTraversableTemplate.scala
+++ b/src/library/scala/collection/generic/GenericTraversableTemplate.scala
@@ -67,7 +67,7 @@ trait GenericTraversableTemplate[+A, +CC[X] <: GenTraversable[X]] extends HasNew
    */
   def genericBuilder[B]: Builder[B, CC[B]] = companion.newBuilder[B]
 
-  private def sequential: TraversableOnce[A] = this.asInstanceOf[TraversableOnce[A]].seq
+  private def sequential: TraversableOnce[A] = this.asInstanceOf[GenTraversableOnce[A]].seq
 
   /** Converts this $coll of pairs into two collections of the first and second
    *  half of each pair.
diff --git a/src/library/scala/collection/immutable/MapLike.scala b/src/library/scala/collection/immutable/MapLike.scala
index fb2826b4df..beea72d676 100644
--- a/src/library/scala/collection/immutable/MapLike.scala
+++ b/src/library/scala/collection/immutable/MapLike.scala
@@ -116,7 +116,16 @@ trait MapLike[A, +B, +This <: MapLike[A, B, This] with Map[A, B]]
   /** Collects all keys of this map in a set.
    *  @return  a set containing all keys of this map.
    */
-  override def keySet: immutable.Set[A] = immutable.Set.empty ++ (this map (_._1))
+  override def keySet: immutable.Set[A] = new ImmutableDefaultKeySet
+
+  protected class ImmutableDefaultKeySet extends super.DefaultKeySet with immutable.Set[A] {
+    override def + (elem: A): immutable.Set[A] =
+      if (this(elem)) this
+      else immutable.Set[A]() ++ this + elem
+    override def - (elem: A): immutable.Set[A] =
+      if (this(elem)) immutable.Set[A]() ++ this - elem
+      else this
+  }
 
   /** This function transforms all the values of mappings contained
    *  in this map with function `f`.
diff --git a/src/library/scala/collection/immutable/Range.scala b/src/library/scala/collection/immutable/Range.scala
index ef0f08bcfb..b22998fb4b 100644
--- a/src/library/scala/collection/immutable/Range.scala
+++ b/src/library/scala/collection/immutable/Range.scala
@@ -330,7 +330,7 @@ object Range {
 
   @deprecated("use Range instead", "2.9.0")
   trait ByOne extends Range {
-    @bridge override def foreach[@specialized(Unit) U](f: Int => U) =
-      super.foreach(f)
+//    @bridge override def foreach[@specialized(Unit) U](f: Int => U) =
+//      super.foreach(f)
   }
 }
diff --git a/src/library/scala/collection/immutable/SortedMap.scala b/src/library/scala/collection/immutable/SortedMap.scala
index f7e05fef69..902a0f8457 100644
--- a/src/library/scala/collection/immutable/SortedMap.scala
+++ b/src/library/scala/collection/immutable/SortedMap.scala
@@ -31,14 +31,27 @@ import annotation.bridge
 trait SortedMap[A, +B] extends Map[A, B]
                          with scala.collection.SortedMap[A, B]
                          with MapLike[A, B, SortedMap[A, B]]
-                         with SortedMapLike[A, B, SortedMap[A, B]] {
+                         with SortedMapLike[A, B, SortedMap[A, B]] { self =>
 
   override protected[this] def newBuilder : Builder[(A, B), SortedMap[A, B]] =
     SortedMap.newBuilder[A, B]
 
   override def empty: SortedMap[A, B] = SortedMap.empty
   override def updated [B1 >: B](key: A, value: B1): SortedMap[A, B1] = this + ((key, value))
-  override def keySet: immutable.SortedSet[A] = SortedSet.empty ++ (this map (_._1))
+  override def keySet: immutable.SortedSet[A] = new DefaultKeySortedSet
+
+  protected class DefaultKeySortedSet extends super.DefaultKeySortedSet with immutable.SortedSet[A] {
+    override def + (elem: A): SortedSet[A] =
+      if (this(elem)) this
+      else SortedSet[A]() ++ this + elem
+    override def - (elem: A): SortedSet[A] =
+      if (this(elem)) SortedSet[A]() ++ this - elem
+      else this
+    override def rangeImpl(from : Option[A], until : Option[A]) : SortedSet[A] = {
+      val map = self.rangeImpl(from, until)
+      new map.DefaultKeySortedSet
+    }
+  }
 
   /** Add a key/value pair to this map.
    *  @param    kv the key/value pair
diff --git a/src/library/scala/runtime/RichInt.scala b/src/library/scala/runtime/RichInt.scala
index cb02b6d3a8..c1439669f8 100644
--- a/src/library/scala/runtime/RichInt.scala
+++ b/src/library/scala/runtime/RichInt.scala
@@ -21,15 +21,15 @@ final class RichInt(val self: Int) extends ScalaNumberProxy[Int] with RangedProx
   def until(end: Int): Range = Range(self, end)
   def until(end: Int, step: Int): Range = Range(self, end, step)
 
-  @bridge
-  def until(end: Int): Range with Range.ByOne = new Range(self, end, 1) with Range.ByOne
+//  @bridge
+//  def until(end: Int): Range with Range.ByOne = new Range(self, end, 1) with Range.ByOne
 
   /** like `until`, but includes the last index */
   def to(end: Int): Range.Inclusive = Range.inclusive(self, end)
   def to(end: Int, step: Int): Range.Inclusive = Range.inclusive(self, end, step)
 
-  @bridge
-  def to(end: Int): Range with Range.ByOne = new Range.Inclusive(self, end, 1) with Range.ByOne
+//  @bridge
+//  def to(end: Int): Range with Range.ByOne = new Range.Inclusive(self, end, 1) with Range.ByOne
 
   override def min(that: Int): Int = if (self < that) self else that
   override def max(that: Int): Int = if (self > that) self else that
diff --git a/test/files/run/bug4558.scala b/test/files/run/bug4558.scala
new file mode 100644
index 0000000000..e7661421dc
--- /dev/null
+++ b/test/files/run/bug4558.scala
@@ -0,0 +1,6 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    val xs = Seq(1,2,3).view.groupBy(identity)
+    assert(xs.size == 3)
+  }
+}
diff --git a/test/files/run/bug4617.check b/test/files/run/bug4617.check
new file mode 100644
index 0000000000..6bbcce30eb
--- /dev/null
+++ b/test/files/run/bug4617.check
@@ -0,0 +1 @@
+Str 8.0
diff --git a/test/files/run/bug4617.scala b/test/files/run/bug4617.scala
new file mode 100644
index 0000000000..2fea5e29ec
--- /dev/null
+++ b/test/files/run/bug4617.scala
@@ -0,0 +1,15 @@
+object Test {
+  def f1 = new { def f { lazy val d = 0d } }
+  def f2 = {
+    lazy val d = 4D
+    lazy val f = 4f
+
+    def bar = "Str " + (d + f)
+    bar
+  }
+
+  def main(args: Array[String]): Unit = {
+    f1
+    println(f2)
+  }
+}
diff --git a/test/files/run/t4560.check b/test/files/run/t4560.check
index 7ed6ff82de..fd3c81a4d7 100644
--- a/test/files/run/t4560.check
+++ b/test/files/run/t4560.check
@@ -1 +1,2 @@
 5
+5
diff --git a/test/files/run/t4560.scala b/test/files/run/t4560.scala
index f1eb5d4169..f809e67898 100644
--- a/test/files/run/t4560.scala
+++ b/test/files/run/t4560.scala
@@ -16,8 +16,24 @@ trait B {
   }
 }
 
+class A2
+
+trait B2 {
+  self: A2 =>
+
+  def test {
+    import Pimper.pimp
+
+    println(5.test)
+  }
+}
+
 object Test extends A with B {
   def main(args: Array[String]) {
     test
+    Test2.test
   }
 }
+
+object Test2 extends A2 with B2
+
diff --git a/test/files/run/t4608.scala b/test/files/run/t4608.scala
new file mode 100644
index 0000000000..a25d2fea05
--- /dev/null
+++ b/test/files/run/t4608.scala
@@ -0,0 +1,11 @@
+
+
+
+// #4608
+object Test {
+
+  def main(args: Array[String]) {
+    ((1 to 100) sliding 10).toList.par.map{_.map{i => i * i}}.flatten
+  }
+
+}