From 5362f3df48a363308e41434b17fca60a0d4d84da Mon Sep 17 00:00:00 2001
From: Aleksandar Prokopec <axel22@gmail.com>
Date: Wed, 27 Jun 2012 16:30:35 +0200
Subject: Fix SI-3326.

The heart of the problem - we want to retain the ordering when
using `++` on sorted maps.

There are 2 `++` overloads - a generic one in traversables and
a map-specific one in `MapLike` - which knows about the ordering.

The problem here is that the expected return type for the expression
in which `++` appears drives the decision of the overload that needs
to be taken.
The `collection.SortedMap` does not have `++` overridden to return
`SortedMap`, but `immutable.Map` instead.
This is why `collection.SortedMap` used to resort to the generic
`TraversableLike.++` which knows nothing about the ordering.

To avoid `collection.SortedMap`s resort to the more generic `TraverableLike.++`,
we override the `MapLike.++` overload in `collection.SortedMap` to return
the proper type `SortedMap`.
---
 test/files/run/t3326.check |  8 +++++
 test/files/run/t3326.scala | 74 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 82 insertions(+)
 create mode 100644 test/files/run/t3326.check
 create mode 100644 test/files/run/t3326.scala

(limited to 'test/files/run')

diff --git a/test/files/run/t3326.check b/test/files/run/t3326.check
new file mode 100644
index 0000000000..d0e11cebf7
--- /dev/null
+++ b/test/files/run/t3326.check
@@ -0,0 +1,8 @@
+Map(2 -> Hello, 1 -> World)
+Map(5 -> Foo, 4 -> Bar)
+Map(5 -> Foo, 4 -> Bar, 2 -> Hello, 1 -> World)
+Map(3 -> ?, 2 -> Hello, 1 -> World)
+Map(2 -> Hello, 1 -> World)
+Map(5 -> Foo, 4 -> Bar)
+Map(5 -> Foo, 4 -> Bar, 2 -> Hello, 1 -> World)
+Map(3 -> ?, 2 -> Hello, 1 -> World)
\ No newline at end of file
diff --git a/test/files/run/t3326.scala b/test/files/run/t3326.scala
new file mode 100644
index 0000000000..f70cb01504
--- /dev/null
+++ b/test/files/run/t3326.scala
@@ -0,0 +1,74 @@
+
+
+
+import scala.math.Ordering
+
+
+
+/** The heart of the problem - we want to retain the ordering when
+ *  using `++` on sorted maps.
+ *
+ *  There are 2 `++` overloads - a generic one in traversables and
+ *  a map-specific one in `MapLike` - which knows about the ordering.
+ *  
+ *  The problem here is that the expected return type for the expression
+ *  in which `++` appears drives the decision of the overload that needs
+ *  to be taken.
+ *  The `collection.SortedMap` does not have `++` overridden to return
+ *  `SortedMap`, but `immutable.Map` instead.
+ *  This is why `collection.SortedMap` used to resort to the generic
+ *  `TraversableLike.++` which knows nothing about the ordering.
+ *  
+ *  To avoid `collection.SortedMap`s resort to the more generic `TraverableLike.++`,
+ *  we override the `MapLike.++` overload in `collection.SortedMap` to return
+ *  the proper type `SortedMap`.
+ */
+object Test {
+  
+  def main(args: Array[String]) {
+    testCollectionSorted()
+    testImmutableSorted()
+  }
+  
+  def testCollectionSorted() {
+    import collection._
+    val order = implicitly[Ordering[Int]].reverse
+    var m1: SortedMap[Int, String] = SortedMap.empty[Int, String](order)
+    var m2: SortedMap[Int, String] = SortedMap.empty[Int, String](order)
+    
+    m1 += (1 -> "World")
+    m1 += (2 -> "Hello")
+    
+    m2 += (4 -> "Bar")
+    m2 += (5 -> "Foo")
+    
+    val m3: SortedMap[Int, String] = m1 ++ m2
+    
+    println(m1)
+    println(m2)
+    println(m3)
+    
+    println(m1 + (3 -> "?"))
+  }
+
+  def testImmutableSorted() {
+    import collection.immutable._
+    val order = implicitly[Ordering[Int]].reverse
+    var m1: SortedMap[Int, String] = SortedMap.empty[Int, String](order)
+    var m2: SortedMap[Int, String] = SortedMap.empty[Int, String](order)
+    
+    m1 += (1 -> "World")
+    m1 += (2 -> "Hello")
+    
+    m2 += (4 -> "Bar")
+    m2 += (5 -> "Foo")
+    
+    val m3: SortedMap[Int, String] = m1 ++ m2
+    
+    println(m1)
+    println(m2)
+    println(m3)
+    
+    println(m1 + (3 -> "?"))
+  }
+}
-- 
cgit v1.2.3