diff options
39 files changed, 71 insertions, 73 deletions
diff --git a/src/actors/scala/actors/Scheduler.scala b/src/actors/scala/actors/Scheduler.scala index bbdf691fad..3bf1b33abf 100644 --- a/src/actors/scala/actors/Scheduler.scala +++ b/src/actors/scala/actors/Scheduler.scala @@ -45,7 +45,7 @@ object Scheduler extends DelegatingScheduler { if (sched.isInstanceOf[ForkJoinScheduler]) { sched.asInstanceOf[ForkJoinScheduler].snapshot() } else - sys.error("scheduler does not implement snapshot", "2.8.0") + sys.error("scheduler does not implement snapshot") } /* Only <code>ForkJoinScheduler</code> implements this method. diff --git a/src/build/genprod.scala b/src/build/genprod.scala index 9ae80873f2..315af55d41 100644 --- a/src/build/genprod.scala +++ b/src/build/genprod.scala @@ -280,7 +280,7 @@ object TupleTwo extends Tuple(2) */ def swap: Tuple2[T2,T1] = Tuple2(_2, _1) - @deprecated("Use `zipped` instead.", "2.9") + @deprecated("Use `zipped` instead.", "2.9.0") def zip[Repr1, El1, El2, To](implicit w1: T1 => TLike[El1, Repr1], w2: T2 => Iterable[El2], cbf1: CBF[Repr1, (El1, El2), To]): To = { @@ -387,7 +387,7 @@ object TupleThree extends Tuple(3) { override def imports = Tuple.zipImports override def moreMethods = """ - @deprecated("Use `zipped` instead.") + @deprecated("Use `zipped` instead.", "2.9.0") def zip[Repr1, El1, El2, El3, To](implicit w1: T1 => TLike[El1, Repr1], w2: T2 => Iterable[El2], w3: T3 => Iterable[El3], diff --git a/src/compiler/scala/tools/cmd/gen/AnyVals.scala b/src/compiler/scala/tools/cmd/gen/AnyVals.scala index a1280eec8e..9f8e488c43 100644 --- a/src/compiler/scala/tools/cmd/gen/AnyVals.scala +++ b/src/compiler/scala/tools/cmd/gen/AnyVals.scala @@ -206,7 +206,7 @@ final val NaN = @boxed@.NaN final val PositiveInfinity = @boxed@.POSITIVE_INFINITY final val NegativeInfinity = @boxed@.NEGATIVE_INFINITY -@deprecated("use @name@.MinPositiveValue instead") +@deprecated("use @name@.MinPositiveValue instead", "2.9.0") final val Epsilon = MinPositiveValue /** The negative number with the greatest (finite) absolute value which is representable diff --git a/src/library/scala/Application.scala b/src/library/scala/Application.scala index 79f4da6669..d3c024b38e 100644 --- a/src/library/scala/Application.scala +++ b/src/library/scala/Application.scala @@ -67,7 +67,7 @@ import scala.compat.Platform.currentTime * @author Matthias Zenger * @version 1.0, 10/09/2003 */ -@deprecated("use App instead", "2.9") +@deprecated("use App instead", "2.9.0") trait Application { /** The time when the execution of this program started, in milliseconds since 1 diff --git a/src/library/scala/Cell.scala b/src/library/scala/Cell.scala index f4fbc72c19..f4fc3e3e77 100644 --- a/src/library/scala/Cell.scala +++ b/src/library/scala/Cell.scala @@ -17,5 +17,5 @@ package scala * @author Martin Odersky * @version 1.0, 08/08/2003 */ -@deprecated("use `scala.Option` or `scala.Some` instead", "2.9") +@deprecated("use `scala.Option` or `scala.Some` instead", "2.9.0") case class Cell[+T](elem: T) diff --git a/src/library/scala/Double.scala b/src/library/scala/Double.scala index fb782df108..5f2e01063f 100644 --- a/src/library/scala/Double.scala +++ b/src/library/scala/Double.scala @@ -129,7 +129,7 @@ object Double extends AnyValCompanion { final val PositiveInfinity = java.lang.Double.POSITIVE_INFINITY final val NegativeInfinity = java.lang.Double.NEGATIVE_INFINITY - @deprecated("use Double.MinPositiveValue instead", "2.9") + @deprecated("use Double.MinPositiveValue instead", "2.9.0") final val Epsilon = MinPositiveValue /** The negative number with the greatest (finite) absolute value which is representable diff --git a/src/library/scala/Float.scala b/src/library/scala/Float.scala index ed774df75e..f403e5ccab 100644 --- a/src/library/scala/Float.scala +++ b/src/library/scala/Float.scala @@ -129,7 +129,7 @@ object Float extends AnyValCompanion { final val PositiveInfinity = java.lang.Float.POSITIVE_INFINITY final val NegativeInfinity = java.lang.Float.NEGATIVE_INFINITY - @deprecated("use Float.MinPositiveValue instead", "2.9") + @deprecated("use Float.MinPositiveValue instead", "2.9.0") final val Epsilon = MinPositiveValue /** The negative number with the greatest (finite) absolute value which is representable diff --git a/src/library/scala/Function0.scala b/src/library/scala/Function0.scala index f8e68a2e04..a3220f9752 100644 --- a/src/library/scala/Function0.scala +++ b/src/library/scala/Function0.scala @@ -6,7 +6,7 @@ ** |/ ** \* */ // GENERATED CODE: DO NOT EDIT. -// genprod generated these sources at: Wed Mar 30 13:47:19 PDT 2011 +// genprod generated these sources at: Thu Apr 14 13:08:25 PDT 2011 package scala diff --git a/src/library/scala/Function10.scala b/src/library/scala/Function10.scala index c4b8764d58..632883f518 100644 --- a/src/library/scala/Function10.scala +++ b/src/library/scala/Function10.scala @@ -26,7 +26,7 @@ trait Function10[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R] extends def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 10 arguments, diff --git a/src/library/scala/Function11.scala b/src/library/scala/Function11.scala index 48ba6e2737..1c27ac757c 100644 --- a/src/library/scala/Function11.scala +++ b/src/library/scala/Function11.scala @@ -26,7 +26,7 @@ trait Function11[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R] ex def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 11 arguments, diff --git a/src/library/scala/Function12.scala b/src/library/scala/Function12.scala index bb25c62ceb..7f53d87b33 100644 --- a/src/library/scala/Function12.scala +++ b/src/library/scala/Function12.scala @@ -26,7 +26,7 @@ trait Function12[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 12 arguments, diff --git a/src/library/scala/Function13.scala b/src/library/scala/Function13.scala index 19cdf0103c..9e05c6c69a 100644 --- a/src/library/scala/Function13.scala +++ b/src/library/scala/Function13.scala @@ -26,7 +26,7 @@ trait Function13[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 13 arguments, diff --git a/src/library/scala/Function14.scala b/src/library/scala/Function14.scala index 258dc230c3..5dae9116b3 100644 --- a/src/library/scala/Function14.scala +++ b/src/library/scala/Function14.scala @@ -26,7 +26,7 @@ trait Function14[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 14 arguments, diff --git a/src/library/scala/Function15.scala b/src/library/scala/Function15.scala index 6bc63a1c24..b50974a868 100644 --- a/src/library/scala/Function15.scala +++ b/src/library/scala/Function15.scala @@ -26,7 +26,7 @@ trait Function15[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 15 arguments, diff --git a/src/library/scala/Function16.scala b/src/library/scala/Function16.scala index f969e0d8ae..2dc726126b 100644 --- a/src/library/scala/Function16.scala +++ b/src/library/scala/Function16.scala @@ -26,7 +26,7 @@ trait Function16[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 16 arguments, diff --git a/src/library/scala/Function17.scala b/src/library/scala/Function17.scala index 5218f2fce7..520c9d1288 100644 --- a/src/library/scala/Function17.scala +++ b/src/library/scala/Function17.scala @@ -26,7 +26,7 @@ trait Function17[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 17 arguments, diff --git a/src/library/scala/Function18.scala b/src/library/scala/Function18.scala index a68d5e27ae..8d72a3f487 100644 --- a/src/library/scala/Function18.scala +++ b/src/library/scala/Function18.scala @@ -26,7 +26,7 @@ trait Function18[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 18 arguments, diff --git a/src/library/scala/Function19.scala b/src/library/scala/Function19.scala index 8f22c00b76..3990bc60d6 100644 --- a/src/library/scala/Function19.scala +++ b/src/library/scala/Function19.scala @@ -26,7 +26,7 @@ trait Function19[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 19 arguments, diff --git a/src/library/scala/Function2.scala b/src/library/scala/Function2.scala index f8dff7dc75..7d0b9a5195 100644 --- a/src/library/scala/Function2.scala +++ b/src/library/scala/Function2.scala @@ -39,7 +39,7 @@ trait Function2[@specialized(scala.Int, scala.Long, scala.Double) -T1, @speciali def curried: T1 => T2 => R = { (x1: T1) => (x2: T2) => apply(x1, x2) } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 2 arguments, diff --git a/src/library/scala/Function20.scala b/src/library/scala/Function20.scala index 11942c0766..94fa1cf56e 100644 --- a/src/library/scala/Function20.scala +++ b/src/library/scala/Function20.scala @@ -26,7 +26,7 @@ trait Function20[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 20 arguments, diff --git a/src/library/scala/Function21.scala b/src/library/scala/Function21.scala index cb1a38fc06..f41d8899fc 100644 --- a/src/library/scala/Function21.scala +++ b/src/library/scala/Function21.scala @@ -26,7 +26,7 @@ trait Function21[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => T21 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20, x21: T21) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 21 arguments, diff --git a/src/library/scala/Function22.scala b/src/library/scala/Function22.scala index b202a1f437..c1b290ff33 100644 --- a/src/library/scala/Function22.scala +++ b/src/library/scala/Function22.scala @@ -26,7 +26,7 @@ trait Function22[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => T21 => T22 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20, x21: T21, x22: T22) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 22 arguments, diff --git a/src/library/scala/Function3.scala b/src/library/scala/Function3.scala index f67ed3cc66..1b592f5c88 100644 --- a/src/library/scala/Function3.scala +++ b/src/library/scala/Function3.scala @@ -26,7 +26,7 @@ trait Function3[-T1, -T2, -T3, +R] extends AnyRef { self => def curried: T1 => T2 => T3 => R = { (x1: T1) => (x2: T2) => (x3: T3) => apply(x1, x2, x3) } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 3 arguments, diff --git a/src/library/scala/Function4.scala b/src/library/scala/Function4.scala index 1e798bb9c5..bd1123276b 100644 --- a/src/library/scala/Function4.scala +++ b/src/library/scala/Function4.scala @@ -26,7 +26,7 @@ trait Function4[-T1, -T2, -T3, -T4, +R] extends AnyRef { self => def curried: T1 => T2 => T3 => T4 => R = { (x1: T1) => (x2: T2) => (x3: T3) => (x4: T4) => apply(x1, x2, x3, x4) } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 4 arguments, diff --git a/src/library/scala/Function5.scala b/src/library/scala/Function5.scala index e347afa706..af83dcf303 100644 --- a/src/library/scala/Function5.scala +++ b/src/library/scala/Function5.scala @@ -26,7 +26,7 @@ trait Function5[-T1, -T2, -T3, -T4, -T5, +R] extends AnyRef { self => def curried: T1 => T2 => T3 => T4 => T5 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5) => self.apply(x1, x2, x3, x4, x5)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 5 arguments, diff --git a/src/library/scala/Function6.scala b/src/library/scala/Function6.scala index 3818bac6ee..caceb55c33 100644 --- a/src/library/scala/Function6.scala +++ b/src/library/scala/Function6.scala @@ -26,7 +26,7 @@ trait Function6[-T1, -T2, -T3, -T4, -T5, -T6, +R] extends AnyRef { self => def curried: T1 => T2 => T3 => T4 => T5 => T6 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6) => self.apply(x1, x2, x3, x4, x5, x6)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 6 arguments, diff --git a/src/library/scala/Function7.scala b/src/library/scala/Function7.scala index 6c03f51e81..16aa9a90b6 100644 --- a/src/library/scala/Function7.scala +++ b/src/library/scala/Function7.scala @@ -26,7 +26,7 @@ trait Function7[-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R] extends AnyRef { self => def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7) => self.apply(x1, x2, x3, x4, x5, x6, x7)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 7 arguments, diff --git a/src/library/scala/Function8.scala b/src/library/scala/Function8.scala index eb5065835d..6f97cc182b 100644 --- a/src/library/scala/Function8.scala +++ b/src/library/scala/Function8.scala @@ -26,7 +26,7 @@ trait Function8[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R] extends AnyRef { sel def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 8 arguments, diff --git a/src/library/scala/Function9.scala b/src/library/scala/Function9.scala index a5a132b52a..3c39cb472b 100644 --- a/src/library/scala/Function9.scala +++ b/src/library/scala/Function9.scala @@ -26,7 +26,7 @@ trait Function9[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +R] extends AnyRef def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9)).curried } - @deprecated("Use 'curried' instead") + @deprecated("Use 'curried' instead", "2.8.0") def curry = curried /** Creates a tupled version of this function: instead of 9 arguments, diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala index 1a0dbd70a4..e03eab45a2 100644 --- a/src/library/scala/Predef.scala +++ b/src/library/scala/Predef.scala @@ -59,16 +59,16 @@ object Predef extends LowPriorityImplicits { // Deprecated - @deprecated("Use sys.error(message) instead", "2.9") + @deprecated("Use sys.error(message) instead", "2.9.0") def error(message: String): Nothing = sys.error(message) - @deprecated("Use sys.exit() instead", "2.9") + @deprecated("Use sys.exit() instead", "2.9.0") def exit(): Nothing = sys.exit() - @deprecated("Use sys.exit(status) instead", "2.9") + @deprecated("Use sys.exit(status) instead", "2.9.0") def exit(status: Int): Nothing = sys.exit(status) - @deprecated("Use formatString.format(args: _*) or arg.formatted(formatString) instead", "2.9") + @deprecated("Use formatString.format(args: _*) or arg.formatted(formatString) instead", "2.9.0") def format(text: String, xs: Any*) = augmentString(text).format(xs: _*) // errors and asserts ------------------------------------------------- @@ -358,7 +358,7 @@ object Predef extends LowPriorityImplicits { } // less useful due to #2781 - @deprecated("Use From => To instead", "2.9") + @deprecated("Use From => To instead", "2.9.0") sealed abstract class <%<[-From, +To] extends (From => To) with Serializable object <%< { implicit def conformsOrViewsAs[A <% B, B]: A <%< B = new (A <%< B) {def apply(x: A) = x} diff --git a/src/library/scala/Tuple2.scala b/src/library/scala/Tuple2.scala index afac96fe97..dd6ac0cfd2 100644 --- a/src/library/scala/Tuple2.scala +++ b/src/library/scala/Tuple2.scala @@ -30,7 +30,7 @@ case class Tuple2[@specialized(Int, Long, Double) +T1, @specialized(Int, Long, D */ def swap: Tuple2[T2,T1] = Tuple2(_2, _1) - @deprecated("Use `zipped` instead.") + @deprecated("Use `zipped` instead.", "2.9.0") def zip[Repr1, El1, El2, To](implicit w1: T1 => TLike[El1, Repr1], w2: T2 => Iterable[El2], cbf1: CBF[Repr1, (El1, El2), To]): To = { diff --git a/src/library/scala/Tuple3.scala b/src/library/scala/Tuple3.scala index 6458fa5042..dfa0c962a2 100644 --- a/src/library/scala/Tuple3.scala +++ b/src/library/scala/Tuple3.scala @@ -26,7 +26,7 @@ case class Tuple3[+T1, +T2, +T3](_1: T1, _2: T2, _3: T3) override def toString() = "(" + _1 + "," + _2 + "," + _3 + ")" - @deprecated("Use `zipped` instead.") + @deprecated("Use `zipped` instead.", "2.9.0") def zip[Repr1, El1, El2, El3, To](implicit w1: T1 => TLike[El1, Repr1], w2: T2 => Iterable[El2], w3: T3 => Iterable[El3], diff --git a/src/library/scala/annotation/serializable.scala b/src/library/scala/annotation/serializable.scala index a209347c37..5a0d1261d6 100644 --- a/src/library/scala/annotation/serializable.scala +++ b/src/library/scala/annotation/serializable.scala @@ -11,5 +11,5 @@ package scala.annotation /** * An annotation that designates the class to which it is applied as serializable */ -@deprecated("instead of `@serializable class C`, use `class C extends Serializable`", "2.9") +@deprecated("instead of `@serializable class C`, use `class C extends Serializable`", "2.9.0") class serializable extends annotation.StaticAnnotation diff --git a/src/library/scala/collection/JavaConversions.scala b/src/library/scala/collection/JavaConversions.scala index 29930299be..fdb77a48c1 100644 --- a/src/library/scala/collection/JavaConversions.scala +++ b/src/library/scala/collection/JavaConversions.scala @@ -154,7 +154,7 @@ object JavaConversions { case JListWrapper(wrapped) => wrapped case _ => new MutableBufferWrapper(b) } - @deprecated("use bufferAsJavaList instead", "2.9") + @deprecated("use bufferAsJavaList instead", "2.9.0") def asJavaList[A](b : mutable.Buffer[A]): ju.List[A] = bufferAsJavaList[A](b) @deprecated("use bufferAsJavaList instead", "2.8.1") def asList[A](b : mutable.Buffer[A]): ju.List[A] = bufferAsJavaList[A](b) @@ -176,7 +176,7 @@ object JavaConversions { case JListWrapper(wrapped) => wrapped case _ => new MutableSeqWrapper(b) } - @deprecated("use mutableSeqAsJavaList instead", "2.9") + @deprecated("use mutableSeqAsJavaList instead", "2.9.0") def asJavaList[A](b : mutable.Seq[A]): ju.List[A] = mutableSeqAsJavaList[A](b) @deprecated("use mutableSeqAsJavaList instead", "2.8.1") def asList[A](b : mutable.Seq[A]): ju.List[A] = mutableSeqAsJavaList[A](b) @@ -199,7 +199,7 @@ object JavaConversions { case _ => new SeqWrapper(b) } - @deprecated("use seqAsJavaList instead", "2.9") + @deprecated("use seqAsJavaList instead", "2.9.0") def asJavaList[A](b : Seq[A]): ju.List[A] = seqAsJavaList[A](b) @deprecated("use seqAsJavaList instead", "2.8.1") def asList[A](b : Seq[A]): ju.List[A] = seqAsJavaList[A](b) @@ -222,7 +222,7 @@ object JavaConversions { case _ => new MutableSetWrapper(s) } - @deprecated("use mutableSetAsJavaSet instead", "2.9") + @deprecated("use mutableSetAsJavaSet instead", "2.9.0") def asJavaSet[A](s : mutable.Set[A]): ju.Set[A] = mutableSetAsJavaSet[A](s) @deprecated("use mutableSetAsJavaSet instead", "2.8.1") def asSet[A](s : mutable.Set[A]): ju.Set[A] = mutableSetAsJavaSet[A](s) @@ -245,7 +245,7 @@ object JavaConversions { case _ => new SetWrapper(s) } - @deprecated("use setAsJavaSet instead", "2.9") + @deprecated("use setAsJavaSet instead", "2.9.0") def asJavaSet[A](s: Set[A]): ju.Set[A] = setAsJavaSet[A](s) @deprecated("use setAsJavaSet instead", "2.8.1") def asSet[A](s : Set[A]): ju.Set[A] = setAsJavaSet[A](s) @@ -269,7 +269,7 @@ object JavaConversions { case _ => new MutableMapWrapper(m) } - @deprecated("use mutableMapAsJavaMap instead", "2.9") + @deprecated("use mutableMapAsJavaMap instead", "2.9.0") def asJavaMap[A, B](m : mutable.Map[A, B]): ju.Map[A, B] = mutableMapAsJavaMap[A, B](m) @deprecated("use mutableMapAsJavaMap instead", "2.8.1") def asMap[A, B](m : mutable.Map[A, B]): ju.Map[A, B] = mutableMapAsJavaMap[A, B](m) @@ -315,7 +315,7 @@ object JavaConversions { case _ => new MapWrapper(m) } - @deprecated("use mapAsJavaMap instead", "2.9") + @deprecated("use mapAsJavaMap instead", "2.9.0") def asJavaMap[A, B](m : Map[A, B]): ju.Map[A, B] = mapAsJavaMap[A, B](m) @deprecated("use mapAsJavaMap instead", "2.8.1") def asMap[A, B](m : Map[A, B]): ju.Map[A, B] = mapAsJavaMap[A, B](m) @@ -403,7 +403,7 @@ object JavaConversions { case _ => JIterableWrapper(i) } - @deprecated("use iterableAsScalaIterable instead", "2.9") + @deprecated("use iterableAsScalaIterable instead", "2.9.0") def asScalaIterable[A](i : jl.Iterable[A]): Iterable[A] = iterableAsScalaIterable[A](i) @deprecated("use iterableAsScalaIterable instead", "2.8.1") def asIterable[A](i : jl.Iterable[A]): Iterable[A] = iterableAsScalaIterable[A](i) @@ -422,7 +422,7 @@ object JavaConversions { case IterableWrapper(wrapped) => wrapped case _ => JCollectionWrapper(i) } - @deprecated("use collectionAsScalaIterable instead", "2.9") + @deprecated("use collectionAsScalaIterable instead", "2.9.0") def asScalaIterable[A](i : ju.Collection[A]): Iterable[A] = collectionAsScalaIterable[A](i) @deprecated("use collectionAsScalaIterable instead", "2.8.1") def asIterable[A](i : ju.Collection[A]): Iterable[A] = collectionAsScalaIterable[A](i) @@ -488,7 +488,7 @@ object JavaConversions { case _ => new JMapWrapper(m) } - @deprecated("use mapAsScalaMap instead", "2.9") + @deprecated("use mapAsScalaMap instead", "2.9.0") def asScalaMap[A, B](m : ju.Map[A, B]): mutable.Map[A, B] = mapAsScalaMap[A, B](m) @deprecated("use mapAsScalaMap instead", "2.8.1") def asMap[A, B](m : ju.Map[A, B]): mutable.Map[A, B] = mapAsScalaMap[A, B](m) @@ -544,7 +544,7 @@ object JavaConversions { case _ => new JPropertiesWrapper(p) } - @deprecated("use propertiesAsScalaMap instead", "2.9") + @deprecated("use propertiesAsScalaMap instead", "2.9.0") def asScalaMap(p: ju.Properties): mutable.Map[String, String] = propertiesAsScalaMap(p) @deprecated("use propertiesAsScalaMap instead", "2.8.1") def asMap(p: ju.Properties): mutable.Map[String, String] = propertiesAsScalaMap(p) diff --git a/src/library/scala/collection/JavaConverters.scala b/src/library/scala/collection/JavaConverters.scala index e6bda59396..4bb61b960a 100755 --- a/src/library/scala/collection/JavaConverters.scala +++ b/src/library/scala/collection/JavaConverters.scala @@ -210,11 +210,11 @@ object JavaConverters { implicit def seqAsJavaListConverter[A](b : Seq[A]): AsJava[ju.List[A]] = new AsJava(seqAsJavaList(b)) - @deprecated("Use bufferAsJavaListConverter instead", "2.9") + @deprecated("Use bufferAsJavaListConverter instead", "2.9.0") def asJavaListConverter[A](b : mutable.Buffer[A]): AsJava[ju.List[A]] = bufferAsJavaListConverter(b) - @deprecated("Use mutableSeqAsJavaListConverter instead", "2.9") + @deprecated("Use mutableSeqAsJavaListConverter instead", "2.9.0") def asJavaListConverter[A](b : mutable.Seq[A]): AsJava[ju.List[A]] = mutableSeqAsJavaListConverter(b) - @deprecated("Use seqAsJavaListConverter instead", "2.9") + @deprecated("Use seqAsJavaListConverter instead", "2.9.0") def asJavaListConverter[A](b : Seq[A]): AsJava[ju.List[A]] = seqAsJavaListConverter(b) /** @@ -233,7 +233,7 @@ object JavaConverters { implicit def mutableSetAsJavaSetConverter[A](s : mutable.Set[A]): AsJava[ju.Set[A]] = new AsJava(mutableSetAsJavaSet(s)) - @deprecated("Use mutableSetAsJavaSetConverter instead", "2.9") + @deprecated("Use mutableSetAsJavaSetConverter instead", "2.9.0") def asJavaSetConverter[A](s : mutable.Set[A]): AsJava[ju.Set[A]] = mutableSetAsJavaSetConverter(s) /** @@ -252,7 +252,7 @@ object JavaConverters { implicit def setAsJavaSetConverter[A](s : Set[A]): AsJava[ju.Set[A]] = new AsJava(setAsJavaSet(s)) - @deprecated("Use setAsJavaSetConverter instead", "2.9") + @deprecated("Use setAsJavaSetConverter instead", "2.9.0") def asJavaSetConverter[A](s : Set[A]): AsJava[ju.Set[A]] = setAsJavaSetConverter(s) /** @@ -271,7 +271,7 @@ object JavaConverters { implicit def mutableMapAsJavaMapConverter[A, B](m : mutable.Map[A, B]): AsJava[ju.Map[A, B]] = new AsJava(mutableMapAsJavaMap(m)) - @deprecated("use mutableMapAsJavaMapConverter instead", "2.9") + @deprecated("use mutableMapAsJavaMapConverter instead", "2.9.0") def asJavaMapConverter[A, B](m : mutable.Map[A, B]): AsJava[ju.Map[A, B]] = mutableMapAsJavaMapConverter(m) /** @@ -306,7 +306,7 @@ object JavaConverters { implicit def mapAsJavaMapConverter[A, B](m : Map[A, B]): AsJava[ju.Map[A, B]] = new AsJava(mapAsJavaMap(m)) - @deprecated("Use mapAsJavaMapConverter instead", "2.9") + @deprecated("Use mapAsJavaMapConverter instead", "2.9.0") def asJavaMapConverter[A, B](m : Map[A, B]): AsJava[ju.Map[A, B]] = mapAsJavaMapConverter(m) /** @@ -373,7 +373,7 @@ object JavaConverters { implicit def iterableAsScalaIterableConverter[A](i : jl.Iterable[A]): AsScala[Iterable[A]] = new AsScala(iterableAsScalaIterable(i)) - @deprecated("Use iterableAsScalaIterableConverter instead", "2.9") + @deprecated("Use iterableAsScalaIterableConverter instead", "2.9.0") def asScalaIterableConverter[A](i : jl.Iterable[A]): AsScala[Iterable[A]] = iterableAsScalaIterableConverter(i) /** @@ -389,7 +389,7 @@ object JavaConverters { implicit def collectionAsScalaIterableConverter[A](i : ju.Collection[A]): AsScala[Iterable[A]] = new AsScala(collectionAsScalaIterable(i)) - @deprecated("Use collectionAsScalaIterableConverter instead", "2.9") + @deprecated("Use collectionAsScalaIterableConverter instead", "2.9.0") def asScalaIterableConverter[A](i : ju.Collection[A]): AsScala[Iterable[A]] = collectionAsScalaIterableConverter(i) /** @@ -440,7 +440,7 @@ object JavaConverters { implicit def mapAsScalaMapConverter[A, B](m : ju.Map[A, B]): AsScala[mutable.Map[A, B]] = new AsScala(mapAsScalaMap(m)) - @deprecated("Use mapAsScalaMapConverter instead", "2.9") + @deprecated("Use mapAsScalaMapConverter instead", "2.9.0") def asScalaMapConverter[A, B](m : ju.Map[A, B]): AsScala[mutable.Map[A, B]] = mapAsScalaMapConverter(m) /** @@ -483,7 +483,7 @@ object JavaConverters { implicit def propertiesAsScalaMapConverter(p: ju.Properties): AsScala[mutable.Map[String, String]] = new AsScala(propertiesAsScalaMap(p)) - @deprecated("Use propertiesAsScalaMapConverter instead", "2.9") + @deprecated("Use propertiesAsScalaMapConverter instead", "2.9.0") def asScalaMapConverter(p: ju.Properties): AsScala[mutable.Map[String, String]] = propertiesAsScalaMapConverter(p) diff --git a/src/library/scala/collection/immutable/Queue.scala b/src/library/scala/collection/immutable/Queue.scala index dd93c1435b..bf5dc6816a 100644 --- a/src/library/scala/collection/immutable/Queue.scala +++ b/src/library/scala/collection/immutable/Queue.scala @@ -81,7 +81,7 @@ class Queue[+A] protected(protected val in: List[A], protected val out: List[A]) * * @param elem the element to insert */ - @deprecated("Use the method <code>enqueue</code> from now on.", "2.7.2") + @deprecated("Use `enqueue` instead", "2.7.2") def +[B >: A](elem: B) = enqueue(elem) /** Creates a new queue with element added at the end @@ -99,7 +99,7 @@ class Queue[+A] protected(protected val in: List[A], protected val out: List[A]) * * @param iter an iterable object */ - @deprecated("Use the method <code>enqueue</code> from now on.", "2.7.2") + @deprecated("Use `enqueue` instead", "2.7.2") def +[B >: A](iter: Iterable[B]) = enqueue(iter) /** Returns a new queue with all elements provided by diff --git a/src/library/scala/deprecated.scala b/src/library/scala/deprecated.scala index 8b93a35075..f64e34a5ac 100644 --- a/src/library/scala/deprecated.scala +++ b/src/library/scala/deprecated.scala @@ -6,8 +6,6 @@ ** |/ ** \* */ - - package scala import annotation.target._ @@ -19,4 +17,4 @@ import annotation.target._ * @since 2.3 */ @getter @setter @beanGetter @beanSetter -class deprecated(message: String = "", since: String = null) extends annotation.StaticAnnotation +class deprecated(message: String = "", since: String = "") extends annotation.StaticAnnotation diff --git a/src/library/scala/package.scala b/src/library/scala/package.scala index 788684182a..0e966acd6b 100644 --- a/src/library/scala/package.scala +++ b/src/library/scala/package.scala @@ -28,7 +28,7 @@ package object scala { type NumberFormatException = java.lang.NumberFormatException type AbstractMethodError = java.lang.AbstractMethodError - @deprecated("instead of `@serializable class C`, use `class C extends Serializable`", "2.9") + @deprecated("instead of `@serializable class C`, use `class C extends Serializable`", "2.9.0") type serializable = annotation.serializable type TraversableOnce[+A] = scala.collection.TraversableOnce[A] @@ -75,7 +75,7 @@ package object scala { val $scope = scala.xml.TopScope - @deprecated("Use Thread.currentThread instead", "2.9") + @deprecated("Use Thread.currentThread instead", "2.9.0") def currentThread = java.lang.Thread.currentThread() // Numeric types which were moved into scala.math.* @@ -186,12 +186,12 @@ package object scala { @deprecated("use IndexedSeq instead", "2.8.0") val RandomAccessSeq = scala.collection.IndexedSeq - @deprecated("use scala.annotation.Annotation instead", "2.9") + @deprecated("use scala.annotation.Annotation instead", "2.9.0") type Annotation = scala.annotation.Annotation - @deprecated("use scala.annotation.ClassfileAnnotation instead", "2.9") + @deprecated("use scala.annotation.ClassfileAnnotation instead", "2.9.0") type ClassfileAnnotation = scala.annotation.ClassfileAnnotation - @deprecated("use scala.annotation.StaticAnnotation instead", "2.9") + @deprecated("use scala.annotation.StaticAnnotation instead", "2.9.0") type StaticAnnotation = scala.annotation.StaticAnnotation - @deprecated("use scala.annotation.TypeConstraint instead", "2.9") + @deprecated("use scala.annotation.TypeConstraint instead", "2.9.0") type TypeConstraint = scala.annotation.TypeConstraint } diff --git a/src/library/scala/util/parsing/syntax/package.scala b/src/library/scala/util/parsing/syntax/package.scala index 2fc6053b9b..547136c21d 100644 --- a/src/library/scala/util/parsing/syntax/package.scala +++ b/src/library/scala/util/parsing/syntax/package.scala @@ -14,8 +14,8 @@ import scala.util.parsing.combinator.token * be done, but it doesn't (yet) so it isn't. */ package object syntax { - @deprecated("Moved to scala.util.parsing.combinator.token") + @deprecated("Moved to scala.util.parsing.combinator.token", "2.8.0") type Tokens = token.Tokens - @deprecated("Moved to scala.util.parsing.combinator.token") + @deprecated("Moved to scala.util.parsing.combinator.token", "2.8.0") type StdTokens = token.StdTokens } |