Warn when Any or AnyVal is inferred.

For the very small price of annotating types as Any/AnyVal in those
cases where we wish to use them, we can obtain useful warnings.
I made trunk clean against this warning and found several bugs
or at least suboptimalities in the process.

I put the warning behind -Xlint for the moment, but I think this
belongs on by default, even for this alone:

  scala> List(1, 2, 3) contains "a"
  <console>:8: warning: a type was inferred to be `Any`; this may indicate a programming error.
                List(1, 2, 3) contains "a"
                                       ^
  res0: Boolean = false

Or this punishment meted out by SI-4042:

  scala> 1l to 5l contains 5
  <console>:8: warning: a type was inferred to be `AnyVal`; this may indicate a programming error.
                1l to 5l contains 5
                                  ^
  res0: Boolean = false

A different situation where this arises, which I have seen variations
of many times:

  scala> class A[T](default: T) {
    def get(x: => Option[T]) = x getOrElse Some(default)
  }
  <console>:7: warning: a type was inferred to be `Any`; this may indicate a programming error.
         class A[T](default: T) { def get(x: => Option[T]) = x getOrElse Some(default) }
                                                                             ^
  // Oops, this was what I meant
  scala> class A[T](default: T) {
    def get(x: => Option[T]) = x getOrElse default
  }
  defined class A

Harder to avoid spurious warnings when "Object" is inferred.

1 files changed, 18 insertions, 46 deletions

diff --git a/src/library/scala/collection/parallel/ParIterableLike.scala b/src/library/scala/collection/parallel/ParIterableLike.scala
index 85758b29bc..4feff34751 100644
--- a/src/library/scala/collection/parallel/ParIterableLike.scala
+++ b/src/library/scala/collection/parallel/ParIterableLike.scala
@@ -171,9 +171,9 @@ self: ParIterableLike[T, Repr, Sequential] =>
 
   /** The task support object which is responsible for scheduling and
    *  load-balancing tasks to processors.
-   *                                                                              
+   *
    *  @see [[scala.collection.parallel.TaskSupport]]
-   */     
+   */
   def tasksupport = {
     val ts = _tasksupport
     if (ts eq null) {
@@ -188,18 +188,18 @@ self: ParIterableLike[T, Repr, Sequential] =>
    *  A task support object can be changed in a parallel collection after it
    *  has been created, but only during a quiescent period, i.e. while there
    *  are no concurrent invocations to parallel collection methods.
-   *                                                                              
-   *  Here is a way to change the task support of a parallel collection:          
-   *                                                                              
-   *  {{{                                                                         
-   *  import scala.collection.parallel._                                          
-   *  val pc = mutable.ParArray(1, 2, 3)                                          
-   *  pc.tasksupport = new ForkJoinTaskSupport(                                   
-   *    new scala.concurrent.forkjoin.ForkJoinPool(2))                            
-   *  }}}                                                                         
+   *
+   *  Here is a way to change the task support of a parallel collection:
+   *
+   *  {{{
+   *  import scala.collection.parallel._
+   *  val pc = mutable.ParArray(1, 2, 3)
+   *  pc.tasksupport = new ForkJoinTaskSupport(
+   *    new scala.concurrent.forkjoin.ForkJoinPool(2))
+   *  }}}
    *
    *  @see [[scala.collection.parallel.TaskSupport]]
-   */     
+   */
   def tasksupport_=(ts: TaskSupport) = _tasksupport = ts
 
   def seq: Sequential
@@ -877,13 +877,13 @@ self: ParIterableLike[T, Repr, Sequential] =>
   override def toSet[U >: T]: immutable.ParSet[U] = toParCollection[U, immutable.ParSet[U]](() => immutable.ParSet.newCombiner[U])
 
   override def toMap[K, V](implicit ev: T <:< (K, V)): immutable.ParMap[K, V] = toParMap[K, V, immutable.ParMap[K, V]](() => immutable.ParMap.newCombiner[K, V])
-  
+
   override def toVector: Vector[T] = to[Vector]
 
   override def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, T, Col[T @uncheckedVariance]]): Col[T @uncheckedVariance] = if (cbf().isCombiner) {
     toParCollection[T, Col[T]](() => cbf().asCombiner)
   } else seq.to(cbf)
-  
+
   /* tasks */
 
   protected trait StrictSplitterCheckTask[R, Tp] extends Task[R, Tp] {
@@ -935,8 +935,8 @@ self: ParIterableLike[T, Repr, Sequential] =>
   (f: First, s: Second)
   extends Composite[FR, SR, R, First, Second](f, s) {
     def leaf(prevr: Option[R]) = {
-      tasksupport.executeAndWaitResult(ft)
-      tasksupport.executeAndWaitResult(st)
+      tasksupport.executeAndWaitResult(ft) : Any
+      tasksupport.executeAndWaitResult(st) : Any
       mergeSubtasks
     }
   }
@@ -946,8 +946,8 @@ self: ParIterableLike[T, Repr, Sequential] =>
   (f: First, s: Second)
   extends Composite[FR, SR, R, First, Second](f, s) {
     def leaf(prevr: Option[R]) = {
-      val ftfuture = tasksupport.execute(ft)
-      tasksupport.executeAndWaitResult(st)
+      val ftfuture: () => Any = tasksupport.execute(ft)
+      tasksupport.executeAndWaitResult(st) : Any
       ftfuture()
       mergeSubtasks
     }
@@ -1504,31 +1504,3 @@ self: ParIterableLike[T, Repr, Sequential] =>
   })
 
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-