run srewrite version 88d3cd4126d135617a8189f0a855757d7e2ab806 on src/library

Author: samuelgruetter

src/library/scala/App.scala

@@ -56,7 +56,7 @@ trait App extends DelayedInit {
    *  themselves define a `delayedInit` method.
    *  @param body the initialization code to be stored for later execution
    */
-  override def delayedInit(body: => Unit) {
+  override def delayedInit(body: => Unit): Unit = {
     initCode += (() => body)
   }
 

src/library/scala/Application.scala

@@ -70,7 +70,7 @@ trait Application {
    *
    *  @param args the arguments passed to the main method
    */
-  def main(args: Array[String]) {
+  def main(args: Array[String]): Unit = {
     if (util.Properties propIsSet "scala.time") {
       val total = currentTime - executionStart
       Console.println("[total " + total + "ms]")

src/library/scala/Array.scala

@@ -73,7 +73,7 @@ object Array extends FallbackArrayBuilding {
                        srcPos : Int,
                        dest : AnyRef,
                        destPos : Int,
-                       length : Int) {
+                       length : Int): Unit = {
     var i = srcPos
     var j = destPos
     val srcUntil = srcPos + length
@@ -99,7 +99,7 @@ object Array extends FallbackArrayBuilding {
    *
    *  @see `java.lang.System#arraycopy`
    */
-  def copy(src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int) {
+  def copy(src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int): Unit = {
     val srcClass = src.getClass
     if (srcClass.isArray && dest.getClass.isAssignableFrom(srcClass))
       arraycopy(src, srcPos, dest, destPos, length)
@@ -525,7 +525,7 @@ final class Array[T](_length: Int) extends java.io.Serializable with java.lang.C
    *  @param    x   the value to be written at index `i`
    *  @throws       ArrayIndexOutOfBoundsException if `i < 0` or `length <= i`
    */
-  def update(i: Int, x: T) { throw new Error() }
+  def update(i: Int, x: T): Unit = { throw new Error() }
 
   /** Clone the Array.
    *

src/library/scala/Console.scala

@@ -88,7 +88,7 @@ object Console {
    *
    *  @param out the new output stream.
    */
-  def setOut(out: PrintStream) { outVar.value = out }
+  def setOut(out: PrintStream): Unit = { outVar.value = out }
 
   /** Sets the default output stream for the duration
    *  of execution of one thunk.
@@ -130,7 +130,7 @@ object Console {
    *
    *  @param err the new error stream.
    */
-  def setErr(err: PrintStream) { errVar.value = err }
+  def setErr(err: PrintStream): Unit = { errVar.value = err }
 
   /** Set the default error stream for the duration
    *  of execution of one thunk.
@@ -171,7 +171,7 @@ object Console {
    *
    *  @param reader specifies the new input stream.
    */
-  def setIn(reader: Reader) {
+  def setIn(reader: Reader): Unit = {
     inVar.value = new BufferedReader(reader)
   }
 
@@ -199,7 +199,7 @@ object Console {
    *
    *  @param in the new input stream.
    */
-  def setIn(in: InputStream) {
+  def setIn(in: InputStream): Unit = {
     setIn(new InputStreamReader(in))
   }
 
@@ -219,25 +219,25 @@ object Console {
    *
    *  @param obj the object to print; may be null.
    */
-  def print(obj: Any) {
+  def print(obj: Any): Unit = {
     out.print(if (null == obj) "null" else obj.toString())
   }
 
   /** Flushes the output stream. This function is required when partial
    *  output (i.e. output not terminated by a newline character) has
    *  to be made visible on the terminal.
    */
-  def flush() { out.flush() }
+  def flush(): Unit = { out.flush() }
 
   /** Prints a newline character on the default output.
    */
-  def println() { out.println() }
+  def println(): Unit = { out.println() }
 
   /** Prints out an object to the default output, followed by a newline character.
    *
    *  @param x the object to print.
    */
-  def println(x: Any) { out.println(x) }
+  def println(x: Any): Unit = { out.println(x) }
 
   /** Prints its arguments as a formatted string to the default output,
    *  based on a string pattern (in a fashion similar to printf in C).
@@ -250,7 +250,7 @@ object Console {
    *  @param args the arguments used to instantiating the pattern.
    *  @throws java.lang.IllegalArgumentException if there was a problem with the format string or arguments
    */
-  def printf(text: String, args: Any*) { out.print(text format (args : _*)) }
+  def printf(text: String, args: Any*): Unit = { out.print(text format (args : _*)) }
 
   /** Read a full line from the default input.  Returns `null` if the end of the
    * input stream has been reached.

src/library/scala/DelayedInit.scala

@@ -45,4 +45,4 @@ package scala
  */
 trait DelayedInit {
   def delayedInit(x: => Unit): Unit
-}
+}

src/library/scala/Enumeration.scala

@@ -160,7 +160,7 @@ abstract class Enumeration (initial: Int) extends Serializable {
    */
   protected final def Value(i: Int, name: String): Value = new Val(i, name)
 
-  private def populateNameMap() {
+  private def populateNameMap(): Unit = {
     val fields = getClass.getDeclaredFields
     def isValDef(m: JMethod) = fields exists (fd => fd.getName == m.getName && fd.getType == m.getReturnType)
 

src/library/scala/LowPriorityImplicits.scala

@@ -33,14 +33,14 @@ class LowPriorityImplicits {
    *  Even inlined, every call site does a no-op retrieval of Predef's MODULE$
    *  because maybe loading Predef has side effects!
    */
-  @inline implicit def byteWrapper(x: Byte)       = new runtime.RichByte(x)
-  @inline implicit def shortWrapper(x: Short)     = new runtime.RichShort(x)
-  @inline implicit def intWrapper(x: Int)         = new runtime.RichInt(x)
-  @inline implicit def charWrapper(c: Char)       = new runtime.RichChar(c)
-  @inline implicit def longWrapper(x: Long)       = new runtime.RichLong(x)
-  @inline implicit def floatWrapper(x: Float)     = new runtime.RichFloat(x)
-  @inline implicit def doubleWrapper(x: Double)   = new runtime.RichDouble(x)
-  @inline implicit def booleanWrapper(x: Boolean) = new runtime.RichBoolean(x)
+  @inline implicit def byteWrapper(x: Byte)      : scala.runtime.RichByte = new runtime.RichByte(x)
+  @inline implicit def shortWrapper(x: Short)    : scala.runtime.RichShort = new runtime.RichShort(x)
+  @inline implicit def intWrapper(x: Int)        : scala.runtime.RichInt = new runtime.RichInt(x)
+  @inline implicit def charWrapper(c: Char)      : scala.runtime.RichChar = new runtime.RichChar(c)
+  @inline implicit def longWrapper(x: Long)      : scala.runtime.RichLong = new runtime.RichLong(x)
+  @inline implicit def floatWrapper(x: Float)    : scala.runtime.RichFloat = new runtime.RichFloat(x)
+  @inline implicit def doubleWrapper(x: Double)  : scala.runtime.RichDouble = new runtime.RichDouble(x)
+  @inline implicit def booleanWrapper(x: Boolean): scala.runtime.RichBoolean = new runtime.RichBoolean(x)
 
   // These eight implicits exist solely to exclude Null from the domain of
   // the boxed types, so that e.g. "var x: Int = null" is a compile time

src/library/scala/Option.scala

@@ -232,7 +232,7 @@ sealed abstract class Option[+A] extends Product with Serializable {
    *  @see map
    *  @see flatMap
    */
-  @inline final def foreach[U](f: A => U) {
+  @inline final def foreach[U](f: A => U): Unit = {
     if (!isEmpty) f(this.get)
   }
 

src/library/scala/Predef.scala

@@ -160,7 +160,7 @@ object Predef extends LowPriorityImplicits {
    *  @param assertion   the expression to test
    */
   @elidable(ASSERTION)
-  def assert(assertion: Boolean) {
+  def assert(assertion: Boolean): Unit = {
     if (!assertion)
       throw new java.lang.AssertionError("assertion failed")
   }
@@ -174,7 +174,7 @@ object Predef extends LowPriorityImplicits {
    *  @param message     a String to include in the failure message
    */
   @elidable(ASSERTION) @inline
-  final def assert(assertion: Boolean, message: => Any) {
+  final def assert(assertion: Boolean, message: => Any): Unit = {
     if (!assertion)
       throw new java.lang.AssertionError("assertion failed: "+ message)
   }
@@ -189,7 +189,7 @@ object Predef extends LowPriorityImplicits {
    *  @param assumption   the expression to test
    */
   @elidable(ASSERTION)
-  def assume(assumption: Boolean) {
+  def assume(assumption: Boolean): Unit = {
     if (!assumption)
       throw new java.lang.AssertionError("assumption failed")
   }
@@ -205,7 +205,7 @@ object Predef extends LowPriorityImplicits {
    *  @param message      a String to include in the failure message
    */
   @elidable(ASSERTION) @inline
-  final def assume(assumption: Boolean, message: => Any) {
+  final def assume(assumption: Boolean, message: => Any): Unit = {
     if (!assumption)
       throw new java.lang.AssertionError("assumption failed: "+ message)
   }
@@ -216,7 +216,7 @@ object Predef extends LowPriorityImplicits {
    *
    *  @param requirement   the expression to test
    */
-  def require(requirement: Boolean) {
+  def require(requirement: Boolean): Unit = {
     if (!requirement)
       throw new IllegalArgumentException("requirement failed")
   }
@@ -228,7 +228,7 @@ object Predef extends LowPriorityImplicits {
    *  @param requirement   the expression to test
    *  @param message       a String to include in the failure message
    */
-  @inline final def require(requirement: Boolean, message: => Any) {
+  @inline final def require(requirement: Boolean, message: => Any): Unit = {
     if (!requirement)
       throw new IllegalArgumentException("requirement failed: "+ message)
   }
@@ -304,9 +304,9 @@ object Predef extends LowPriorityImplicits {
 
   // views --------------------------------------------------------------
 
-  implicit def exceptionWrapper(exc: Throwable)                                 = new runtime.RichException(exc)
-  implicit def tuple2ToZippedOps[T1, T2](x: (T1, T2))                           = new runtime.Tuple2Zipped.Ops(x)
-  implicit def tuple3ToZippedOps[T1, T2, T3](x: (T1, T2, T3))                   = new runtime.Tuple3Zipped.Ops(x)
+  implicit def exceptionWrapper(exc: Throwable)                                : scala.runtime.RichException = new runtime.RichException(exc)
+  implicit def tuple2ToZippedOps[T1, T2](x: (T1, T2))                          : runtime.Tuple2Zipped.Ops[T1,T2] = new runtime.Tuple2Zipped.Ops(x)
+  implicit def tuple3ToZippedOps[T1, T2, T3](x: (T1, T2, T3))                  : runtime.Tuple3Zipped.Ops[T1,T2,T3] = new runtime.Tuple3Zipped.Ops(x)
   implicit def seqToCharSequence(xs: scala.collection.IndexedSeq[Char]): CharSequence = new runtime.SeqCharSequence(xs)
   implicit def arrayToCharSequence(xs: Array[Char]): CharSequence               = new runtime.ArrayCharSequence(xs, 0, xs.length)
 
@@ -364,27 +364,27 @@ object Predef extends LowPriorityImplicits {
 
   // "Autoboxing" and "Autounboxing" ---------------------------------------------------
 
-  implicit def byte2Byte(x: Byte)           = java.lang.Byte.valueOf(x)
-  implicit def short2Short(x: Short)        = java.lang.Short.valueOf(x)
-  implicit def char2Character(x: Char)      = java.lang.Character.valueOf(x)
-  implicit def int2Integer(x: Int)          = java.lang.Integer.valueOf(x)
-  implicit def long2Long(x: Long)           = java.lang.Long.valueOf(x)
-  implicit def float2Float(x: Float)        = java.lang.Float.valueOf(x)
-  implicit def double2Double(x: Double)     = java.lang.Double.valueOf(x)
-  implicit def boolean2Boolean(x: Boolean)  = java.lang.Boolean.valueOf(x)
+  implicit def byte2Byte(x: Byte)          : Byte = java.lang.Byte.valueOf(x)
+  implicit def short2Short(x: Short)       : Short = java.lang.Short.valueOf(x)
+  implicit def char2Character(x: Char)     : Character = java.lang.Character.valueOf(x)
+  implicit def int2Integer(x: Int)         : Integer = java.lang.Integer.valueOf(x)
+  implicit def long2Long(x: Long)          : Long = java.lang.Long.valueOf(x)
+  implicit def float2Float(x: Float)       : Float = java.lang.Float.valueOf(x)
+  implicit def double2Double(x: Double)    : Double = java.lang.Double.valueOf(x)
+  implicit def boolean2Boolean(x: Boolean) : Boolean = java.lang.Boolean.valueOf(x)
 
   // These next eight implicits exist solely to exclude AnyRef methods from the
   // eight implicits above so that primitives are not coerced to AnyRefs.  They
   // only create such conflict for AnyRef methods, so the methods on the java.lang
   // boxed types are unambiguously reachable.
-  implicit def byte2ByteConflict(x: Byte)           = new AnyRef
-  implicit def short2ShortConflict(x: Short)        = new AnyRef
-  implicit def char2CharacterConflict(x: Char)      = new AnyRef
-  implicit def int2IntegerConflict(x: Int)          = new AnyRef
-  implicit def long2LongConflict(x: Long)           = new AnyRef
-  implicit def float2FloatConflict(x: Float)        = new AnyRef
-  implicit def double2DoubleConflict(x: Double)     = new AnyRef
-  implicit def boolean2BooleanConflict(x: Boolean)  = new AnyRef
+  implicit def byte2ByteConflict(x: Byte)          : Object = new AnyRef
+  implicit def short2ShortConflict(x: Short)       : Object = new AnyRef
+  implicit def char2CharacterConflict(x: Char)     : Object = new AnyRef
+  implicit def int2IntegerConflict(x: Int)         : Object = new AnyRef
+  implicit def long2LongConflict(x: Long)          : Object = new AnyRef
+  implicit def float2FloatConflict(x: Float)       : Object = new AnyRef
+  implicit def double2DoubleConflict(x: Double)    : Object = new AnyRef
+  implicit def boolean2BooleanConflict(x: Boolean) : Object = new AnyRef
 
   implicit def Byte2byte(x: java.lang.Byte): Byte             = x.byteValue
   implicit def Short2short(x: java.lang.Short): Short         = x.shortValue
@@ -397,9 +397,9 @@ object Predef extends LowPriorityImplicits {
 
   // Strings and CharSequences --------------------------------------------------------------
 
-  @inline implicit def any2stringfmt(x: Any) = new runtime.StringFormat(x)
+  @inline implicit def any2stringfmt(x: Any): scala.runtime.StringFormat = new runtime.StringFormat(x)
   @inline implicit def augmentString(x: String): StringOps = new StringOps(x)
-  implicit def any2stringadd(x: Any) = new runtime.StringAdd(x)
+  implicit def any2stringadd(x: Any): scala.runtime.StringAdd = new runtime.StringAdd(x)
   implicit def unaugmentString(x: StringOps): String = x.repr
 
   @deprecated("Use `StringCanBuildFrom`", "2.10.0")

src/library/scala/Responder.scala

@@ -62,22 +62,22 @@ abstract class Responder[+A] extends Serializable {
 
   def respond(k: A => Unit): Unit
 
-  def foreach(k: A => Unit) { respond(k) }
+  def foreach(k: A => Unit): Unit = { respond(k) }
 
   def map[B](f: A => B) = new Responder[B] {
-    def respond(k: B => Unit) {
+    def respond(k: B => Unit): Unit = {
       Responder.this.respond(x => k(f(x)))
     }
   }
 
   def flatMap[B](f: A => Responder[B]) = new Responder[B] {
-    def respond(k: B => Unit) {
+    def respond(k: B => Unit): Unit = {
       Responder.this.respond(x => f(x).respond(k))
     }
   }
 
   def filter(p: A => Boolean) = new Responder[A] {
-    def respond(k: A => Unit) {
+    def respond(k: A => Unit): Unit = {
       Responder.this.respond(x => if (p(x)) k(x) else ())
     }
   }

src/library/scala/beans/ScalaBeanInfo.scala

@@ -34,7 +34,7 @@ abstract class ScalaBeanInfo(clazz: java.lang.Class[_],
 
   // override def getAdditionalBeanInfo() = Array(Introspector getBeanInfo clazz.getSuperclass)
 
-  private def init() {
+  private def init(): Unit = {
     var i = 0;
     while (i < props.length) {
       pd(i/3) = new PropertyDescriptor(props(i), clazz, props(i+1), props(i+2))

src/library/scala/collection/BitSetLike.scala

@@ -111,7 +111,7 @@ trait BitSetLike[+This <: BitSetLike[This] with SortedSet[Int]] extends SortedSe
       else Iterator.empty.next
   }
 
-  override def foreach[B](f: Int => B) {
+  override def foreach[B](f: Int => B): Unit = {
     for (i <- 0 until nwords) {
       val w = word(i)
       for (j <- i * WordLength until (i + 1) * WordLength) {

src/library/scala/collection/GenIterable.scala

@@ -30,7 +30,7 @@ extends GenIterableLike[A, GenIterable[A]]
 
 
 object GenIterable extends GenTraversableFactory[GenIterable] {
-  implicit def canBuildFrom[A] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]]
+  implicit def canBuildFrom[A]: scala.collection.GenIterable.GenericCanBuildFrom[A] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]]
   def newBuilder[A] = Iterable.newBuilder
 }
 

src/library/scala/collection/GenSeq.scala

@@ -31,6 +31,6 @@ extends GenSeqLike[A, GenSeq[A]]
 
 
 object GenSeq extends GenTraversableFactory[GenSeq] {
-  implicit def canBuildFrom[A] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]]
+  implicit def canBuildFrom[A]: scala.collection.GenSeq.GenericCanBuildFrom[A] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]]
   def newBuilder[A] = Seq.newBuilder
 }

src/library/scala/collection/GenSet.scala

@@ -31,7 +31,7 @@ extends GenSetLike[A, GenSet[A]]
 
 
 object GenSet extends GenTraversableFactory[GenSet] {
-  implicit def canBuildFrom[A] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]]
+  implicit def canBuildFrom[A]: scala.collection.GenSet.GenericCanBuildFrom[A] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]]
   def newBuilder[A] = Set.newBuilder
 }
 

src/library/scala/collection/GenTraversable.scala

@@ -32,7 +32,7 @@ extends GenTraversableLike[A, GenTraversable[A]]
 
 
 object GenTraversable extends GenTraversableFactory[GenTraversable] {
-  implicit def canBuildFrom[A] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]]
+  implicit def canBuildFrom[A]: scala.collection.GenTraversable.GenericCanBuildFrom[A] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]]
   def newBuilder[A] = Traversable.newBuilder
 }