Merge pull request scala/scala#8125 from asakaev/fix-formatting

Fix formatting

Author: adriaanm

library/src/scala/Console.scala

@@ -162,7 +162,7 @@ object Console extends AnsiColor {
    *  @see `withOut[T](out:OutputStream)(thunk: => T)`
    *  @group io-redefinition
    */
-  def withOut[T](out: PrintStream)(thunk: =>T): T =
+  def withOut[T](out: PrintStream)(thunk: => T): T =
     outVar.withValue(out)(thunk)
 
   /** Sets the default output stream for the duration
@@ -175,7 +175,7 @@ object Console extends AnsiColor {
    *  @see `withOut[T](out:PrintStream)(thunk: => T)`
    *  @group io-redefinition
    */
-  def withOut[T](out: OutputStream)(thunk: =>T): T =
+  def withOut[T](out: OutputStream)(thunk: => T): T =
     withOut(new PrintStream(out))(thunk)
 
   /** Set the default error stream for the duration
@@ -188,10 +188,10 @@ object Console extends AnsiColor {
    *  @param thunk the code to execute with
    *               the new error stream active
    *  @return the results of `thunk`
-   *  @see `withErr[T](err:OutputStream)(thunk: =>T)`
+   *  @see `withErr[T](err:OutputStream)(thunk: => T)`
    *  @group io-redefinition
    */
-  def withErr[T](err: PrintStream)(thunk: =>T): T =
+  def withErr[T](err: PrintStream)(thunk: => T): T =
     errVar.withValue(err)(thunk)
 
   /** Sets the default error stream for the duration
@@ -201,10 +201,10 @@ object Console extends AnsiColor {
    *  @param thunk the code to execute with
    *               the new error stream active
    *  @return the results of `thunk`
-   *  @see `withErr[T](err:PrintStream)(thunk: =>T)`
+   *  @see `withErr[T](err:PrintStream)(thunk: => T)`
    *  @group io-redefinition
    */
-  def withErr[T](err: OutputStream)(thunk: =>T): T =
+  def withErr[T](err: OutputStream)(thunk: => T): T =
     withErr(new PrintStream(err))(thunk)
 
   /** Sets the default input stream for the duration
@@ -222,10 +222,10 @@ object Console extends AnsiColor {
    *               the new input stream active
    *
    *  @return the results of `thunk`
-   *  @see `withIn[T](in:InputStream)(thunk: =>T)`
+   *  @see `withIn[T](in:InputStream)(thunk: => T)`
    *  @group io-redefinition
    */
-  def withIn[T](reader: Reader)(thunk: =>T): T =
+  def withIn[T](reader: Reader)(thunk: => T): T =
     inVar.withValue(new BufferedReader(reader))(thunk)
 
   /** Sets the default input stream for the duration
@@ -235,10 +235,10 @@ object Console extends AnsiColor {
    *  @param thunk the code to execute with
    *               the new input stream active
    *  @return the results of `thunk`
-   *  @see `withIn[T](reader:Reader)(thunk: =>T)`
+   *  @see `withIn[T](reader:Reader)(thunk: => T)`
    *  @group io-redefinition
    */
-  def withIn[T](in: InputStream)(thunk: =>T): T =
+  def withIn[T](in: InputStream)(thunk: => T): T =
     withIn(new InputStreamReader(in))(thunk)
 
   /** Prints an object to `out` using its `toString` method.

library/src/scala/collection/concurrent/Map.scala

@@ -94,7 +94,7 @@ trait Map[K, V] extends scala.collection.mutable.Map[K, V] {
     */
   def replace(k: K, v: V): Option[V]
 
-  override def getOrElseUpdate(key: K, op: =>V): V = get(key) match {
+  override def getOrElseUpdate(key: K, op: => V): V = get(key) match {
     case Some(v) => v
     case None =>
       val v = op

library/src/scala/collection/concurrent/TrieMap.scala

@@ -944,7 +944,7 @@ final class TrieMap[K, V] private (r: AnyRef, rtupd: AtomicReferenceFieldUpdater
     *  @param op     the expression that computes the value
     *  @return       the newly added value
     */
-  override def getOrElseUpdate(k: K, op: =>V): V = {
+  override def getOrElseUpdate(k: K, op: => V): V = {
     val hc = computeHash(k)
     lookuphc(k, hc) match {
       case INodeBase.NO_SUCH_ELEMENT_SENTINEL =>

library/src/scala/concurrent/BlockContext.scala

@@ -29,7 +29,7 @@ package scala.concurrent
  * {{{
  *  val oldContext = BlockContext.current
  *  val myContext = new BlockContext {
- *    override def blockOn[T](thunk: =>T)(implicit permission: CanAwait): T = {
+ *    override def blockOn[T](thunk: => T)(implicit permission: CanAwait): T = {
  *      // you'd have code here doing whatever you need to do
  *      // when the thread is about to block.
  *      // Then you'd chain to the previous context:
@@ -54,12 +54,12 @@ trait BlockContext {
     *
     * @throws IllegalArgumentException if the `permission` is `null`
     */
-  def blockOn[T](thunk: =>T)(implicit permission: CanAwait): T
+  def blockOn[T](thunk: => T)(implicit permission: CanAwait): T
 }
 
 object BlockContext {
   private[this] object DefaultBlockContext extends BlockContext {
-    override final def blockOn[T](thunk: =>T)(implicit permission: CanAwait): T = thunk
+    override final def blockOn[T](thunk: => T)(implicit permission: CanAwait): T = thunk
   }
 
   /**

library/src/scala/concurrent/Future.scala

@@ -656,7 +656,7 @@ object Future {
   *  @param executor  the execution context on which the future is run
   *  @return          the `Future` holding the result of the computation
   */
-  final def apply[T](body: =>T)(implicit executor: ExecutionContext): Future[T] =
+  final def apply[T](body: => T)(implicit executor: ExecutionContext): Future[T] =
     unit.map(_ => body)
 
   /** Starts an asynchronous computation and returns a `Future` instance with the result of that computation once it completes.

library/src/scala/concurrent/impl/ExecutionContextImpl.scala

@@ -49,7 +49,7 @@ private[concurrent] object ExecutionContextImpl {
     def newThread(fjp: ForkJoinPool): ForkJoinWorkerThread =
       wire(new ForkJoinWorkerThread(fjp) with BlockContext {
         private[this] final var isBlocked: Boolean = false // This is only ever read & written if this thread is the current thread
-        final override def blockOn[T](thunk: =>T)(implicit permission: CanAwait): T =
+        final override def blockOn[T](thunk: => T)(implicit permission: CanAwait): T =
           if ((Thread.currentThread eq this) && !isBlocked && blockerPermits.tryAcquire()) {
             try {
               val b: ForkJoinPool.ManagedBlocker with (() => T) =

library/src/scala/concurrent/package.scala

@@ -121,7 +121,7 @@ package object concurrent {
    *  @throws InterruptedException in the case that a wait within the blocking `body` was interrupted
    */
   @throws(classOf[Exception])
-  final def blocking[T](body: =>T): T = BlockContext.current.blockOn(body)(scala.concurrent.AwaitPermission)
+  final def blocking[T](body: => T): T = BlockContext.current.blockOn(body)(scala.concurrent.AwaitPermission)
 }
 
 package concurrent {

library/src/scala/jdk/Accumulator.scala

@@ -54,7 +54,7 @@ import scala.collection.{Stepper, StepperShape, mutable}
   * There are two possibilities to process elements of a primitive Accumulator without boxing:
   * specialized operations of the Accumulator, or the Stepper interface. The most common collection
   * operations are overloaded or overridden in the primitive Accumulator classes, for example
-  * [[IntAccumulator.map(f:Int=>Int)* IntAccumulator.map]] or [[IntAccumulator.exists]]. Thanks to Scala's function specialization,
+  * [[IntAccumulator.map(f: Int => Int)* IntAccumulator.map]] or [[IntAccumulator.exists]]. Thanks to Scala's function specialization,
   * `intAcc.exists(x => testOn(x))` does not incur boxing.
   *
   * The [[Stepper]] interface provides iterator-like `hasStep` and `nextStep` methods, and is

library/src/scala/util/control/Breaks.scala

@@ -47,7 +47,7 @@ class Breaks {
   }
 
   sealed trait TryBlock[T] {
-    def catchBreak(onBreak: =>T): T
+    def catchBreak(onBreak: => T): T
   }
 
   /**
@@ -62,8 +62,8 @@ class Breaks {
    * }
    * }}}
    */
-  def tryBreakable[T](op: =>T) = new TryBlock[T] {
-    def catchBreak(onBreak: =>T) = try {
+  def tryBreakable[T](op: => T) = new TryBlock[T] {
+    def catchBreak(onBreak: => T) = try {
       op
     } catch {
       case ex: BreakControl =>