serialisation compatability before we change the red black trees

Author: mkeskells

library/src/scala/collection/immutable/OldRedBlackTree.scala

@@ -0,0 +1,80 @@
+/*
+ * 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.immutable
+
+import java.io.IOException
+import scala.annotation.meta.getter
+
+private[immutable] object RedBlackTree {
+
+  // Trees for serialisation compat with 2.12 legacy format
+  // allow the format to be written in that manner for 2.12.11 and before
+  //on write this is the same format as before
+  //on read the `readResolve` will convert to the NewRedBlackTree format
+
+  // the Tree children must be AnyRef as during construction then are RedBlackTree.Tree
+  // due to the readResolve the tree is migrated to new format and the children will be converted to
+  // NewRedBlackTree as they are read
+
+  @SerialVersionUID(7757490705548110898L)
+  sealed abstract class Tree[A, +B](
+                                     @(inline@getter) final val key: A,
+                                     @(inline@getter) final val value: B,
+                                     @(inline@getter) final val left: AnyRef,
+                                     @(inline@getter) final val right: AnyRef)
+    extends Serializable {
+    private def _count(tree: AnyRef) = if (tree eq null) 0 else tree.asInstanceOf[Tree[A, B]].count
+    @(inline @getter) final val count: Int = 1 + _count(left) + _count(right)
+  }
+
+  @SerialVersionUID(6516527240275040268L)
+  final class RedTree[A, +B](key: A,
+                             value: B,
+                             left: AnyRef,
+                             right: AnyRef) extends Tree[A, B](key, value, left, right) {
+    @throws[IOException]
+    private[this] def readResolve(): AnyRef =
+      NewRedBlackTree.RedTree(key, value,
+        this.left.asInstanceOf[NewRedBlackTree.Tree[A, B]],
+        this.right.asInstanceOf[NewRedBlackTree.Tree[A, B]])
+
+    override def toString: String = "RedTree(" + key + ", " + value + ", " + left + ", " + right + ")"
+  }
+
+  @SerialVersionUID(-3666942709716265983L)
+  final class BlackTree[A, +B](key: A,
+                               value: B,
+                               left: AnyRef,
+                               right: AnyRef) extends Tree[A, B](key, value, left, right) {
+    @throws[IOException]
+    private[this] def readResolve(): AnyRef =
+      NewRedBlackTree.BlackTree(key, value,
+        this.left.asInstanceOf[NewRedBlackTree.Tree[A, B]],
+        this.right.asInstanceOf[NewRedBlackTree.Tree[A, B]])
+
+    override def toString: String = "BlackTree(" + key + ", " + value + ", " + left + ", " + right + ")"
+  }
+
+  def from[A, B](tree: NewRedBlackTree.Tree[A, B]): Tree[A, B] = {
+    if (tree eq null) null
+    else {
+      val left = from(tree.left)
+      val right = from(tree.right)
+      if (NewRedBlackTree.isBlack(tree))
+        new BlackTree(tree.key, tree.value, left, right)
+      else
+        new RedTree(tree.key, tree.value, left, right)
+    }
+  }
+
+}

library/src/scala/collection/immutable/RedBlackTree.scala

@@ -28,7 +28,7 @@ import java.lang.{Integer, String}
  *  easily be used. The API represented by the RedBlackTree object tries to hide these
  *  optimizations behind a reasonably clean API.
  */
-private[collection] object RedBlackTree {
+private[collection] object NewRedBlackTree {
 
   def isEmpty(tree: Tree[_, _]): Boolean = tree eq null
 
@@ -378,7 +378,7 @@ private[collection] object RedBlackTree {
                                      @(`inline` @getter) final val left: Tree[A, B],
                                      @(`inline` @getter) final val right: Tree[A, B]) extends Serializable
   {
-    @(`inline` @getter) final val count: Int = 1 + RedBlackTree.count(left) + RedBlackTree.count(right)
+    @(`inline` @getter) final val count: Int = 1 + NewRedBlackTree.count(left) + NewRedBlackTree.count(right)
     def black: Tree[A, B]
     def red: Tree[A, B]
   }

library/src/scala/collection/immutable/TreeMap.scala

@@ -17,7 +17,7 @@ package immutable
 import java.io.IOException
 
 import generic._
-import immutable.{RedBlackTree => RB}
+import immutable.{NewRedBlackTree => RB}
 import mutable.Builder
 import scala.util.hashing.MurmurHash3
 
@@ -93,7 +93,7 @@ object TreeMap extends ImmutableSortedMapFactory[TreeMap] {
   private val legacySerialisation = System.getProperty("scala.collection.immutable.TreeMap.newSerialisation", "false") != "false"
 
   private class TreeMapProxy[A, B](
-    @transient private[this] var tree: RedBlackTree.Tree[A, B],
+    @transient private[this] var tree: RB.Tree[A, B],
     @transient private[this] var ordering: Ordering[A]) extends Serializable {
 
     @throws[IOException]
@@ -387,4 +387,12 @@ final class TreeMap[A, +B] private (tree: RB.Tree[A, B])(implicit val ordering:
   @throws[IOException]
   private[this] def writeReplace(out: java.io.ObjectOutputStream): AnyRef =
     if (TreeMap.legacySerialisation) this else new TreeMap.TreeMapProxy(tree, ordering)
+
+  @throws[IOException]
+  private[this] def writeObject(out: java.io.ObjectOutputStream) = {
+    out.writeObject(ordering)
+    out.writeObject(RedBlackTree.from(tree))
+  }
+
+
 }

library/src/scala/collection/immutable/TreeSet.scala

@@ -17,7 +17,7 @@ package immutable
 import java.io.IOException
 
 import generic._
-import immutable.{RedBlackTree => RB}
+import immutable.{NewRedBlackTree => RB}
 import mutable.Builder
 
 /** $factoryInfo
@@ -59,7 +59,7 @@ object TreeSet extends ImmutableSortedSetFactory[TreeSet] {
   private val legacySerialisation = System.getProperty("scala.collection.immutable.TreeSet.newSerialisation", "false") != "false"
 
   private class TreeSetProxy[A](
-    @transient private[this] var tree: RedBlackTree.Tree[A, Any],
+    @transient private[this] var tree: RB.Tree[A, Any],
     @transient private[this] var ordering: Ordering[A]) extends Serializable {
 
     @throws[IOException]
@@ -283,4 +283,10 @@ final class TreeSet[A] private[immutable] (private[immutable] val tree: RB.Tree[
   @throws[IOException]
   private[this] def writeReplace(out: java.io.ObjectOutputStream): AnyRef =
     if (TreeSet.legacySerialisation) this else new TreeSet.TreeSetProxy(tree, ordering)
+
+  @throws[IOException]
+  private[this] def writeObject(out: java.io.ObjectOutputStream) = {
+    out.writeObject(ordering)
+    out.writeObject(RedBlackTree.from(tree))
+  }
 }