Explicit SerialVersionUID for all ClassTags / Manifests

Looking at the class hierarchy around ClassTag and Manifest, the only
class that had a serialVersionUID is AnyValManifest, where the hierarchy
is something like:

trait ClassTag                      // extends Serializable
|- class GenericClassTag
|- trait Manifest
   |- class ClassTypeManifest
   |- class SingletonTypeManifest
   |- ...
   |- abstract class AnyValManifest // has SerialVersionUID
      |- class DoubleManifest
      |- ...

Note that AnyValManifest is an abstract class, so the SerialVersionUID
annotation does not help there.

This commit adds explicit SerialVersionUID annotations to (hopefully)
all subclasses of ClassTag, to make sure they are stable under
compatible changes (such as changing -Xmixin-force-forwarders).

4 files changed, 32 insertions, 10 deletions

diff --git a/src/library/scala/collection/immutable/Set.scala b/src/library/scala/collection/immutable/Set.scala
index 3a8ee8b0be..047ea736bd 100644
--- a/src/library/scala/collection/immutable/Set.scala
+++ b/src/library/scala/collection/immutable/Set.scala
@@ -65,6 +65,7 @@ object Set extends ImmutableSetFactory[Set] {
   implicit def canBuildFrom[A]: CanBuildFrom[Coll, A, Set[A]] = setCanBuildFrom[A]
 
   /** An optimized representation for immutable empty sets */
+  @SerialVersionUID(-2443710944435909512L)
   private object EmptySet extends AbstractSet[Any] with Set[Any] with Serializable {
     override def size: Int = 0
     def contains(elem: Any): Boolean = false
diff --git a/src/library/scala/reflect/ClassManifestDeprecatedApis.scala b/src/library/scala/reflect/ClassManifestDeprecatedApis.scala
index 30a99340cc..cd46f0ff76 100644
--- a/src/library/scala/reflect/ClassManifestDeprecatedApis.scala
+++ b/src/library/scala/reflect/ClassManifestDeprecatedApis.scala
@@ -205,15 +205,18 @@ object ClassManifestFactory {
     case m: ClassManifest[_] => m.asInstanceOf[ClassManifest[T]].arrayManifest
   }
 
+  @SerialVersionUID(1L)
+  private class AbstractTypeClassManifest[T](prefix: OptManifest[_], name: String, clazz: jClass[_], args: OptManifest[_]*) extends ClassManifest[T] {
+    override def runtimeClass = clazz
+    override val typeArguments = args.toList
+    override def toString = prefix.toString+"#"+name+argString
+  }
+
   /** ClassManifest for the abstract type `prefix # name`. `upperBound` is not
     * strictly necessary as it could be obtained by reflection. It was
     * added so that erasure can be calculated without reflection. */
   def abstractType[T](prefix: OptManifest[_], name: String, clazz: jClass[_], args: OptManifest[_]*): ClassManifest[T] =
-    new ClassManifest[T] {
-      override def runtimeClass = clazz
-      override val typeArguments = args.toList
-      override def toString = prefix.toString+"#"+name+argString
-    }
+    new AbstractTypeClassManifest(prefix, name, clazz)
 
   /** ClassManifest for the abstract type `prefix # name`. `upperBound` is not
     * strictly necessary as it could be obtained by reflection. It was
@@ -221,15 +224,12 @@ object ClassManifestFactory {
     * todo: remove after next bootstrap
     */
   def abstractType[T](prefix: OptManifest[_], name: String, upperbound: ClassManifest[_], args: OptManifest[_]*): ClassManifest[T] =
-    new ClassManifest[T] {
-      override def runtimeClass = upperbound.runtimeClass
-      override val typeArguments = args.toList
-      override def toString = prefix.toString+"#"+name+argString
-    }
+    new AbstractTypeClassManifest(prefix, name, upperbound.runtimeClass)
 }
 
 /** Manifest for the class type `clazz[args]`, where `clazz` is
   * a top-level or static class */
+@SerialVersionUID(1L)
 private class ClassTypeManifest[T](
   prefix: Option[OptManifest[_]],
   val runtimeClass: jClass[_],
diff --git a/src/library/scala/reflect/ClassTag.scala b/src/library/scala/reflect/ClassTag.scala
index eb3aeeecfc..30ceadceeb 100644
--- a/src/library/scala/reflect/ClassTag.scala
+++ b/src/library/scala/reflect/ClassTag.scala
@@ -119,6 +119,7 @@ object ClassTag {
   val Nothing : ClassTag[scala.Nothing]    = Manifest.Nothing
   val Null    : ClassTag[scala.Null]       = Manifest.Null
 
+  @SerialVersionUID(1L)
   private class GenericClassTag[T](val runtimeClass: jClass[_]) extends ClassTag[T]
 
   def apply[T](runtimeClass1: jClass[_]): ClassTag[T] =
diff --git a/src/library/scala/reflect/Manifest.scala b/src/library/scala/reflect/Manifest.scala
index 9c38864194..8e5ba6376e 100644
--- a/src/library/scala/reflect/Manifest.scala
+++ b/src/library/scala/reflect/Manifest.scala
@@ -87,6 +87,7 @@ object ManifestFactory {
   def valueManifests: List[AnyValManifest[_]] =
     List(Byte, Short, Char, Int, Long, Float, Double, Boolean, Unit)
 
+  @SerialVersionUID(1L)
   private class ByteManifest extends AnyValManifest[scala.Byte]("Byte") {
     def runtimeClass = java.lang.Byte.TYPE
     override def newArray(len: Int): Array[Byte] = new Array[Byte](len)
@@ -96,6 +97,7 @@ object ManifestFactory {
   }
   val Byte: AnyValManifest[Byte] = new ByteManifest
 
+  @SerialVersionUID(1L)
   private class ShortManifest extends AnyValManifest[scala.Short]("Short") {
     def runtimeClass = java.lang.Short.TYPE
     override def newArray(len: Int): Array[Short] = new Array[Short](len)
@@ -105,6 +107,7 @@ object ManifestFactory {
   }
   val Short: AnyValManifest[Short] = new ShortManifest
 
+  @SerialVersionUID(1L)
   private class CharManifest extends AnyValManifest[scala.Char]("Char") {
     def runtimeClass = java.lang.Character.TYPE
     override def newArray(len: Int): Array[Char] = new Array[Char](len)
@@ -114,6 +117,7 @@ object ManifestFactory {
   }
   val Char: AnyValManifest[Char] = new CharManifest
 
+  @SerialVersionUID(1L)
   private class IntManifest extends AnyValManifest[scala.Int]("Int") {
     def runtimeClass = java.lang.Integer.TYPE
     override def newArray(len: Int): Array[Int] = new Array[Int](len)
@@ -123,6 +127,7 @@ object ManifestFactory {
   }
   val Int: AnyValManifest[Int] = new IntManifest
 
+  @SerialVersionUID(1L)
   private class LongManifest extends AnyValManifest[scala.Long]("Long") {
     def runtimeClass = java.lang.Long.TYPE
     override def newArray(len: Int): Array[Long] = new Array[Long](len)
@@ -132,6 +137,7 @@ object ManifestFactory {
   }
   val Long: AnyValManifest[Long] = new LongManifest
 
+  @SerialVersionUID(1L)
   private class FloatManifest extends AnyValManifest[scala.Float]("Float") {
     def runtimeClass = java.lang.Float.TYPE
     override def newArray(len: Int): Array[Float] = new Array[Float](len)
@@ -141,6 +147,7 @@ object ManifestFactory {
   }
   val Float: AnyValManifest[Float] = new FloatManifest
 
+  @SerialVersionUID(1L)
   private class DoubleManifest extends AnyValManifest[scala.Double]("Double") {
     def runtimeClass = java.lang.Double.TYPE
     override def newArray(len: Int): Array[Double] = new Array[Double](len)
@@ -150,6 +157,7 @@ object ManifestFactory {
   }
   val Double: AnyValManifest[Double] = new DoubleManifest
 
+  @SerialVersionUID(1L)
   private class BooleanManifest extends AnyValManifest[scala.Boolean]("Boolean") {
     def runtimeClass = java.lang.Boolean.TYPE
     override def newArray(len: Int): Array[Boolean] = new Array[Boolean](len)
@@ -159,6 +167,7 @@ object ManifestFactory {
   }
   val Boolean: AnyValManifest[Boolean] = new BooleanManifest
 
+  @SerialVersionUID(1L)
   private class UnitManifest extends AnyValManifest[scala.Unit]("Unit") {
     def runtimeClass = java.lang.Void.TYPE
     override def newArray(len: Int): Array[Unit] = new Array[Unit](len)
@@ -175,6 +184,7 @@ object ManifestFactory {
   private val NothingTYPE = classOf[scala.runtime.Nothing$]
   private val NullTYPE = classOf[scala.runtime.Null$]
 
+  @SerialVersionUID(1L)
   private class AnyManifest extends PhantomManifest[scala.Any](ObjectTYPE, "Any") {
     override def newArray(len: Int) = new Array[scala.Any](len)
     override def <:<(that: ClassManifest[_]): Boolean = (that eq this)
@@ -182,6 +192,7 @@ object ManifestFactory {
   }
   val Any: Manifest[scala.Any] = new AnyManifest
 
+  @SerialVersionUID(1L)
   private class ObjectManifest extends PhantomManifest[java.lang.Object](ObjectTYPE, "Object") {
     override def newArray(len: Int) = new Array[java.lang.Object](len)
     override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any)
@@ -191,6 +202,7 @@ object ManifestFactory {
 
   val AnyRef: Manifest[scala.AnyRef] = Object.asInstanceOf[Manifest[scala.AnyRef]]
 
+  @SerialVersionUID(1L)
   private class AnyValPhantomManifest extends PhantomManifest[scala.AnyVal](ObjectTYPE, "AnyVal") {
     override def newArray(len: Int) = new Array[scala.AnyVal](len)
     override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any)
@@ -198,6 +210,7 @@ object ManifestFactory {
   }
   val AnyVal: Manifest[scala.AnyVal] = new AnyValPhantomManifest
 
+  @SerialVersionUID(1L)
   private class NullManifest extends PhantomManifest[scala.Null](NullTYPE, "Null") {
     override def newArray(len: Int) = new Array[scala.Null](len)
     override def <:<(that: ClassManifest[_]): Boolean =
@@ -206,6 +219,7 @@ object ManifestFactory {
   }
   val Null: Manifest[scala.Null] = new NullManifest
 
+  @SerialVersionUID(1L)
   private class NothingManifest extends PhantomManifest[scala.Nothing](NothingTYPE, "Nothing") {
     override def newArray(len: Int) = new Array[scala.Nothing](len)
     override def <:<(that: ClassManifest[_]): Boolean = (that ne null)
@@ -213,6 +227,7 @@ object ManifestFactory {
   }
   val Nothing: Manifest[scala.Nothing] = new NothingManifest
 
+  @SerialVersionUID(1L)
   private class SingletonTypeManifest[T <: AnyRef](value: AnyRef) extends Manifest[T] {
     lazy val runtimeClass = value.getClass
     override lazy val toString = value.toString + ".type"
@@ -243,6 +258,7 @@ object ManifestFactory {
   def classType[T](prefix: Manifest[_], clazz: Predef.Class[_], args: Manifest[_]*): Manifest[T] =
     new ClassTypeManifest[T](Some(prefix), clazz, args.toList)
 
+  @SerialVersionUID(1L)
   private abstract class PhantomManifest[T](_runtimeClass: Predef.Class[_],
                                             override val toString: String) extends ClassTypeManifest[T](None, _runtimeClass, Nil) {
     override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef]
@@ -252,6 +268,7 @@ object ManifestFactory {
 
   /** Manifest for the class type `clazz[args]`, where `clazz` is
     * a top-level or static class. */
+  @SerialVersionUID(1L)
   private class ClassTypeManifest[T](prefix: Option[Manifest[_]],
                                      val runtimeClass: Predef.Class[_],
                                      override val typeArguments: List[Manifest[_]]) extends Manifest[T] {
@@ -264,6 +281,7 @@ object ManifestFactory {
   def arrayType[T](arg: Manifest[_]): Manifest[Array[T]] =
     arg.asInstanceOf[Manifest[T]].arrayManifest
 
+  @SerialVersionUID(1L)
   private class AbstractTypeManifest[T](prefix: Manifest[_], name: String, upperBound: Predef.Class[_], args: Seq[Manifest[_]]) extends Manifest[T] {
     def runtimeClass = upperBound
     override val typeArguments = args.toList
@@ -276,6 +294,7 @@ object ManifestFactory {
   def abstractType[T](prefix: Manifest[_], name: String, upperBound: Predef.Class[_], args: Manifest[_]*): Manifest[T] =
     new AbstractTypeManifest[T](prefix, name, upperBound, args)
 
+  @SerialVersionUID(1L)
   private class WildcardManifest[T](lowerBound: Manifest[_], upperBound: Manifest[_]) extends Manifest[T] {
     def runtimeClass = upperBound.runtimeClass
     override def toString =
@@ -289,6 +308,7 @@ object ManifestFactory {
   def wildcardType[T](lowerBound: Manifest[_], upperBound: Manifest[_]): Manifest[T] =
     new WildcardManifest[T](lowerBound, upperBound)
 
+  @SerialVersionUID(1L)
   private class IntersectionTypeManifest[T](parents: Seq[Manifest[_]]) extends Manifest[T] {
     def runtimeClass = parents.head.runtimeClass
     override def toString = parents.mkString(" with ")