big overhaul of annotations implementation.

author: Lukas Rytz <lukas.rytz@epfl.ch> 2009-05-30 18:10:21 +0000
committer: Lukas Rytz <lukas.rytz@epfl.ch> 2009-05-30 18:10:21 +0000
commit: c6cf4fc02204d20f792bd493641d8ccd12421800 (patch)
tree: a8827ab270cf77a1c5f36a48a8cf125e1bcfb8c3 /src/library
parent: ab9381b4539097205d19df235f8cc3a5b2349e95 (diff)
download: scala-c6cf4fc02204d20f792bd493641d8ccd12421800.tar.gz
scala-c6cf4fc02204d20f792bd493641d8ccd12421800.tar.bz2
scala-c6cf4fc02204d20f792bd493641d8ccd12421800.zip
57 files changed, 384 insertions, 536 deletions
diff --git a/src/library/scala/Array.scala b/src/library/scala/Array.scala
index 0ea2b9f972..b72bdb01e7 100644
--- a/src/library/scala/Array.scala
+++ b/src/library/scala/Array.scala
@@ -171,22 +171,21 @@ object Array extends SequenceFactory[Array] {
   def ofDim[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[A]]]]] =
     tabulate(n1)(_ => ofDim[A](n2, n3, n4, n5))
 
-  /** Create array with given dimensions
-   * @deprecated   use ofDim instead */
-  @deprecated def withDims[A](n1: Int): Array[A] = ofDim(n1)
-  @deprecated def withDims[A](n1: Int, n2: Int): Array[Array[A]] = ofDim(n1, n2)
-  @deprecated def withDims[A](n1: Int, n2: Int, n3: Int): Array[Array[Array[A]]] = ofDim(n1, n2, n3)
-  @deprecated def withDims[A](n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[A]]]] = ofDim(n1, n2, n3, n4)
-  @deprecated def withDims[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[A]]]]] = ofDim(n1, n2, n3, n4, n5)
+  /** Create array with given dimensions */
+  @deprecated("use `ofDim' instead") def withDims[A](n1: Int): Array[A] = ofDim(n1)
+  @deprecated("use `ofDim' instead") def withDims[A](n1: Int, n2: Int): Array[Array[A]] = ofDim(n1, n2)
+  @deprecated("use `ofDim' instead") def withDims[A](n1: Int, n2: Int, n3: Int): Array[Array[Array[A]]] = ofDim(n1, n2, n3)
+  @deprecated("use `ofDim' instead") def withDims[A](n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[A]]]] = ofDim(n1, n2, n3, n4)
+  @deprecated("use `ofDim' instead") def withDims[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[A]]]]] = ofDim(n1, n2, n3, n4, n5)
 
   /** Create an array containing several copies of an element.
    *
    *  @param n    the length of the resulting array
    *  @param elem the element composing the resulting array
    *  @return     an array composed of n elements all equal to elem
-   *  @deprecated use `Array.fill` instead.
    */
-  @deprecated def make[A](n: Int, elem: A): Array[A] = {
+  @deprecated("use `Array.fill' instead")
+  def make[A](n: Int, elem: A): Array[A] = {
     val a = new Array[A](n)
     var i = 0
     while (i < n) {
@@ -198,9 +197,9 @@ object Array extends SequenceFactory[Array] {
 
   /** Create an array containing the values of a given function <code>f</code>
    *  over given range <code>[0..n)</code>
-   *  @deprecated use `Array.tabulate` instead.
    */
-  @deprecated def fromFunction[A](f: Int => A)(n: Int): Array[A] = {
+  @deprecated("use `Array.tabulate' instead")
+  def fromFunction[A](f: Int => A)(n: Int): Array[A] = {
     val a = new Array[A](n)
     var i = 0
     while (i < n) {
@@ -212,30 +211,30 @@ object Array extends SequenceFactory[Array] {
 
   /** Create an array containing the values of a given function <code>f</code>
    *  over given range <code>[0..n1, 0..n2)</code>
-   *  @deprecated use `Array.tabulate` instead.
    */
-  @deprecated def fromFunction[A](f: (Int, Int) => A)(n1: Int, n2: Int): Array[Array[A]] =
+  @deprecated("use `Array.tabulate' instead")
+  def fromFunction[A](f: (Int, Int) => A)(n1: Int, n2: Int): Array[Array[A]] =
     fromFunction(i => fromFunction(f(i, _))(n2))(n1)
 
   /** Create an array containing the values of a given function <code>f</code>
    *  over given range <code>[0..n1, 0..n2, 0..n3)</code>
-   *  @deprecated use `Array.tabulate` instead.
    */
-  @deprecated def fromFunction[A](f: (Int, Int, Int) => A)(n1: Int, n2: Int, n3: Int): Array[Array[Array[A]]] =
+  @deprecated("use `Array.tabulate' instead")
+  def fromFunction[A](f: (Int, Int, Int) => A)(n1: Int, n2: Int, n3: Int): Array[Array[Array[A]]] =
     fromFunction(i => fromFunction(f(i, _, _))(n2, n3))(n1)
 
   /** Create an array containing the values of a given function <code>f</code>
    *  over given range <code>[0..n1, 0..n2, 0..n3, 0..n4)</code>
-   *  @deprecated use `Array.tabulate` instead.
    */
-  @deprecated def fromFunction[A](f: (Int, Int, Int, Int) => A)(n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[A]]]] =
+  @deprecated("use `Array.tabulate' instead")
+  def fromFunction[A](f: (Int, Int, Int, Int) => A)(n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[A]]]] =
     fromFunction(i => fromFunction(f(i, _, _, _))(n2, n3, n4))(n1)
 
   /** Create an array containing the values of a given function <code>f</code>
    *  over given range <code>[0..n1, 0..n2, 0..n3, 0..n4, 0..n5)</code>
-   *  @deprecated use `Array.tabulate` instead.
    */
-  @deprecated def fromFunction[A](f: (Int, Int, Int, Int, Int) => A)(n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[A]]]]] =
+  @deprecated("use `Array.tabulate' instead")
+  def fromFunction[A](f: (Int, Int, Int, Int, Int) => A)(n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[A]]]]] =
     fromFunction(i => fromFunction(f(i, _, _, _, _))(n2, n3, n4, n5))(n1)
 }
 
@@ -251,59 +250,58 @@ final class Array[A](_length: Int) extends Vector[A]
 
   override def companion: Companion[Array] = throw new Error()
 
-   /** Multidimensional array creation
-    *  @deprecated use Array.ofDim instead
-    */
-   @deprecated def this(dim1: Int, dim2: Int) = {
+   /** Multidimensional array creation */
+   @deprecated("use `Array.ofDim' instead")
+   def this(dim1: Int, dim2: Int) = {
      this(dim1)
      throw new Error()
    }
 
-   /** Multidimensional array creation
-    *  @deprecated use Array.ofDim instead */
-   @deprecated def this(dim1: Int, dim2: Int, dim3: Int) = {
+   /** Multidimensional array creation */
+   @deprecated("use `Array.ofDim' instead")
+   def this(dim1: Int, dim2: Int, dim3: Int) = {
      this(dim1)
      throw new Error()
    }
 
-   /** Multidimensional array creation
-    *  @deprecated use Array.ofDim instead */
-   @deprecated def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int) = {
+   /** Multidimensional array creation */
+   @deprecated("use `Array.ofDim' instead")
+   def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int) = {
      this(dim1)
      throw new Error()
    }
 
-   /** Multidimensional array creation
-    *  @deprecated use Array.ofDim instead */
-   @deprecated def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int) = {
+   /** Multidimensional array creation */
+   @deprecated("use `Array.ofDim' instead")
+   def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int) = {
      this(dim1);
      throw new Error()
    }
 
-   /** Multidimensional array creation
-    *  @deprecated use Array.ofDim instead */
-   @deprecated def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int, dim6: Int) = {
+   /** Multidimensional array creation */
+   @deprecated("use `Array.ofDim' instead")
+   def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int, dim6: Int) = {
      this(dim1)
      throw new Error()
    }
 
-   /** Multidimensional array creation
-    *  @deprecated use Array.ofDim instead */
-   @deprecated def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int, dim6: Int, dim7: Int) = {
+   /** Multidimensional array creation */
+   @deprecated("use `Array.ofDim' instead")
+   def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int, dim6: Int, dim7: Int) = {
      this(dim1)
      throw new Error()
    }
 
-   /** Multidimensional array creation
-    *  @deprecated use Array.ofDim instead */
-   @deprecated def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int, dim6: Int, dim7: Int, dim8: Int) = {
+   /** Multidimensional array creation */
+   @deprecated("use `Array.ofDim' instead")
+   def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int, dim6: Int, dim7: Int, dim8: Int) = {
      this(dim1)
      throw new Error()
    }
 
-   /** Multidimensional array creation
-    *  @deprecated use Array.ofDim instead */
-   @deprecated def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int, dim6: Int, dim7: Int, dim8: Int, dim9: Int) = {
+   /** Multidimensional array creation */
+   @deprecated("use `Array.ofDim' instead")
+   def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int, dim6: Int, dim7: Int, dim8: Int, dim9: Int) = {
      this(dim1)
      throw new Error()
    }
@@ -400,6 +398,6 @@ final class Array[A](_length: Int) extends Vector[A]
    */
   def deepEquals(that: Any): Boolean = throw new Error()
 
- /** @deprecated use slice instead */
-  @deprecated def subArray(from: Int, end: Int): Array[A] = throw new Error()
+  @deprecated("use `slice' instead")
+  def subArray(from: Int, end: Int): Array[A] = throw new Error()
 }
diff --git a/src/library/scala/Attribute.scala b/src/library/scala/Attribute.scala
deleted file mode 100644
index 1d4d1a6c60..0000000000
--- a/src/library/scala/Attribute.scala
+++ /dev/null
@@ -1,22 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2006-2009, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-// $Id$
-
-
-package scala
-
-/** <p>
- *  </p>
- *
- *  @deprecated  use Annotation instead
- *  @author  Martin Odersky
- *  @version 1.1, 2/02/2007
- */
-@deprecated
-abstract class Attribute {}
diff --git a/src/library/scala/ClassfileAnnotation.scala b/src/library/scala/ClassfileAnnotation.scala
index 62a9bea663..8bf1fffcf6 100644
--- a/src/library/scala/ClassfileAnnotation.scala
+++ b/src/library/scala/ClassfileAnnotation.scala
@@ -20,4 +20,4 @@ package scala
  *  @author  Martin Odersky
  *  @version 1.1, 2/02/2007
  */
-trait ClassfileAnnotation extends Annotation
+trait ClassfileAnnotation extends StaticAnnotation
diff --git a/src/library/scala/ClassfileAttribute.scala b/src/library/scala/ClassfileAttribute.scala
deleted file mode 100644
index ae71060e9d..0000000000
--- a/src/library/scala/ClassfileAttribute.scala
+++ /dev/null
@@ -1,26 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2006-2009, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-// $Id$
-
-
-package scala
-
-/** <p>
- *    A base class for classfile attributes. These are stored as
- *    <a href="http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html"
- *    target="_top">Java annotations</a> in classfiles.
- *  </p>
- *
- *  @deprecated  use <a href="ClassfileAnnotation.html"
- *               target="contentFrame">ClassfileAnnotation</a> instead
- *  @author  Martin Odersky
- *  @version 1.1, 2/02/2007
- */
-@deprecated
-trait ClassfileAttribute extends Attribute {}
diff --git a/src/library/scala/Console.scala b/src/library/scala/Console.scala
index 31672ac8e6..bbef8aa3ce 100644
--- a/src/library/scala/Console.scala
+++ b/src/library/scala/Console.scala
@@ -182,10 +182,9 @@ object Console {
   /**
    *  @see <a href="#printf(java.lang.String,scala.Any*)"
    *       target="contentFrame">Console.printf</a>.
-   *  @deprecated For console output, use <code>Console.printf</code>.  For <code>String</code> formatting,
-   *              <code>RichString</code>'s <code>format</code> method.
    */
-  @deprecated
+  @deprecated("For console output, use <code>Console.printf</code>. For <code>String</code>\n"+
+              "formatting, <code>RichString</code>'s <code>format</code> method.")
   def format(text: String, args: Any*) {
     if (text eq null) out.printf("null")
     else out.print(text format (args : _*))
diff --git a/src/library/scala/CountedIterator.scala b/src/library/scala/CountedIterator.scala
index 490743d733..2b627437dc 100644
--- a/src/library/scala/CountedIterator.scala
+++ b/src/library/scala/CountedIterator.scala
@@ -12,9 +12,9 @@
 package scala
 
 /** Counted iterators keep track of the number of elements seen so far
- *  @deprecated  use iterator.zipWithIndex instead
  */
-@deprecated trait CountedIterator[+A] extends Iterator[A] {
+@deprecated("use iterator.zipWithIndex instead")
+trait CountedIterator[+A] extends Iterator[A] {
   /** counts the elements in this iterator; counts start at 0
    */
   def count: Int
diff --git a/src/library/scala/Either.scala b/src/library/scala/Either.scala
index 9fbb4b71ba..fc2d598f41 100644
--- a/src/library/scala/Either.scala
+++ b/src/library/scala/Either.scala
@@ -68,10 +68,8 @@ object Either {
 
   /**
    * Returns the <code>Left</code> values in the given <code>Iterable</code> of <code>Either</code>s.
-   *
-   * @deprecated use `for (Left(a) <- es) yield a`
-   *
    */
+  @deprecated("use `for (Left(a) <- es) yield a'")
   def lefts[A, B](es: Iterable[Either[A, B]]) =
     es.foldRight[List[A]](Nil)((e, as) => e match {
       case Left(a) => a :: as
@@ -80,9 +78,8 @@ object Either {
 
   /**
    * Returns the <code>Right</code> values in the given<code>Iterable</code> of  <code>Either</code>s.
-   *
-   * @deprecated use `for (Right(a) <- es) yield a`
    */
+  @deprecated("use `for (Right(a) <- es) yield a'")
   def rights[A, B](es: Iterable[Either[A, B]]) =
     es.foldRight[List[B]](Nil)((e, bs) => e match {
       case Left(_) => bs
@@ -93,9 +90,8 @@ object Either {
    *
    *  @param xs the iterable of Eithers to separate
    *  @return a pair of lists.
-   *
-   *  @deprecated  use `for ((Left(l), Right(r)) <- es partition isLeft) yield (l, r)`
    */
+  @deprecated("use `for ((Left(l), Right(r)) <- es partition isLeft) yield (l, r)'")
   def separate[A,B](es: Iterable[Either[A,B]]): (List[A], List[B]) =
       es.foldRight[(List[A], List[B])]((Nil, Nil)) {
       case (Left(a), (lefts, rights)) => (a :: lefts, rights)
diff --git a/src/library/scala/Enumeration.scala b/src/library/scala/Enumeration.scala
index e5800a209e..f3a6b2f68c 100644
--- a/src/library/scala/Enumeration.scala
+++ b/src/library/scala/Enumeration.scala
@@ -167,7 +167,6 @@ abstract class Enumeration(initial: Int, names: String*) {
 
     /** this enumeration value as an <code>Int</code> bit mask.
      *  @throws IllegalArgumentException if <code>id</code> is greater than 31
-     *  @deprecated
      */
     @deprecated def mask32: Int = {
       if (id >= 32) throw new IllegalArgumentException
@@ -175,7 +174,6 @@ abstract class Enumeration(initial: Int, names: String*) {
     }
     /** this enumeration value as an <code>Long</code> bit mask.
      *  @throws IllegalArgumentException if <code>id</code> is greater than 63
-     *  @deprecated
      */
     @deprecated def mask64: Long = {
       if (id >= 64) throw new IllegalArgumentException
@@ -239,52 +237,47 @@ abstract class Enumeration(initial: Int, names: String*) {
     implicit def builderFactory: BuilderFactory[Value, ValueSet, ValueSet] = new BuilderFactory[Value, ValueSet, ValueSet] { def apply(from: ValueSet) = newBuilder }
   }
 
-  /** The name of this enumeration.
-   *  @deprecated  use toString instead
-   */
-  @deprecated def name = toString
+  /** The name of this enumeration. */
+  @deprecated("use toString instead") def name = toString
 
-  /** @deprecated use withName instead
-   */
-  @deprecated def valueOf(s: String) = values.find(_.toString == s)
+  @deprecated("use withName instead")
+  def valueOf(s: String) = values.find(_.toString == s)
 
-  /** A new iterator over all values of this enumeration.
-   *  @deprecated use values.iterator instead
-   */
-  @deprecated final def iterator: Iterator[Value] = values.iterator
+  /** A new iterator over all values of this enumeration. */
+  @deprecated("use values.iterator instead")
+  final def iterator: Iterator[Value] = values.iterator
 
-  /** Apply a function f to all values of this enumeration.
-   *  @deprecated use values.foreach instead
-   */
-  @deprecated def foreach(f: Value => Unit): Unit = this.iterator foreach f
+  /** Apply a function f to all values of this enumeration. */
+  @deprecated("use values.foreach instead")
+  def foreach(f: Value => Unit): Unit = this.iterator foreach f
 
   /** Apply a predicate p to all values of this enumeration and return
     * true, iff the predicate yields true for all values.
-   *  @deprecated use values.forall instead
    */
-  @deprecated def forall(p: Value => Boolean): Boolean = this.iterator forall p
+  @deprecated("use values.forall instead")
+  def forall(p: Value => Boolean): Boolean = this.iterator forall p
 
   /** Apply a predicate p to all values of this enumeration and return
     * true, iff there is at least one value for which p yields true.
-    *  @deprecated use values.exists instead
     */
-  @deprecated def exists(p: Value => Boolean): Boolean = this.iterator exists p
+  @deprecated("use values.exists instead")
+  def exists(p: Value => Boolean): Boolean = this.iterator exists p
 
   /** Returns an iterator resulting from applying the given function f to each
     * value of this enumeration.
-    *  @deprecated use values.map instead
     */
-  @deprecated def map[B](f: Value => B): Iterator[B] = this.iterator map f
+  @deprecated("use values.map instead")
+  def map[B](f: Value => B): Iterator[B] = this.iterator map f
 
   /** Applies the given function f to each value of this enumeration, then
     * concatenates the results.
-    *  @deprecated use values.flatMap instead
     */
-  @deprecated def flatMap[B](f: Value => Iterator[B]): Iterator[B] = this.iterator flatMap f
+  @deprecated("use values.flatMap instead")
+  def flatMap[B](f: Value => Iterator[B]): Iterator[B] = this.iterator flatMap f
 
   /** Returns all values of this enumeration that satisfy the predicate p.
     * The order of values is preserved.
-    *  @deprecated use values.filter instead
     */
-  @deprecated def filter(p: Value => Boolean): Iterator[Value] = this.iterator filter p
+  @deprecated("use values.filter instead")
+  def filter(p: Value => Boolean): Iterator[Value] = this.iterator filter p
 }
diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala
index f6cbd94748..263c9dec37 100644
--- a/src/library/scala/Option.scala
+++ b/src/library/scala/Option.scala
@@ -44,9 +44,7 @@ sealed abstract class Option[+A] extends Product {
    */
   def get: A
 
-  /** @deprecated; use <code>getOrElse</code> instead
-   */
-  @deprecated
+  @deprecated("use <code>getOrElse</code> instead")
   def get[B >: A](default: B): B = this match {
     case None => default
     case Some(x) => x
diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala
index da4e51e2aa..49af94b716 100644
--- a/src/library/scala/Predef.scala
+++ b/src/library/scala/Predef.scala
@@ -25,20 +25,20 @@ object Predef {
 
   // aliases ------------------------------------------------------------
 
-  @deprecated type byte    = scala.Byte
-  @deprecated type short   = scala.Short
-  @deprecated type char    = scala.Char
-  @deprecated type int     = scala.Int
-  @deprecated type long    = scala.Long
-  @deprecated type float   = scala.Float
-  @deprecated type double  = scala.Double
-  @deprecated type boolean = scala.Boolean
-  @deprecated type unit    = scala.Unit
-
-  /** @deprecated use <code>java.lang.Integer</code> instead */
-  @deprecated type Integer = java.lang.Integer
-  /** @deprecated use <code>java.lang.Character</code> instead */
-  @deprecated type Character = java.lang.Character
+  @deprecated("lower-case type aliases will be removed") type byte    = scala.Byte
+  @deprecated("lower-case type aliases will be removed") type short   = scala.Short
+  @deprecated("lower-case type aliases will be removed") type char    = scala.Char
+  @deprecated("lower-case type aliases will be removed") type int     = scala.Int
+  @deprecated("lower-case type aliases will be removed") type long    = scala.Long
+  @deprecated("lower-case type aliases will be removed") type float   = scala.Float
+  @deprecated("lower-case type aliases will be removed") type double  = scala.Double
+  @deprecated("lower-case type aliases will be removed") type boolean = scala.Boolean
+  @deprecated("lower-case type aliases will be removed") type unit    = scala.Unit
+
+  @deprecated("use <code>java.lang.Integer</code> instead")
+  type Integer = java.lang.Integer
+  @deprecated("use <code>java.lang.Character</code> instead")
+  type Character = java.lang.Character
 
   type String        = java.lang.String
   type Class[T]      = java.lang.Class[T]
diff --git a/src/library/scala/Product.scala b/src/library/scala/Product.scala
index b9a60e4c95..2e0a0b2816 100644
--- a/src/library/scala/Product.scala
+++ b/src/library/scala/Product.scala
@@ -39,9 +39,8 @@ trait Product extends AnyRef {
     def next() = { val result = productElement(c); c += 1; result }
   }
 
-  /** @deprecated use productIterator instead
-   */
-  @deprecated def productElements: Iterator[Any] = productIterator
+  @deprecated("use productIterator instead")
+  def productElements: Iterator[Any] = productIterator
 
   /**
    *  By default the empty string. Implementations may override this
diff --git a/src/library/scala/Range.scala b/src/library/scala/Range.scala
index 3be4dfb4ed..4f21bc36dc 100644
--- a/src/library/scala/Range.scala
+++ b/src/library/scala/Range.scala
@@ -200,7 +200,7 @@ extends VectorView[Int, Vector[Int]] with RangeToString[Int]
 }
 
 object Range {
-  /** @deprecated use Range.inclusive instead */
+  @deprecated("use Range.inclusive instead")
   final class Inclusive(start: Int, end0: Int, step: Int)
       extends Range(start, if (step > 0) end0 + 1 else end0 - 1, step) { self =>
     override def by(step: Int): Range = new Inclusive(start, end0, step)
diff --git a/src/library/scala/StaticAttribute.scala b/src/library/scala/StaticAttribute.scala
deleted file mode 100644
index e9e11a01c7..0000000000
--- a/src/library/scala/StaticAttribute.scala
+++ /dev/null
@@ -1,25 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2006-2009, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-// $Id$
-
-
-package scala
-
-/** <p>
- *    A base class for static attributes. These are available
- *    to the Scala type checker, even across different compilation units.
- *  </p>
- *
- *  @deprecated  use <a href="StaticAnnotation.html"
- *               target="contentFrame">StaticAnnotation</a> instead
- *  @author  Martin Odersky
- *  @version 1.1, 2/02/2007
- */
-@deprecated
-trait StaticAttribute extends Attribute {}
diff --git a/src/library/scala/collection/Iterable.scala b/src/library/scala/collection/Iterable.scala
index 179ff99d92..3e886f6d5e 100644
--- a/src/library/scala/collection/Iterable.scala
+++ b/src/library/scala/collection/Iterable.scala
@@ -54,10 +54,9 @@ object Iterable extends TraversableFactory[Iterable] {
   implicit def builderFactory[A]: BuilderFactory[A, Iterable[A], Coll] = new VirtualBuilderFactory[A]
   def newBuilder[A]: Builder[A, Iterable[A]] = immutable.Iterable.newBuilder[A]
 
-  /** The minimum element of a non-empty sequence of ordered elements
-   *  @deprecated use seq.min instead
-   */
-  @deprecated def min[A <% Ordered[A]](seq: Iterable[A]): A = {
+  /** The minimum element of a non-empty sequence of ordered elements */
+  @deprecated("use seq.min instead")
+  def min[A <% Ordered[A]](seq: Iterable[A]): A = {
     val xs = seq.iterator
     if (!xs.hasNext) throw new IllegalArgumentException("min(<empty>)")
     var min = xs.next
@@ -68,10 +67,9 @@ object Iterable extends TraversableFactory[Iterable] {
     min
   }
 
-  /** The maximum element of a non-empty sequence of ordered elements
-   *  @deprecated use seq.max iConstead
-   */
-  @deprecated def max[A <% Ordered[A]](seq: Iterable[A]): A = {
+  /** The maximum element of a non-empty sequence of ordered elements */
+  @deprecated("use seq.max iConstead")
+  def max[A <% Ordered[A]](seq: Iterable[A]): A = {
     val xs = seq.iterator
     if (!xs.hasNext) throw new IllegalArgumentException("max(<empty>)")
     var max = xs.next
@@ -82,7 +80,5 @@ object Iterable extends TraversableFactory[Iterable] {
     max
   }
 
-  /** @deprecated use View instead
-   */
-  @deprecated type Projection[A] = IterableView[A, Coll]
+  @deprecated("use View instead") type Projection[A] = IterableView[A, Coll]
 }
diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala
index 5ebe0df11e..9e8cb67a65 100644
--- a/src/library/scala/collection/Iterator.scala
+++ b/src/library/scala/collection/Iterator.scala
@@ -165,16 +165,15 @@ object Iterator {
   implicit def iteratorIteratorWrapper[A](its: Iterator[Iterator[A]]): IteratorIteratorOps[A] =
     new IteratorIteratorOps[A](its)
 
-  /** @deprecated  use `xs.iterator` or `Iterator(xs)` instead
-   */
-  @deprecated def fromValues[a](xs: a*) = xs.iterator
+  @deprecated("use `xs.iterator' or `Iterator(xs)' instead")
+  def fromValues[a](xs: a*) = xs.iterator
 
   /**
    *  @param xs the array of elements
    *  @see also: Vector.iterator and slice
-   *  @deprecated  use `xs.iterator` instead
    */
-  @deprecated def fromArray[a](xs: Array[a]): Iterator[a] =
+  @deprecated("use `xs.iterator' instead")
+  def fromArray[a](xs: Array[a]): Iterator[a] =
     fromArray(xs, 0, xs.length)
 
   /**
@@ -182,24 +181,24 @@ object Iterator {
    *  @param start  the start index
    *  @param length  the length
    *  @see also: Vector.iterator and slice
-   *  @deprecated  use `xs.slice(start, start + length).iterator` instead
    */
-  @deprecated def fromArray[a](xs: Array[a], start: Int, length: Int): Iterator[a] =
+  @deprecated("use `xs.slice(start, start + length).iterator' instead")
+  def fromArray[a](xs: Array[a], start: Int, length: Int): Iterator[a] =
     xs.slice(start, start + length).iterator
 
   /**
    *  @param str the given string
    *  @return    the iterator on <code>str</code>
-   *  @deprecated replaced by <code>str.iterator</code>
    */
-  @deprecated def fromString(str: String): Iterator[Char] = str.iterator
+  @deprecated("replaced by <code>str.iterator</code>")
+  def fromString(str: String): Iterator[Char] = str.iterator
 
   /**
    *  @param n the product arity
    *  @return  the iterator on <code>Product&lt;n&gt;</code>.
-   *  @deprecated use product.productIterator instead
    */
-  @deprecated def fromProduct(n: Product): Iterator[Any] = new Iterator[Any] {
+  @deprecated("use product.productIterator instead")
+  def fromProduct(n: Product): Iterator[Any] = new Iterator[Any] {
     private var c: Int = 0
     private val cmax = n.productArity
     def hasNext = c < cmax
@@ -216,9 +215,9 @@ object Iterator {
    *  @param end   the end value of the iterator
    *  @param step  the increment function of the iterator, must be monotonically increasing or decreasing
    *  @return      the iterator with values in range <code>[start;end)</code>.
-   *  @deprecated  use Iterator.iterate(start, end - start)(step) instead
    */
-  @deprecated def range(start: Int, end: Int, step: Int => Int) = new Iterator[Int] {
+  @deprecated("use Iterator.iterate(start, end - start)(step) instead")
+  def range(start: Int, end: Int, step: Int => Int) = new Iterator[Int] {
     private val up = step(start) > start
     private val down = step(start) < start
     private var i = start
@@ -235,9 +234,9 @@ object Iterator {
    *  @param start the start value of the iterator
    *  @param step  the increment function of the iterator
    *  @return      the iterator starting at value <code>start</code>.
-   *  @deprecated  use iterate(start)(step) instead
    */
-  @deprecated def from(start: Int, step: Int => Int): Iterator[Int] = new Iterator[Int] {
+  @deprecated("use iterate(start)(step) instead")
+  def from(start: Int, step: Int => Int): Iterator[Int] = new Iterator[Int] {
     private var i = start
     override def hasNext: Boolean = true
     def next(): Int = { val j = i; i = step(i); j }
@@ -247,9 +246,9 @@ object Iterator {
    *  returned by a given iterator of iterators.
    *   @param its   The iterator which returns on each call to next
    *                a new iterator whose elements are to be concatenated to the result.
-   *   @deprecated  use its.flatten instead
    */
-  @deprecated def flatten[T](its: Iterator[Iterator[T]]): Iterator[T] = new Iterator[T] {
+  @deprecated("use its.flatten instead")
+  def flatten[T](its: Iterator[Iterator[T]]): Iterator[T] = new Iterator[T] {
     private var cur = its.next
     def hasNext: Boolean = {
       while (!cur.hasNext && its.hasNext) cur = its.next
@@ -902,30 +901,28 @@ trait Iterator[+A] { self =>
 
  /** Returns a new iterator that first yields the elements of this
    *  iterator followed by the elements provided by iterator <code>that</code>.
-   *  @deprecated  use <code>++</code>
    */
-  @deprecated def append[B >: A](that: Iterator[B]) = new Iterator[B] {
+  @deprecated("use <code>++</code>")
+  def append[B >: A](that: Iterator[B]) = new Iterator[B] {
     def hasNext = self.hasNext || that.hasNext
     def next() = (if (self.hasNext) self else that).next()
   }
 
-  /** Returns index of the first element satisfying a predicate, or -1.
-   *
-   *  @deprecated use `indexWhere` instead
-   */
-  @deprecated def findIndexOf(p: A => Boolean): Int = indexWhere(p)
+  /** Returns index of the first element satisfying a predicate, or -1. */
+  @deprecated("use `indexWhere` instead")
+  def findIndexOf(p: A => Boolean): Int = indexWhere(p)
 
   /** Collect elements into a seq.
    *
    * @return  a sequence which enumerates all elements of this iterator.
-   * @deprecated  use toSequence instead
    */
-  @deprecated def collect: Sequence[A] = toSequence
+  @deprecated("use toSequence instead")
+  def collect: Sequence[A] = toSequence
 
   /** Returns a counted iterator from this iterator.
-   *  @deprecated use @see zipWithIndex in Iterator
    */
-  @deprecated def counted = new CountedIterator[A] {
+  @deprecated("use zipWithIndex in Iterator")
+  def counted = new CountedIterator[A] {
     private var cnt = 0
     def count = cnt
     def hasNext: Boolean = self.hasNext
@@ -940,19 +937,21 @@ trait Iterator[+A] { self =>
    *  @param  start the starting index.
    *  @param  sz    the maximum number of elements to be read.
    *  @pre          the array must be large enough to hold <code>sz</code> elements.
-   *  @deprecated   use copyToArray instead
    */
-  @deprecated def readInto[B >: A](xs: Array[B], start: Int, sz: Int) {
+  @deprecated("use copyToArray instead")
+  def readInto[B >: A](xs: Array[B], start: Int, sz: Int) {
     var i = start
     while (hasNext && i - start < sz) {
       xs(i) = next
       i += 1
     }
   }
-  @deprecated def readInto[B >: A](xs: Array[B], start: Int) {
+  @deprecated("use copyToArray instead")
+  def readInto[B >: A](xs: Array[B], start: Int) {
     readInto(xs, start, xs.length - start)
   }
-  @deprecated def readInto[B >: A](xs: Array[B]) {
+  @deprecated("use copyToArray instead")
+  def readInto[B >: A](xs: Array[B]) {
     readInto(xs, 0, xs.length)
   }
 }
diff --git a/src/library/scala/collection/Sequence.scala b/src/library/scala/collection/Sequence.scala
index 8abfdc3334..04411c8db3 100644
--- a/src/library/scala/collection/Sequence.scala
+++ b/src/library/scala/collection/Sequence.scala
@@ -40,17 +40,13 @@ object Sequence extends SequenceFactory[Sequence] {
   implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new VirtualBuilderFactory[A]
   def newBuilder[A]: Builder[A, Sequence[A]] = immutable.Sequence.newBuilder[A]
 
-  /** @deprecated use View instead
-   */
-  @deprecated type Projection[A] = SequenceView[A, Coll]
-
-  /** @deprecated use Sequence(value) instead */
-  @deprecated def singleton[A](value: A) = Sequence(value)
-
-  /** Builds a singleton sequence.
-   *
-   * @deprecated use <code>Sequence(x)</code> instead.
-   */
-  @deprecated def single[A](x: A) = singleton(x)
+  @deprecated("use View instead") type Projection[A] = SequenceView[A, Coll]
+
+  @deprecated("use Sequence(value) instead")
+  def singleton[A](value: A) = Sequence(value)
+
+  /** Builds a singleton sequence. */
+  @deprecated("use <code>Sequence(x)</code> instead.")
+  def single[A](x: A) = singleton(x)
 }
 
diff --git a/src/library/scala/collection/generic/BufferTemplate.scala b/src/library/scala/collection/generic/BufferTemplate.scala
index 53d74a2d45..65c6631fbd 100644
--- a/src/library/scala/collection/generic/BufferTemplate.scala
+++ b/src/library/scala/collection/generic/BufferTemplate.scala
@@ -222,9 +222,9 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
    *  @param src    the array
    *  @param start  the first element to append
    *  @param len    the number of elements to append
-   *  @deprecated   replace by: <code>buf ++= src.view(start, end)</code>
    */
-  @deprecated def ++=(src: Array[A], start: Int, len: Int) {
+  @deprecated("replace by: <code>buf ++= src.view(start, end)</code>")
+  def ++=(src: Array[A], start: Int, len: Int) {
     var i = start
     val end = i + len
     while (i < end) {
@@ -237,10 +237,10 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
    *  the collection itself.
    *
    *  @param elem  the element to add.
-   *  @deprecated  use += instead if you intend to add by side effect to an existing collection.
-   *               Use `clone() ++=` if you intend to create a new collection.
    */
-  @deprecated override def + (elem: A): This = { +=(elem); thisCollection }
+  @deprecated("Use += instead if you intend to add by side effect to an existing collection.\n"+
+              "Use `clone() ++=' if you intend to create a new collection.")
+  override def + (elem: A): This = { +=(elem); thisCollection }
 
   /** Adds two or more elements to this collection and returns
    *  the collection itself.
@@ -248,10 +248,10 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
    *  @param elem1 the first element to add.
    *  @param elem2 the second element to add.
    *  @param elems the remaining elements to add.
-   *  @deprecated  use += instead if you intend to add by side effect to an existing collection.
-   *               Use `clone() ++=` if you intend to create a new collection.
    */
-  @deprecated override def + (elem1: A, elem2: A, elems: A*): This = {
+  @deprecated("Use += instead if you intend to add by side effect to an existing collection.\n"+
+              "Use `clone() ++=' if you intend to create a new collection.")
+  override def + (elem1: A, elem2: A, elems: A*): This = {
     this += elem1 += elem2 ++= elems
     thisCollection
   }
@@ -260,10 +260,10 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
    *  either the collection itself.
    *
    *  @param iter     the iterable object.
-   *  @deprecated  use ++= instead if you intend to add by side effect to an existing collection.
-   *               Use `clone() ++=` if you intend to create a new collection.
    */
-  @deprecated override def ++(iter: Traversable[A]): This = {
+  @deprecated("Use ++= instead if you intend to add by side effect to an existing collection.\n"+
+              "Use `clone() ++=` if you intend to create a new collection.")
+  override def ++(iter: Traversable[A]): This = {
     for (elem <- iter) +=(elem)
     thisCollection
   }
@@ -272,10 +272,10 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
    *  the collection itself.
    *
    *  @param iter   the iterator
-   *  @deprecated  use ++= instead if you intend to add by side effect to an existing collection.
-   *               Use `clone() ++=` if you intend to create a new collection.
    */
-  @deprecated override def ++ (iter: Iterator[A]): This = {
+  @deprecated("Use ++= instead if you intend to add by side effect to an existing collection.\n"+
+              "Use `clone() ++=` if you intend to create a new collection.")
+  override def ++ (iter: Iterator[A]): This = {
     for (elem <- iter) +=(elem)
     thisCollection
   }
@@ -284,10 +284,10 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
    *  the collection itself.
    *
    *  @param elem  the element to remove.
-   *  @deprecated  use -= instead if you intend to remove by side effect from an existing collection.
-   *               Use `clone() -=` if you intend to create a new collection.
    */
-  @deprecated override def -(elem: A): This = { -=(elem); thisCollection }
+  @deprecated("Use -= instead if you intend to remove by side effect from an existing collection.\n"+
+              "Use `clone() -=` if you intend to create a new collection.")
+  override def -(elem: A): This = { -=(elem); thisCollection }
 
   /** Removes two or more elements from this collection and returns
    *  the collection itself.
@@ -295,22 +295,22 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
    *  @param elem1 the first element to remove.
    *  @param elem2 the second element to remove.
    *  @param elems the remaining elements to remove.
-   *  @deprecated  use -= instead if you intend to remove by side effect from an existing collection.
-   *               Use `clone() -=` if you intend to create a new collection.
    */
-  @deprecated override def -(elem1: A, elem2: A, elems: A*): This = {
+  @deprecated("Use -= instead if you intend to remove by side effect from an existing collection.\n"+
+              "Use `clone() -=` if you intend to create a new collection.")
+  override def -(elem1: A, elem2: A, elems: A*): This = {
     this -= elem1 -= elem2 --= elems
     thisCollection
   }
 
   /** Removes a number of elements provided by a traversible object and returns
    *  the collection itself.
-   *  @deprecated  use --= instead if you intend to remove by side effect from an existing collection.
-   *               Use `clone() --=` if you intend to create a new collection.
    *
    *  @param iter     the iterable object.
    */
-  @deprecated override def --(iter: Traversable[A]): This = {
+  @deprecated("Use --= instead if you intend to remove by side effect from an existing collection.\n"+
+              "Use `clone() --=` if you intend to create a new collection.")
+  override def --(iter: Traversable[A]): This = {
     for (elem <- iter) -=(elem)
     thisCollection
   }
@@ -319,10 +319,10 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
    *  the collection itself.
    *
    *  @param iter   the iterator
-   *  @deprecated  use --= instead if you intend to remove by side effect from an existing collection.
-   *               Use `clone() --=` if you intend to create a new collection.
    */
-  @deprecated override def --(iter: Iterator[A]): This = {
+  @deprecated("Use --= instead if you intend to remove by side effect from an existing collection.\n"+
+              "Use `clone() --=` if you intend to create a new collection.")
+  override def --(iter: Iterator[A]): This = {
     for (elem <- iter) -=(elem)
     thisCollection
   }
diff --git a/src/library/scala/collection/generic/ImmutableMapTemplate.scala b/src/library/scala/collection/generic/ImmutableMapTemplate.scala
index 6c5331689e..7a8c79ca41 100644
--- a/src/library/scala/collection/generic/ImmutableMapTemplate.scala
+++ b/src/library/scala/collection/generic/ImmutableMapTemplate.scala
@@ -97,6 +97,6 @@ self =>
     res
   }
 
-  /** @deprecated use updated instead */
-  @deprecated def update[B1 >: B](key: A, value: B1): immutable.Map[A, B1] = updated(key, value).asInstanceOf[immutable.Map[A, B1]]
+  @deprecated("use `updated' instead")
+  def update[B1 >: B](key: A, value: B1): immutable.Map[A, B1] = updated(key, value).asInstanceOf[immutable.Map[A, B1]]
 }
diff --git a/src/library/scala/collection/generic/IterableTemplate.scala b/src/library/scala/collection/generic/IterableTemplate.scala
index d5e6fb2523..fa7a2529fc 100644
--- a/src/library/scala/collection/generic/IterableTemplate.scala
+++ b/src/library/scala/collection/generic/IterableTemplate.scala
@@ -39,7 +39,8 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
    */
   def iterator: Iterator[A]
 
-  @deprecated def elements = iterator
+  @deprecated("use `iterator' instead")
+  def elements = iterator
 
   /** Apply a function <code>f</code> to all elements of this
    *  traversable object.
@@ -177,23 +178,17 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]]
    */
   override def view(from: Int, until: Int) = view.slice(from, until)
 
-   /** @deprecated  use head instead */
-  @deprecated def first: A = head
+  @deprecated("use `updated' instead") def first: A = head
 
-  /** @deprecated use headOption instead
-   *  <code>None</code> if traversable is empty.
-   */
-  @deprecated def firstOption: Option[A] = headOption
+  /** <code>None</code> if traversable is empty. */
+  @deprecated("use `updated' instead") def firstOption: Option[A] = headOption
 
-  /** @deprecated use toSequence instead
-   */
-  @deprecated def toSeq: Sequence[A] = toSequence
+  @deprecated("use `toSequence' instead") def toSeq: Sequence[A] = toSequence
 
   /**
    * returns a projection that can be used to call non-strict <code>filter</code>,
    * <code>map</code>, and <code>flatMap</code> methods that build projections
    * of the collection.
-   * @deprecated use view instead
    */
-  @deprecated def projection = view
+  @deprecated("use `view' instead") def projection = view
 }
diff --git a/src/library/scala/collection/generic/MapTemplate.scala b/src/library/scala/collection/generic/MapTemplate.scala
index 74130cb487..8c1112f6bc 100644
--- a/src/library/scala/collection/generic/MapTemplate.scala
+++ b/src/library/scala/collection/generic/MapTemplate.scala
@@ -124,11 +124,8 @@ self =>
     override def foreach[B](f: A => B) = for ((k, v) <- self) f(k)
   }
 
-  /** @deprecated use `keys` instead
-   *
-   *  @return the keys of this map as a set.
-   */
-  @deprecated def keySet: collection.Set[A] = new DefaultKeySet
+  /** @return the keys of this map as a set. */
+  @deprecated("use `keys' instead") def keySet: collection.Set[A] = new DefaultKeySet
 
   /** Creates an iterator for all keys.
    *
@@ -187,9 +184,7 @@ self =>
     def get(key: A) = self.get(key).map(f)
   }
 
-  /** @deprecated  use mapValues instead
-   */
-  @deprecated def mapElements[C](f: B => C) = mapValues(f)
+  @deprecated("use `mapValues' instead") def mapElements[C](f: B => C) = mapValues(f)
 
   // The following 5 operations (updated, two times +, two times ++) should really be
   // generic, returning This[B]. We need better covariance support to express that though.
diff --git a/src/library/scala/collection/generic/MutableMapTemplate.scala b/src/library/scala/collection/generic/MutableMapTemplate.scala
index 6d6d05a119..9290986dfd 100644
--- a/src/library/scala/collection/generic/MutableMapTemplate.scala
+++ b/src/library/scala/collection/generic/MutableMapTemplate.scala
@@ -82,12 +82,11 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
   /** Add a new key/value mapping and return the map itself.
    *
    *  @param kv    the key/value mapping to be added
-   *  @deprecated  This operation will create a new map in the future. To add
-   *               an element as a side effect to an existing map and return
-   *               that map itself, use +=. If you do want to create a fresh map,
-   *               you can use `clone() +=` to avoid a @deprecated warning.
    */
-  @deprecated def + (kv: (A, B)): this.type = { update(kv._1, kv._2); this }
+  @deprecated("This operation will create a new map in the future. To add an element as a side\n"+
+              "effect to an existing map and return that map itself, use +=. If you do want\n"+
+              "to create a fresh map, you can use `clone() +=' to avoid a @deprecated warning.")
+ def + (kv: (A, B)): this.type = { update(kv._1, kv._2); this }
 
   /** Adds two or more key/value mappings and return the map itself.
    *  with the added elements.
@@ -95,37 +94,35 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
    *  @param elem1 the first element to add.
    *  @param elem2 the second element to add.
    *  @param elems the remaining elements to add.
-   *  @deprecated  This operation will create a new map in the future. To add
-   *               an element as a side effect to an existing map and return
-   *               that map itself, use +=. If you do want to create a fresh map,
-   *               you can use `clone() +=` to avoid a @deprecated warning.
    */
-  @deprecated def +(elem1: (A, B), elem2: (A, B), elems: (A, B)*): this.type =
+  @deprecated("This operation will create a new map in the future. To add an element as a side\n"+
+              "effect to an existing map and return that map itself, use +=. If you do want to\n"+
+              "create a fresh map, you can use `clone() +=` to avoid a @deprecated warning.")
+  def +(elem1: (A, B), elem2: (A, B), elems: (A, B)*): this.type =
     this += elem1 += elem2 ++= elems
 
   /** Adds a number of elements provided by a traversable object
    *  via its <code>iterator</code> method and returns
    *  either the collection itself (if it is mutable), or a new collection
    *  with the added elements.
-   *  @deprecated  This operation will create a new map in the future. To add
-   *               elements as a side effect to an existing map and return
-   *               that map itself, use ++=. If you do want to create a fresh map,
-   *               you can use `clone() ++=` to avoid a @deprecated warning.
+   *
    *  @param iter     the traversable object.
    */
-  @deprecated def ++(iter: Traversable[(A, B)]): this.type = { for (elem <- iter) +=(elem); this }
+  @deprecated("This operation will create a new map in the future. To add elements as a side\n"+
+              "effect to an existing map and return that map itself, use ++=. If you do want\n"+
+              "to create a fresh map, you can use `clone() ++=` to avoid a @deprecated warning.")
+  def ++(iter: Traversable[(A, B)]): this.type = { for (elem <- iter) +=(elem); this }
 
   /** Adds a number of elements provided by an iterator
    *  via its <code>iterator</code> method and returns
    *  the collection itself.
-   *  @deprecated  This operation will create a new map in the future. To add
-   *               elements as a side effect to an existing map and return
-   *               that map itself, use ++=. If you do want to create a fresh map,
-   *               you can use `clone() +=` to avoid a @deprecated warning.
    *
    *  @param iter   the iterator
    */
-  @deprecated def ++(iter: Iterator[(A, B)]): this.type = { for (elem <- iter) +=(elem); this }
+  @deprecated("This operation will create a new map in the future. To add elements as a side\n"+
+              "effect to an existing map and return that map itself, use ++=. If you do want\n"+
+              "to create a fresh map, you can use `clone() +=` to avoid a @deprecated warning.")
+  def ++(iter: Iterator[(A, B)]): this.type = { for (elem <- iter) +=(elem); this }
 
   /** If given key is defined in this map, remove it and return associated value as an Option.
    *  If key is not present return None.
@@ -145,19 +142,17 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
 
   /** Delete a key from this map if it is present and return the map itself.
    *  @param    key the key to be removed
-   *  @deprecated  This operation will create a new map in the future. To add
-   *               elements as a side effect to an existing map and return
-   *               that map itself, use -=. If you do want to create a fresh map,
-   *               you can use `clone() -=` to avoid a @deprecated warning.
    */
-  @deprecated override def -(key: A): This = { -=(key); thisCollection }
+  @deprecated("This operation will create a new map in the future. To add elements as a side\n"+
+              "effect to an existing map and return that map itself, use -=. If you do want\n"+
+              "to create a fresh map, you can use `clone() -=` to avoid a @deprecated warning.")
+  override def -(key: A): This = { -=(key); thisCollection }
 
   /** If given key is defined in this map, remove it and return associated value as an Option.
    *  If key is not present return None.
    *  @param    key the key to be removed
-   *  @deprecated  Use `remove` instead.
    */
-   @deprecated def removeKey(key: A): Option[B] = remove(key)
+   @deprecated("Use `remove' instead") def removeKey(key: A): Option[B] = remove(key)
 
 
   /** Removes all elements from the set. After this operation is completed,
@@ -191,8 +186,8 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
    *  <code>p</code> returns <code>true</code>.
    *
    * @param p  The test predicate
-   * @deprecated cannot be type inferred because of retain in Iterable.
    */
+  @deprecated("cannot be type inferred because of retain in Iterable.")
   def retain(p: (A, B) => Boolean): this.type = {
     for ((k, v) <- this) if (!p(k, v)) -=(k)
     this
@@ -213,22 +208,22 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
    *  @param elem1 the first element to remove.
    *  @param elem2 the second element to remove.
    *  @param elems the remaining elements to remove.
-   *  @deprecated  use -= instead if you intend to remove by side effect from an existing collection.
-   *               Use `clone() -=` if you intend to create a new collection.
    */
-  @deprecated override def -(elem1: A, elem2: A, elems: A*): This = {
+  @deprecated("Use -= instead if you intend to remove by side effect from an existing collection.\n"+
+              "Use `clone() -=' if you intend to create a new collection.")
+  override def -(elem1: A, elem2: A, elems: A*): This = {
     this -= elem1 -= elem2 --= elems
     thisCollection
   }
 
   /** Removes a number of elements provided by a traversible object and returns
    *  the collection itself.
-   *  @deprecated  use --= instead if you intend to remove by side effect from an existing collection.
-   *               Use `clone() --=` if you intend to create a new collection.
    *
    *  @param iter     the iterable object.
    */
-  @deprecated override def --(iter: Traversable[A]): This = {
+  @deprecated("Use --= instead if you intend to remove by side effect from an existing collection.\n"+
+              "Use `clone() --=' if you intend to create a new collection.")
+  override def --(iter: Traversable[A]): This = {
     for (elem <- iter) -=(elem)
     thisCollection
   }
@@ -238,10 +233,10 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
    *  the collection itself.
    *
    *  @param iter   the iterator
-   *  @deprecated  use --= instead if you intend to remove by side effect from an existing collection.
-   *               Use `clone() --=` if you intend to create a new collection.
    */
-  @deprecated override def --(iter: Iterator[A]): This = {
+  @deprecated("Use --= instead if you intend to remove by side effect from an existing collection.\n"+
+              "Use `clone() --=' if you intend to create a new collection.")
+  override def --(iter: Iterator[A]): This = {
     for (elem <- iter) -=(elem)
     thisCollection
   }
diff --git a/src/library/scala/collection/generic/MutableSetTemplate.scala b/src/library/scala/collection/generic/MutableSetTemplate.scala
index 40386fe27b..a266d7680d 100644
--- a/src/library/scala/collection/generic/MutableSetTemplate.scala
+++ b/src/library/scala/collection/generic/MutableSetTemplate.scala
@@ -103,10 +103,10 @@ trait MutableSetTemplate[A, +This <: MutableSetTemplate[A, This] with mutable.Se
    *  the collection itself.
    *
    *  @param elem  the element to add.
-   *  @deprecated  use += instead if you intend to add by side effect to an existing collection.
-   *               Use `clone() +=` if you intend to create a new collection.
    */
-  @deprecated override def + (elem: A): This = { +=(elem); thisCollection }
+  @deprecated("Use += instead if you intend to add by side effect to an existing collection.\n"+
+              "Use `clone() +=' if you intend to create a new collection.")
+ override def + (elem: A): This = { +=(elem); thisCollection }
 
   /** Adds two or more elements to this collection and returns
    *  the collection itself.
@@ -114,10 +114,10 @@ trait MutableSetTemplate[A, +This <: MutableSetTemplate[A, This] with mutable.Se
    *  @param elem1 the first element to add.
    *  @param elem2 the second element to add.
    *  @param elems the remaining elements to add.
-   *  @deprecated  use += instead if you intend to add by side effect to an existing collection.
-   *               Use `clone() +=` if you intend to create a new collection.
    */
-  @deprecated override def + (elem1: A, elem2: A, elems: A*): This = {
+  @deprecated("Use += instead if you intend to add by side effect to an existing collection.\n"+
+              "Use `clone() +=' if you intend to create a new collection.")
+  override def + (elem1: A, elem2: A, elems: A*): This = {
     this += elem1 += elem2 ++= elems
     thisCollection
   }
@@ -126,10 +126,10 @@ trait MutableSetTemplate[A, +This <: MutableSetTemplate[A, This] with mutable.Se
    *  either the collection itself.
    *
    *  @param iter     the iterable object.
-   *  @deprecated  use ++= instead if you intend to add by side effect to an existing collection.
-   *               Use `clone() ++=` if you intend to create a new collection.
    */
-  @deprecated override def ++(iter: Traversable[A]): This = {
+  @deprecated("Use ++= instead if you intend to add by side effect to an existing collection.\n"+
+              "Use `clone() ++=' if you intend to create a new collection.")
+  override def ++(iter: Traversable[A]): This = {
     for (elem <- iter) +=(elem)
     thisCollection
   }
@@ -139,10 +139,10 @@ trait MutableSetTemplate[A, +This <: MutableSetTemplate[A, This] with mutable.Se
    *  the collection itself.
    *
    *  @param iter   the iterator
-   *  @deprecated  use ++= instead if you intend to add by side effect to an existing collection.
-   *               Use `clone() ++=` if you intend to create a new collection.
    */
-  @deprecated override def ++ (iter: Iterator[A]): This = {
+  @deprecated("Use ++= instead if you intend to add by side effect to an existing collection.\n"+
+              "Use `clone() ++=' if you intend to create a new collection.")
+  override def ++ (iter: Iterator[A]): This = {
     for (elem <- iter) +=(elem)
     thisCollection
   }
@@ -151,10 +151,10 @@ trait MutableSetTemplate[A, +This <: MutableSetTemplate[A, This] with mutable.Se
    *  the collection itself.
    *
    *  @param elem  the element to remove.
-   *  @deprecated  use -= instead if you intend to remove by side effect from an existing collection.
-   *               Use `clone() -=` if you intend to create a new collection.
    */
-  @deprecated override def -(elem: A): This = { -=(elem); thisCollection }
+  @deprecated("Use -= instead if you intend to remove by side effect from an existing collection.\n"+
+              "Use `clone() -=' if you intend to create a new collection.")
+  override def -(elem: A): This = { -=(elem); thisCollection }
 
   /** Removes two or more elements from this collection and returns
    *  the collection itself.
@@ -162,22 +162,22 @@ trait MutableSetTemplate[A, +This <: MutableSetTemplate[A, This] with mutable.Se
    *  @param elem1 the first element to remove.
    *  @param elem2 the second element to remove.
    *  @param elems the remaining elements to remove.
-   *  @deprecated  use -= instead if you intend to remove by side effect from an existing collection.
-   *               Use `clone() -=` if you intend to create a new collection.
    */
-  @deprecated override def -(elem1: A, elem2: A, elems: A*): This = {
+  @deprecated("Use -= instead if you intend to remove by side effect from an existing collection.\n"+
+              "Use `clone() -=' if you intend to create a new collection.")
+  override def -(elem1: A, elem2: A, elems: A*): This = {
     this -= elem1 -= elem2 --= elems
     thisCollection
   }
 
   /** Removes a number of elements provided by a traversible object and returns
    *  the collection itself.
-   *  @deprecated  use --= instead if you intend to remove by side effect from an existing collection.
-   *               Use `clone() --=` if you intend to create a new collection.
    *
    *  @param iter     the iterable object.
    */
-  @deprecated override def --(iter: Traversable[A]): This = {
+  @deprecated("Use --= instead if you intend to remove by side effect from an existing collection.\n"+
+              "Use `clone() --=' if you intend to create a new collection.")
+  override def --(iter: Traversable[A]): This = {
     for (elem <- iter) -=(elem)
     thisCollection
   }
@@ -186,10 +186,10 @@ trait MutableSetTemplate[A, +This <: MutableSetTemplate[A, This] with mutable.Se
    *  the collection itself.
    *
    *  @param iter   the iterator
-   *  @deprecated  use --= instead if you intend to remove by side effect from an existing collection.
-   *               Use `clone() --=` if you intend to create a new collection.
    */
-  @deprecated override def --(iter: Iterator[A]): This = {
+  @deprecated("Use --= instead if you intend to remove by side effect from an existing collection.\n"+
+              "Use `clone() --=' if you intend to create a new collection.")
+  override def --(iter: Iterator[A]): This = {
     for (elem <- iter) -=(elem)
     thisCollection
   }
@@ -207,4 +207,4 @@ trait MutableSetTemplate[A, +This <: MutableSetTemplate[A, This] with mutable.Se
      case s: Script[_]      => s.iterator foreach <<
      case _                 => throw new UnsupportedOperationException("message " + cmd + " not understood")
    }
-}
-\ No newline at end of file
+}
diff --git a/src/library/scala/collection/generic/SequenceTemplate.scala b/src/library/scala/collection/generic/SequenceTemplate.scala
index 3890665adf..ade5f45dad 100644
--- a/src/library/scala/collection/generic/SequenceTemplate.scala
+++ b/src/library/scala/collection/generic/SequenceTemplate.scala
@@ -180,11 +180,8 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]]
     result
   }
 
-  /** Returns index of the first element satisying a predicate, or -1.
-   *
-   *  @deprecated  Use `indexWhere` instead
-   */
-  @deprecated def findIndexOf(p: A => Boolean): Int = indexWhere(p)
+  /** Returns index of the first element satisying a predicate, or -1. */
+  @deprecated("Use `indexWhere' instead") def findIndexOf(p: A => Boolean): Int = indexWhere(p)
 
   /** Returns the index of the first occurence of the specified
    *  object in this iterable object.
@@ -268,8 +265,7 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]]
    */
   def reverseIterator: Iterator[A] = reverse.iterator
 
-  /** @deprecated use `reverseIterator` instead */
-  @deprecated def reversedElements = reverseIterator
+  @deprecated("use `reverseIterator' instead") def reversedElements = reverseIterator
 
   /**
    * Checks whether the argument sequence is contained at the
@@ -491,42 +487,36 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]]
    */
   override def toString = super[IterableTemplate].toString
 
-  /** Returns index of the last element satisying a predicate, or -1.
-   *  @deprecated use `lastIndexWhere` instead
-   */
-  @deprecated def findLastIndexOf(p: A => Boolean): Int = lastIndexWhere(p)
+  /** Returns index of the last element satisying a predicate, or -1. */
+  @deprecated("use `lastIndexWhere' instead")
+  def findLastIndexOf(p: A => Boolean): Int = lastIndexWhere(p)
 
   /** A sub-sequence starting at index <code>from</code>
     *  and extending up to the length of the current sequence
     *
     *  @param from   The index of the first element of the slice
     *  @throws IndexOutOfBoundsException if <code>from &lt; 0</code>
-    *  @deprecated   use <code>drop</code> instead
     */
-  @deprecated def slice(from: Int): Sequence[A] = slice(from, length)
+  @deprecated("use `drop' instead")
+  def slice(from: Int): Sequence[A] = slice(from, length)
 
-  /** @deprecated Should be replaced by
-   *
-   *   <code>(s1, s2) forall { case (x, y) => f(x, y) }</code>
-   */
-  @deprecated def equalsWith[B](that: Sequence[B])(f: (A,B) => Boolean): Boolean = {
+  @deprecated("Should be replaced by  <code>(s1, s2) forall { case (x, y) => f(x, y) }</code>")
+  def equalsWith[B](that: Sequence[B])(f: (A,B) => Boolean): Boolean = {
     val i = this.iterator
     val j = that.iterator
     while (i.hasNext && j.hasNext && f(i.next, j.next)) ()
     !i.hasNext && !j.hasNext
   }
 
-  /** Is <code>that</code> a slice in this?
-   *  @deprecated  Should be repaced by <code>indexOf(that) != -1</code>
-   */
-  @deprecated def containsSlice[B](that: Sequence[B]): Boolean = indexOf(that) != -1
+  /** Is <code>that</code> a slice in this? */
+  @deprecated("Should be repaced by <code>indexOf(that) != -1</code>")
+  def containsSlice[B](that: Sequence[B]): Boolean = indexOf(that) != -1
 
  /**
    * returns a projection that can be used to call non-strict <code>filter</code>,
    * <code>map</code>, and <code>flatMap</code> methods that build projections
    * of the collection.
-   * @deprecated use view instead
    */
-  @deprecated override def projection = view
+  @deprecated("use `view' instead") override def projection = view
 }
 
diff --git a/src/library/scala/collection/generic/SetTemplate.scala b/src/library/scala/collection/generic/SetTemplate.scala
index cce6ec4229..61b34108c5 100644
--- a/src/library/scala/collection/generic/SetTemplate.scala
+++ b/src/library/scala/collection/generic/SetTemplate.scala
@@ -91,9 +91,8 @@ self =>
    *  It removes all the elements that are not present in <code>that</code>.
    *
    *  @param that the set to intersect with
-   *  @deprecated use & instead
    */
-  @deprecated def ** (that: Set[A]): This = intersect(that)
+  @deprecated("use & instead") def ** (that: Set[A]): This = intersect(that)
 
   /** The union of this set and the given set <code>that</code>.
    *
diff --git a/src/library/scala/collection/generic/TraversableTemplate.scala b/src/library/scala/collection/generic/TraversableTemplate.scala
index 32402217c8..09396ef3dc 100644
--- a/src/library/scala/collection/generic/TraversableTemplate.scala
+++ b/src/library/scala/collection/generic/TraversableTemplate.scala
@@ -190,9 +190,9 @@ self =>
    *
    *  @param p the predicate used to test elements
    *  @return  the traversable without all elements that satisfy <code>p</code>
-   *  @deprecated use `filterNot` instead
    */
-  @deprecated def remove(p: A => Boolean): This = filterNot(p)
+  @deprecated("use `filterNot' instead")
+  def remove(p: A => Boolean): This = filterNot(p)
 
   /** Partitions this traversable in two traversables according to a predicate.
    *
diff --git a/src/library/scala/collection/generic/TraversableView.scala b/src/library/scala/collection/generic/TraversableView.scala
index deacb1b5bb..3c2efdc92f 100644
--- a/src/library/scala/collection/generic/TraversableView.scala
+++ b/src/library/scala/collection/generic/TraversableView.scala
@@ -21,7 +21,7 @@ object TraversableView {
   class NoBuilder[A] extends Builder[A, Nothing] {
     def +=(elem: A): this.type = this
     def iterator: Iterator[A] = Iterator.empty
-    @deprecated def elements = iterator
+    @deprecated("use `iterator' instead") def elements = iterator
     def result() = throw new UnsupportedOperationException("TraversableView.Builder.result")
     def clear() {}
   }
diff --git a/src/library/scala/collection/generic/TraversableView.scala.1 b/src/library/scala/collection/generic/TraversableView.scala.1
index 916f1182ff..69f1682339 100755
--- a/src/library/scala/collection/generic/TraversableView.scala.1
+++ b/src/library/scala/collection/generic/TraversableView.scala.1
@@ -138,7 +138,7 @@ object TraversableView {
   class NoBuilder[A] extends Builder[A, Nothing, TraversableView[_, _]] {
     def +=(elem: A) {}
     def iterator: Iterator[A] = Iterator.empty
-    @deprecated def elements = iterator
+    @deprecated("use `iterator' instead") def elements = iterator
     def result() = throw new UnsupportedOperationException("TraversableView.Builder.result")
     def clear() {}
   }
diff --git a/src/library/scala/collection/immutable/ImmutableIterator.scala.disabled b/src/library/scala/collection/immutable/ImmutableIterator.scala.disabled
index 0cdfc4a988..db17a0c467 100644
--- a/src/library/scala/collection/immutable/ImmutableIterator.scala.disabled
+++ b/src/library/scala/collection/immutable/ImmutableIterator.scala.disabled
@@ -106,7 +106,7 @@ sealed abstract class ImmutableIterator[+A] {
    */
   def iterator: Iterator[A] = new Elements
 
-  @deprecated def elements = iterator
+  @deprecated("use `iterator' instead") def elements = iterator
   
 }
 
diff --git a/src/library/scala/collection/immutable/IntMap.scala b/src/library/scala/collection/immutable/IntMap.scala
index 32ad7fca42..88e17ea09b 100644
--- a/src/library/scala/collection/immutable/IntMap.scala
+++ b/src/library/scala/collection/immutable/IntMap.scala
@@ -250,8 +250,8 @@ sealed abstract class IntMap[+T] extends scala.collection.immutable.Map[Int, T]
     case IntMap.Nil => IntMap.Tip(key, value);
   }
 
-  /** @deprecated use updated instead */
-  @deprecated override def update[S >: T](key: Int, value: S): IntMap[S] = updated(key, value)
+  @deprecated("use `updated' instead")
+  override def update[S >: T](key: Int, value: S): IntMap[S] = updated(key, value)
 
   /**
    * Updates the map, using the provided function to resolve conflicts if the key is already present.
diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala
index 38ddfee8b5..78bb4a125e 100644
--- a/src/library/scala/collection/immutable/List.scala
+++ b/src/library/scala/collection/immutable/List.scala
@@ -313,9 +313,9 @@ sealed abstract class List[+A] extends LinearSequence[A]
    *  @param that the list of elements to remove from this list.
    *  @return     this list without the elements of the given list
    *              <code>that</code>.
-   *  @deprecated use diff instead
    */
-  @deprecated def -- [B >: A](that: List[B]): List[B] = {
+  @deprecated("use `diff' instead")
+  def -- [B >: A](that: List[B]): List[B] = {
     val b = new ListBuffer[B]
     var these = this
     while (!these.isEmpty) {
@@ -331,9 +331,9 @@ sealed abstract class List[+A] extends LinearSequence[A]
    *  @param x    the object to remove from this list.
    *  @return     this list without occurrences of the given object
    *              <code>x</code>.
-   *  @deprecated use diff instead
    */
-  @deprecated def - [B >: A](x: B): List[B] = {
+  @deprecated("use `diff' instead")
+  def - [B >: A](x: B): List[B] = {
     val b = new ListBuffer[B]
     var these = this
     while (!these.isEmpty) {
@@ -358,9 +358,9 @@ sealed abstract class List[+A] extends LinearSequence[A]
    *    List("Steve", "Tom", "John", "Bob")
    *      .sort((e1, e2) => (e1 compareTo e2) &lt; 0) =
    *    List("Bob", "John", "Steve", "Tom")</pre>
-   *  @deprecated  use sortWith instead
    */
-  @deprecated def sort(lt : (A,A) => Boolean): List[A] = {
+  @deprecated("use `sortWith' instead")
+  def sort(lt : (A,A) => Boolean): List[A] = {
     /** Merge two already-sorted lists */
     def merge(l1: List[A], l2: List[A]): List[A] = {
       val res = new ListBuffer[A]
@@ -501,7 +501,6 @@ object List extends SequenceFactory[List] {
    * and elements are in the range between <code>start</code> (inclusive)
    * and <code>end</code> (exclusive)
    *
-   *  @deprecated  use @see iterate instead.
    *  @param start the start value of the list
    *  @param end  the end value of the list
    *  @param step the increment function of the list, which given <code>v<sub>n</sub></code>,
@@ -509,7 +508,8 @@ object List extends SequenceFactory[List] {
    *              or decreasing.
    *  @return     the sorted list of all integers in range [start;end).
    */
-  @deprecated def range(start: Int, end: Int, step: Int => Int): List[Int] = {
+  @deprecated("use `iterate' instead")
+  def range(start: Int, end: Int, step: Int => Int): List[Int] = {
     val up = step(start) > start
     val down = step(start) < start
     val b = new ListBuffer[Int]
@@ -525,13 +525,13 @@ object List extends SequenceFactory[List] {
   }
 
   /** Create a list containing several copies of an element.
-   *  @deprecated use @see fill instead
    *
    *  @param n    the length of the resulting list
    *  @param elem the element composing the resulting list
    *  @return     a list composed of n elements all equal to elem
    */
-  @deprecated def make[A](n: Int, elem: A): List[A] = {
+  @deprecated("use `fill' instead")
+  def make[A](n: Int, elem: A): List[A] = {
     val b = new ListBuffer[A]
     var i = 0
     while (i < n) {
@@ -543,11 +543,11 @@ object List extends SequenceFactory[List] {
 
   /** Concatenate all the elements of a given list of lists.
    *
-   *  @deprecated use `xss.flatten` instead
    *  @param xss the list of lists that are to be concatenated
    *  @return    the concatenation of all the lists
    */
-  @deprecated def flatten[A](xss: List[List[A]]): List[A] = {
+  @deprecated("use `xss.flatten' instead")
+  def flatten[A](xss: List[List[A]]): List[A] = {
     val b = new ListBuffer[A]
     for (xs <- xss) {
       var xc = xs
@@ -563,9 +563,9 @@ object List extends SequenceFactory[List] {
    *
    *  @param xs the list of pairs to unzip
    *  @return a pair of lists.
-   *  @deprecated  use `xs.unzp` instead
    */
-  @deprecated def unzip[A,B](xs: List[(A,B)]): (List[A], List[B]) = {
+  @deprecated("use `xs.unzip' instead")
+  def unzip[A,B](xs: List[(A,B)]): (List[A], List[B]) = {
     val b1 = new ListBuffer[A]
     val b2 = new ListBuffer[B]
     var xc = xs
@@ -579,20 +579,21 @@ object List extends SequenceFactory[List] {
 
   /** Transforms an iterable of pairs into a pair of lists.
    *
-   *  @deprecated use `xs.unzip` instead
    *  @param xs the iterable of pairs to unzip
    *  @return a pair of lists.
    */
-  @deprecated def unzip[A,B](xs: Iterable[(A,B)]): (List[A], List[B]) =
+  @deprecated("use `xs.unzip' instead")
+  def unzip[A,B](xs: Iterable[(A,B)]): (List[A], List[B]) =
       xs.foldRight[(List[A], List[B])]((Nil, Nil)) {
         case ((x, y), (xs, ys)) => (x :: xs, y :: ys)
       }
 
   /**
-   * Returns the <code>Left</code> values in the given <code>Iterable</code> of <code>Either</code>s.
-   * @deprecated use `Either.lefts` instead
+   * Returns the <code>Left</code> values in the given <code>Iterable</code>
+   * of <code>Either</code>s.
    */
-  @deprecated def lefts[A, B](es: Iterable[Either[A, B]]) =
+  @deprecated("use `Either.lefts' instead")
+  def lefts[A, B](es: Iterable[Either[A, B]]) =
     es.foldRight[List[A]](Nil)((e, as) => e match {
       case Left(a) => a :: as
       case Right(_) => as
@@ -600,9 +601,9 @@ object List extends SequenceFactory[List] {
 
   /**
    * Returns the <code>Right</code> values in the given<code>Iterable</code> of  <code>Either</code>s.
-   * @deprecated use `Either.rights` instead
    */
-  @deprecated def rights[A, B](es: Iterable[Either[A, B]]) =
+  @deprecated("use `Either.rights' instead")
+  def rights[A, B](es: Iterable[Either[A, B]]) =
     es.foldRight[List[B]](Nil)((e, bs) => e match {
       case Left(_) => bs
       case Right(b) => b :: bs
@@ -612,9 +613,9 @@ object List extends SequenceFactory[List] {
    *
    *  @param xs the iterable of Eithers to separate
    *  @return a pair of lists.
-   *  @deprecated  use `Either.separate` instead
    */
-  @deprecated def separate[A,B](es: Iterable[Either[A,B]]): (List[A], List[B]) =
+  @deprecated("use `Either.separate' instead")
+  def separate[A,B](es: Iterable[Either[A,B]]): (List[A], List[B]) =
       es.foldRight[(List[A], List[B])]((Nil, Nil)) {
       case (Left(a), (lefts, rights)) => (a :: lefts, rights)
       case (Right(b), (lefts, rights)) => (lefts, b :: rights)
@@ -625,18 +626,18 @@ object List extends SequenceFactory[List] {
    *  @param it the iterator to convert
    *  @return   a list that contains the elements returned by successive
    *            calls to <code>it.next</code>
-   *  @deprecated use it.toList instead
    */
-  @deprecated def fromIterator[A](it: Iterator[A]): List[A] = it.toList
+  @deprecated("use `it.toList' instead")
+  def fromIterator[A](it: Iterator[A]): List[A] = it.toList
 
   /** Converts an array into a list.
    *
    *  @param arr the array to convert
    *  @return    a list that contains the same elements than <code>arr</code>
    *             in the same order
-   *  @deprecated use `array.toList` instead
    */
-  @deprecated def fromArray[A](arr: Array[A]): List[A] = fromArray(arr, 0, arr.length)
+  @deprecated("use `array.toList' instead")
+  def fromArray[A](arr: Array[A]): List[A] = fromArray(arr, 0, arr.length)
 
   /** Converts a range of an array into a list.
    *
@@ -645,9 +646,9 @@ object List extends SequenceFactory[List] {
    *  @param len   the lenght of the range to convert
    *  @return      a list that contains the same elements than <code>arr</code>
    *               in the same order
-   *  @deprecated use `array.view(start, end).toList` instead
    */
-  @deprecated def fromArray[A](arr: Array[A], start: Int, len: Int): List[A] = {
+  @deprecated("use `array.view(start, end).toList' instead")
+  def fromArray[A](arr: Array[A], start: Int, len: Int): List[A] = {
     var res: List[A] = Nil
     var i = start + len
     while (i > start) {
@@ -663,9 +664,9 @@ object List extends SequenceFactory[List] {
    *  @param str       the string to parse
    *  @param separator the separator character
    *  @return          the list of substrings
-   *  @deprecated      use `str.split(separator).toList` instead
    */
-  @deprecated def fromString(str: String, separator: Char): List[String] = {
+  @deprecated("use `str.split(separator).toList' instead")
+  def fromString(str: String, separator: Char): List[String] = {
     var words: List[String] = Nil
     var pos = str.length()
     while (pos > 0) {
@@ -681,17 +682,17 @@ object List extends SequenceFactory[List] {
    *
    *  @param str the string to convert.
    *  @return    the string as a list of characters.
-   *  @deprecated use <code>str.toList</code> instead
    */
-  @deprecated def fromString(str: String): List[Char] = str.toList
+  @deprecated("use `str.toList' instead")
+  def fromString(str: String): List[Char] = str.toList
 
   /** Returns the given list of characters as a string.
    *
    *  @param xs the list to convert.
    *  @return   the list in form of a string.
-   *  @deprecated  use xs.mkString instead
    */
-  @deprecated def toString(xs: List[Char]): String = {
+  @deprecated("use `xs.mkString' instead")
+  def toString(xs: List[Char]): String = {
     val sb = new StringBuilder()
     var xc = xs
     while (!xc.isEmpty) {
@@ -703,9 +704,9 @@ object List extends SequenceFactory[List] {
 
   /** Like xs map f, but returns <code>xs</code> unchanged if function
    *  <code>f</code> maps all elements to themselves.
-   *  @deprecated  use xs.mapConserve(f)
    */
-  @deprecated def mapConserve[A <: AnyRef](xs: List[A])(f: A => A): List[A] = {
+  @deprecated("use `xs.mapConserve(f)' instead")
+  def mapConserve[A <: AnyRef](xs: List[A])(f: A => A): List[A] = {
     def loop(ys: List[A]): List[A] =
       if (ys.isEmpty) xs
       else {
@@ -732,13 +733,13 @@ object List extends SequenceFactory[List] {
 
   /** Returns the list resulting from applying the given function <code>f</code>
    *  to corresponding elements of the argument lists.
-   *  @deprecated   use (xs, ys).map(f) instead
    *  @param f function to apply to each pair of elements.
    *  @return <code>[f(a0,b0), ..., f(an,bn)]</code> if the lists are
    *          <code>[a0, ..., ak]</code>, <code>[b0, ..., bl]</code> and
    *          <code>n = min(k,l)</code>
    */
-  @deprecated def map2[A,B,C](xs: List[A], ys: List[B])(f: (A, B) => C): List[C] = {
+  @deprecated("use `(xs, ys).map(f)' instead")
+  def map2[A,B,C](xs: List[A], ys: List[B])(f: (A, B) => C): List[C] = {
     val b = new ListBuffer[C]
     var xc = xs
     var yc = ys
@@ -754,7 +755,6 @@ object List extends SequenceFactory[List] {
    *  <code>f</code> to corresponding elements of the argument lists.
    *
    *  @param f function to apply to each pair of elements.
-   *  @deprecated  use (xs, ys, zs).map(f) instead
    *  @return  <code>[f(a<sub>0</sub>,b<sub>0</sub>,c<sub>0</sub>),
    *           ..., f(a<sub>n</sub>,b<sub>n</sub>,c<sub>n</sub>)]</code>
    *           if the lists are <code>[a<sub>0</sub>, ..., a<sub>k</sub>]</code>,
@@ -762,7 +762,8 @@ object List extends SequenceFactory[List] {
    *           <code>[c<sub>0</sub>, ..., c<sub>m</sub>]</code> and
    *           <code>n = min(k,l,m)</code>
    */
-  @deprecated def map3[A,B,C,D](xs: List[A], ys: List[B], zs: List[C])(f: (A, B, C) => D): List[D] = {
+  @deprecated("use `(xs, ys, zs).map(f)' instead")
+  def map3[A,B,C,D](xs: List[A], ys: List[B], zs: List[C])(f: (A, B, C) => D): List[D] = {
     val b = new ListBuffer[D]
     var xc = xs
     var yc = ys
@@ -785,9 +786,9 @@ object List extends SequenceFactory[List] {
    *           if the lists are <code>[a<sub>0</sub>, ..., a<sub>k</sub>]</code>;
    *           <code>[b<sub>0</sub>, ..., b<sub>l</sub>]</code>
    *           and <code>n = min(k,l)</code>
-   *  @deprecated  use (xs, ys).forall(f) instead
    */
-  @deprecated def forall2[A,B](xs: List[A], ys: List[B])(f: (A, B) => Boolean): Boolean = {
+  @deprecated("use `(xs, ys).forall(f)' instead")
+  def forall2[A,B](xs: List[A], ys: List[B])(f: (A, B) => Boolean): Boolean = {
     var xc = xs
     var yc = ys
     while (!xc.isEmpty && !yc.isEmpty) {
@@ -807,9 +808,9 @@ object List extends SequenceFactory[List] {
    *           <code>[a<sub>0</sub>, ..., a<sub>k</sub>]</code>,
    *           <code>[b<sub>0</sub>, ..., b<sub>l</sub>]</code> and
    *           <code>n = min(k,l)</code>
-   *  @deprecated  use (xs, ys).exists(f) instead
    */
-  @deprecated def exists2[A,B](xs: List[A], ys: List[B])(f: (A, B) => Boolean): Boolean = {
+  @deprecated("use `(xs, ys).exists(f)' instead")
+  def exists2[A,B](xs: List[A], ys: List[B])(f: (A, B) => Boolean): Boolean = {
     var xc = xs
     var yc = ys
     while (!xc.isEmpty && !yc.isEmpty) {
@@ -825,9 +826,9 @@ object List extends SequenceFactory[List] {
    *
    *  @param xss the list of lists
    *  @return    the transposed list of lists
-   *  @deprecated use xss.transpose  instead
    */
-  @deprecated def transpose[A](xss: List[List[A]]): List[List[A]] = {
+  @deprecated("use p`xss.transpose' instead")
+  def transpose[A](xss: List[List[A]]): List[List[A]] = {
     val buf = new ListBuffer[List[A]]
     var yss = xss
     while (!yss.head.isEmpty) {
diff --git a/src/library/scala/collection/immutable/LongMap.scala b/src/library/scala/collection/immutable/LongMap.scala
index 346e97345f..5ea52e5add 100644
--- a/src/library/scala/collection/immutable/LongMap.scala
+++ b/src/library/scala/collection/immutable/LongMap.scala
@@ -251,8 +251,8 @@ sealed abstract class LongMap[+T] extends scala.collection.immutable.Map[Long, T
     case LongMap.Nil => LongMap.Tip(key, value);
   }
 
-  /** @deprecated use updated instead */
-  @deprecated override def update[S >: T](key: Long, value: S): LongMap[S] = updated(key, value)
+  @deprecated("use `updated' instead")
+  override def update[S >: T](key: Long, value: S): LongMap[S] = updated(key, value)
 
   /**
    * Updates the map, using the provided function to resolve conflicts if the key is already present.
diff --git a/src/library/scala/collection/immutable/Queue.scala b/src/library/scala/collection/immutable/Queue.scala
index e0a2387ea4..f63545cbe7 100644
--- a/src/library/scala/collection/immutable/Queue.scala
+++ b/src/library/scala/collection/immutable/Queue.scala
@@ -68,11 +68,10 @@ extends immutable.Sequence[A]
   /** Creates a new queue with element added at the end
    *  of the old queue.
    *
-   *  @deprecated Use the method <code>enqueue</code> from now on.
-   *
    *  @param  elem        the element to insert
    */
-  @deprecated def +[B >: A](elem: B) = enqueue(elem)
+  @deprecated("Use the method <code>enqueue</code> from now on.")
+  def +[B >: A](elem: B) = enqueue(elem)
 
   /** Creates a new queue with element added at the end
    *  of the old queue.
@@ -87,11 +86,10 @@ extends immutable.Sequence[A]
    *  The elements are prepended in the order they
    *  are given out by the iterator.
    *
-   *  @deprecated Use the method <code>enqueue</code> from now on.
-   *
    *  @param  iter        an iterable object
    */
-  @deprecated def +[B >: A](iter: Iterable[B]) = enqueue(iter)
+  @deprecated("Use the method <code>enqueue</code> from now on.")
+  def +[B >: A](iter: Iterable[B]) = enqueue(iter)
 
   /** Returns a new queue with all elements provided by
    *  an <code>Iterable</code> object added at the end of
diff --git a/src/library/scala/collection/immutable/RedBlack.scala b/src/library/scala/collection/immutable/RedBlack.scala
index a13250363d..a33e5b11c2 100644
--- a/src/library/scala/collection/immutable/RedBlack.scala
+++ b/src/library/scala/collection/immutable/RedBlack.scala
@@ -29,11 +29,11 @@ abstract class RedBlack[A] {
     def update[B1 >: B](k: A, v: B1): Tree[B1] = blacken(upd(k, v))
     def delete(k: A): Tree[B] = del(k)
     def foreach[U](f: (A, B) =>  U)
-    /** @deprecated use foreach instead */
-    @deprecated def visit[T](input : T)(f : (T,A,B) => Tuple2[Boolean,T]) : Tuple2[Boolean,T];
+    @deprecated("use `foreach' instead")
+    def visit[T](input : T)(f : (T,A,B) => Tuple2[Boolean,T]) : Tuple2[Boolean,T];
     def toStream: Stream[(A,B)]
     def iterator: Iterator[(A, B)]
-    @deprecated def elements = iterator
+    @deprecated("use `iterator' instead") def elements = iterator
     def upd[B1 >: B](k: A, v: B1): Tree[B1]
     def del(k: A): Tree[B]
     def smallest: NonEmpty[B]
@@ -97,8 +97,7 @@ abstract class RedBlack[A] {
       right foreach f
     }
 
-    /** @deprecated use foreach instead */
-    @deprecated
+    @deprecated("use `foreach' instead")
     def visit[T](input : T)(f : (T,A,B) => Tuple2[Boolean,T]) : Tuple2[Boolean,T] = {
       val left = this.left.visit(input)(f)
       if (!left._1) return left
@@ -135,8 +134,7 @@ abstract class RedBlack[A] {
 
     def foreach[U](f: (A, Nothing) =>  U) {}
 
-    /** @deprecated use foreach instead */
-    @deprecated
+    @deprecated("use `foreach' instead")
     def visit[T](input : T)(f : (T,A,Nothing) => Tuple2[Boolean,T]) = Tuple2(true,input)
 
     def range(from : Option[A], until : Option[A]) = this
diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala
index 538e9d85fe..77b196c167 100644
--- a/src/library/scala/collection/immutable/Stream.scala
+++ b/src/library/scala/collection/immutable/Stream.scala
@@ -416,8 +416,7 @@ object Stream extends SequenceFactory[Stream] {
       else Some((xs.head, xs.tail))
   }
 
-  /** @deprecated   use #:: instead */
-  @deprecated lazy val lazy_:: = #::
+  @deprecated("use #:: instead") lazy val lazy_:: = #::
 
   /** An alternative way of building and matching Streams using Stream.cons(hd, tl).
    */
@@ -480,8 +479,8 @@ object Stream extends SequenceFactory[Stream] {
    * occurrence)
    * @param elem the element composing the resulting stream
    * @return the stream containing an inifinite number of elem
-   * @deprecated use fill instead
    */
+  @deprecated("use `fill' instead")
   def continually[A](elem: => A): Stream[A] = new Cons(elem, continually(elem))
 
   override def fill[A](n: Int)(elem: => A): Stream[A] =
@@ -499,19 +498,19 @@ object Stream extends SequenceFactory[Stream] {
 
   /** A stream containing all elements of a given iterator, in the order they are produced.
    *  @param it   The iterator producing the stream's elements
-   *  @deprecated use it.toStream instead
    */
-  @deprecated def fromIterator[A](it: Iterator[A]): Stream[A] =
+  @deprecated("use it.toStream instead")
+  def fromIterator[A](it: Iterator[A]): Stream[A] =
     if (it.hasNext) cons(it.next, fromIterator(it)) else empty
 
   /** The concatenation of a sequence of streams
-   * @deprecated use xs.flatten instead
    */
+  @deprecated("use xs.flatten instead")
   def concat[A](xs: Iterable[Stream[A]]): Stream[A] = concat(xs.iterator)
 
   /** The concatenation of all streams returned by an iterator
-   * @deprecated use xs.toStream.flatten instead
    */
+  @deprecated("use xs.toStream.flatten instead")
   def concat[A](xs: Iterator[Stream[A]]): Stream[A] =
     if (xs.hasNext) xs.next append concat(xs)
     else empty
@@ -522,13 +521,13 @@ object Stream extends SequenceFactory[Stream] {
    * where <code>v<sub>0</sub> = start</code>
    * and elements are in the range between <code>start</code> (inclusive)
    * and <code>end</code> (exclusive)
-   * @deprecated  use @see iterate instead.
    * @param start the start value of the stream
    * @param end the end value of the stream
    * @param step the increment function of the stream, must be monotonically increasing or decreasing
    * @return the stream starting at value <code>start</code>.
    */
-  @deprecated def range(start: Int, end: Int, step: Int => Int): Stream[Int] = {
+  @deprecated("use `iterate' instead.")
+  def range(start: Int, end: Int, step: Int => Int): Stream[Int] = {
     val up = step(start) > start
     val down = step(start) < start
     def loop(lo: Int): Stream[Int] =
@@ -542,18 +541,18 @@ object Stream extends SequenceFactory[Stream] {
    *
    * @param elem the element composing the resulting stream
    * @return the stream containing an inifinite number of elem
-   * @deprecated use fill(elem) instead
    */
-  @deprecated def const[A](elem: A): Stream[A] = cons(elem, const(elem))
+  @deprecated("use fill(elem) instead")
+  def const[A](elem: A): Stream[A] = cons(elem, const(elem))
 
   /** Create a stream containing several copies of an element.
    *
    *  @param n    the length of the resulting stream
    *  @param elem the element composing the resulting stream
    *  @return     the stream composed of n elements all equal to elem
-   *  @deprecated use fill(n, elem) instead
    */
-  @deprecated def make[A](n: Int, elem: A): Stream[A] =
+  @deprecated("use fill(n, elem) instead")
+  def make[A](n: Int, elem: A): Stream[A] =
     const(elem) take n
 }
 
diff --git a/src/library/scala/collection/immutable/TreeHashMap.scala b/src/library/scala/collection/immutable/TreeHashMap.scala
index 1b45a8b5b8..76ce1ab16e 100644
--- a/src/library/scala/collection/immutable/TreeHashMap.scala
+++ b/src/library/scala/collection/immutable/TreeHashMap.scala
@@ -184,7 +184,7 @@ private[collection] sealed abstract class AssocMap[Key, +Value] extends immutabl
 
   def iterator : Iterator[(Key, Value)] = new AssocMapIterator(this)
 
-  @deprecated def elements = iterator
+  @deprecated("use `iterator' instead") def elements = iterator
 
   override final def foreach[U](f : ((Key, Value)) =>  U) = this match {
     case Cons(key, value, tail) => { f((key, value)); tail.foreach(f); }
diff --git a/src/library/scala/collection/mutable/ArrayStack.scala b/src/library/scala/collection/mutable/ArrayStack.scala
index 0c420300a4..b0090da156 100644
--- a/src/library/scala/collection/mutable/ArrayStack.scala
+++ b/src/library/scala/collection/mutable/ArrayStack.scala
@@ -57,10 +57,8 @@ class ArrayStack[T] private(private var table : Array[AnyRef],
     x;
   }
 
-  /**
-   * View the top element of the stack.
-   * @deprecated use top instead
-   */
+  /** View the top element of the stack. */
+  @deprecated("use top instead")
   def peek = top
 
   /**
diff --git a/src/library/scala/collection/mutable/CloneableCollection.scala b/src/library/scala/collection/mutable/CloneableCollection.scala
index 8dea90eb2a..354e71435e 100644
--- a/src/library/scala/collection/mutable/CloneableCollection.scala
+++ b/src/library/scala/collection/mutable/CloneableCollection.scala
@@ -13,8 +13,7 @@ package scala.collection.mutable
 
 /** The J2ME version of the library defined this trait with a clone method
  * to substitute for the lack of Object.clone there
- *  @deprecated use Cloneable instead
  */
-@deprecated trait CloneableCollection {
+@deprecated("use Cloneable instead") trait CloneableCollection {
   override def clone(): AnyRef = super.clone()
 }
diff --git a/src/library/scala/collection/mutable/HashTable.scala b/src/library/scala/collection/mutable/HashTable.scala
index be0a84bd41..56843013ad 100644
--- a/src/library/scala/collection/mutable/HashTable.scala
+++ b/src/library/scala/collection/mutable/HashTable.scala
@@ -131,10 +131,9 @@ trait HashTable[A] extends AnyRef {
     }
   }
 
-  /** An iterator returning all entries
-   *  @deprecated use entriesIterator instead
-   */
-  @deprecated protected def entries: Iterator[Entry] = entriesIterator
+  /** An iterator returning all entries */
+  @deprecated("use entriesIterator instead")
+  protected def entries: Iterator[Entry] = entriesIterator
 
   /** Remove all entries from table
    */
diff --git a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
index 86d8facfc4..6f954d299b 100644
--- a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
+++ b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
@@ -50,7 +50,7 @@ extends Map[A, B]
 
   def iterator: Iterator[(A, B)] = imap.iterator
 
-  @deprecated def elements = iterator
+  @deprecated("use `iterator' instead") def elements = iterator
 
   override def toList: List[(A, B)] = imap.toList
 
diff --git a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala
index bac4f95246..452aa3afe1 100644
--- a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala
+++ b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala
@@ -41,7 +41,7 @@ class ImmutableSetAdaptor[A](protected var set: immutable.Set[A]) extends Set[A]
 
   def iterator: Iterator[A] = set.iterator
 
-  @deprecated override def elements: Iterator[A] = iterator
+  @deprecated("use `iterator' instead") override def elements: Iterator[A] = iterator
 
   def +=(elem: A): this.type = { set = set + elem; this }
 
diff --git a/src/library/scala/collection/mutable/MutableList.scala b/src/library/scala/collection/mutable/MutableList.scala
index a2a283f2c4..ce9060acf8 100644
--- a/src/library/scala/collection/mutable/MutableList.scala
+++ b/src/library/scala/collection/mutable/MutableList.scala
@@ -87,8 +87,7 @@ class MutableList[A] extends LinearSequence[A] with LinearSequenceTemplate[A, Mu
       len = len + 1
     }
 
-  /** @deprecated use clear instead */
-  @deprecated def reset() { clear() }
+  @deprecated("use clear instead") def reset() { clear() }
 
   /** Returns an iterator over all elements of this list.
    */
diff --git a/src/library/scala/collection/mutable/OpenHashMap.scala b/src/library/scala/collection/mutable/OpenHashMap.scala
index 8373b4fdde..ab5e897ca3 100644
--- a/src/library/scala/collection/mutable/OpenHashMap.scala
+++ b/src/library/scala/collection/mutable/OpenHashMap.scala
@@ -184,8 +184,8 @@ class OpenHashMap[Key, Value](initialSize : Int) extends scala.collection.mutabl
     }
   }
 
-  /** @deprecated use `iterator` instead */
-  @deprecated override def elements: Iterator[(Key, Value)] = iterator
+  @deprecated("use `iterator' instead")
+  override def elements: Iterator[(Key, Value)] = iterator
 
   override def clone : OpenHashMap[Key, Value] = {
     val it = new OpenHashMap[Key, Value]
diff --git a/src/library/scala/collection/mutable/Stack.scala b/src/library/scala/collection/mutable/Stack.scala
index b079a94f92..9735eeb215 100644
--- a/src/library/scala/collection/mutable/Stack.scala
+++ b/src/library/scala/collection/mutable/Stack.scala
@@ -71,10 +71,8 @@ class Stack[A] private (var elems: List[A]) extends collection.Sequence[A] with
    */
   def pushAll(elems: collection.Traversable[A]): this.type = { for (elem <- elems) { push(elem); () }; this }
 
-  /** @deprecated use pushAll */
-  @deprecated def ++=(it: Iterator[A]): this.type = pushAll(it)
-  /** @deprecated use pushAll */
-  @deprecated def ++=(it: Iterable[A]): this.type = pushAll(it)
+  @deprecated("use pushAll") def ++=(it: Iterator[A]): this.type = pushAll(it)
+  @deprecated("use pushAll") def ++=(it: Iterable[A]): this.type = pushAll(it)
 
   /** Returns the top element of the stack. This method will not remove
    *  the element from the stack. An error is signaled if there is no
diff --git a/src/library/scala/collection/mutable/StringBuilder.scala b/src/library/scala/collection/mutable/StringBuilder.scala
index c8ddb065ea..245e867e9f 100644
--- a/src/library/scala/collection/mutable/StringBuilder.scala
+++ b/src/library/scala/collection/mutable/StringBuilder.scala
@@ -87,11 +87,10 @@ final class StringBuilder(initCapacity: Int, private val initValue: String)
    */
   def capacity: Int = array.length
 
-  /** Same as <code>ensureCapacity</code>.
-   *  @deprecated use `ensureCapacity` instead. An assignment is misleading
-   *  because it can never decrease the capacity.
-   */
-  @deprecated def capacity_=(n: Int) { ensureCapacity(n) }
+  /** Same as <code>ensureCapacity</code>. */
+  @deprecated("use `ensureCapacity' instead. An assignment is misleading because\n"+
+              "it can never decrease the capacity.")
+  def capacity_=(n: Int) { ensureCapacity(n) }
 
   /** <p>
    *    Ensures that the capacity is at least equal to the specified minimum.
@@ -293,10 +292,9 @@ final class StringBuilder(initCapacity: Int, private val initValue: String)
   def appendAll(x: Seq[Char]): StringBuilder =
     appendAll(x.toArray, 0, x.length)
 
-   /*  @deprecated  use appendAll instead. This method is deprecated
-    *               because of the possible confusion with `append(Any)`.
-    */
-  @deprecated def append(x: Seq[Char]): StringBuilder =
+  @deprecated("use appendAll instead. This method is deprecated because of the\n"+
+              "possible confusion with `append(Any)'.")
+  def append(x: Seq[Char]): StringBuilder =
     appendAll(x)
 
   /** <p>
@@ -315,10 +313,9 @@ final class StringBuilder(initCapacity: Int, private val initValue: String)
   def appendAll(x: Array[Char]): StringBuilder =
     appendAll(x, 0, x.length)
 
-  /**  @deprecated  use appendAll instead. This method is deprecated
-   *               because of the possible confusion with `append(Any)`.
-   */
-  @deprecated def append(x: Array[Char]): StringBuilder =
+  @deprecated("use appendAll instead. This method is deprecated because\n"+
+              "of the possible confusion with `append(Any)'.")
+  def append(x: Array[Char]): StringBuilder =
     appendAll(x)
 
   /** <p>
@@ -344,10 +341,9 @@ final class StringBuilder(initCapacity: Int, private val initValue: String)
     this
   }
 
-  /**  @deprecated  use appendAll instead. This method is deprecated
-   *               because of the possible confusion with `append(Any, Int, Int)`.
-   */
-  @deprecated def append(x: Array[Char], offset: Int, len: Int): StringBuilder =
+  @deprecated("use appendAll instead. This method is deprecated because\n"+
+              "of the possible confusion with `append(Any, Int, Int)'.")
+  def append(x: Array[Char], offset: Int, len: Int): StringBuilder =
     appendAll(x, offset, len)
 
   /** <p>
@@ -477,10 +473,9 @@ final class StringBuilder(initCapacity: Int, private val initValue: String)
     this
   }
 
-  /**  @deprecated  use insertAll instead. This method is deprecated
-   *               because of the possible confusion with `insert(Int, Any, Int, Int)`.
-   */
-  @deprecated def insert(index: Int, str: Array[Char], offset: Int, len: Int): StringBuilder =
+  @deprecated("use insertAll instead. This method is deprecated because of the\n"+
+              "possible confusion with `insert(Int, Any, Int, Int)'.")
+  def insert(index: Int, str: Array[Char], offset: Int, len: Int): StringBuilder =
     insertAll(index, str, offset, len)
 
   /** <p>
@@ -537,10 +532,9 @@ final class StringBuilder(initCapacity: Int, private val initValue: String)
   def insertAll(at: Int, x: Seq[Char]): StringBuilder =
     insertAll(at, x.toArray)
 
-  /*  @deprecated use insertAll instead. This method is deprecated
-   *  because of the possible confusion with `insert(Int, Any)`.
-   */
-  @deprecated def insert(at: Int, x: Seq[Char]): StringBuilder =
+  @deprecated("use insertAll instead. This method is deprecated because of\n"+
+              "the possible confusion with `insert(Int, Any)'.")
+  def insert(at: Int, x: Seq[Char]): StringBuilder =
     insertAll(at, x)
 
   /** Inserts the string representation of the <code>Char</code> array
@@ -562,10 +556,9 @@ final class StringBuilder(initCapacity: Int, private val initValue: String)
     this
   }
 
-  /*  @deprecated use insertAll instead. This method is deprecated
-   *  because of the possible confusion with `insert(Int, Any)`.
-   */
-  @deprecated def insert(at: Int, x: Array[Char]): StringBuilder =
+  @deprecated("use insertAll instead. This method is deprecated because of\n"+
+              "the possible confusion with `insert(Int, Any)'.")
+  def insert(at: Int, x: Array[Char]): StringBuilder =
     insertAll(at, x)
 
   /** <p>
diff --git a/src/library/scala/concurrent/SyncVar.scala b/src/library/scala/concurrent/SyncVar.scala
index 3e25f8a514..3b35c9ef10 100644
--- a/src/library/scala/concurrent/SyncVar.scala
+++ b/src/library/scala/concurrent/SyncVar.scala
@@ -49,10 +49,8 @@ class SyncVar[A] {
     notifyAll()
   }
 
-  /**
-   *  @deprecated Will be removed in 2.8. SyncVar should not allow exception by design.
-   */
-  @deprecated def setWithCatch(x: => A) = synchronized {
+  @deprecated("Will be removed in 2.8. SyncVar should not allow exception by design.")
+  def setWithCatch(x: => A) = synchronized {
     try {
       this set x
     } catch {
diff --git a/src/library/scala/deprecated.scala b/src/library/scala/deprecated.scala
index cb152f1465..fb4e4e879d 100644
--- a/src/library/scala/deprecated.scala
+++ b/src/library/scala/deprecated.scala
@@ -15,4 +15,6 @@ package scala
  * An annotation that designates the definition to which it is applied as deprecated.
  * Access to the member then generates a deprecated warning.
  */
-class deprecated extends StaticAnnotation {}
+class deprecated(message: String) extends StaticAnnotation {
+  def this() = this("")
+}
diff --git a/src/library/scala/io/Source.scala b/src/library/scala/io/Source.scala
index 03c2e4dc00..b79de507f6 100644
--- a/src/library/scala/io/Source.scala
+++ b/src/library/scala/io/Source.scala
@@ -145,8 +145,8 @@ object Source {
   /**
    *  @param s    ...
    *  @return     ...
-   *  @deprecated use fromURL(s, enc)
    */
+  @deprecated("use fromURL(s, enc)")
   def fromURL(s: String): Source =
     fromURL(new URL(s))
 
@@ -158,8 +158,8 @@ object Source {
   /**
    *  @param url  the source URL
    *  @return     ...
-   *  @deprecated use fromURL(url, enc)
    */
+  @deprecated("use fromURL(url, enc)")
   def fromURL(url: URL): Source = {
     val it = new Iterator[Char] {
       var data: Int = _
diff --git a/src/library/scala/package.scala b/src/library/scala/package.scala
index d4130b3920..7bec5ae8ac 100755
--- a/src/library/scala/package.scala
+++ b/src/library/scala/package.scala
@@ -2,10 +2,8 @@ package object scala {
   type Iterable[+A] = scala.collection.Iterable[A]
   val Iterable = scala.collection.Iterable
 
-  /** @deprecated  use Iterable instead */
-  @deprecated type Collection[+A] = Iterable[A]
-  /** @deprecated  use Iterable instead */
-  @deprecated val Collection = Iterable
+  @deprecated("use Iterable instead") type Collection[+A] = Iterable[A]
+  @deprecated("use Iterable instead") val Collection = Iterable
 
   type Seq[+A] = scala.collection.Sequence[A]
   val Seq = scala.collection.Sequence
diff --git a/src/library/scala/reflect/BeanInfo.scala b/src/library/scala/reflect/BeanInfo.scala
index eea808b6bd..a2249c818b 100644
--- a/src/library/scala/reflect/BeanInfo.scala
+++ b/src/library/scala/reflect/BeanInfo.scala
@@ -11,8 +11,8 @@
 package scala.reflect
 
 /** <p>
- *    This attribute indicates that a JavaBean-compliant BeanInfo
- *    class should be generated for this attributed Scala class.
+ *    This annotation indicates that a JavaBean-compliant BeanInfo
+ *    class should be generated for this annotated Scala class.
  *    A val becomes a read-only property. A var becomes a read-write
  *    property. A def becomes a method.
  *  </p>
diff --git a/src/library/scala/reflect/BeanInfoSkip.scala b/src/library/scala/reflect/BeanInfoSkip.scala
index b3c7a1dfa8..f7717a8825 100644
--- a/src/library/scala/reflect/BeanInfoSkip.scala
+++ b/src/library/scala/reflect/BeanInfoSkip.scala
@@ -10,7 +10,7 @@
 
 package scala.reflect
 
-/** This attribute indicates that bean information should
+/** This annotation indicates that bean information should
  *  <strong>not</strong> be generated for the val, var, or def that it is
  *  attached to.
  *
diff --git a/src/library/scala/reflect/BeanProperty.scala b/src/library/scala/reflect/BeanProperty.scala
index 6c432fbd03..1c75cb02fc 100644
--- a/src/library/scala/reflect/BeanProperty.scala
+++ b/src/library/scala/reflect/BeanProperty.scala
@@ -12,7 +12,7 @@
 package scala.reflect
 
 /** <p>
- *    This attribute adds a setter and a getter method, following the
+ *    This annotation adds a setter and a getter method, following the
  *    Java Bean convention (first letter of the property is capitalized)
  *    used by popular Java web frameworks. For example:
  *  </p><pre>
diff --git a/src/library/scala/runtime/BoxedArray.scala b/src/library/scala/runtime/BoxedArray.scala
index 91651a9cec..d13c08ba38 100644
--- a/src/library/scala/runtime/BoxedArray.scala
+++ b/src/library/scala/runtime/BoxedArray.scala
@@ -139,6 +139,6 @@ abstract class BoxedArray[A] extends Vector[A] with VectorTemplate[A, BoxedArray
     (count, memo)
   }
 
-  /** @deprecated use slice instead */
-  @deprecated def subArray(from: Int, end: Int): BoxedArray[A] = slice(from, end)
+  @deprecated("use slice instead")
+  def subArray(from: Int, end: Int): BoxedArray[A] = slice(from, end)
 }
diff --git a/src/library/scala/testing/SUnit.scala b/src/library/scala/testing/SUnit.scala
index 1a333397a7..2cb8517527 100644
--- a/src/library/scala/testing/SUnit.scala
+++ b/src/library/scala/testing/SUnit.scala
@@ -44,13 +44,10 @@ import scala.collection.mutable.ArrayBuffer
  *   a <code>main</code> method, for convenience.
  * </p>
  *
- * @deprecated SUnit will be removed in 2.8.0. There are several free and
- * sophisticated testing frameworks for Scala available, examples are
- * "ScalaTest", "ScalaCheck" or "Specs".
- *
  * @author Burak Emir
  */
-@deprecated
+@deprecated("SUnit will be removed in 2.8.0. There are several free and sophisticated testing\n"+
+            "frameworks for Scala available, examples are \"ScalaTest\", \"ScalaCheck\" or \"Specs\".")
 object SUnit {
 
   /** <p>
diff --git a/src/library/scala/unsealed.scala b/src/library/scala/unsealed.scala
index ad021eda1f..847c2d3e1d 100644
--- a/src/library/scala/unsealed.scala
+++ b/src/library/scala/unsealed.scala
@@ -11,7 +11,5 @@
 
 package scala
 
-/** @deprecated   use <a href="unchecked.html">
- *  <code>@unchecked</code></a> instead.
- */
-@deprecated class unsealed extends Annotation
+@deprecated("use `unchecked' instead")
+class unsealed extends Annotation
diff --git a/src/library/scala/util/parsing/input/CharArrayPosition.scala b/src/library/scala/util/parsing/input/CharArrayPosition.scala
index a465184bc0..54907e037e 100644
--- a/src/library/scala/util/parsing/input/CharArrayPosition.scala
+++ b/src/library/scala/util/parsing/input/CharArrayPosition.scala
@@ -18,9 +18,8 @@ package scala.util.parsing.input
  *  @param columm The column number of the position (1-based)
  *
  * @author Martin Odersky, Adriaan Moors
- * @deprecated; use OffsetPosition instead
  */
-@deprecated
+@deprecated("use OffsetPosition instead")
 class CharArrayPosition(val source: Array[Char], val line: Int, val column: Int) extends Position {
 
   // TODO: this could be implemented more high-level:
diff --git a/src/library/scala/util/parsing/input/CharArrayReader.scala b/src/library/scala/util/parsing/input/CharArrayReader.scala
index 8562ffe150..360820608c 100644
--- a/src/library/scala/util/parsing/input/CharArrayReader.scala
+++ b/src/library/scala/util/parsing/input/CharArrayReader.scala
@@ -17,8 +17,8 @@ package scala.util.parsing.input
 object CharArrayReader {
   final val EofCh = '\032'
 
-  /** @deprecated  This should probably be LF instead? */
-  @deprecated final val CR = '\015'
+  @deprecated("This should probably be LF instead?")
+  final val CR = '\015'
 }
 
 /** A character array reader reads a stream of characters (keeping track of their positions)
diff --git a/src/library/scala/xml/Utility.scala b/src/library/scala/xml/Utility.scala
index 635585f79c..42f71cd981 100644
--- a/src/library/scala/xml/Utility.scala
+++ b/src/library/scala/xml/Utility.scala
@@ -82,9 +82,8 @@ object Utility extends AnyRef with parsing.TokenTests
 	  case _ => n
   }
 
-  /** @deprecated a string might also be Atom(s) - define your own conversion
-   */
-  @deprecated def view(s: String): Text = Text(s)
+  @deprecated("a string might also be Atom(s) - define your own conversion")
+  def view(s: String): Text = Text(s)
 
   /**
    * Escapes the characters &lt; &gt; &amp; and &quot; from string.
author	Lukas Rytz <lukas.rytz@epfl.ch>	2009-05-30 18:10:21 +0000
committer	Lukas Rytz <lukas.rytz@epfl.ch>	2009-05-30 18:10:21 +0000
commit	c6cf4fc02204d20f792bd493641d8ccd12421800 (patch)
tree	a8827ab270cf77a1c5f36a48a8cf125e1bcfb8c3 /src/library
parent	ab9381b4539097205d19df235f8cc3a5b2349e95 (diff)
download	scala-c6cf4fc02204d20f792bd493641d8ccd12421800.tar.gz scala-c6cf4fc02204d20f792bd493641d8ccd12421800.tar.bz2 scala-c6cf4fc02204d20f792bd493641d8ccd12421800.zip