Merge pull request #117 from SethTisue/cleanups-for-dotty

SethTisue · web-flow · commit 39357a35dac5 · 2020-10-13T09:04:12.000-07:00
prepare for Dotty
diff --git a/core/src/main/scala/scala/collection/generic/Signalling.scala b/core/src/main/scala/scala/collection/generic/Signalling.scala
@@ -131,19 +131,19 @@ trait AtomicIndexFlag extends Signalling {
   abstract override def setIndexFlag(f: Int) = intflag.set(f)
   abstract override def setIndexFlagIfGreater(f: Int) = {
     var loop = true
-    do {
+    while (loop) {
       val old = intflag.get
       if (f <= old) loop = false
       else if (intflag.compareAndSet(old, f)) loop = false
-    } while (loop)
+    }
   }
   abstract override def setIndexFlagIfLesser(f: Int) = {
     var loop = true
-    do {
+    while (loop) {
       val old = intflag.get
       if (f >= old) loop = false
       else if (intflag.compareAndSet(old, f)) loop = false
-    } while (loop)
+    }
   }
 }
 
diff --git a/core/src/main/scala/scala/collection/parallel/ParIterableLike.scala b/core/src/main/scala/scala/collection/parallel/ParIterableLike.scala
@@ -296,7 +296,7 @@ self =>
   }
 
   /* convenience task operations wrapper */
-  protected implicit def task2ops[R, Tp](tsk: SSCTask[R, Tp]) = new TaskOps[R, Tp] {
+  protected implicit def task2ops[R, Tp](tsk: SSCTask[R, Tp]): TaskOps[R, Tp] = new TaskOps[R, Tp] {
     def mapResult[R1](mapping: R => R1): ResultMapping[R, Tp, R1] = new ResultMapping[R, Tp, R1](tsk) {
       def map(r: R): R1 = mapping(r)
     }
@@ -316,14 +316,14 @@ self =>
   }
 
   /* convenience signalling operations wrapper */
-  protected implicit def delegatedSignalling2ops[PI <: DelegatedSignalling](it: PI) = new SignallingOps[PI] {
+  protected implicit def delegatedSignalling2ops[PI <: DelegatedSignalling](it: PI): SignallingOps[PI] = new SignallingOps[PI] {
     def assign(cntx: Signalling): PI = {
       it.signalDelegate = cntx
       it
     }
   }
 
-  protected implicit def builder2ops[Elem, To](cb: Builder[Elem, To]) = new BuilderOps[Elem, To] {
+  protected implicit def builder2ops[Elem, To](cb: Builder[Elem, To]): BuilderOps[Elem, To] = new BuilderOps[Elem, To] {
     def ifIs[Cmb](isbody: Cmb => Unit) = new Otherwise[Cmb] {
       def otherwise(notbody: => Unit)(implicit t: ClassTag[Cmb]): Unit = {
         if (cb.getClass == t.runtimeClass) isbody(cb.asInstanceOf[Cmb]) else notbody
diff --git a/core/src/main/scala/scala/collection/parallel/Tasks.scala b/core/src/main/scala/scala/collection/parallel/Tasks.scala
@@ -180,15 +180,16 @@ trait AdaptiveWorkStealingTasks extends Tasks {
     def spawnSubtasks() = {
       var last: AWSTWrappedTask[R, Tp] = null
       var head: AWSTWrappedTask[R, Tp] = this
-      do {
+      while ({
         val subtasks = head.split
         head = subtasks.head
         for (t <- subtasks.tail.reverse) {
           t.next = last
           last = t
           t.start()
         }
-      } while (head.body.shouldSplitFurther)
+        head.body.shouldSplitFurther
+      }) ()
       head.next = last
       head
     }
diff --git a/core/src/main/scala/scala/collection/parallel/mutable/ParArray.scala b/core/src/main/scala/scala/collection/parallel/mutable/ParArray.scala
@@ -461,17 +461,15 @@ self =>
 
     override def copy2builder[U >: T, Coll, Bld <: Builder[U, Coll]](cb: Bld): Bld = {
       cb.sizeHint(remaining)
-      cb.ifIs[ResizableParArrayCombiner[T]] {
-      pac =>
+      cb.ifIs[ResizableParArrayCombiner[T]] { pac =>
         // with res. combiner:
         val targetarr: Array[Any] = pac.lastbuff.internalArray.asInstanceOf[Array[Any]]
         Array.copy(arr, i, targetarr, pac.lastbuff.size, until - i)
         pac.lastbuff.setInternalSize(remaining)
       } otherwise {
-        cb.ifIs[UnrolledParArrayCombiner[T]] {
-          pac =>
-            // with unr. combiner:
-            val targetarr: Array[Any] = pac.buff.lastPtr.array.asInstanceOf[Array[Any]]
+        cb.ifIs[UnrolledParArrayCombiner[T]] { pac =>
+          // with unr. combiner:
+          val targetarr: Array[Any] = pac.buff.lastPtr.array.asInstanceOf[Array[Any]]
           Array.copy(arr, i, targetarr, 0, until - i)
           pac.buff.size = pac.buff.size + until - i
           pac.buff.lastPtr.size = until - i
diff --git a/core/src/main/scala/scala/collection/parallel/package.scala b/core/src/main/scala/scala/collection/parallel/package.scala
@@ -66,7 +66,7 @@ package object parallel {
 package parallel {
   /** Implicit conversions used in the implementation of parallel collections. */
   private[collection] object ParallelCollectionImplicits {
-    implicit def traversable2ops[T](t: scala.collection.IterableOnce[T]) = new TraversableOps[T] {
+    implicit def traversable2ops[T](t: scala.collection.IterableOnce[T]): TraversableOps[T] = new TraversableOps[T] {
       def isParallel = t.isInstanceOf[Parallel]
       def isParIterable = t.isInstanceOf[ParIterable[_]]
       def asParIterable = t.asInstanceOf[ParIterable[T]]
diff --git a/junit/src/test/scala/scala/SerializationStabilityTest.scala b/junit/src/test/scala/scala/SerializationStabilityTest.scala
@@ -13,7 +13,7 @@
 package scala
 
 import javax.xml.bind.DatatypeConverter._
-import scala.reflect.io.File
+import java.nio.file.{ Path, Paths, Files }
 import org.junit.Test
 
 // This test is self-modifying when run as follows:
@@ -24,7 +24,10 @@ import org.junit.Test
 
 // based on run/t8549.scala partest
 object SerializationStability extends App {
-  val overwrite: Option[File] = sys.props.get("overwrite.source").map(s => new File(new java.io.File(s).getAbsoluteFile))
+
+  val overwrite: Option[Path] =
+    sys.props.get("overwrite.source")
+      .map(s => Paths.get(s).toAbsolutePath)
 
   def serialize(o: AnyRef): String = {
     val bos = new java.io.ByteArrayOutputStream()
@@ -34,13 +37,15 @@ object SerializationStability extends App {
     printBase64Binary(bos.toByteArray())
   }
 
-  def amend(file: File)(f: String => String): Unit = {
-    file.writeAll(f(file.slurp()))
+  def amend(path: Path)(f: String => String): Unit = {
+    val old = new String(java.nio.file.Files.readAllBytes(path))
+    Files.write(path, f(old).getBytes)
   }
+
   def quote(s: String) = List("\"", s, "\"").mkString
 
-  def patch(file: File, line: Int, prevResult: String, result: String): Unit = {
-    amend(file) {
+  def patch(path: Path, line: Int, prevResult: String, result: String): Unit = {
+    amend(path) {
       content =>
         content.linesIterator.toList.zipWithIndex.map {
           case (content, i) if i == line - 1 =>
@@ -53,14 +58,14 @@ object SerializationStability extends App {
     }
   }
 
-  def updateComment(file: File): Unit = {
+  def updateComment(path: Path): Unit = {
     val timestamp = {
       import java.text.SimpleDateFormat
       val sdf = new SimpleDateFormat("yyyyMMdd-HH:mm:ss")
       sdf.format(new java.util.Date)
     }
     val newComment = s"  // Generated on $timestamp with Scala ${scala.util.Properties.versionString})"
-    amend(file) {
+    amend(path) {
       content =>
         content.linesIterator.toList.map {
           f => f.replaceAll("""^ +// Generated on.*""", newComment)
diff --git a/junit/src/test/scala/scala/collection/concurrent/ctries_new/ConcurrentMapSpec.scala b/junit/src/test/scala/scala/collection/concurrent/ctries_new/ConcurrentMapSpec.scala
@@ -64,7 +64,7 @@ class ConcurrentMapSpec extends Spec {
     }
 
     def assertEqual(a: Any, b: Any) = {
-      if (a != b) println(a, b)
+      if (a != b) println((a, b))
       assert(a == b)
     }
 
@@ -79,10 +79,11 @@ class ConcurrentMapSpec extends Spec {
           for (i <- 0 until sz) {
             val j = (offs + i) % sz
             var k = Int.MaxValue
-            do {
+            while ({
               if (k != Int.MaxValue) repeats += 1
               k = ct.getOrElse(new Wrap(j), 0)
-            } while (!ct.replace(new Wrap(j), k, -k))
+              !ct.replace(new Wrap(j), k, -k)
+            }) ()
           }
           //println("Thread %d repeats: %d".format(index, repeats))
         }
@@ -154,13 +155,14 @@ class ConcurrentMapSpec extends Spec {
           for (j <- 0 until sz) {
             val i = (offs + j) % sz
             var success = false
-            do {
+            while ({
               if (ct.contains(new Wrap(i))) {
                 success = ct.remove(new Wrap(i)) != None
               } else {
                 success = ct.putIfAbsent(new Wrap(i), i) == None
               }
-            } while (!success)
+              !success
+            }) ()
           }
         }
       }
diff --git a/junit/src/test/scala/scala/collection/concurrent/ctries_new/SnapshotSpec.scala b/junit/src/test/scala/scala/collection/concurrent/ctries_new/SnapshotSpec.scala
@@ -88,7 +88,7 @@ class SnapshotSpec extends Spec {
             for (i <- 0 until sz) {
               val tres = trie.get(new Wrap(i))
               val ires = initial.get(new Wrap(i))
-              if (tres != ires) println(i, "initially: " + ires, "traversal %d: %s".format(k, tres))
+              if (tres != ires) println((i, "initially: " + ires, "traversal %d: %s".format(k, tres)))
               assert(tres == ires)
             }
           }
diff --git a/junit/src/test/scala/scala/collection/concurrent/ctries_new/Spec.scala b/junit/src/test/scala/scala/collection/concurrent/ctries_new/Spec.scala
@@ -16,22 +16,21 @@ import scala.reflect.{ClassTag, classTag}
 
 trait Spec {
 
-  implicit def implicitously = scala.language.implicitConversions
-  implicit def reflectively  = scala.language.reflectiveCalls
-
-  implicit def str2ops(s: String) = new {
+  implicit class Str2ops(s: String) {
     def in[U](body: =>U): Unit = {
       // just execute body
       body
     }
   }
 
-  implicit def any2ops(a: Any) = new {
+  implicit class Any2ops(a: Any) {
     def shouldEqual(other: Any) = assert(a == other)
   }
 
-  def evaluating[U](body: =>U) = new {
-    def shouldProduce[T <: Throwable: ClassTag]() = {
+  trait HasShouldProduce[U] { def shouldProduce[T <: Throwable: ClassTag](): Unit }
+
+  def evaluating[U](body: =>U): HasShouldProduce[U] = new HasShouldProduce[U] {
+    override def shouldProduce[T <: Throwable: ClassTag]() = {
       var produced = false
       try body
       catch {
diff --git a/junit/src/test/scala/scala/collection/concurrent/ctries_old/ConcurrentMapSpec.scala b/junit/src/test/scala/scala/collection/concurrent/ctries_old/ConcurrentMapSpec.scala
@@ -64,7 +64,7 @@ class ConcurrentMapSpec extends Spec {
     }
 
     def assertEqual(a: Any, b: Any) = {
-      if (a != b) println(a, b)
+      if (a != b) println((a, b))
       assert(a == b)
     }
 
@@ -79,10 +79,11 @@ class ConcurrentMapSpec extends Spec {
           for (i <- 0 until sz) {
             val j = (offs + i) % sz
             var k = Int.MaxValue
-            do {
+            while ({
               if (k != Int.MaxValue) repeats += 1
               k = ct.getOrElse(new Wrap(j), 0)
-            } while (!ct.replace(new Wrap(j), k, -k))
+              !ct.replace(new Wrap(j), k, -k)
+            }) ()
           }
           //println("Thread %d repeats: %d".format(index, repeats))
         }
@@ -154,13 +155,14 @@ class ConcurrentMapSpec extends Spec {
           for (j <- 0 until sz) {
             val i = (offs + j) % sz
             var success = false
-            do {
+            while ({
               if (ct.contains(new Wrap(i))) {
                 success = ct.remove(new Wrap(i)) != None
               } else {
                 success = ct.putIfAbsent(new Wrap(i), i) == None
               }
-            } while (!success)
+              !success
+            }) ()
           }
         }
       }
diff --git a/junit/src/test/scala/scala/collection/concurrent/ctries_old/SnapshotSpec.scala b/junit/src/test/scala/scala/collection/concurrent/ctries_old/SnapshotSpec.scala
@@ -89,7 +89,7 @@ class SnapshotSpec extends Spec {
             for (i <- 0 until sz) {
               val tres = trie.get(new Wrap(i))
               val ires = initial.get(new Wrap(i))
-              if (tres != ires) println(i, "initially: " + ires, "traversal %d: %s".format(k, tres))
+              if (tres != ires) println((i, "initially: " + ires, "traversal %d: %s".format(k, tres)))
               assert(tres == ires)
             }
           }
diff --git a/junit/src/test/scala/scala/collection/concurrent/ctries_old/Spec.scala b/junit/src/test/scala/scala/collection/concurrent/ctries_old/Spec.scala
@@ -12,26 +12,25 @@
 
 package scala.collection.concurrent.ctries_old
 
-import scala.reflect.ClassTag
+import scala.reflect.{ClassTag, classTag}
 
 trait Spec {
 
-  implicit def implicitously = scala.language.implicitConversions
-  implicit def reflectively  = scala.language.reflectiveCalls
-
-  implicit def str2ops(s: String) = new {
+  implicit class Str2ops(s: String) {
     def in[U](body: =>U): Unit = {
       // just execute body
       body
     }
   }
 
-  implicit def any2ops(a: Any) = new {
+  implicit class Any2ops(a: Any) {
     def shouldEqual(other: Any) = assert(a == other)
   }
 
-  def evaluating[U](body: =>U) = new {
-    def shouldProduce[T <: Throwable: ClassTag]() = {
+  trait HasShouldProduce[U] { def shouldProduce[T <: Throwable: ClassTag](): Unit }
+
+  def evaluating[U](body: =>U): HasShouldProduce[U] = new HasShouldProduce[U] {
+    override def shouldProduce[T <: Throwable: ClassTag]() = {
       var produced = false
       try body
       catch {
diff --git a/scalacheck/src/test/scala/ParallelIterableCheck.scala b/scalacheck/src/test/scala/ParallelIterableCheck.scala
@@ -275,8 +275,7 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col
     ("drop " + n + " elements") |: t.drop(n).iterator.sameElements(coll.drop(n))
   }
 
-  if (hasStrictOrder) property("slices must be equal") = forAllNoShrink(collectionPairsWith2Indices)
-  { case (t, coll, fr, slicelength) =>
+  if (hasStrictOrder) property("slices must be equal") = forAllNoShrink(collectionPairsWith2Indices) { case (t, coll, fr, slicelength) =>
     val from = if (fr < 0) 0 else fr
     val until = if (from + slicelength > t.size) t.size else from + slicelength
     val tsl = t.slice(from, until)

Original file line number	Diff line number	Diff line change
`@@ -296,7 +296,7 @@ self =>`
`296`	`296`	`}`
`297`	`297`
`298`	`298`	`/* convenience task operations wrapper */`
`299`		`- protected implicit def task2ops[R, Tp](tsk: SSCTask[R, Tp]) = new TaskOps[R, Tp] {`
	`299`	`+ protected implicit def task2ops[R, Tp](tsk: SSCTask[R, Tp]): TaskOps[R, Tp] = new TaskOps[R, Tp] {`
`300`	`300`	`def mapResult[R1](mapping: R => R1): ResultMapping[R, Tp, R1] = new ResultMapping[R, Tp, R1](tsk) {`
`301`	`301`	`def map(r: R): R1 = mapping(r)`
`302`	`302`	`}`
`@@ -316,14 +316,14 @@ self =>`
`316`	`316`	`}`
`317`	`317`
`318`	`318`	`/* convenience signalling operations wrapper */`
`319`		`- protected implicit def delegatedSignalling2ops[PI <: DelegatedSignalling](it: PI) = new SignallingOps[PI] {`
	`319`	`+ protected implicit def delegatedSignalling2ops[PI <: DelegatedSignalling](it: PI): SignallingOps[PI] = new SignallingOps[PI] {`
`320`	`320`	`def assign(cntx: Signalling): PI = {`
`321`	`321`	`it.signalDelegate = cntx`
`322`	`322`	`it`
`323`	`323`	`}`
`324`	`324`	`}`
`325`	`325`
`326`		`- protected implicit def builder2ops[Elem, To](cb: Builder[Elem, To]) = new BuilderOps[Elem, To] {`
	`326`	`+ protected implicit def builder2ops[Elem, To](cb: Builder[Elem, To]): BuilderOps[Elem, To] = new BuilderOps[Elem, To] {`
`327`	`327`	`def ifIs[Cmb](isbody: Cmb => Unit) = new Otherwise[Cmb] {`
`328`	`328`	`def otherwise(notbody: => Unit)(implicit t: ClassTag[Cmb]): Unit = {`
`329`	`329`	`if (cb.getClass == t.runtimeClass) isbody(cb.asInstanceOf[Cmb]) else notbody`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ class ConcurrentMapSpec extends Spec {`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`def assertEqual(a: Any, b: Any) = {`
`67`		`- if (a != b) println(a, b)`
	`67`	`+ if (a != b) println((a, b))`
`68`	`68`	`assert(a == b)`
`69`	`69`	`}`
`70`	`70`
`@@ -79,10 +79,11 @@ class ConcurrentMapSpec extends Spec {`
`79`	`79`	`for (i <- 0 until sz) {`
`80`	`80`	`val j = (offs + i) % sz`
`81`	`81`	`var k = Int.MaxValue`
`82`		`- do {`
	`82`	`+ while ({`
`83`	`83`	`if (k != Int.MaxValue) repeats += 1`
`84`	`84`	`k = ct.getOrElse(new Wrap(j), 0)`
`85`		`- } while (!ct.replace(new Wrap(j), k, -k))`
	`85`	`+ !ct.replace(new Wrap(j), k, -k)`
	`86`	`+ }) ()`
`86`	`87`	`}`
`87`	`88`	`//println("Thread %d repeats: %d".format(index, repeats))`
`88`	`89`	`}`
`@@ -154,13 +155,14 @@ class ConcurrentMapSpec extends Spec {`
`154`	`155`	`for (j <- 0 until sz) {`
`155`	`156`	`val i = (offs + j) % sz`
`156`	`157`	`var success = false`
`157`		`- do {`
	`158`	`+ while ({`
`158`	`159`	`if (ct.contains(new Wrap(i))) {`
`159`	`160`	`success = ct.remove(new Wrap(i)) != None`
`160`	`161`	`} else {`
`161`	`162`	`success = ct.putIfAbsent(new Wrap(i), i) == None`
`162`	`163`	`}`
`163`		`- } while (!success)`
	`164`	`+ !success`
	`165`	`+ }) ()`
`164`	`166`	`}`
`165`	`167`	`}`
`166`	`168`	`}`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ class SnapshotSpec extends Spec {`
`88`	`88`	`for (i <- 0 until sz) {`
`89`	`89`	`val tres = trie.get(new Wrap(i))`
`90`	`90`	`val ires = initial.get(new Wrap(i))`
`91`		`- if (tres != ires) println(i, "initially: " + ires, "traversal %d: %s".format(k, tres))`
	`91`	`+ if (tres != ires) println((i, "initially: " + ires, "traversal %d: %s".format(k, tres)))`
`92`	`92`	`assert(tres == ires)`
`93`	`93`	`}`
`94`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ class SnapshotSpec extends Spec {`
`89`	`89`	`for (i <- 0 until sz) {`
`90`	`90`	`val tres = trie.get(new Wrap(i))`
`91`	`91`	`val ires = initial.get(new Wrap(i))`
`92`		`- if (tres != ires) println(i, "initially: " + ires, "traversal %d: %s".format(k, tres))`
	`92`	`+ if (tres != ires) println((i, "initially: " + ires, "traversal %d: %s".format(k, tres)))`
`93`	`93`	`assert(tres == ires)`
`94`	`94`	`}`
`95`	`95`	`}`
Original file line number	Diff line number	Diff line change
`@@ -275,8 +275,7 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col`
`275`	`275`	`("drop " + n + " elements") \|: t.drop(n).iterator.sameElements(coll.drop(n))`
`276`	`276`	`}`
`277`	`277`
`278`		`- if (hasStrictOrder) property("slices must be equal") = forAllNoShrink(collectionPairsWith2Indices)`
`279`		`- { case (t, coll, fr, slicelength) =>`
	`278`	`+ if (hasStrictOrder) property("slices must be equal") = forAllNoShrink(collectionPairsWith2Indices) { case (t, coll, fr, slicelength) =>`
`280`	`279`	`val from = if (fr < 0) 0 else fr`
`281`	`280`	`val until = if (from + slicelength > t.size) t.size else from + slicelength`
`282`	`281`	`val tsl = t.slice(from, until)`