diff options
83 files changed, 258 insertions, 248 deletions
diff --git a/src/actors/scala/actors/Actor.scala b/src/actors/scala/actors/Actor.scala index d92dab9b17..77b55e288c 100644 --- a/src/actors/scala/actors/Actor.scala +++ b/src/actors/scala/actors/Actor.scala @@ -417,8 +417,8 @@ object Actor extends Combinators { * @define actor actor * @define channel actor's mailbox */ -@serializable @SerialVersionUID(-781154067877019505L) -trait Actor extends AbstractActor with ReplyReactor with ActorCanReply with InputChannel[Any] { +@SerialVersionUID(-781154067877019505L) +trait Actor extends AbstractActor with ReplyReactor with ActorCanReply with InputChannel[Any] with Serializable { /* The following two fields are only used when the actor * suspends by blocking its underlying thread, for example, diff --git a/src/actors/scala/actors/MessageQueue.scala b/src/actors/scala/actors/MessageQueue.scala index 6936bf63a8..73537c661a 100644 --- a/src/actors/scala/actors/MessageQueue.scala +++ b/src/actors/scala/actors/MessageQueue.scala @@ -15,9 +15,9 @@ package scala.actors * * @author Philipp Haller */ -@serializable @SerialVersionUID(7124278808020037465L) +@SerialVersionUID(7124278808020037465L) @deprecated("this class is going to be removed in a future release") -class MessageQueueElement(msg: Any, session: OutputChannel[Any], next: MessageQueueElement) extends MQueueElement[Any](msg, session, next) { +class MessageQueueElement(msg: Any, session: OutputChannel[Any], next: MessageQueueElement) extends MQueueElement[Any](msg, session, next) with Serializable { def this() = this(null, null, null) def this(msg: Any, session: OutputChannel[Any]) = this(msg, session, null) } @@ -35,9 +35,9 @@ private[actors] class MQueueElement[Msg >: Null](val msg: Msg, val session: Outp * * @author Philipp Haller */ -@serializable @SerialVersionUID(2168935872884095767L) +@SerialVersionUID(2168935872884095767L) @deprecated("this class is going to be removed in a future release") -class MessageQueue(label: String) extends MQueue[Any](label) +class MessageQueue(label: String) extends MQueue[Any](label) with Serializable private[actors] class MQueue[Msg >: Null](protected val label: String) { protected var first: MQueueElement[Msg] = null diff --git a/src/actors/scala/actors/remote/Proxy.scala b/src/actors/scala/actors/remote/Proxy.scala index 625ce8bb0b..8df723adee 100644 --- a/src/actors/scala/actors/remote/Proxy.scala +++ b/src/actors/scala/actors/remote/Proxy.scala @@ -15,8 +15,7 @@ import scala.collection.mutable.HashMap /** * @author Philipp Haller */ -@serializable -private[remote] class Proxy(node: Node, name: Symbol, @transient var kernel: NetKernel) extends AbstractActor { +private[remote] class Proxy(node: Node, name: Symbol, @transient var kernel: NetKernel) extends AbstractActor with Serializable { import java.io.{IOException, ObjectOutputStream, ObjectInputStream} @transient @@ -82,8 +81,7 @@ private[remote] class Proxy(node: Node, name: Symbol, @transient var kernel: Net name+"@"+node } -@serializable -class LinkToFun extends Function2[AbstractActor, Proxy, Unit] { +class LinkToFun extends Function2[AbstractActor, Proxy, Unit] with Serializable { def apply(target: AbstractActor, creator: Proxy) { target.linkTo(creator) } @@ -91,8 +89,7 @@ class LinkToFun extends Function2[AbstractActor, Proxy, Unit] { "<LinkToFun>" } -@serializable -class UnlinkFromFun extends Function2[AbstractActor, Proxy, Unit] { +class UnlinkFromFun extends Function2[AbstractActor, Proxy, Unit] with Serializable { def apply(target: AbstractActor, creator: Proxy) { target.unlinkFrom(creator) } @@ -100,8 +97,7 @@ class UnlinkFromFun extends Function2[AbstractActor, Proxy, Unit] { "<UnlinkFromFun>" } -@serializable -class ExitFun(reason: AnyRef) extends Function2[AbstractActor, Proxy, Unit] { +class ExitFun(reason: AnyRef) extends Function2[AbstractActor, Proxy, Unit] with Serializable { def apply(target: AbstractActor, creator: Proxy) { target.exit(creator, reason) } diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala index 2acfa20c50..1ac2c3442a 100644 --- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala +++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala @@ -26,6 +26,7 @@ abstract class TreeGen { def scalaUnitConstr = scalaDot(nme.Unit.toTypeName) def scalaScalaObjectConstr = scalaDot(nme.ScalaObject.toTypeName) def productConstr = scalaDot(nme.Product.toTypeName) + def serializableConstr = scalaDot(nme.Serializable.toTypeName) private def isRootOrEmptyPackageClass(s: Symbol) = s.isRoot || s.isEmptyPackageClass diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 751c7b5d13..09f1db7249 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -2498,7 +2498,7 @@ self => parents = parents ::: List(scalaScalaObjectConstr) if (parents.isEmpty) parents = List(scalaAnyRefConstr) - if (mods.isCase) parents = parents ::: List(productConstr) + if (mods.isCase) parents = parents ::: List(productConstr, serializableConstr) val tstart0 = if (body.isEmpty && in.lastOffset < tstart) in.lastOffset else tstart atPos(tstart0) { Template(parents, self, constrMods, vparamss, argss, body, o2p(tstart)) diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala index 7a3321f6eb..de5f342a7d 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala @@ -29,6 +29,7 @@ abstract class TreeBuilder { def scalaUnitConstr = gen.scalaUnitConstr def scalaScalaObjectConstr = gen.scalaScalaObjectConstr def productConstr = gen.productConstr + def serializableConstr = gen.serializableConstr /** Convert all occurrences of (lower-case) variables in a pattern as follows: * x becomes x @ _ diff --git a/src/compiler/scala/tools/nsc/backend/JavaPlatform.scala b/src/compiler/scala/tools/nsc/backend/JavaPlatform.scala index ec367b61bb..8d77eef488 100644 --- a/src/compiler/scala/tools/nsc/backend/JavaPlatform.scala +++ b/src/compiler/scala/tools/nsc/backend/JavaPlatform.scala @@ -36,7 +36,7 @@ trait JavaPlatform extends Platform[AbstractFile] { def isMaybeBoxed(sym: Symbol): Boolean = { import definitions._ (sym == ObjectClass) || - (sym == SerializableClass) || + (sym == JavaSerializableClass) || (sym == ComparableClass) || (sym isNonBottomSubClass BoxedNumberClass) || (sym isNonBottomSubClass BoxedCharacterClass) diff --git a/src/compiler/scala/tools/nsc/symtab/Definitions.scala b/src/compiler/scala/tools/nsc/symtab/Definitions.scala index a468e81b3e..5a4fa51899 100644 --- a/src/compiler/scala/tools/nsc/symtab/Definitions.scala +++ b/src/compiler/scala/tools/nsc/symtab/Definitions.scala @@ -169,11 +169,12 @@ trait Definitions extends reflect.generic.StandardDefinitions { def scalaRuntimeSameElements = getMember(ScalaRunTimeModule, nme.sameElements) // classes with special meanings - lazy val NotNullClass = getClass("scala.NotNull") - lazy val TypeConstraintClass = getClass("scala.TypeConstraint") - lazy val SingletonClass = newClass(ScalaPackageClass, nme.Singleton, anyparam) setFlag (ABSTRACT | TRAIT | FINAL) - lazy val SerializableClass = getClass(sn.Serializable) - lazy val ComparableClass = getClass("java.lang.Comparable") + lazy val NotNullClass = getClass("scala.NotNull") + lazy val TypeConstraintClass = getClass("scala.TypeConstraint") + lazy val SingletonClass = newClass(ScalaPackageClass, nme.Singleton, anyparam) setFlag (ABSTRACT | TRAIT | FINAL) + lazy val SerializableClass = getClass("scala.Serializable") + lazy val JavaSerializableClass = getClass(sn.JavaSerializable) + lazy val ComparableClass = getClass("java.lang.Comparable") lazy val RepeatedParamClass = newCovariantPolyClass( ScalaPackageClass, @@ -486,7 +487,7 @@ trait Definitions extends reflect.generic.StandardDefinitions { lazy val ScalaNumberClass: Symbol = getClass("scala.math.ScalaNumber") lazy val ScalaStrictFPAttr: Symbol = getClass("scala.annotation.strictfp") lazy val SerialVersionUIDAttr: Symbol = getClass("scala.SerialVersionUID") - lazy val SerializableAttr: Symbol = getClass("scala.serializable") + lazy val SerializableAttr: Symbol = getClass("scala.annotation.serializable") // @serializable is deprecated lazy val TraitSetterAnnotationClass: Symbol = getClass("scala.runtime.TraitSetter") lazy val TransientAttr: Symbol = getClass("scala.transient") lazy val VolatileAttr: Symbol = getClass("scala.volatile") diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala index 11773dae4c..64dc254f28 100644 --- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala +++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala @@ -197,6 +197,7 @@ trait StdNames extends reflect.generic.StdNames with NameManglers { val ScalaObject = newTermName("ScalaObject") val ScalaRunTime = newTermName("ScalaRunTime") val Seq = newTermName("Seq") + val Serializable = newTermName("Serializable") val Short = newTermName("Short") val Singleton = newTermName("Singleton") val Some = newTermName("Some") @@ -379,7 +380,7 @@ trait StdNames extends reflect.generic.StdNames with NameManglers { val NLRControl : Name = newTermName("scala.runtime.NonLocalReturnControl") val NPException : Name // NullPointerException val Object : Name - val Serializable : Name + val JavaSerializable : Name val String : Name val Throwable : Name val ValueType : Name @@ -446,7 +447,7 @@ trait StdNames extends reflect.generic.StdNames with NameManglers { final val MethodAsObject = newTermName("System.Reflection.MethodInfo") final val NPException = newTermName("System.NullReferenceException") final val Object = newTermName("System.Object") - final val Serializable = nme.NOSYMBOL + final val JavaSerializable = nme.NOSYMBOL final val String = newTermName("System.String") final val Throwable = newTermName("System.Exception") final val ValueType = newTermName("System.ValueType") @@ -467,7 +468,7 @@ trait StdNames extends reflect.generic.StdNames with NameManglers { final val BeanProperty = newTermName("scala.reflect.BeanProperty") final val BooleanBeanProperty = newTermName("scala.reflect.BooleanBeanProperty") final val Code = newTermName("scala.reflect.Code") - final val Serializable = newTermName("java.io.Serializable") + final val JavaSerializable = newTermName("java.io.Serializable") } lazy val sn: SymbolNames = diff --git a/src/compiler/scala/tools/nsc/symtab/Symbols.scala b/src/compiler/scala/tools/nsc/symtab/Symbols.scala index 8aa9c716c9..824d047d6b 100644 --- a/src/compiler/scala/tools/nsc/symtab/Symbols.scala +++ b/src/compiler/scala/tools/nsc/symtab/Symbols.scala @@ -80,9 +80,6 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => annots1 } - def setSerializable(): Unit = - addAnnotation(AnnotationInfo(SerializableAttr.tpe, Nil, Nil)) - def setAnnotations(annots: List[AnnotationInfoBase]): this.type = { this.rawannots = annots this @@ -402,7 +399,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => } def isStrictFP = hasAnnotation(ScalaStrictFPAttr) || (enclClass hasAnnotation ScalaStrictFPAttr) - def isSerializable = hasAnnotation(SerializableAttr) + def isSerializable = info.baseClasses.exists(p => p == SerializableClass || p == JavaSerializableClass) || hasAnnotation(SerializableAttr) // last part can be removed, @serializable annotation is deprecated def isDeprecated = hasAnnotation(DeprecatedAttr) def deprecationMessage = getAnnotation(DeprecatedAttr) flatMap { _.stringArg(0) } // !!! when annotation arguments are not literal strings, but any sort of @@ -955,6 +952,19 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => setInfo(completer) } + /** + * Adds the interface scala.Serializable to the parents of a ClassInfoType. + * Note that the tree also has to be updated accordingly. + */ + def makeSerializable() { + info match { + case ci @ ClassInfoType(_, _, _) => + updateInfo(ci.copy(parents = ci.parents ::: List(SerializableClass.tpe))) + case i => + abort("Only ClassInfoTypes can be made serializable: "+ i) + } + } + // Comparisons ---------------------------------------------------------------- /** A total ordering between symbols that refines the class diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala index f8f185e6d8..943960c3f7 100644 --- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala +++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala @@ -561,19 +561,6 @@ abstract class CleanUp extends Transform with ast.TreeDSL { typedWithPos(theTry.pos)(BLOCK(VAL(tempVar) === EmptyTree, newTry, Ident(tempVar))) - /* Adds @serializable annotation to anonymous function classes */ - case cdef @ ClassDef(mods, name, tparams, impl) => - /** XXX This check is overly specific and bound to break if it hasn't already. */ - if (settings.target.value == "jvm-1.5") { - val sym = cdef.symbol - // is this an anonymous function class? - if (sym.isAnonymousFunction && !sym.isSerializable) { - sym.setSerializable() - sym addAnnotation serialVersionUIDAnnotation - } - } - super.transform(tree) - /* * This transformation should identify Scala symbol invocations in the tree and replace them * with references to a static member. Also, whenever a class has at least a single symbol invocation diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index ed4808ebbd..34015ef092 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -346,7 +346,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { */ def specializeClass(clazz: Symbol, outerEnv: TypeEnv): List[Symbol] = { def specializedClass(env: TypeEnv, normMembers: List[Symbol]): Symbol = { - val cls = clazz.owner.newClass(clazz.pos, specializedName(clazz, env)) + val cls = clazz.owner.newClass(clazz.pos, specializedName(clazz, env).toTypeName) .setFlag(SPECIALIZED | clazz.flags) .resetFlag(CASE) cls.sourceFile = clazz.sourceFile @@ -545,7 +545,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { } else if (m.isClass) { val specClass: Symbol = m.cloneSymbol(cls).setFlag(SPECIALIZED) typeEnv(specClass) = fullEnv - specClass.name = specializedName(specClass, fullEnv) + specClass.name = specializedName(specClass, fullEnv).toTypeName enterMember(specClass) log("entered specialized class " + specClass.fullName) info(specClass) = SpecializedInnerClass(m, fullEnv) @@ -581,6 +581,14 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { val spc = specializedClass(env, decls1) log("entered " + spc + " in " + clazz.owner) hasSubclasses = true + val existing = clazz.owner.info.decl(spc.name) + // a symbol for the specialized class already exists if there's a classfile for it. + // keeping both crashes the compiler on test/files/pos/spec-Function1.scala + if (existing != NoSymbol) { + log("removing existing symbol for "+ existing) + clazz.owner.info.decls.unlink(existing) + } + atPhase(phase.next)(clazz.owner.info.decls enter spc) //!! assumes fully specialized classes } if (hasSubclasses) clazz.resetFlag(FINAL) diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala index ddc14cd95b..0d87ba1203 100644 --- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala +++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala @@ -327,8 +327,8 @@ abstract class UnCurry extends InfoTransform with TypingTransformers with ast.Tr val (formals, restpe) = (targs.init, targs.last) val anonClass = owner newAnonymousFunctionClass fun.pos setFlag (FINAL | SYNTHETIC | inConstructorFlag) def parents = - if (isFunctionType(fun.tpe)) List(abstractFunctionForFunctionType(fun.tpe)) - else List(ObjectClass.tpe, fun.tpe) + if (isFunctionType(fun.tpe)) List(abstractFunctionForFunctionType(fun.tpe), SerializableClass.tpe) + else List(ObjectClass.tpe, fun.tpe, SerializableClass.tpe) anonClass setInfo ClassInfoType(parents, new Scope, anonClass) val applyMethod = anonClass.newMethod(fun.pos, nme.apply) setFlag FINAL diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala index d4cb11b122..1c8414671c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala @@ -243,8 +243,6 @@ trait SyntheticMethods extends ast.TreeDSL { if (!phase.erasedTypes) try { if (clazz.isCase) { val isTop = clazz.ancestors forall (x => !x.isCase) - // case classes are automatically marked serializable - clazz.setSerializable() if (isTop) { // If this case class has fields with less than public visibility, their getter at this @@ -295,12 +293,6 @@ trait SyntheticMethods extends ast.TreeDSL { } if (clazz.isModuleClass) { - if (!clazz.isSerializable) { - val comp = companionClassOf(clazz, context) - if (comp.isCase || comp.isSerializable) - clazz.setSerializable() - } - def hasReadResolve = { val sym = clazz.info member nme.readResolve // any member, including private sym.isTerm && !sym.isDeferred diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 33db7424bc..03c5d2958c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -1337,10 +1337,16 @@ trait Typers { self: Analyzer => for (c <- linkedClass.info.decl(nme.CONSTRUCTOR).alternatives) c.initialize val clazz = mdef.symbol.moduleClass + val maybeAddSerializable = (l: List[Tree]) => + if(linkedClass == NoSymbol || !linkedClass.isSerializable || clazz.isSerializable) l + else { + clazz.makeSerializable() + l ::: List(TypeTree(SerializableClass.tpe)) + } val typedMods = removeAnnotations(mdef.mods) assert(clazz != NoSymbol) val impl1 = newTyper(context.make(mdef.impl, clazz, new Scope)) - .typedTemplate(mdef.impl, parentTypes(mdef.impl)) + .typedTemplate(mdef.impl, maybeAddSerializable(parentTypes(mdef.impl))) val impl2 = typerAddSyntheticMethods(impl1, clazz, context) if (mdef.name == nme.PACKAGEkw) diff --git a/src/library/scala/Enumeration.scala b/src/library/scala/Enumeration.scala index 36ead577f6..fa786ddb0e 100644 --- a/src/library/scala/Enumeration.scala +++ b/src/library/scala/Enumeration.scala @@ -50,9 +50,8 @@ import java.lang.reflect.{ Modifier, Method => JMethod, Field => JField } * @author Matthias Zenger * @version 1.0, 10/02/2004 */ -@serializable @SerialVersionUID(8476000850333817230L) -abstract class Enumeration(initial: Int, names: String*) { +abstract class Enumeration(initial: Int, names: String*) extends Serializable { thisenum => def this() = this(0, null) @@ -178,9 +177,8 @@ abstract class Enumeration(initial: Int, names: String*) { } /** The type of the enumerated values. */ - @serializable @SerialVersionUID(7091335633555234129L) - abstract class Value extends Ordered[Value] { + abstract class Value extends Ordered[Value] with Serializable { /** the id and bit location of this enumeration value */ def id: Int /** a marker so we can tell whose values belong to whom come reflective-naming time */ @@ -216,9 +214,8 @@ abstract class Enumeration(initial: Int, names: String*) { * overridden to change the enumeration's naming and integer identification * behaviour. */ - @serializable @SerialVersionUID(0 - 3501153230598116017L) - protected class Val(i: Int, name: String) extends Value { + protected class Val(i: Int, name: String) extends Value with Serializable { def this(i: Int) = this(i, nextNameOrElse(i.toString)) def this(name: String) = this(nextId, name) def this() = this(nextId) diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala index e853c0ea45..943fa929ed 100644 --- a/src/library/scala/Option.scala +++ b/src/library/scala/Option.scala @@ -83,7 +83,7 @@ object Option { * @define p `p` * @define f `f` */ -sealed abstract class Option[+A] extends Product { +sealed abstract class Option[+A] extends Product with Serializable { self => /** Returns true if the option is $none, false otherwise. diff --git a/src/library/scala/Responder.scala b/src/library/scala/Responder.scala index f86f883894..1096570673 100644 --- a/src/library/scala/Responder.scala +++ b/src/library/scala/Responder.scala @@ -66,8 +66,7 @@ object Responder { * @version 1.0 * @since 2.1 */ -@serializable -abstract class Responder[+A] { +abstract class Responder[+A] extends Serializable { def respond(k: A => Unit): Unit diff --git a/src/library/scala/Serializable.scala b/src/library/scala/Serializable.scala new file mode 100644 index 0000000000..96b4cf5b32 --- /dev/null +++ b/src/library/scala/Serializable.scala @@ -0,0 +1,14 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2002-2010, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + +package scala + +/** + * Classes extending this trait are serializable across platforms (Java, .NET). + */ +trait Serializable extends java.io.Serializable diff --git a/src/library/scala/Symbol.scala b/src/library/scala/Symbol.scala index 9463a186b6..a396231aaa 100644 --- a/src/library/scala/Symbol.scala +++ b/src/library/scala/Symbol.scala @@ -27,8 +27,7 @@ package scala * @author Martin Odersky, Iulian Dragos * @version 1.8 */ -@serializable -final class Symbol private (val name: String) { +final class Symbol private (val name: String) extends Serializable { /** Converts this symbol to a string. */ override def toString(): String = "'" + name diff --git a/src/library/scala/serializable.scala b/src/library/scala/annotation/serializable.scala index 6269359cd8..1364d7dcce 100644 --- a/src/library/scala/serializable.scala +++ b/src/library/scala/annotation/serializable.scala @@ -6,12 +6,10 @@ ** |/ ** \* */ - - -package scala - +package scala.annotation /** * An annotation that designates the class to which it is applied as serializable */ -class serializable extends StaticAnnotation {} +@deprecated("instead of `@serializable class C`, use `class C extends Serializable`") +class serializable extends StaticAnnotation diff --git a/src/library/scala/collection/IndexedSeqLike.scala b/src/library/scala/collection/IndexedSeqLike.scala index 1ad1da715d..a2044ae7ba 100644 --- a/src/library/scala/collection/IndexedSeqLike.scala +++ b/src/library/scala/collection/IndexedSeqLike.scala @@ -48,8 +48,8 @@ trait IndexedSeqLike[+A, +Repr] extends SeqLike[A, Repr] { self => * multiple `take`, `drop`, and `slice` operations on this iterator are bunched * together for better efficiency. */ - @serializable @SerialVersionUID(1756321872811029277L) - protected class Elements(start: Int, end: Int) extends BufferedIterator[A] { + @SerialVersionUID(1756321872811029277L) + protected class Elements(start: Int, end: Int) extends BufferedIterator[A] with Serializable { private var i = start def hasNext: Boolean = i < end diff --git a/src/library/scala/collection/immutable/BitSet.scala b/src/library/scala/collection/immutable/BitSet.scala index e7fd5c7f0f..fe3edbe88b 100644 --- a/src/library/scala/collection/immutable/BitSet.scala +++ b/src/library/scala/collection/immutable/BitSet.scala @@ -20,10 +20,11 @@ import mutable.{ Builder, AddingBuilder } * @define Coll immutable.BitSet * @define coll immutable bitset */ -@serializable @SerialVersionUID(1611436763290191562L) +@SerialVersionUID(1611436763290191562L) abstract class BitSet extends Set[Int] with scala.collection.BitSet - with BitSetLike[BitSet] { + with BitSetLike[BitSet] + with Serializable { override def empty = BitSet.empty def fromArray(elems: Array[Long]): BitSet = BitSet.fromArray(elems) diff --git a/src/library/scala/collection/immutable/HashMap.scala b/src/library/scala/collection/immutable/HashMap.scala index 977dd6d837..448210a330 100644 --- a/src/library/scala/collection/immutable/HashMap.scala +++ b/src/library/scala/collection/immutable/HashMap.scala @@ -35,8 +35,8 @@ import parallel.immutable.ParHashMap * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @SerialVersionUID(2L) -class HashMap[A, +B] extends Map[A,B] with MapLike[A, B, HashMap[A, B]] with Parallelizable[ParHashMap[A, B]] { +@SerialVersionUID(2L) +class HashMap[A, +B] extends Map[A,B] with MapLike[A, B, HashMap[A, B]] with Parallelizable[ParHashMap[A, B]] with Serializable { override def size: Int = 0 @@ -620,7 +620,7 @@ time { mNew.iterator.foreach( p => ()) } } else true } - @serializable @SerialVersionUID(2L) private class SerializationProxy[A,B](@transient private var orig: HashMap[A, B]) { + @SerialVersionUID(2L) private class SerializationProxy[A,B](@transient private var orig: HashMap[A, B]) extends Serializable { private def writeObject(out: java.io.ObjectOutputStream) { val s = orig.size out.writeInt(s) diff --git a/src/library/scala/collection/immutable/HashSet.scala b/src/library/scala/collection/immutable/HashSet.scala index e75c230eb8..1fe790145d 100644 --- a/src/library/scala/collection/immutable/HashSet.scala +++ b/src/library/scala/collection/immutable/HashSet.scala @@ -30,11 +30,12 @@ import collection.parallel.immutable.ParHashSet * @define Coll immutable.HashSet * @define coll immutable hash set */ -@serializable @SerialVersionUID(2L) +@SerialVersionUID(2L) class HashSet[A] extends Set[A] with GenericSetTemplate[A, HashSet] with SetLike[A, HashSet[A]] with Parallelizable[ParHashSet[A]] + with Serializable { override def companion: GenericCompanion[HashSet] = HashSet @@ -412,7 +413,7 @@ time { mNew.iterator.foreach( p => ()) } } } - @serializable @SerialVersionUID(2L) private class SerializationProxy[A,B](@transient private var orig: HashSet[A]) { + @SerialVersionUID(2L) private class SerializationProxy[A,B](@transient private var orig: HashSet[A]) extends Serializable { private def writeObject(out: java.io.ObjectOutputStream) { val s = orig.size out.writeInt(s) diff --git a/src/library/scala/collection/immutable/IndexedSeq.scala b/src/library/scala/collection/immutable/IndexedSeq.scala index ba432517ff..f47f344a16 100644 --- a/src/library/scala/collection/immutable/IndexedSeq.scala +++ b/src/library/scala/collection/immutable/IndexedSeq.scala @@ -31,8 +31,7 @@ trait IndexedSeq[+A] extends Seq[A] * @define Coll IndexedSeq */ object IndexedSeq extends SeqFactory[IndexedSeq] { - @serializable - class Impl[A](buf: ArrayBuffer[A]) extends IndexedSeq[A] { + class Impl[A](buf: ArrayBuffer[A]) extends IndexedSeq[A] with Serializable { def length = buf.length def apply(idx: Int) = buf.apply(idx) } diff --git a/src/library/scala/collection/immutable/ListMap.scala b/src/library/scala/collection/immutable/ListMap.scala index 53c99216c2..5fced699f3 100644 --- a/src/library/scala/collection/immutable/ListMap.scala +++ b/src/library/scala/collection/immutable/ListMap.scala @@ -42,8 +42,8 @@ object ListMap extends ImmutableMapFactory[ListMap] { * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @SerialVersionUID(301002838095710379L) -class ListMap[A, +B] extends Map[A, B] with MapLike[A, B, ListMap[A, B]] { +@SerialVersionUID(301002838095710379L) +class ListMap[A, +B] extends Map[A, B] with MapLike[A, B, ListMap[A, B]] with Serializable { override def empty = ListMap.empty @@ -123,9 +123,9 @@ class ListMap[A, +B] extends Map[A, B] with MapLike[A, B, ListMap[A, B]] { /** This class represents an entry in the `ListMap`. */ - @serializable @SerialVersionUID(-6453056603889598734L) + @SerialVersionUID(-6453056603889598734L) protected class Node[B1 >: B](override protected val key: A, - override protected val value: B1) extends ListMap[A, B1] { + override protected val value: B1) extends ListMap[A, B1] with Serializable { /** Returns the number of mappings in this map. * * @return number of mappings. diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala index cea4d20595..8547ba195b 100644 --- a/src/library/scala/collection/immutable/ListSet.scala +++ b/src/library/scala/collection/immutable/ListSet.scala @@ -63,10 +63,10 @@ object ListSet extends ImmutableSetFactory[ListSet] { * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable class ListSet[A] extends Set[A] with GenericSetTemplate[A, ListSet] - with SetLike[A, ListSet[A]] { self => + with SetLike[A, ListSet[A]] + with Serializable{ self => override def companion: GenericCompanion[ListSet] = ListSet /** Returns the number of elements in this set. @@ -136,8 +136,7 @@ class ListSet[A] extends Set[A] /** Represents an entry in the `ListSet`. */ - @serializable - protected class Node(override protected val elem: A) extends ListSet[A] { + protected class Node(override protected val elem: A) extends ListSet[A] with Serializable { override private[ListSet] def unchecked_outer = self /** Returns the number of elements in this set. diff --git a/src/library/scala/collection/immutable/Map.scala b/src/library/scala/collection/immutable/Map.scala index 272caec5ea..5a6b1be3d5 100644 --- a/src/library/scala/collection/immutable/Map.scala +++ b/src/library/scala/collection/immutable/Map.scala @@ -66,8 +66,7 @@ object Map extends ImmutableMapFactory[Map] { override def withDefaultValue[B1 >: B](d: B1): immutable.Map[A, B1] = new WithDefault[A, B1](underlying, x => d) } - @serializable - private object EmptyMap extends Map[Any, Nothing] { + private object EmptyMap extends Map[Any, Nothing] with Serializable { override def size: Int = 0 def get(key: Any): Option[Nothing] = None def iterator: Iterator[(Any, Nothing)] = Iterator.empty @@ -76,8 +75,8 @@ object Map extends ImmutableMapFactory[Map] { def - (key: Any): Map[Any, Nothing] = this } - @serializable @deprecated("use `Map.empty' instead") - class EmptyMap[A,B] extends Map[A,B] { + @deprecated("use `Map.empty' instead") + class EmptyMap[A,B] extends Map[A,B] with Serializable { override def size: Int = 0 def get(key: A): Option[B] = None def iterator: Iterator[(A, B)] = Iterator.empty @@ -86,8 +85,7 @@ object Map extends ImmutableMapFactory[Map] { def - (key: A): Map[A, B] = this } - @serializable - class Map1[A, +B](key1: A, value1: B) extends Map[A, B] { + class Map1[A, +B](key1: A, value1: B) extends Map[A, B] with Serializable { override def size = 1 def get(key: A): Option[B] = if (key == key1) Some(value1) else None @@ -103,8 +101,7 @@ object Map extends ImmutableMapFactory[Map] { } } - @serializable - class Map2[A, +B](key1: A, value1: B, key2: A, value2: B) extends Map[A, B] { + class Map2[A, +B](key1: A, value1: B, key2: A, value2: B) extends Map[A, B] with Serializable { override def size = 2 def get(key: A): Option[B] = if (key == key1) Some(value1) @@ -125,8 +122,7 @@ object Map extends ImmutableMapFactory[Map] { } } - @serializable - class Map3[A, +B](key1: A, value1: B, key2: A, value2: B, key3: A, value3: B) extends Map[A, B] { + class Map3[A, +B](key1: A, value1: B, key2: A, value2: B, key3: A, value3: B) extends Map[A, B] with Serializable { override def size = 3 def get(key: A): Option[B] = if (key == key1) Some(value1) @@ -150,8 +146,7 @@ object Map extends ImmutableMapFactory[Map] { } } - @serializable - class Map4[A, +B](key1: A, value1: B, key2: A, value2: B, key3: A, value3: B, key4: A, value4: B) extends Map[A, B] { + class Map4[A, +B](key1: A, value1: B, key2: A, value2: B, key3: A, value3: B, key4: A, value4: B) extends Map[A, B] with Serializable { override def size = 4 def get(key: A): Option[B] = if (key == key1) Some(value1) diff --git a/src/library/scala/collection/immutable/NumericRange.scala b/src/library/scala/collection/immutable/NumericRange.scala index 529a1b22c5..e40ef1cba7 100644 --- a/src/library/scala/collection/immutable/NumericRange.scala +++ b/src/library/scala/collection/immutable/NumericRange.scala @@ -39,11 +39,10 @@ import generic._ * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable abstract class NumericRange[T] (val start: T, val end: T, val step: T, val isInclusive: Boolean) (implicit num: Integral[T]) -extends IndexedSeq[T] { +extends IndexedSeq[T] with Serializable { /** Note that NumericRange must be invariant so that constructs * such as "1L to 10 by 5" do not infer the range type as AnyVal. */ diff --git a/src/library/scala/collection/immutable/Queue.scala b/src/library/scala/collection/immutable/Queue.scala index f5cfd83643..bd2f27e57e 100644 --- a/src/library/scala/collection/immutable/Queue.scala +++ b/src/library/scala/collection/immutable/Queue.scala @@ -26,12 +26,12 @@ import annotation.tailrec * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @SerialVersionUID(-7622936493364270175L) class Queue[+A] protected(protected val in: List[A], protected val out: List[A]) extends LinearSeq[A] with GenericTraversableTemplate[A, Queue] - with LinearSeqLike[A, Queue[A]] { + with LinearSeqLike[A, Queue[A]] + with Serializable { override def companion: GenericCompanion[Queue] = Queue diff --git a/src/library/scala/collection/immutable/Range.scala b/src/library/scala/collection/immutable/Range.scala index 26e32e08fb..1ebf6e283c 100644 --- a/src/library/scala/collection/immutable/Range.scala +++ b/src/library/scala/collection/immutable/Range.scala @@ -38,10 +38,11 @@ import scala.collection.parallel.immutable.ParRange * '''Note:''' this method does not use builders to construct a new range, * and its complexity is O(1). */ -@serializable @SerialVersionUID(7618862778670199309L) +@SerialVersionUID(7618862778670199309L) class Range(val start: Int, val end: Int, val step: Int) extends IndexedSeq[Int] with collection.Parallelizable[ParRange] + with Serializable { def par = ParRange(start, end, step, false) diff --git a/src/library/scala/collection/immutable/RedBlack.scala b/src/library/scala/collection/immutable/RedBlack.scala index ae72c3ae69..d8c16f5ac1 100644 --- a/src/library/scala/collection/immutable/RedBlack.scala +++ b/src/library/scala/collection/immutable/RedBlack.scala @@ -15,8 +15,8 @@ package immutable * * @since 2.3 */ -@serializable @SerialVersionUID(8691885935445612921L) -abstract class RedBlack[A] { +@SerialVersionUID(8691885935445612921L) +abstract class RedBlack[A] extends Serializable { def isSmaller(x: A, y: A): Boolean @@ -27,8 +27,7 @@ abstract class RedBlack[A] { private def mkTree[B](isBlack: Boolean, k: A, v: B, l: Tree[B], r: Tree[B]) = if (isBlack) BlackTree(k, v, l, r) else RedTree(k, v, l, r) - @serializable - abstract class Tree[+B] { + abstract class Tree[+B] extends Serializable { def isEmpty: Boolean def isBlack: Boolean def lookup(x: A): Tree[B] @@ -49,8 +48,7 @@ abstract class RedBlack[A] { def last : A def count : Int } - @serializable - abstract class NonEmpty[+B] extends Tree[B] { + abstract class NonEmpty[+B] extends Tree[B] with Serializable { def isEmpty = false def key: A def value: B @@ -270,7 +268,6 @@ abstract class RedBlack[A] { def last = if (right.isEmpty) key else right.last def count = 1 + left.count + right.count } - @serializable case object Empty extends Tree[Nothing] { def isEmpty = true def isBlack = true @@ -291,14 +288,12 @@ abstract class RedBlack[A] { def last = throw new NoSuchElementException("empty map") def count = 0 } - @serializable case class RedTree[+B](override val key: A, override val value: B, override val left: Tree[B], override val right: Tree[B]) extends NonEmpty[B] { def isBlack = false } - @serializable case class BlackTree[+B](override val key: A, override val value: B, override val left: Tree[B], diff --git a/src/library/scala/collection/immutable/Set.scala b/src/library/scala/collection/immutable/Set.scala index 30f0d86139..ffd41752a4 100644 --- a/src/library/scala/collection/immutable/Set.scala +++ b/src/library/scala/collection/immutable/Set.scala @@ -43,8 +43,7 @@ object Set extends ImmutableSetFactory[Set] { private val hashSeed = "Set".hashCode /** An optimized representation for immutable empty sets */ - @serializable - private object EmptySet extends Set[Any] { + private object EmptySet extends Set[Any] with Serializable { override def size: Int = 0 def contains(elem: Any): Boolean = false def + (elem: Any): Set[Any] = new Set1(elem) @@ -53,8 +52,8 @@ object Set extends ImmutableSetFactory[Set] { override def foreach[U](f: Any => U): Unit = {} } - @serializable @deprecated("use `Set.empty' instead") - class EmptySet[A] extends Set[A] { + @deprecated("use `Set.empty' instead") + class EmptySet[A] extends Set[A] with Serializable { override def size: Int = 0 def contains(elem: A): Boolean = false def + (elem: A): Set[A] = new Set1(elem) @@ -64,8 +63,8 @@ object Set extends ImmutableSetFactory[Set] { } /** An optimized representation for immutable sets of size 1 */ - @serializable @SerialVersionUID(1233385750652442003L) - class Set1[A](elem1: A) extends Set[A] { + @SerialVersionUID(1233385750652442003L) + class Set1[A](elem1: A) extends Set[A] with Serializable { override def size: Int = 1 def contains(elem: A): Boolean = elem == elem1 @@ -83,8 +82,8 @@ object Set extends ImmutableSetFactory[Set] { } /** An optimized representation for immutable sets of size 2 */ - @serializable @SerialVersionUID(-6443011234944830092L) - class Set2[A](elem1: A, elem2: A) extends Set[A] { + @SerialVersionUID(-6443011234944830092L) + class Set2[A](elem1: A, elem2: A) extends Set[A] with Serializable { override def size: Int = 2 def contains(elem: A): Boolean = elem == elem1 || elem == elem2 @@ -103,8 +102,8 @@ object Set extends ImmutableSetFactory[Set] { } /** An optimized representation for immutable sets of size 3 */ - @serializable @SerialVersionUID(-3590273538119220064L) - class Set3[A](elem1: A, elem2: A, elem3: A) extends Set[A] { + @SerialVersionUID(-3590273538119220064L) + class Set3[A](elem1: A, elem2: A, elem3: A) extends Set[A] with Serializable { override def size: Int = 3 def contains(elem: A): Boolean = elem == elem1 || elem == elem2 || elem == elem3 @@ -124,8 +123,8 @@ object Set extends ImmutableSetFactory[Set] { } /** An optimized representation for immutable sets of size 4 */ - @serializable @SerialVersionUID(-3622399588156184395L) - class Set4[A](elem1: A, elem2: A, elem3: A, elem4: A) extends Set[A] { + @SerialVersionUID(-3622399588156184395L) + class Set4[A](elem1: A, elem2: A, elem3: A, elem4: A) extends Set[A] with Serializable { override def size: Int = 4 def contains(elem: A): Boolean = elem == elem1 || elem == elem2 || elem == elem3 || elem == elem4 diff --git a/src/library/scala/collection/immutable/Stack.scala b/src/library/scala/collection/immutable/Stack.scala index 58a37a8136..b9c45a1f32 100644 --- a/src/library/scala/collection/immutable/Stack.scala +++ b/src/library/scala/collection/immutable/Stack.scala @@ -46,11 +46,12 @@ object Stack extends SeqFactory[Stack] { * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @SerialVersionUID(1976480595012942526L) +@SerialVersionUID(1976480595012942526L) class Stack[+A] protected (protected val elems: List[A]) extends LinearSeq[A] with GenericTraversableTemplate[A, Stack] - with LinearSeqOptimized[A, Stack[A]] { + with LinearSeqOptimized[A, Stack[A]] + with Serializable { override def companion: GenericCompanion[Stack] = Stack def this() = this(Nil) diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala index 0b1453369c..04fe6225b4 100644 --- a/src/library/scala/collection/immutable/Stream.scala +++ b/src/library/scala/collection/immutable/Stream.scala @@ -610,8 +610,8 @@ object Stream extends SeqFactory[Stream] { } /** A lazy cons cell, from which streams are built. */ - @serializable @SerialVersionUID(-602202424901551803L) - final class Cons[+A](hd: A, tl: => Stream[A]) extends Stream[A] { + @SerialVersionUID(-602202424901551803L) + final class Cons[+A](hd: A, tl: => Stream[A]) extends Stream[A] with Serializable { override def isEmpty = false override def head = hd @volatile private[this] var tlVal: Stream[A] = _ diff --git a/src/library/scala/collection/immutable/TreeMap.scala b/src/library/scala/collection/immutable/TreeMap.scala index 07212f8f5c..d54c31dec8 100644 --- a/src/library/scala/collection/immutable/TreeMap.scala +++ b/src/library/scala/collection/immutable/TreeMap.scala @@ -42,12 +42,12 @@ object TreeMap extends ImmutableSortedMapFactory[TreeMap] { * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable class TreeMap[A, +B](override val size: Int, t: RedBlack[A]#Tree[B])(implicit val ordering: Ordering[A]) extends RedBlack[A] with SortedMap[A, B] with SortedMapLike[A, B, TreeMap[A, B]] - with MapLike[A, B, TreeMap[A, B]] { + with MapLike[A, B, TreeMap[A, B]] + with Serializable { def isSmaller(x: A, y: A) = ordering.lt(x, y) diff --git a/src/library/scala/collection/immutable/TreeSet.scala b/src/library/scala/collection/immutable/TreeSet.scala index 9eee10f165..d769aee84d 100644 --- a/src/library/scala/collection/immutable/TreeSet.scala +++ b/src/library/scala/collection/immutable/TreeSet.scala @@ -43,10 +43,10 @@ object TreeSet extends ImmutableSortedSetFactory[TreeSet] { * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @SerialVersionUID(-234066569443569402L) +@SerialVersionUID(-234066569443569402L) class TreeSet[A](override val size: Int, t: RedBlack[A]#Tree[Unit]) (implicit val ordering: Ordering[A]) - extends RedBlack[A] with SortedSet[A] with SortedSetLike[A, TreeSet[A]] { + extends RedBlack[A] with SortedSet[A] with SortedSetLike[A, TreeSet[A]] with Serializable { override def stringPrefix = "TreeSet" diff --git a/src/library/scala/collection/immutable/Vector.scala b/src/library/scala/collection/immutable/Vector.scala index 3f1aa8c1b5..aeb3b82147 100644 --- a/src/library/scala/collection/immutable/Vector.scala +++ b/src/library/scala/collection/immutable/Vector.scala @@ -32,11 +32,11 @@ object Vector extends SeqFactory[Vector] { // in principle, most members should be private. however, access privileges must // be carefully chosen to not prevent method inlining -@serializable final class Vector[+A](startIndex: Int, endIndex: Int, focus: Int) extends IndexedSeq[A] with GenericTraversableTemplate[A, Vector] with IndexedSeqLike[A, Vector[A]] - with VectorPointer[A @uncheckedVariance] { self => + with VectorPointer[A @uncheckedVariance] + with Serializable { self => override def companion: GenericCompanion[Vector] = Vector diff --git a/src/library/scala/collection/mutable/ArrayBuffer.scala b/src/library/scala/collection/mutable/ArrayBuffer.scala index 83109d0255..1333f2bee1 100644 --- a/src/library/scala/collection/mutable/ArrayBuffer.scala +++ b/src/library/scala/collection/mutable/ArrayBuffer.scala @@ -40,7 +40,7 @@ import parallel.mutable.ParArray * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @SerialVersionUID(1529165946227428979L) +@SerialVersionUID(1529165946227428979L) class ArrayBuffer[A](override protected val initialSize: Int) extends Buffer[A] with GenericTraversableTemplate[A, ArrayBuffer] @@ -48,7 +48,8 @@ class ArrayBuffer[A](override protected val initialSize: Int) with IndexedSeqOptimized[A, ArrayBuffer[A]] with Builder[A, ArrayBuffer[A]] with ResizableArray[A] - with Parallelizable[ParArray[A]] { + with Parallelizable[ParArray[A]] + with Serializable { override def companion: GenericCompanion[ArrayBuffer] = ArrayBuffer diff --git a/src/library/scala/collection/mutable/ArrayBuilder.scala b/src/library/scala/collection/mutable/ArrayBuilder.scala index ec1351f671..0c7196133e 100644 --- a/src/library/scala/collection/mutable/ArrayBuilder.scala +++ b/src/library/scala/collection/mutable/ArrayBuilder.scala @@ -20,8 +20,7 @@ import scala.reflect.ClassManifest * * @tparam T the type of the elements for the builder. */ -@serializable -abstract class ArrayBuilder[T] extends Builder[T, Array[T]] +abstract class ArrayBuilder[T] extends Builder[T, Array[T]] with Serializable /** A companion object for array builders. * diff --git a/src/library/scala/collection/mutable/ArraySeq.scala b/src/library/scala/collection/mutable/ArraySeq.scala index 91bc864224..77dde422d9 100644 --- a/src/library/scala/collection/mutable/ArraySeq.scala +++ b/src/library/scala/collection/mutable/ArraySeq.scala @@ -39,12 +39,13 @@ import parallel.mutable.ParArray * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @SerialVersionUID(1530165946227428979L) +@SerialVersionUID(1530165946227428979L) class ArraySeq[A](override val length: Int) extends IndexedSeq[A] with GenericTraversableTemplate[A, ArraySeq] with IndexedSeqOptimized[A, ArraySeq[A]] with Parallelizable[ParArray[A]] + with Serializable { override def companion: GenericCompanion[ArraySeq] = ArraySeq diff --git a/src/library/scala/collection/mutable/ArrayStack.scala b/src/library/scala/collection/mutable/ArrayStack.scala index 4cf6b78de3..909324f87c 100644 --- a/src/library/scala/collection/mutable/ArrayStack.scala +++ b/src/library/scala/collection/mutable/ArrayStack.scala @@ -59,7 +59,7 @@ object ArrayStack extends SeqFactory[ArrayStack] { * @define mayNotTerminateInf * @define willNotTerminateInf */ -@cloneable @serializable @SerialVersionUID(8565219180626620510L) +@cloneable @SerialVersionUID(8565219180626620510L) class ArrayStack[T] private(private var table : Array[AnyRef], private var index : Int) extends Seq[T] @@ -67,6 +67,7 @@ extends Seq[T] with GenericTraversableTemplate[T, ArrayStack] with Cloneable[ArrayStack[T]] with Builder[T, ArrayStack[T]] + with Serializable { def this() = this(new Array[AnyRef](1), 0) diff --git a/src/library/scala/collection/mutable/BitSet.scala b/src/library/scala/collection/mutable/BitSet.scala index 41977e51a9..747b476a92 100644 --- a/src/library/scala/collection/mutable/BitSet.scala +++ b/src/library/scala/collection/mutable/BitSet.scala @@ -32,11 +32,12 @@ import BitSetLike.{LogWL, updateArray} * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @SerialVersionUID(8483111450368547763L) +@SerialVersionUID(8483111450368547763L) class BitSet(protected var elems: Array[Long]) extends Set[Int] with scala.collection.BitSet with BitSetLike[BitSet] - with SetLike[Int, BitSet] { + with SetLike[Int, BitSet] + with Serializable { override def empty = BitSet.empty diff --git a/src/library/scala/collection/mutable/DefaultEntry.scala b/src/library/scala/collection/mutable/DefaultEntry.scala index 44695c9ebe..464d993e60 100644 --- a/src/library/scala/collection/mutable/DefaultEntry.scala +++ b/src/library/scala/collection/mutable/DefaultEntry.scala @@ -16,9 +16,8 @@ package mutable /** Class used internally for default map model. * @since 2.3 */ -@serializable final class DefaultEntry[A, B](val key: A, var value: B) - extends HashEntry[A, DefaultEntry[A, B]] + extends HashEntry[A, DefaultEntry[A, B]] with Serializable { override def toString = chainString diff --git a/src/library/scala/collection/mutable/DoubleLinkedList.scala b/src/library/scala/collection/mutable/DoubleLinkedList.scala index f71bc12570..3f403f28a1 100644 --- a/src/library/scala/collection/mutable/DoubleLinkedList.scala +++ b/src/library/scala/collection/mutable/DoubleLinkedList.scala @@ -37,10 +37,11 @@ import generic._ * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @SerialVersionUID(-8144992287952814767L) +@SerialVersionUID(-8144992287952814767L) class DoubleLinkedList[A]() extends LinearSeq[A] with GenericTraversableTemplate[A, DoubleLinkedList] - with DoubleLinkedListLike[A, DoubleLinkedList[A]] { + with DoubleLinkedListLike[A, DoubleLinkedList[A]] + with Serializable { next = this /** Creates a node for the double linked list. diff --git a/src/library/scala/collection/mutable/HashMap.scala b/src/library/scala/collection/mutable/HashMap.scala index 3960af763b..33161e1ee3 100644 --- a/src/library/scala/collection/mutable/HashMap.scala +++ b/src/library/scala/collection/mutable/HashMap.scala @@ -39,12 +39,13 @@ import scala.collection.parallel.mutable.ParHashMap * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @SerialVersionUID(1L) +@SerialVersionUID(1L) class HashMap[A, B] private[collection] (contents: HashTable.Contents[A, DefaultEntry[A, B]]) extends Map[A, B] with MapLike[A, B, HashMap[A, B]] with HashTable[A, DefaultEntry[A, B]] with Parallelizable[ParHashMap[A, B]] + with Serializable { initWithContents(contents) diff --git a/src/library/scala/collection/mutable/HashSet.scala b/src/library/scala/collection/mutable/HashSet.scala index 377f58e74e..4a534b3754 100644 --- a/src/library/scala/collection/mutable/HashSet.scala +++ b/src/library/scala/collection/mutable/HashSet.scala @@ -38,13 +38,14 @@ import collection.parallel.mutable.ParHashSet * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @SerialVersionUID(1L) +@SerialVersionUID(1L) class HashSet[A] private[collection] (contents: FlatHashTable.Contents[A]) extends Set[A] with GenericSetTemplate[A, HashSet] with SetLike[A, HashSet[A]] with FlatHashTable[A] with Parallelizable[ParHashSet[A]] + with Serializable { initWithContents(contents) diff --git a/src/library/scala/collection/mutable/History.scala b/src/library/scala/collection/mutable/History.scala index 4a48f5c12c..1a3fa12c82 100644 --- a/src/library/scala/collection/mutable/History.scala +++ b/src/library/scala/collection/mutable/History.scala @@ -24,9 +24,8 @@ package mutable * @tparam Evt Type of events. * @tparam Pub Type of publishers. */ -@serializable @SerialVersionUID(5219213543849892588L) -class History[Evt, Pub] extends Subscriber[Evt, Pub] with Iterable[(Pub, Evt)] +class History[Evt, Pub] extends Subscriber[Evt, Pub] with Iterable[(Pub, Evt)] with Serializable { protected val log: Queue[(Pub, Evt)] = new Queue val maxHistory: Int = 1000 diff --git a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala index 24f11e105f..170e0ec274 100644 --- a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala +++ b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala @@ -24,9 +24,8 @@ import annotation.migration * @version 2.0, 01/01/2007 * @since 1 */ -@serializable class ImmutableMapAdaptor[A, B](protected var imap: immutable.Map[A, B]) -extends Map[A, B] +extends Map[A, B] with Serializable { override def size: Int = imap.size diff --git a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala index 4560d01d4d..0895d20d26 100644 --- a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala +++ b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala @@ -22,8 +22,7 @@ package mutable * @version 1.0, 21/07/2003 * @since 1 */ -@serializable -class ImmutableSetAdaptor[A](protected var set: immutable.Set[A]) extends Set[A] { +class ImmutableSetAdaptor[A](protected var set: immutable.Set[A]) extends Set[A] with Serializable { override def size: Int = set.size diff --git a/src/library/scala/collection/mutable/LinkedEntry.scala b/src/library/scala/collection/mutable/LinkedEntry.scala index 667d45b637..be220cdd7a 100644 --- a/src/library/scala/collection/mutable/LinkedEntry.scala +++ b/src/library/scala/collection/mutable/LinkedEntry.scala @@ -14,9 +14,8 @@ package mutable /** Class for the linked hash map entry, used internally. * @since 2.8 */ -@serializable final class LinkedEntry[A, B](val key: A, var value: B) - extends HashEntry[A, LinkedEntry[A, B]] { + extends HashEntry[A, LinkedEntry[A, B]] with Serializable { var earlier: LinkedEntry[A, B] = null var later: LinkedEntry[A, B] = null } diff --git a/src/library/scala/collection/mutable/LinkedHashMap.scala b/src/library/scala/collection/mutable/LinkedHashMap.scala index f52aebed81..e08c7023cd 100644 --- a/src/library/scala/collection/mutable/LinkedHashMap.scala +++ b/src/library/scala/collection/mutable/LinkedHashMap.scala @@ -44,10 +44,11 @@ object LinkedHashMap extends MutableMapFactory[LinkedHashMap] { * @define orderDependent * @define orderDependentFold */ -@serializable @SerialVersionUID(1L) +@SerialVersionUID(1L) class LinkedHashMap[A, B] extends Map[A, B] with MapLike[A, B, LinkedHashMap[A, B]] - with HashTable[A, LinkedEntry[A, B]] { + with HashTable[A, LinkedEntry[A, B]] + with Serializable { override def empty = LinkedHashMap.empty[A, B] override def size = tableSize diff --git a/src/library/scala/collection/mutable/LinkedHashSet.scala b/src/library/scala/collection/mutable/LinkedHashSet.scala index 2b83316623..3cd32e7b2b 100644 --- a/src/library/scala/collection/mutable/LinkedHashSet.scala +++ b/src/library/scala/collection/mutable/LinkedHashSet.scala @@ -38,11 +38,12 @@ import generic._ * @define orderDependent * @define orderDependentFold */ -@serializable @SerialVersionUID(1L) +@SerialVersionUID(1L) class LinkedHashSet[A] extends Set[A] with GenericSetTemplate[A, LinkedHashSet] with SetLike[A, LinkedHashSet[A]] with FlatHashTable[A] + with Serializable { override def companion: GenericCompanion[LinkedHashSet] = LinkedHashSet diff --git a/src/library/scala/collection/mutable/LinkedList.scala b/src/library/scala/collection/mutable/LinkedList.scala index 538e2f1ba5..7be35c1326 100644 --- a/src/library/scala/collection/mutable/LinkedList.scala +++ b/src/library/scala/collection/mutable/LinkedList.scala @@ -37,10 +37,11 @@ import generic._ * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @SerialVersionUID(-7308240733518833071L) +@SerialVersionUID(-7308240733518833071L) class LinkedList[A]() extends LinearSeq[A] with GenericTraversableTemplate[A, LinkedList] - with LinkedListLike[A, LinkedList[A]] { + with LinkedListLike[A, LinkedList[A]] + with Serializable { next = this def this(elem: A, next: LinkedList[A]) { diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala index 55629fe523..3c58ecb6df 100644 --- a/src/library/scala/collection/mutable/ListBuffer.scala +++ b/src/library/scala/collection/mutable/ListBuffer.scala @@ -38,13 +38,14 @@ import immutable.{List, Nil, ::} * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @SerialVersionUID(3419063961353022661L) +@SerialVersionUID(3419063961353022661L) final class ListBuffer[A] extends Buffer[A] with GenericTraversableTemplate[A, ListBuffer] with BufferLike[A, ListBuffer[A]] with Builder[A, List[A]] with SeqForwarder[A] + with Serializable { override def companion: GenericCompanion[ListBuffer] = ListBuffer diff --git a/src/library/scala/collection/mutable/ListMap.scala b/src/library/scala/collection/mutable/ListMap.scala index 3aa6f9c753..515e18274a 100644 --- a/src/library/scala/collection/mutable/ListMap.scala +++ b/src/library/scala/collection/mutable/ListMap.scala @@ -34,8 +34,7 @@ import generic._ * @define orderDependent * @define orderDependentFold */ -@serializable -class ListMap[A, B] extends Map[A, B] with MapLike[A, B, ListMap[A, B]] { +class ListMap[A, B] extends Map[A, B] with MapLike[A, B, ListMap[A, B]] with Serializable { override def empty = ListMap.empty[A, B] diff --git a/src/library/scala/collection/mutable/MutableList.scala b/src/library/scala/collection/mutable/MutableList.scala index 79c05dff11..71a80134a8 100644 --- a/src/library/scala/collection/mutable/MutableList.scala +++ b/src/library/scala/collection/mutable/MutableList.scala @@ -25,12 +25,13 @@ import immutable.{List, Nil} * @version 2.8 * @since 1 */ -@serializable @SerialVersionUID(5938451523372603072L) +@SerialVersionUID(5938451523372603072L) class MutableList[A] extends LinearSeq[A] with LinearSeqOptimized[A, MutableList[A]] with GenericTraversableTemplate[A, MutableList] with Builder[A, MutableList[A]] + with Serializable { override def companion: GenericCompanion[MutableList] = MutableList diff --git a/src/library/scala/collection/mutable/PriorityQueue.scala b/src/library/scala/collection/mutable/PriorityQueue.scala index 37a5a8fc88..45f1d1f06f 100644 --- a/src/library/scala/collection/mutable/PriorityQueue.scala +++ b/src/library/scala/collection/mutable/PriorityQueue.scala @@ -32,13 +32,14 @@ import annotation.migration * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @cloneable +@cloneable class PriorityQueue[A](implicit val ord: Ordering[A]) extends Iterable[A] with GenericOrderedTraversableTemplate[A, PriorityQueue] with IterableLike[A, PriorityQueue[A]] with Growable[A] with Builder[A, PriorityQueue[A]] + with Serializable { import ord._ diff --git a/src/library/scala/collection/mutable/Queue.scala b/src/library/scala/collection/mutable/Queue.scala index d808cdf537..eaf2be9bba 100644 --- a/src/library/scala/collection/mutable/Queue.scala +++ b/src/library/scala/collection/mutable/Queue.scala @@ -28,11 +28,12 @@ import generic._ * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @cloneable +@cloneable class Queue[A] extends MutableList[A] with GenericTraversableTemplate[A, Queue] with Cloneable[Queue[A]] + with Serializable { override def companion: GenericCompanion[Queue] = Queue diff --git a/src/library/scala/collection/mutable/RevertibleHistory.scala b/src/library/scala/collection/mutable/RevertibleHistory.scala index 87b4efa5f2..7b09dc7792 100644 --- a/src/library/scala/collection/mutable/RevertibleHistory.scala +++ b/src/library/scala/collection/mutable/RevertibleHistory.scala @@ -24,8 +24,7 @@ package mutable * @version 1.0, 08/07/2003 * @since 2.8 */ -@serializable -class RevertibleHistory[Evt <: Undoable, Pub] extends History[Evt, Pub] with Undoable { +class RevertibleHistory[Evt <: Undoable, Pub] extends History[Evt, Pub] with Undoable with Serializable { /** Rollback the full history. */ diff --git a/src/library/scala/collection/mutable/Stack.scala b/src/library/scala/collection/mutable/Stack.scala index 2e35a96e25..51a0fd5a35 100644 --- a/src/library/scala/collection/mutable/Stack.scala +++ b/src/library/scala/collection/mutable/Stack.scala @@ -55,12 +55,13 @@ object Stack extends SeqFactory[Stack] { * @define mayNotTerminateInf * @define willNotTerminateInf */ -@serializable @cloneable +@cloneable class Stack[A] private (var elems: List[A]) extends Seq[A] with SeqLike[A, Stack[A]] with GenericTraversableTemplate[A, Stack] with Cloneable[Stack[A]] + with Serializable { def this() = this(Nil) diff --git a/src/library/scala/collection/mutable/StringBuilder.scala b/src/library/scala/collection/mutable/StringBuilder.scala index f78131111a..2cbf9530b9 100644 --- a/src/library/scala/collection/mutable/StringBuilder.scala +++ b/src/library/scala/collection/mutable/StringBuilder.scala @@ -22,13 +22,13 @@ import immutable.StringLike * @version 2.8 * @since 2.7 */ -@serializable @SerialVersionUID(0 - 8525408645367278351L) final class StringBuilder(private val underlying: JavaStringBuilder) extends Builder[Char, StringBuilder] with java.lang.CharSequence with IndexedSeq[Char] - with StringLike[StringBuilder] { + with StringLike[StringBuilder] + with Serializable { override protected[this] def thisCollection: StringBuilder = this override protected[this] def toCollection(repr: StringBuilder): StringBuilder = repr diff --git a/src/library/scala/collection/mutable/WrappedArray.scala b/src/library/scala/collection/mutable/WrappedArray.scala index 4246a59bf8..a5fba22846 100644 --- a/src/library/scala/collection/mutable/WrappedArray.scala +++ b/src/library/scala/collection/mutable/WrappedArray.scala @@ -104,80 +104,70 @@ object WrappedArray { def newBuilder[A]: Builder[A, IndexedSeq[A]] = new ArrayBuffer - @serializable - final class ofRef[T <: AnyRef](val array: Array[T]) extends WrappedArray[T] { + final class ofRef[T <: AnyRef](val array: Array[T]) extends WrappedArray[T] with Serializable { lazy val elemManifest = ClassManifest.classType[T](array.getClass.getComponentType) def length: Int = array.length def apply(index: Int): T = array(index).asInstanceOf[T] def update(index: Int, elem: T) { array(index) = elem } } - @serializable - final class ofByte(val array: Array[Byte]) extends WrappedArray[Byte] { + final class ofByte(val array: Array[Byte]) extends WrappedArray[Byte] with Serializable { def elemManifest = ClassManifest.Byte def length: Int = array.length def apply(index: Int): Byte = array(index) def update(index: Int, elem: Byte) { array(index) = elem } } - @serializable - final class ofShort(val array: Array[Short]) extends WrappedArray[Short] { + final class ofShort(val array: Array[Short]) extends WrappedArray[Short] with Serializable { def elemManifest = ClassManifest.Short def length: Int = array.length def apply(index: Int): Short = array(index) def update(index: Int, elem: Short) { array(index) = elem } } - @serializable - final class ofChar(val array: Array[Char]) extends WrappedArray[Char] { + final class ofChar(val array: Array[Char]) extends WrappedArray[Char] with Serializable { def elemManifest = ClassManifest.Char def length: Int = array.length def apply(index: Int): Char = array(index) def update(index: Int, elem: Char) { array(index) = elem } } - @serializable - final class ofInt(val array: Array[Int]) extends WrappedArray[Int] { + final class ofInt(val array: Array[Int]) extends WrappedArray[Int] with Serializable { def elemManifest = ClassManifest.Int def length: Int = array.length def apply(index: Int): Int = array(index) def update(index: Int, elem: Int) { array(index) = elem } } - @serializable - final class ofLong(val array: Array[Long]) extends WrappedArray[Long] { + final class ofLong(val array: Array[Long]) extends WrappedArray[Long] with Serializable { def elemManifest = ClassManifest.Long def length: Int = array.length def apply(index: Int): Long = array(index) def update(index: Int, elem: Long) { array(index) = elem } } - @serializable - final class ofFloat(val array: Array[Float]) extends WrappedArray[Float] { + final class ofFloat(val array: Array[Float]) extends WrappedArray[Float] with Serializable { def elemManifest = ClassManifest.Float def length: Int = array.length def apply(index: Int): Float = array(index) def update(index: Int, elem: Float) { array(index) = elem } } - @serializable - final class ofDouble(val array: Array[Double]) extends WrappedArray[Double] { + final class ofDouble(val array: Array[Double]) extends WrappedArray[Double] with Serializable { def elemManifest = ClassManifest.Double def length: Int = array.length def apply(index: Int): Double = array(index) def update(index: Int, elem: Double) { array(index) = elem } } - @serializable - final class ofBoolean(val array: Array[Boolean]) extends WrappedArray[Boolean] { + final class ofBoolean(val array: Array[Boolean]) extends WrappedArray[Boolean] with Serializable { def elemManifest = ClassManifest.Boolean def length: Int = array.length def apply(index: Int): Boolean = array(index) def update(index: Int, elem: Boolean) { array(index) = elem } } - @serializable - final class ofUnit(val array: Array[Unit]) extends WrappedArray[Unit] { + final class ofUnit(val array: Array[Unit]) extends WrappedArray[Unit] with Serializable { def elemManifest = ClassManifest.Unit def length: Int = array.length def apply(index: Int): Unit = array(index) diff --git a/src/library/scala/math/BigDecimal.scala b/src/library/scala/math/BigDecimal.scala index 3fcc00222b..c2c23f9ce8 100644 --- a/src/library/scala/math/BigDecimal.scala +++ b/src/library/scala/math/BigDecimal.scala @@ -34,8 +34,7 @@ object BigDecimal { /** Cache ony for defaultMathContext using BigDecimals in a small range. */ private lazy val cache = new Array[BigDecimal](maxCached - minCached + 1) - @serializable - object RoundingMode extends Enumeration(java.math.RoundingMode.values map (_.toString) : _*) { + object RoundingMode extends Enumeration(java.math.RoundingMode.values map (_.toString) : _*) with Serializable { type RoundingMode = Value val UP, DOWN, CEILING, FLOOR, HALF_UP, HALF_DOWN, HALF_EVEN, UNNECESSARY = Value } @@ -155,11 +154,10 @@ object BigDecimal { * @author Stephane Micheloud * @version 1.0 */ -@serializable class BigDecimal( val bigDecimal: BigDec, val mc: MathContext) -extends ScalaNumber with ScalaNumericConversions +extends ScalaNumber with ScalaNumericConversions with Serializable { def this(bigDecimal: BigDec) = this(bigDecimal, BigDecimal.defaultMathContext) import BigDecimal.RoundingMode._ diff --git a/src/library/scala/math/BigInt.scala b/src/library/scala/math/BigInt.scala index bd20891019..d061f0cb74 100644 --- a/src/library/scala/math/BigInt.scala +++ b/src/library/scala/math/BigInt.scala @@ -113,8 +113,7 @@ object BigInt { * @author Martin Odersky * @version 1.0, 15/07/2003 */ -@serializable -class BigInt(val bigInteger: BigInteger) extends ScalaNumber with ScalaNumericConversions +class BigInt(val bigInteger: BigInteger) extends ScalaNumber with ScalaNumericConversions with Serializable { /** Returns the hash code for this BigInt. */ override def hashCode(): Int = diff --git a/src/library/scala/math/Ordering.scala b/src/library/scala/math/Ordering.scala index 047b0c3d11..392cbf5e81 100644 --- a/src/library/scala/math/Ordering.scala +++ b/src/library/scala/math/Ordering.scala @@ -40,8 +40,7 @@ import java.util.Comparator * @version 0.9.5, 2008-04-15 * @since 2.7 */ -@serializable -trait Ordering[T] extends Comparator[T] with PartialOrdering[T] { +trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializable { outer => /** An Ordering is defined at all x and y. */ diff --git a/src/library/scala/package.scala b/src/library/scala/package.scala index 2931722dba..86efe7c379 100644 --- a/src/library/scala/package.scala +++ b/src/library/scala/package.scala @@ -28,6 +28,9 @@ package object scala { type NumberFormatException = java.lang.NumberFormatException type AbstractMethodError = java.lang.AbstractMethodError + @deprecated("instead of `@serializable class C`, use `class C extends Serializable`") + type serializable = annotation.serializable + type TraversableOnce[+A] = scala.collection.TraversableOnce[A] type Traversable[+A] = scala.collection.Traversable[A] diff --git a/src/library/scala/reflect/ClassManifest.scala b/src/library/scala/reflect/ClassManifest.scala index 4b1aa2a8db..4b5966e240 100644 --- a/src/library/scala/reflect/ClassManifest.scala +++ b/src/library/scala/reflect/ClassManifest.scala @@ -9,7 +9,6 @@ package scala.reflect import scala.collection.mutable.{ WrappedArray, ArrayBuilder } -import java.io.Serializable /** <p> * A <code>ClassManifest[T]</code> is an opaque descriptor for type <code>T</code>. diff --git a/src/library/scala/reflect/NoManifest.scala b/src/library/scala/reflect/NoManifest.scala index d0497d4244..419d2d64c4 100644 --- a/src/library/scala/reflect/NoManifest.scala +++ b/src/library/scala/reflect/NoManifest.scala @@ -12,7 +12,6 @@ package scala.reflect /** <p> One of the branches of an OptManifest */ -@serializable -object NoManifest extends OptManifest[Nothing] { +object NoManifest extends OptManifest[Nothing] with Serializable { override def toString = "<?>" } diff --git a/src/library/scala/reflect/OptManifest.scala b/src/library/scala/reflect/OptManifest.scala index f3ccef5af0..ad2b9b4598 100644 --- a/src/library/scala/reflect/OptManifest.scala +++ b/src/library/scala/reflect/OptManifest.scala @@ -18,5 +18,4 @@ package scala.reflect * * @author Martin Odersky */ -@serializable -trait OptManifest[+T] +trait OptManifest[+T] extends Serializable diff --git a/src/library/scala/util/matching/Regex.scala b/src/library/scala/util/matching/Regex.scala index cf2c1d2cea..b9acb8a3a4 100644 --- a/src/library/scala/util/matching/Regex.scala +++ b/src/library/scala/util/matching/Regex.scala @@ -31,9 +31,8 @@ import collection.{Iterator, Seq} * @param regex A string representing a regular expression * @param groupNames A mapping from names to indices in capture groups */ -@serializable @SerialVersionUID(-2094783597747625537L) -class Regex(regex: String, groupNames: String*) { +class Regex(regex: String, groupNames: String*) extends Serializable { import Regex._ diff --git a/src/library/scala/xml/Atom.scala b/src/library/scala/xml/Atom.scala index 8d8667eae6..b2cbc53964 100644 --- a/src/library/scala/xml/Atom.scala +++ b/src/library/scala/xml/Atom.scala @@ -15,8 +15,7 @@ package scala.xml * @author Burak Emir * @param text the text contained in this node, may not be <code>null</code>. */ -@serializable -class Atom[+A](val data: A) extends SpecialNode +class Atom[+A](val data: A) extends SpecialNode with Serializable { if (data == null) throw new IllegalArgumentException("cannot construct Atom(null)") diff --git a/src/library/scala/xml/Document.scala b/src/library/scala/xml/Document.scala index 60e4790139..a1a6827b86 100644 --- a/src/library/scala/xml/Document.scala +++ b/src/library/scala/xml/Document.scala @@ -18,8 +18,8 @@ package scala.xml * @author Burak Emir * @version 1.0, 26/04/2005 */ -@serializable @SerialVersionUID(-2289320563321795109L) -class Document extends NodeSeq with pull.XMLEvent { +@SerialVersionUID(-2289320563321795109L) +class Document extends NodeSeq with pull.XMLEvent with Serializable { /** An ordered list of child information items, in document * order. The list contains exactly one element information item. The diff --git a/src/library/scala/xml/Elem.scala b/src/library/scala/xml/Elem.scala index c65608f5fb..bb4e3b2794 100644 --- a/src/library/scala/xml/Elem.scala +++ b/src/library/scala/xml/Elem.scala @@ -40,14 +40,13 @@ object Elem * Copyright 2008 Google Inc. All Rights Reserved. * @author Burak Emir <bqe@google.com> */ -@serializable class Elem( override val prefix: String, val label: String, override val attributes: MetaData, override val scope: NamespaceBinding, val child: Node*) -extends Node +extends Node with Serializable { final override def doCollectNamespaces = true final override def doTransform = true diff --git a/src/library/scala/xml/Group.scala b/src/library/scala/xml/Group.scala index 614adc98a9..7a8f2f3e81 100644 --- a/src/library/scala/xml/Group.scala +++ b/src/library/scala/xml/Group.scala @@ -14,7 +14,6 @@ package scala.xml * @author Burak Emir * @version 1.0 */ -@serializable final case class Group(val nodes: Seq[Node]) extends Node { override def theSeq = nodes diff --git a/src/library/scala/xml/MetaData.scala b/src/library/scala/xml/MetaData.scala index ab3d476deb..02e5cf32ad 100644 --- a/src/library/scala/xml/MetaData.scala +++ b/src/library/scala/xml/MetaData.scala @@ -71,8 +71,7 @@ object MetaData { * Copyright 2008 Google Inc. All Rights Reserved. * @author Burak Emir <bqe@google.com> */ -@serializable -abstract class MetaData extends Iterable[MetaData] with Equality +abstract class MetaData extends Iterable[MetaData] with Equality with Serializable { /** Updates this MetaData with the MetaData given as argument. All attributes that occur in updates * are part of the resulting MetaData. If an attribute occurs in both this instance and diff --git a/test/files/jvm/serialization.scala b/test/files/jvm/serialization.scala index b16d46adad..2e34079505 100644 --- a/test/files/jvm/serialization.scala +++ b/test/files/jvm/serialization.scala @@ -40,7 +40,6 @@ object Test1_scala { (a1.length == a2.length) && (Iterator.range(0, a1.length) forall { i => a1(i) == a2(i) }) - @serializable object WeekDay extends Enumeration { type WeekDay = Value val Monday, Tuesday, Wednesday, Thusday, Friday, Saturday, Sunday = Value @@ -187,7 +186,6 @@ object Test1_scala { //############################################################################ // Test classes in package "scala.collection.immutable" -@serializable object Test2_immutable { import scala.collection.immutable.{ BitSet, HashMap, HashSet, ListMap, ListSet, Queue, Range, SortedMap, @@ -353,10 +351,6 @@ object Test3_mutable { val _hs1: HashSet[String] = read(write(hs1)) check(hs1, _hs1) - // History - @serializable - class Feed extends Publisher[String] - val h1 = new History[String, Int] val _h1: History[String, Int] = read(write(h1)) check(h1, _h1) @@ -373,8 +367,6 @@ object Test3_mutable { val _lb1: ListBuffer[String] = read(write(lb1)) check(lb1, _lb1) - // Publisher - // Queue val q1 = new Queue[Int] q1 ++= List(20, 2, 3).iterator @@ -471,8 +463,7 @@ object Test4_xml { //############################################################################ // Test user-defined classes WITHOUT nesting -@serializable -class Person(_name: String) { +class Person(_name: String) extends Serializable { private var name = _name override def toString() = name override def equals(that: Any): Boolean = @@ -480,12 +471,11 @@ class Person(_name: String) { (name == that.asInstanceOf[Person].name) } -@serializable -class Employee(_name: String) { +class Employee(_name: String) extends Serializable { private var name = _name override def toString() = name } -@serializable + object bob extends Employee("Bob") object Test5 { @@ -508,13 +498,10 @@ object Test5 { //############################################################################ // Test user-defined classes WITH nesting -@serializable object Test6 { - @serializable object bill extends Employee("Bill") { val x = paul } - @serializable object paul extends Person("Paul") { val x = 4 // bill; => StackOverflowException !!! } @@ -540,11 +527,8 @@ object Test6 { //############################################################################ // Nested objects cannot get readresolve automatically because after deserialization // they would be null (they are treated as lazy vals) -@serializable -class Outer { - - @serializable - object Inner +class Outer extends Serializable { + object Inner extends Serializable } object Test7 { @@ -564,11 +548,10 @@ object Test7 { // Verify that transient lazy vals don't get serialized -@serializable -class WithTransient { +class WithTransient extends Serializable { @transient lazy val a1 = 1 @transient private lazy val a2 = 2 - @transient @serializable object B + @transient object B extends Serializable def test = { println(a1) diff --git a/test/files/pos/t3924.scala b/test/files/pos/t3924.scala new file mode 100644 index 0000000000..35165baaf0 --- /dev/null +++ b/test/files/pos/t3924.scala @@ -0,0 +1,6 @@ +object Test { + class Hoe extends Serializable { + def add(a: java.io.Serializable): Unit = println(a) + def someMethod() { add(this) } + } +} diff --git a/test/files/run/t3667.check b/test/files/run/t3667.check index 01e79c32a8..bbe5d1bc48 100644 --- a/test/files/run/t3667.check +++ b/test/files/run/t3667.check @@ -1,3 +1,6 @@ 1 2 3 +4 +2 +3 diff --git a/test/files/run/t3667.scala b/test/files/run/t3667.scala index 7bd0b4ec5e..f30d57ce3a 100644 --- a/test/files/run/t3667.scala +++ b/test/files/run/t3667.scala @@ -3,6 +3,9 @@ object Test { val o1 = new Outer1 val o2 = new Outer2 val o3 = new Outer3 + val o4 = new Outer4 + val o5 = new Outer5 + val o6 = new Outer6 println(1) ser(new o1.Inner(1)) @@ -19,6 +22,21 @@ object Test { o3.Inner ser(new o3.Inner(1)) + println(4) + ser(new o4.Inner(1)) + o4.Inner + ser(new o4.Inner(1)) + + println(2) + ser(new o5.Inner(1)) + o5.Inner + ser(new o5.Inner(1)) + + println(3) + ser(new o6.Inner(1)) + o6.Inner + ser(new o6.Inner(1)) + foo } @@ -51,3 +69,16 @@ class Outer2 { class Outer3 { case class Inner(x: Int) } + + +class Outer4 extends Serializable { + class Inner(x: Int = 1) extends Serializable +} + +class Outer5 extends Serializable { + case class Inner(x: Int = 1) +} + +class Outer6 extends Serializable { + case class Inner(x: Int) +} diff --git a/test/files/scalap/caseClass/result.test b/test/files/scalap/caseClass/result.test index eb1ad74295..9b65be4b48 100644 --- a/test/files/scalap/caseClass/result.test +++ b/test/files/scalap/caseClass/result.test @@ -1,5 +1,4 @@ -@scala.serializable -case class CaseClass[A <: scala.Seq[scala.Int]](i : A, s : scala.Predef.String) extends java.lang.Object with scala.ScalaObject with scala.Product { +case class CaseClass[A <: scala.Seq[scala.Int]](i : A, s : scala.Predef.String) extends java.lang.Object with scala.ScalaObject with scala.Product with scala.Serializable { val i : A = { /* compiled code */ } val s : scala.Predef.String = { /* compiled code */ } def foo : scala.Int = { /* compiled code */ } @@ -11,4 +10,4 @@ case class CaseClass[A <: scala.Seq[scala.Int]](i : A, s : scala.Predef.String) override def productArity : scala.Int = { /* compiled code */ } override def productElement(x$1 : scala.Int) : scala.Any = { /* compiled code */ } override def canEqual(x$1 : scala.Any) : scala.Boolean = { /* compiled code */ } -}
\ No newline at end of file +} diff --git a/test/files/scalap/caseObject/result.test b/test/files/scalap/caseObject/result.test index d888191919..d4e90a0375 100644 --- a/test/files/scalap/caseObject/result.test +++ b/test/files/scalap/caseObject/result.test @@ -1,4 +1,4 @@ -case object CaseObject extends java.lang.Object with scala.ScalaObject with scala.Product { +case object CaseObject extends java.lang.Object with scala.ScalaObject with scala.Product with scala.Serializable { def bar : scala.Int = { /* compiled code */ } final override def toString() : java.lang.String = { /* compiled code */ } override def productPrefix : java.lang.String = { /* compiled code */ } |