More explicit empty paren lists in method calls.

15 files changed, 82 insertions, 82 deletions

diff --git a/src/library/scala/collection/parallel/Combiner.scala b/src/library/scala/collection/parallel/Combiner.scala
index 00993c09ff..00e20e7616 100644
--- a/src/library/scala/collection/parallel/Combiner.scala
+++ b/src/library/scala/collection/parallel/Combiner.scala
@@ -86,7 +86,7 @@ trait Combiner[-Elem, +To] extends Builder[Elem, To] with Sizing with Parallel {
    *  if this is applicable.
    */
   def resultWithTaskSupport: To = {
-    val res = result
+    val res = result()
     setTaskSupport(res, combinerTaskSupport)
   }
   
diff --git a/src/library/scala/collection/parallel/ParIterableLike.scala b/src/library/scala/collection/parallel/ParIterableLike.scala
index 33af99067d..f0b0fd2aa0 100644
--- a/src/library/scala/collection/parallel/ParIterableLike.scala
+++ b/src/library/scala/collection/parallel/ParIterableLike.scala
@@ -214,7 +214,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
 
   def nonEmpty = size != 0
 
-  def head = iterator.next
+  def head = iterator.next()
 
   def headOption = if (nonEmpty) Some(head) else None
 
@@ -627,7 +627,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
       val b = bf(repr)
       this.splitter.copy2builder[U, That, Builder[U, That]](b)
       for (elem <- that.seq) b += elem
-      setTaskSupport(b.result, tasksupport)
+      setTaskSupport(b.result(), tasksupport)
     }
   }
 
@@ -728,7 +728,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
         tree => tasksupport.executeAndWaitResult(new FromScanTree(tree, z, op, combinerFactory(() => bf(repr).asCombiner)) mapResult {
           cb => cb.resultWithTaskSupport
         })
-      }) else setTaskSupport((bf(repr) += z).result, tasksupport)
+      }) else setTaskSupport((bf(repr) += z).result(), tasksupport)
     } else setTaskSupport(seq.scan(z)(op)(bf2seq(bf)), tasksupport)
   } else setTaskSupport(seq.scan(z)(op)(bf2seq(bf)), tasksupport)
 
@@ -904,7 +904,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
     protected[this] def newSubtask(p: IterableSplitter[T]): Accessor[R, Tp]
     def shouldSplitFurther = pit.shouldSplitFurther(self.repr, tasksupport.parallelismLevel)
     def split = pit.splitWithSignalling.map(newSubtask(_)) // default split procedure
-    private[parallel] override def signalAbort = pit.abort
+    private[parallel] override def signalAbort = pit.abort()
     override def toString = this.getClass.getSimpleName + "(" + pit.toString + ")(" + result + ")(supername: " + super.toString + ")"
   }
 
@@ -921,8 +921,8 @@ self: ParIterableLike[T, Repr, Sequential] =>
     def combineResults(fr: FR, sr: SR): R
     @volatile var result: R = null.asInstanceOf[R]
     private[parallel] override def signalAbort() {
-      ft.signalAbort
-      st.signalAbort
+      ft.signalAbort()
+      st.signalAbort()
     }
     protected def mergeSubtasks() {
       ft mergeThrowables st
@@ -938,7 +938,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
     def leaf(prevr: Option[R]) = {
       tasksupport.executeAndWaitResult(ft) : Any
       tasksupport.executeAndWaitResult(st) : Any
-      mergeSubtasks
+      mergeSubtasks()
     }
   }
 
@@ -950,7 +950,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
       val ftfuture: () => Any = tasksupport.execute(ft)
       tasksupport.executeAndWaitResult(st) : Any
       ftfuture()
-      mergeSubtasks
+      mergeSubtasks()
     }
   }
 
@@ -963,7 +963,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
       result = map(initialResult)
     }
     private[parallel] override def signalAbort() {
-      inner.signalAbort
+      inner.signalAbort()
     }
     override def requiresStrictSplitters = inner.requiresStrictSplitters
   }
@@ -1085,7 +1085,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
   protected[this] class Forall(pred: T => Boolean, protected[this] val pit: IterableSplitter[T])
   extends Accessor[Boolean, Forall] {
     @volatile var result: Boolean = true
-    def leaf(prev: Option[Boolean]) = { if (!pit.isAborted) result = pit.forall(pred); if (result == false) pit.abort }
+    def leaf(prev: Option[Boolean]) = { if (!pit.isAborted) result = pit.forall(pred); if (result == false) pit.abort() }
     protected[this] def newSubtask(p: IterableSplitter[T]) = new Forall(pred, p)
     override def merge(that: Forall) = result = result && that.result
   }
@@ -1093,7 +1093,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
   protected[this] class Exists(pred: T => Boolean, protected[this] val pit: IterableSplitter[T])
   extends Accessor[Boolean, Exists] {
     @volatile var result: Boolean = false
-    def leaf(prev: Option[Boolean]) = { if (!pit.isAborted) result = pit.exists(pred); if (result == true) pit.abort }
+    def leaf(prev: Option[Boolean]) = { if (!pit.isAborted) result = pit.exists(pred); if (result == true) pit.abort() }
     protected[this] def newSubtask(p: IterableSplitter[T]) = new Exists(pred, p)
     override def merge(that: Exists) = result = result || that.result
   }
@@ -1101,7 +1101,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
   protected[this] class Find[U >: T](pred: T => Boolean, protected[this] val pit: IterableSplitter[T])
   extends Accessor[Option[U], Find[U]] {
     @volatile var result: Option[U] = None
-    def leaf(prev: Option[Option[U]]) = { if (!pit.isAborted) result = pit.find(pred); if (result != None) pit.abort }
+    def leaf(prev: Option[Option[U]]) = { if (!pit.isAborted) result = pit.find(pred); if (result != None) pit.abort() }
     protected[this] def newSubtask(p: IterableSplitter[T]) = new Find(pred, p)
     override def merge(that: Find[U]) = if (this.result == None) result = that.result
   }
@@ -1153,7 +1153,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
       // note: HashMapCombiner doesn't merge same keys until evaluation
       val cb = mcf()
       while (pit.hasNext) {
-        val elem = pit.next
+        val elem = pit.next()
         cb += f(elem) -> elem
       }
       result = cb
@@ -1489,7 +1489,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
   def debugBuffer: ArrayBuffer[String] = null
 
   private[parallel] def debugclear() = synchronized {
-    debugBuffer.clear
+    debugBuffer.clear()
   }
 
   private[parallel] def debuglog(s: String) = synchronized {
diff --git a/src/library/scala/collection/parallel/ParIterableViewLike.scala b/src/library/scala/collection/parallel/ParIterableViewLike.scala
index b2105e1e9e..aaf83e49af 100644
--- a/src/library/scala/collection/parallel/ParIterableViewLike.scala
+++ b/src/library/scala/collection/parallel/ParIterableViewLike.scala
@@ -140,7 +140,7 @@ self =>
   } otherwise {
     val b = bf(underlying)
     b ++= this.iterator
-    b.result
+    b.result()
   }
 
   /* wrapper virtual ctors */
diff --git a/src/library/scala/collection/parallel/ParMapLike.scala b/src/library/scala/collection/parallel/ParMapLike.scala
index 56594bec96..798ba71b95 100644
--- a/src/library/scala/collection/parallel/ParMapLike.scala
+++ b/src/library/scala/collection/parallel/ParMapLike.scala
@@ -67,7 +67,7 @@ self =>
       i =>
       val iter = s
       def hasNext = iter.hasNext
-      def next() = iter.next._1
+      def next() = iter.next()._1
       def split = {
         val ss = iter.split.map(keysIterator(_))
         ss.foreach { _.signalDelegate = i.signalDelegate }
@@ -84,7 +84,7 @@ self =>
       i =>
       val iter = s
       def hasNext = iter.hasNext
-      def next() = iter.next._2
+      def next() = iter.next()._2
       def split = {
         val ss = iter.split.map(valuesIterator(_))
         ss.foreach { _.signalDelegate = i.signalDelegate }
diff --git a/src/library/scala/collection/parallel/ParSeqLike.scala b/src/library/scala/collection/parallel/ParSeqLike.scala
index 4aaadbaac5..68bc1bc12c 100644
--- a/src/library/scala/collection/parallel/ParSeqLike.scala
+++ b/src/library/scala/collection/parallel/ParSeqLike.scala
@@ -68,7 +68,7 @@ self =>
       val x = self(i)
       i += 1
       x
-    } else Iterator.empty.next
+    } else Iterator.empty.next()
 
     def head = self(i)
 
@@ -228,7 +228,7 @@ self =>
     b ++= pits(0)
     b ++= patch
     b ++= pits(2)
-    setTaskSupport(b.result, tasksupport)
+    setTaskSupport(b.result(), tasksupport)
   }
 
   def updated[U >: T, That](index: Int, elem: U)(implicit bf: CanBuildFrom[Repr, U, That]): That = if (bf(repr).isCombiner) {
@@ -423,7 +423,7 @@ self =>
     @volatile var result: Boolean = true
     def leaf(prev: Option[Boolean]) = if (!pit.isAborted) {
       result = pit.sameElements(otherpit)
-      if (!result) pit.abort
+      if (!result) pit.abort()
     }
     protected[this] def newSubtask(p: SuperParIterator) = unsupported
     override def split = {
@@ -471,7 +471,7 @@ self =>
     @volatile var result: Boolean = true
     def leaf(prev: Option[Boolean]) = if (!pit.isAborted) {
       result = pit.corresponds(corr)(otherpit)
-      if (!result) pit.abort
+      if (!result) pit.abort()
     }
     protected[this] def newSubtask(p: SuperParIterator) = unsupported
     override def split = {
diff --git a/src/library/scala/collection/parallel/ParSeqViewLike.scala b/src/library/scala/collection/parallel/ParSeqViewLike.scala
index d03b377860..22773464ed 100644
--- a/src/library/scala/collection/parallel/ParSeqViewLike.scala
+++ b/src/library/scala/collection/parallel/ParSeqViewLike.scala
@@ -173,7 +173,7 @@ self =>
   } otherwise {
     val b = bf(underlying)
     b ++= this.iterator
-    b.result
+    b.result()
   }
 
   /* tasks */
diff --git a/src/library/scala/collection/parallel/RemainsIterator.scala b/src/library/scala/collection/parallel/RemainsIterator.scala
index 726f5a2e93..a3a47e2e40 100644
--- a/src/library/scala/collection/parallel/RemainsIterator.scala
+++ b/src/library/scala/collection/parallel/RemainsIterator.scala
@@ -47,47 +47,47 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
 
   override def count(p: T => Boolean): Int = {
     var i = 0
-    while (hasNext) if (p(next)) i += 1
+    while (hasNext) if (p(next())) i += 1
     i
   }
 
   override def reduce[U >: T](op: (U, U) => U): U = {
-    var r: U = next
-    while (hasNext) r = op(r, next)
+    var r: U = next()
+    while (hasNext) r = op(r, next())
     r
   }
 
   override def fold[U >: T](z: U)(op: (U, U) => U): U = {
     var r = z
-    while (hasNext) r = op(r, next)
+    while (hasNext) r = op(r, next())
     r
   }
 
   override def sum[U >: T](implicit num: Numeric[U]): U = {
     var r: U = num.zero
-    while (hasNext) r = num.plus(r, next)
+    while (hasNext) r = num.plus(r, next())
     r
   }
 
   override def product[U >: T](implicit num: Numeric[U]): U = {
     var r: U = num.one
-    while (hasNext) r = num.times(r, next)
+    while (hasNext) r = num.times(r, next())
     r
   }
 
   override def min[U >: T](implicit ord: Ordering[U]): T = {
-    var r = next
+    var r = next()
     while (hasNext) {
-      val curr = next
+      val curr = next()
       if (ord.lteq(curr, r)) r = curr
     }
     r
   }
 
   override def max[U >: T](implicit ord: Ordering[U]): T = {
-    var r = next
+    var r = next()
     while (hasNext) {
-      val curr = next
+      val curr = next()
       if (ord.gteq(curr, r)) r = curr
     }
     r
@@ -97,16 +97,16 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
     var i = from
     val until = from + len
     while (i < until && hasNext) {
-      array(i) = next
+      array(i) = next()
       i += 1
     }
   }
 
   def reduceLeft[U >: T](howmany: Int, op: (U, U) => U): U = {
     var i = howmany - 1
-    var u: U = next
+    var u: U = next()
     while (i > 0 && hasNext) {
-      u = op(u, next)
+      u = op(u, next())
       i -= 1
     }
     u
@@ -117,7 +117,7 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
   def map2combiner[S, That](f: T => S, cb: Combiner[S, That]): Combiner[S, That] = {
     //val cb = pbf(repr)
     if (isRemainingCheap) cb.sizeHint(remaining)
-    while (hasNext) cb += f(next)
+    while (hasNext) cb += f(next())
     cb
   }
 
@@ -125,7 +125,7 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
     //val cb = pbf(repr)
     val runWith = pf.runWith(cb += _)
     while (hasNext) {
-      val curr = next
+      val curr = next()
       runWith(curr)
     }
     cb
@@ -134,7 +134,7 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
   def flatmap2combiner[S, That](f: T => GenTraversableOnce[S], cb: Combiner[S, That]): Combiner[S, That] = {
     //val cb = pbf(repr)
     while (hasNext) {
-      val traversable = f(next).seq
+      val traversable = f(next()).seq
       if (traversable.isInstanceOf[Iterable[_]]) cb ++= traversable.asInstanceOf[Iterable[S]].iterator
       else cb ++= traversable
     }
@@ -149,7 +149,7 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
 
   def filter2combiner[U >: T, This](pred: T => Boolean, cb: Combiner[U, This]): Combiner[U, This] = {
     while (hasNext) {
-      val curr = next
+      val curr = next()
       if (pred(curr)) cb += curr
     }
     cb
@@ -157,7 +157,7 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
 
   def filterNot2combiner[U >: T, This](pred: T => Boolean, cb: Combiner[U, This]): Combiner[U, This] = {
     while (hasNext) {
-      val curr = next
+      val curr = next()
       if (!pred(curr)) cb += curr
     }
     cb
@@ -165,7 +165,7 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
 
   def partition2combiners[U >: T, This](pred: T => Boolean, btrue: Combiner[U, This], bfalse: Combiner[U, This]) = {
     while (hasNext) {
-      val curr = next
+      val curr = next()
       if (pred(curr)) btrue += curr
       else bfalse += curr
     }
@@ -215,7 +215,7 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
   def takeWhile2combiner[U >: T, This](p: T => Boolean, cb: Combiner[U, This]) = {
     var loop = true
     while (hasNext && loop) {
-      val curr = next
+      val curr = next()
       if (p(curr)) cb += curr
       else loop = false
     }
@@ -225,7 +225,7 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
   def span2combiners[U >: T, This](p: T => Boolean, before: Combiner[U, This], after: Combiner[U, This]) = {
     var isBefore = true
     while (hasNext && isBefore) {
-      val curr = next
+      val curr = next()
       if (p(curr)) before += curr
       else {
         if (isRemainingCheap) after.sizeHint(remaining + 1)
@@ -241,7 +241,7 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
     var last = z
     var i = from
     while (hasNext) {
-      last = op(last, next)
+      last = op(last, next())
       array(i) = last
       i += 1
     }
@@ -250,7 +250,7 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
   def scanToCombiner[U >: T, That](startValue: U, op: (U, U) => U, cb: Combiner[U, That]) = {
     var curr = startValue
     while (hasNext) {
-      curr = op(curr, next)
+      curr = op(curr, next())
       cb += curr
     }
     cb
@@ -260,7 +260,7 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
     var curr = startValue
     var left = howmany
     while (left > 0) {
-      curr = op(curr, next)
+      curr = op(curr, next())
       cb += curr
       left -= 1
     }
@@ -270,16 +270,16 @@ private[collection] trait AugmentedIterableIterator[+T] extends RemainsIterator[
   def zip2combiner[U >: T, S, That](otherpit: RemainsIterator[S], cb: Combiner[(U, S), That]): Combiner[(U, S), That] = {
     if (isRemainingCheap && otherpit.isRemainingCheap) cb.sizeHint(remaining min otherpit.remaining)
     while (hasNext && otherpit.hasNext) {
-      cb += ((next, otherpit.next))
+      cb += ((next(), otherpit.next()))
     }
     cb
   }
 
   def zipAll2combiner[U >: T, S, That](that: RemainsIterator[S], thiselem: U, thatelem: S, cb: Combiner[(U, S), That]): Combiner[(U, S), That] = {
     if (isRemainingCheap && that.isRemainingCheap) cb.sizeHint(remaining max that.remaining)
-    while (this.hasNext && that.hasNext) cb += ((this.next, that.next))
-    while (this.hasNext) cb += ((this.next, thatelem))
-    while (that.hasNext) cb += ((thiselem, that.next))
+    while (this.hasNext && that.hasNext) cb += ((this.next(), that.next()))
+    while (this.hasNext) cb += ((this.next(), thatelem))
+    while (that.hasNext) cb += ((thiselem, that.next()))
     cb
   }
 
@@ -299,7 +299,7 @@ private[collection] trait AugmentedSeqIterator[+T] extends AugmentedIterableIter
     var total = 0
     var loop = true
     while (hasNext && loop) {
-      if (pred(next)) total += 1
+      if (pred(next())) total += 1
       else loop = false
     }
     total
@@ -309,7 +309,7 @@ private[collection] trait AugmentedSeqIterator[+T] extends AugmentedIterableIter
     var i = 0
     var loop = true
     while (hasNext && loop) {
-      if (pred(next)) loop = false
+      if (pred(next())) loop = false
       else i += 1
     }
     if (loop) -1 else i
@@ -319,7 +319,7 @@ private[collection] trait AugmentedSeqIterator[+T] extends AugmentedIterableIter
     var pos = -1
     var i = 0
     while (hasNext) {
-      if (pred(next)) pos = i
+      if (pred(next())) pos = i
       i += 1
     }
     pos
@@ -327,7 +327,7 @@ private[collection] trait AugmentedSeqIterator[+T] extends AugmentedIterableIter
 
   def corresponds[S](corr: (T, S) => Boolean)(that: Iterator[S]): Boolean = {
     while (hasNext && that.hasNext) {
-      if (!corr(next, that.next)) return false
+      if (!corr(next(), that.next())) return false
     }
     hasNext == that.hasNext
   }
@@ -349,7 +349,7 @@ private[collection] trait AugmentedSeqIterator[+T] extends AugmentedIterableIter
     //val cb = cbf(repr)
     if (isRemainingCheap) cb.sizeHint(remaining)
     var lst = List[S]()
-    while (hasNext) lst ::= f(next)
+    while (hasNext) lst ::= f(next())
     while (lst != Nil) {
       cb += lst.head
       lst = lst.tail
@@ -364,7 +364,7 @@ private[collection] trait AugmentedSeqIterator[+T] extends AugmentedIterableIter
     while (hasNext) {
       if (j == index) {
         cb += elem
-        next
+        next()
       } else cb += next
       j += 1
     }
@@ -439,7 +439,7 @@ self =>
   class Taken(taken: Int) extends IterableSplitter[T] {
     var remaining = taken min self.remaining
     def hasNext = remaining > 0
-    def next = { remaining -= 1; self.next }
+    def next = { remaining -= 1; self.next() }
     def dup: IterableSplitter[T] = self.dup.take(taken)
     def split: Seq[IterableSplitter[T]] = takeSeq(self.split) { (p, n) => p.take(n) }
     protected[this] def takeSeq[PI <: IterableSplitter[T]](sq: Seq[PI])(taker: (PI, Int) => PI) = {
@@ -467,7 +467,7 @@ self =>
   class Mapped[S](f: T => S) extends IterableSplitter[S] {
     signalDelegate = self.signalDelegate
     def hasNext = self.hasNext
-    def next = f(self.next)
+    def next = f(self.next())
     def remaining = self.remaining
     def dup: IterableSplitter[S] = self.dup map f
     def split: Seq[IterableSplitter[S]] = self.split.map { _ map f }
@@ -484,8 +484,8 @@ self =>
     } else false
     def next = if (curr eq self) {
       hasNext
-      curr.next
-    } else curr.next
+      curr.next()
+    } else curr.next()
     def remaining = if (curr eq self) curr.remaining + that.remaining else curr.remaining
     protected def firstNonEmpty = (curr eq self) && curr.hasNext
     def dup: IterableSplitter[U] = self.dup.appendParIterable[U, PI](that)
@@ -497,7 +497,7 @@ self =>
   class Zipped[S](protected val that: SeqSplitter[S]) extends IterableSplitter[(T, S)] {
     signalDelegate = self.signalDelegate
     def hasNext = self.hasNext && that.hasNext
-    def next = (self.next, that.next)
+    def next = (self.next(), that.next())
     def remaining = self.remaining min that.remaining
     def dup: IterableSplitter[(T, S)] = self.dup.zipParSeq(that)
     def split: Seq[IterableSplitter[(T, S)]] = {
@@ -515,9 +515,9 @@ self =>
     signalDelegate = self.signalDelegate
     def hasNext = self.hasNext || that.hasNext
     def next = if (self.hasNext) {
-      if (that.hasNext) (self.next, that.next)
-      else (self.next, thatelem)
-    } else (thiselem, that.next)
+      if (that.hasNext) (self.next(), that.next())
+      else (self.next(), thatelem)
+    } else (thiselem, that.next())
 
     def remaining = self.remaining max that.remaining
     def dup: IterableSplitter[(U, S)] = self.dup.zipAllParSeq(that, thiselem, thatelem)
diff --git a/src/library/scala/collection/parallel/Splitter.scala b/src/library/scala/collection/parallel/Splitter.scala
index dc49bcf9d7..458742df96 100644
--- a/src/library/scala/collection/parallel/Splitter.scala
+++ b/src/library/scala/collection/parallel/Splitter.scala
@@ -52,7 +52,7 @@ trait Splitter[+T] extends Iterator[T] {
 object Splitter {
   def empty[T]: Splitter[T] = new Splitter[T] {
     def hasNext = false
-    def next = Iterator.empty.next
+    def next = Iterator.empty.next()
     def split = Seq(this)
   }
 }
diff --git a/src/library/scala/collection/parallel/Tasks.scala b/src/library/scala/collection/parallel/Tasks.scala
index ec1bcbb27a..441c4269c3 100644
--- a/src/library/scala/collection/parallel/Tasks.scala
+++ b/src/library/scala/collection/parallel/Tasks.scala
@@ -54,13 +54,13 @@ trait Task[R, +Tp] {
         leaf(lastres)
         result = result // ensure that effects of `leaf` are visible to readers of `result`
       } catchBreak {
-        signalAbort
+        signalAbort()
       }
     } catch {
       case thr: Exception =>
         result = result // ensure that effects of `leaf` are visible
       throwable = thr
-      signalAbort
+      signalAbort()
     }
   }
 
@@ -302,7 +302,7 @@ trait ThreadPoolTasks extends Tasks {
 
     () => {
       t.sync()
-      t.body.forwardThrowable
+      t.body.forwardThrowable()
       t.body.result
     }
   }
@@ -314,7 +314,7 @@ trait ThreadPoolTasks extends Tasks {
     t.start()
 
     t.sync()
-    t.body.forwardThrowable
+    t.body.forwardThrowable()
     t.body.result
   }
 
@@ -402,8 +402,8 @@ trait ForkJoinTasks extends Tasks with HavingForkJoinPool {
     }
 
     () => {
-      fjtask.sync
-      fjtask.body.forwardThrowable
+      fjtask.sync()
+      fjtask.body.forwardThrowable()
       fjtask.body.result
     }
   }
@@ -424,9 +424,9 @@ trait ForkJoinTasks extends Tasks with HavingForkJoinPool {
       forkJoinPool.execute(fjtask)
     }
 
-    fjtask.sync
+    fjtask.sync()
     // if (fjtask.body.throwable != null) println("throwing: " + fjtask.body.throwable + " at " + fjtask.body)
-    fjtask.body.forwardThrowable
+    fjtask.body.forwardThrowable()
     fjtask.body.result
   }
 
diff --git a/src/library/scala/collection/parallel/immutable/ParHashMap.scala b/src/library/scala/collection/parallel/immutable/ParHashMap.scala
index b25230bbeb..f3be47ea03 100644
--- a/src/library/scala/collection/parallel/immutable/ParHashMap.scala
+++ b/src/library/scala/collection/parallel/immutable/ParHashMap.scala
@@ -109,7 +109,7 @@ self =>
     }
     def next(): (K, V) = {
       i += 1
-      val r = triter.next
+      val r = triter.next()
       r
     }
     def hasNext: Boolean = {
diff --git a/src/library/scala/collection/parallel/immutable/ParHashSet.scala b/src/library/scala/collection/parallel/immutable/ParHashSet.scala
index e7e64eb2ad..4f34993b85 100644
--- a/src/library/scala/collection/parallel/immutable/ParHashSet.scala
+++ b/src/library/scala/collection/parallel/immutable/ParHashSet.scala
@@ -106,7 +106,7 @@ self =>
     }
     def next(): T = {
       i += 1
-      triter.next
+      triter.next()
     }
     def hasNext: Boolean = {
       i < sz
diff --git a/src/library/scala/collection/parallel/immutable/ParRange.scala b/src/library/scala/collection/parallel/immutable/ParRange.scala
index a3f473c6a7..78cde1724b 100644
--- a/src/library/scala/collection/parallel/immutable/ParRange.scala
+++ b/src/library/scala/collection/parallel/immutable/ParRange.scala
@@ -60,7 +60,7 @@ self =>
       val r = range.apply(ind)
       ind += 1
       r
-    } else Iterator.empty.next
+    } else Iterator.empty.next()
 
     private def rangeleft = range.drop(ind)
 
diff --git a/src/library/scala/collection/parallel/mutable/ParArray.scala b/src/library/scala/collection/parallel/mutable/ParArray.scala
index 0e9eac62e2..68c43e682e 100644
--- a/src/library/scala/collection/parallel/mutable/ParArray.scala
+++ b/src/library/scala/collection/parallel/mutable/ParArray.scala
@@ -226,7 +226,7 @@ self =>
         if (all) i = nextuntil
         else {
           i = until
-          abort
+          abort()
         }
 
         if (isAborted) return false
@@ -254,7 +254,7 @@ self =>
         some = exists_quick(p, array, nextuntil, i)
         if (some) {
           i = until
-          abort
+          abort()
         } else i = nextuntil
 
         if (isAborted) return true
@@ -283,7 +283,7 @@ self =>
 
         if (r != None) {
           i = until
-          abort
+          abort()
         } else i = nextuntil
 
         if (isAborted) return r
diff --git a/src/library/scala/collection/parallel/mutable/ParFlatHashTable.scala b/src/library/scala/collection/parallel/mutable/ParFlatHashTable.scala
index b151e45d65..aa790dd548 100644
--- a/src/library/scala/collection/parallel/mutable/ParFlatHashTable.scala
+++ b/src/library/scala/collection/parallel/mutable/ParFlatHashTable.scala
@@ -48,7 +48,7 @@ trait ParFlatHashTable[T] extends scala.collection.mutable.FlatHashTable[T] {
       idx += 1
       if (hasNext) scan()
       r
-    } else Iterator.empty.next
+    } else Iterator.empty.next()
     def dup = newIterator(idx, until, totalsize)
     def split = if (remaining > 1) {
       val divpt = (until + idx) / 2
diff --git a/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala b/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala
index f5c0b10526..7766f07e23 100644
--- a/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala
+++ b/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala
@@ -47,7 +47,7 @@ extends Combiner[T, ParArray[T]] {
   }
 
   def clear() {
-    buff.clear
+    buff.clear()
   }
 
   override def sizeHint(sz: Int) = {