Merge pull request #1473 from soc/SI-6388-without-predef

SI-6388 Remove deprecated items scheduled for 2.11

9 files changed, 1 insertions, 426 deletions

diff --git a/src/library/scala/Application.scala b/src/library/scala/Application.scala
deleted file mode 100644
index 5b1098bd72..0000000000
--- a/src/library/scala/Application.scala
+++ /dev/null
@@ -1,79 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2002-2011, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-package scala
-
-import scala.compat.Platform.currentTime
-
-/** The `Application` trait can be used to quickly turn objects
- *  into executable programs, but is ''not recommended''.
- *  Here is an example:
- *  {{{
- *  object Main extends Application {
- *    Console.println("Hello World!")
- *  }
- *  }}}
- *  Here, object `Main` inherits the `main` method of `Application`.
- *  The body of the `Main` object defines the main program. This technique
- *  does not work if the main program depends on command-line arguments
- *  (which are not accessible with the technique presented here).
- *
- *  It is possible to time the execution of objects that inherit from class
- *  `Application` by setting the global `scala.time`
- *  property. Here is an example for benchmarking object `Main`:
- *  {{{
- *  java -Dscala.time Main
- *  }}}
- *  In practice the `Application` trait has a number of serious pitfalls:
- *
- *  - Threaded code that references the object will block until static
- *    initialization is complete.  However, because the entire execution
- *    of an `object` extending `Application` takes place during
- *    static initialization, concurrent code will ''always'' deadlock if
- *    it must synchronize with the enclosing object.
- *  - As described above, there is no way to obtain the
- *    command-line arguments because all code in body of an `object`
- *    extending `Application` is run as part of the static initialization
- *    which occurs before `Application`'s `main` method
- *    even begins execution.
- *  - Static initializers are run only once during program execution, and
- *    JVM authors usually assume their execution to be relatively short.
- *    Therefore, certain JVM configurations may become confused, or simply
- *    fail to optimize or JIT the code in the body of an `object` extending
- *    `Application`.  This can lead to a significant performance degradation.
- *
- *  It is recommended to use the [[scala.App]] trait instead.
- *  {{{
- *  object Main {
- *    def main(args: Array[String]) {
- *      //..
- *    }
- *  }
- *  }}}
- *
- *  @author  Matthias Zenger
- *  @version 1.0, 10/09/2003
- */
-@deprecated("use App instead", "2.9.0")
-trait Application {
-
-  /** The time when the execution of this program started,
-    * in milliseconds since 1 January 1970 UTC. */
-  val executionStart: Long = currentTime
-
-  /** The default main method.
-   *
-   *  @param args the arguments passed to the main method
-   */
-  def main(args: Array[String]) {
-    if (util.Properties propIsSet "scala.time") {
-      val total = currentTime - executionStart
-      Console.println("[total " + total + "ms]")
-    }
-  }
-}
diff --git a/src/library/scala/collection/JavaConversions.scala b/src/library/scala/collection/JavaConversions.scala
index 8e4fdf537d..173ce2d71d 100644
--- a/src/library/scala/collection/JavaConversions.scala
+++ b/src/library/scala/collection/JavaConversions.scala
@@ -91,42 +91,6 @@ object JavaConversions extends WrapAsScala with WrapAsJava {
   @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val MutableSeqWrapper            = Wrappers.MutableSeqWrapper
   @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val MutableSetWrapper            = Wrappers.MutableSetWrapper
   @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val SeqWrapper                   = Wrappers.SeqWrapper
-
-  // Note to implementors: the cavalcade of deprecated methods herein should
-  // serve as a warning to any who follow: don't overload implicit methods.
-
-  @deprecated("use bufferAsJavaList instead", "2.9.0")
-  def asJavaList[A](b : mutable.Buffer[A]): ju.List[A] = bufferAsJavaList[A](b)
-
-  @deprecated("use mutableSeqAsJavaList instead", "2.9.0")
-  def asJavaList[A](b : mutable.Seq[A]): ju.List[A] = mutableSeqAsJavaList[A](b)
-
-  @deprecated("use seqAsJavaList instead", "2.9.0")
-  def asJavaList[A](b : Seq[A]): ju.List[A] = seqAsJavaList[A](b)
-
-  @deprecated("use mutableSetAsJavaSet instead", "2.9.0")
-  def asJavaSet[A](s : mutable.Set[A]): ju.Set[A] = mutableSetAsJavaSet[A](s)
-
-  @deprecated("use setAsJavaSet instead", "2.9.0")
-  def asJavaSet[A](s: Set[A]): ju.Set[A] = setAsJavaSet[A](s)
-
-  @deprecated("use mutableMapAsJavaMap instead", "2.9.0")
-  def asJavaMap[A, B](m : mutable.Map[A, B]): ju.Map[A, B] = mutableMapAsJavaMap[A, B](m)
-
-  @deprecated("use mapAsJavaMap instead", "2.9.0")
-  def asJavaMap[A, B](m : Map[A, B]): ju.Map[A, B] = mapAsJavaMap[A, B](m)
-
-  @deprecated("use iterableAsScalaIterable instead", "2.9.0")
-  def asScalaIterable[A](i : jl.Iterable[A]): Iterable[A] = iterableAsScalaIterable[A](i)
-
-  @deprecated("use collectionAsScalaIterable instead", "2.9.0")
-  def asScalaIterable[A](i : ju.Collection[A]): Iterable[A] = collectionAsScalaIterable[A](i)
-
-  @deprecated("use mapAsScalaMap instead", "2.9.0")
-  def asScalaMap[A, B](m: ju.Map[A, B]): mutable.Map[A, B] = mapAsScalaMap[A, B](m)
-
-  @deprecated("use propertiesAsScalaMap instead", "2.9.0")
-  def asScalaMap(p: ju.Properties): mutable.Map[String, String] = propertiesAsScalaMap(p)
 }
 
 
diff --git a/src/library/scala/collection/JavaConverters.scala b/src/library/scala/collection/JavaConverters.scala
index f8a9466caf..98afffe3b4 100755
--- a/src/library/scala/collection/JavaConverters.scala
+++ b/src/library/scala/collection/JavaConverters.scala
@@ -67,37 +67,4 @@ object JavaConverters extends DecorateAsJava with DecorateAsScala {
   type AsJavaEnumeration[A] = Decorators.AsJavaEnumeration[A]
   @deprecated("Don't access these decorators directly.", "2.10.0")
   type AsJavaDictionary[A, B]  = Decorators.AsJavaDictionary[A, B]
-
-  @deprecated("Use bufferAsJavaListConverter instead", "2.9.0")
-  def asJavaListConverter[A](b : mutable.Buffer[A]): AsJava[ju.List[A]] = bufferAsJavaListConverter(b)
-
-  @deprecated("Use mutableSeqAsJavaListConverter instead", "2.9.0")
-  def asJavaListConverter[A](b : mutable.Seq[A]): AsJava[ju.List[A]] = mutableSeqAsJavaListConverter(b)
-
-  @deprecated("Use seqAsJavaListConverter instead", "2.9.0")
-  def asJavaListConverter[A](b : Seq[A]): AsJava[ju.List[A]] = seqAsJavaListConverter(b)
-
-  @deprecated("Use mutableSetAsJavaSetConverter instead", "2.9.0")
-  def asJavaSetConverter[A](s : mutable.Set[A]): AsJava[ju.Set[A]] = mutableSetAsJavaSetConverter(s)
-
-  @deprecated("Use setAsJavaSetConverter instead", "2.9.0")
-  def asJavaSetConverter[A](s : Set[A]): AsJava[ju.Set[A]] = setAsJavaSetConverter(s)
-
-  @deprecated("use mutableMapAsJavaMapConverter instead", "2.9.0")
-  def asJavaMapConverter[A, B](m : mutable.Map[A, B]): AsJava[ju.Map[A, B]] = mutableMapAsJavaMapConverter(m)
-
-  @deprecated("Use mapAsJavaMapConverter instead", "2.9.0")
-  def asJavaMapConverter[A, B](m : Map[A, B]): AsJava[ju.Map[A, B]] = mapAsJavaMapConverter(m)
-
-  @deprecated("Use iterableAsScalaIterableConverter instead", "2.9.0")
-  def asScalaIterableConverter[A](i : jl.Iterable[A]): AsScala[Iterable[A]] = iterableAsScalaIterableConverter(i)
-
-  @deprecated("Use collectionAsScalaIterableConverter instead", "2.9.0")
-  def asScalaIterableConverter[A](i : ju.Collection[A]): AsScala[Iterable[A]] = collectionAsScalaIterableConverter(i)
-
-  @deprecated("Use mapAsScalaMapConverter instead", "2.9.0")
-  def asScalaMapConverter[A, B](m : ju.Map[A, B]): AsScala[mutable.Map[A, B]] = mapAsScalaMapConverter(m)
-
-  @deprecated("Use propertiesAsScalaMapConverter instead", "2.9.0")
-  def asScalaMapConverter(p: ju.Properties): AsScala[mutable.Map[String, String]] = propertiesAsScalaMapConverter(p)
 }
diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala
index 83da68eb68..47cac9a1d5 100644
--- a/src/library/scala/collection/immutable/List.scala
+++ b/src/library/scala/collection/immutable/List.scala
@@ -311,9 +311,6 @@ sealed abstract class List[+A] extends AbstractSeq[A]
   override def toStream : Stream[A] =
     if (isEmpty) Stream.Empty
     else new Stream.Cons(head, tail.toStream)
-
-  @deprecated("use `distinct` instead", "2.8.0")
-  def removeDuplicates: List[A] = distinct
 }
 
 /** The empty list.
@@ -407,248 +404,6 @@ object List extends SeqFactory[List] {
   override def empty[A]: List[A] = Nil
 
   override def apply[A](xs: A*): List[A] = xs.toList
-
-  /** Create a sorted list with element values `v,,>n+1,, = step(v,,n,,)`
-   * where `v,,0,, = start` and elements are in the range between `start`
-   * (inclusive) and `end` (exclusive).
-   *
-   *  @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 `v,,n,,`,
-   *              computes `v,,n+1,,`. Must be monotonically increasing
-   *              or decreasing.
-   *  @return     the sorted list of all integers in range `[start;end)`.
-   */
-  @deprecated("use `iterate` instead", "2.8.0")
-  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]
-    var i = start
-    while ((!up || i < end) && (!down || i > end)) {
-      b += i
-      val next = step(i)
-      if (i == next)
-        throw new IllegalArgumentException("the step function did not make any progress on "+ i)
-      i = next
-    }
-    b.toList
-  }
-
-  /** Create a list containing several copies of an element.
-   *
-   *  @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("use `fill` instead", "2.8.0")
-  def make[A](n: Int, elem: A): List[A] = {
-    val b = new ListBuffer[A]
-    var i = 0
-    while (i < n) {
-      b += elem
-      i += 1
-    }
-    b.toList
-  }
-
-  /** Concatenate all the elements of a given list of lists.
-   *
-   *  @param xss the list of lists that are to be concatenated
-   *  @return    the concatenation of all the lists
-   */
-  @deprecated("use `xss.flatten` instead of `List.flatten(xss)`", "2.8.0")
-  def flatten[A](xss: List[List[A]]): List[A] = {
-    val b = new ListBuffer[A]
-    for (xs <- xss) {
-      var xc = xs
-      while (!xc.isEmpty) {
-        b += xc.head
-        xc = xc.tail
-      }
-    }
-    b.toList
-  }
-
-  /** Transforms a list of pairs into a pair of lists.
-   *
-   *  @param xs the list of pairs to unzip
-   *  @return a pair of lists.
-   */
-  @deprecated("use `xs.unzip` instead of `List.unzip(xs)`", "2.8.0")
-  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
-    while (!xc.isEmpty) {
-      b1 += xc.head._1
-      b2 += xc.head._2
-      xc = xc.tail
-    }
-    (b1.toList, b2.toList)
-  }
-
-  /** Transforms an iterable of pairs into a pair of lists.
-   *
-   *  @param xs the iterable of pairs to unzip
-   *  @return a pair of lists.
-   */
-  @deprecated("use `xs.unzip` instead of `List.unzip(xs)`", "2.8.0")
-  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 `Left` values in the given `Iterable` of `Either`s.
-   */
-  @deprecated("use `xs collect { case Left(x: A) => x }` instead of `List.lefts(xs)`", "2.8.0")
-  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
-    })
-
-  /**
-   * Returns the `Right` values in the given `Iterable` of  `Either`s.
-   */
-  @deprecated("use `xs collect { case Right(x: B) => x }` instead of `List.rights(xs)`", "2.8.0")
-  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
-    })
-
-  /** Transforms an Iterable of Eithers into a pair of lists.
-   *
-   *  @param es the iterable of Eithers to separate
-   *  @return a pair of lists.
-   */
-  @deprecated("use `(for (Left(x) <- es) yield x, for (Right(x) <- es) yield x)` instead", "2.8.0")
-  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)
-    }
-
-  /** Converts an iterator to a list.
-   *
-   *  @param it the iterator to convert
-   *  @return   a list that contains the elements returned by successive
-   *            calls to `it.next`
-   */
-  @deprecated("use `it.toList` instead of `List.toList(it)`", "2.8.0")
-  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 `arr`
-   *             in the same order
-   */
-  @deprecated("use `array.toList` instead of `List.fromArray(array)`", "2.8.0")
-  def fromArray[A](arr: Array[A]): List[A] = fromArray(arr, 0, arr.length)
-
-  /** Converts a range of an array into a list.
-   *
-   *  @param arr   the array to convert
-   *  @param start the first index to consider
-   *  @param len   the length of the range to convert
-   *  @return      a list that contains the same elements than `arr`
-   *               in the same order
-   */
-  @deprecated("use `array.view(start, end).toList` instead of `List.fromArray(array, start, end)`", "2.8.0")
-  def fromArray[A](arr: Array[A], start: Int, len: Int): List[A] = {
-    var res: List[A] = Nil
-    var i = start + len
-    while (i > start) {
-      i -= 1
-      res = arr(i) :: res
-    }
-    res
-  }
-
-  /** Returns the list resulting from applying the given function `f`
-   *  to corresponding elements of the argument lists.
-   *
-   *  @param f function to apply to each pair of elements.
-   *  @return `[f(a,,0,,,b,,0,,), ..., f(a,,n,,,b,,n,,)]` if the lists are
-   *          `[a,,0,,, ..., a,,k,,]`, `[b,,0,,, ..., b,,l,,]` and
-   *          `n = min(k,l)`
-   */
-  @deprecated("use `(xs, ys).zipped.map(f)` instead of `List.map2(xs, ys)(f)`", "2.8.0")
-  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
-    while (!xc.isEmpty && !yc.isEmpty) {
-      b += f(xc.head, yc.head)
-      xc = xc.tail
-      yc = yc.tail
-    }
-    b.toList
-  }
-
-  /** Tests whether the given predicate `p` holds
-   *  for all corresponding elements of the argument lists.
-   *
-   *  @param f function to apply to each pair of elements.
-   *  @return  `(p(a<sub>0</sub>,b<sub>0</sub>) &amp;&amp;
-   *           ... &amp;&amp; p(a<sub>n</sub>,b<sub>n</sub>))]`
-   *           if the lists are `[a<sub>0</sub>, ..., a<sub>k</sub>]`;
-   *           `[b<sub>0</sub>, ..., b<sub>l</sub>]`
-   *           and `n = min(k,l)`
-   */
-  @deprecated("use `(xs, ys).zipped.forall(f)` instead of `List.forall2(xs, ys)(f)`", "2.8.0")
-  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) {
-      if (!f(xc.head, yc.head)) return false
-      xc = xc.tail
-      yc = yc.tail
-    }
-    true
-  }
-
-  /** Tests whether the given predicate `p` holds
-   *  for some corresponding elements of the argument lists.
-   *
-   *  @param f function to apply to each pair of elements.
-   *  @return  `n != 0 &amp;&amp; (p(a<sub>0</sub>,b<sub>0</sub>) ||
-   *           ... || p(a<sub>n</sub>,b<sub>n</sub>))]` if the lists are
-   *           `[a<sub>0</sub>, ..., a<sub>k</sub>]`,
-   *           `[b<sub>0</sub>, ..., b<sub>l</sub>]` and
-   *           `n = min(k,l)`
-   */
-  @deprecated("use `(xs, ys).zipped.exists(f)` instead of `List.exists2(xs, ys)(f)`", "2.8.0")
-  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) {
-      if (f(xc.head, yc.head)) return true
-      xc = xc.tail
-      yc = yc.tail
-    }
-    false
-  }
-
-  /** Transposes a list of lists.
-   *  pre: All element lists have the same length.
-   *
-   *  @param xss the list of lists
-   *  @return    the transposed list of lists
-   */
-  @deprecated("use `xss.transpose` instead of `List.transpose(xss)`", "2.8.0")
-  def transpose[A](xss: List[List[A]]): List[List[A]] = {
-    val buf = new ListBuffer[List[A]]
-    var yss = xss
-    while (!yss.head.isEmpty) {
-      buf += (yss map (_.head))
-      yss = (yss map (_.tail))
-    }
-    buf.toList
-  }
 }
 
 /** Only used for list serialization */
diff --git a/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala b/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala
index bc32537798..120b3d66a0 100644
--- a/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala
+++ b/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala
@@ -73,14 +73,6 @@ class SynchronizedPriorityQueue[A](implicit ord: Ordering[A]) extends PriorityQu
    */
   override def head: A = synchronized { super.head }
 
-  /** Returns the element with the highest priority in the queue,
-   *  or throws an error if there is no element contained in the queue.
-   *
-   *  @return   the element with the highest priority.
-   */
-  @deprecated("Use `head` instead.", "2.9.0")
-  override def max: A = synchronized { super.max }
-
   /** Removes all elements from the queue. After this operation is completed,
    *  the queue will be empty.
    */
diff --git a/src/library/scala/io/Position.scala b/src/library/scala/io/Position.scala
index dae478f31a..8c2d62f5b1 100644
--- a/src/library/scala/io/Position.scala
+++ b/src/library/scala/io/Position.scala
@@ -68,14 +68,6 @@ abstract class Position {
 }
 
 object Position extends Position {
-  /** The undefined position */
-  @deprecated("This will be removed", "2.9.0")
-  final val NOPOS = 0
-
-  /** The first position in a source file */
-  @deprecated("This will be removed", "2.9.0")
-  final val FIRSTPOS = encode(1, 1)
-
   def checkInput(line: Int, column: Int) {
     if (line < 0)
       throw new IllegalArgumentException(line + " < 0")
diff --git a/src/library/scala/math/BigDecimal.scala b/src/library/scala/math/BigDecimal.scala
index eb73d58d1c..a721fd647c 100644
--- a/src/library/scala/math/BigDecimal.scala
+++ b/src/library/scala/math/BigDecimal.scala
@@ -25,12 +25,6 @@ object BigDecimal {
   private val maxCached = 512
   val defaultMathContext = MathContext.DECIMAL128
 
-  @deprecated("Use Long.MinValue", "2.9.0")
-  val MinLong = new BigDecimal(BigDec valueOf Long.MinValue, defaultMathContext)
-
-  @deprecated("Use Long.MaxValue", "2.9.0")
-  val MaxLong = new BigDecimal(BigDec valueOf Long.MaxValue, defaultMathContext)
-
   /** Cache ony for defaultMathContext using BigDecimals in a small range. */
   private lazy val cache = new Array[BigDecimal](maxCached - minCached + 1)
 
diff --git a/src/library/scala/math/BigInt.scala b/src/library/scala/math/BigInt.scala
index 3eb41053f7..9218e41ceb 100644
--- a/src/library/scala/math/BigInt.scala
+++ b/src/library/scala/math/BigInt.scala
@@ -23,12 +23,6 @@ object BigInt {
   private val cache = new Array[BigInt](maxCached - minCached + 1)
   private val minusOne = BigInteger.valueOf(-1)
 
-  @deprecated("Use Long.MinValue", "2.9.0")
-  val MinLong = BigInt(Long.MinValue)
-
-  @deprecated("Use Long.MaxValue", "2.9.0")
-  val MaxLong = BigInt(Long.MaxValue)
-
   /** Constructs a `BigInt` whose value is equal to that of the
    *  specified integer value.
    *
diff --git a/src/library/scala/package.scala b/src/library/scala/package.scala
index a41cdedfa9..9b7ca64b7e 100644
--- a/src/library/scala/package.scala
+++ b/src/library/scala/package.scala
@@ -34,9 +34,6 @@ package object scala {
     override def toString = "object AnyRef"
   }
 
-  @deprecated("instead of `@serializable class C`, use `class C extends Serializable`", "2.9.0")
-  type serializable = annotation.serializable
-
   @deprecated("instead of `@cloneable class C`, use `class C extends Cloneable`", "2.10.0")
   type cloneable = annotation.cloneable
 
@@ -126,9 +123,8 @@ package object scala {
   type deprecatedName = annotation.deprecatedName
   type inline = annotation.inline
   type native = annotation.native
-  type noinline = noannotation.inline
+  type noinline = annotation.noinline
   type remote = annotation.remote
-  type serializable = annotation.serializable
   type specialized = annotation.specialized
   type transient = annotation.transient
   type throws  = annotation.throws