remove unused imports

getkyo · Feb 23, 2024 · 09b58b8 · 09b58b8
1 parent 6ce725b
commit 09b58b8
Show file tree

Hide file tree

Showing 57 changed files with 48 additions and 175 deletions.
diff --git a/build.sbt b/build.sbt
@@ -7,7 +7,9 @@ val compilerOptions = Seq(
     "-unchecked",
     "-deprecation",
     "-language:implicitConversions",
-    "-Wvalue-discard"
+    "-Wvalue-discard",
+    "-Wunused:all"
+    // "-Xfatal-warnings"
     // "-explain"
     // "-Vprofile",
 )

diff --git a/kyo-bench/src/main/scala/kyo/bench/Bench.scala b/kyo-bench/src/main/scala/kyo/bench/Bench.scala
@@ -30,7 +30,7 @@ import zio.UIO
     // jvm = "/Users/flavio.brasil/Downloads/graalvm-ce-java17-22.3.0/Contents/Home/bin/java"
 )
 @BenchmarkMode(Array(Mode.Throughput))
-sealed abstract class Bench[T](using f: Flat[T]):
+sealed abstract class Bench[T]:
     def zioBench(): UIO[T]
     def kyoBenchFiber(): T < Fibers = kyoBench()
     def kyoBench(): T < IOs

diff --git a/kyo-bench/src/main/scala/kyo/bench/ForkManyBench.scala b/kyo-bench/src/main/scala/kyo/bench/ForkManyBench.scala
@@ -69,7 +69,6 @@ class ForkManyBench extends Bench.ForkOnly[Int]:
     @Benchmark
     def forkOx() =
         import ox.*
-        import ox.channels.*
         import java.util.concurrent.CompletableFuture
         import java.util.concurrent.atomic.AtomicInteger
 

diff --git a/kyo-bench/src/main/scala/kyo/bench/ForkSpawnBench.scala b/kyo-bench/src/main/scala/kyo/bench/ForkSpawnBench.scala
@@ -10,7 +10,6 @@ class ForkSpawnBench extends Bench.ForkOnly[Unit]:
 
     def catsBench() =
         import cats.effect.IO
-        import cats.effect.std.Semaphore
         import cats.effect.std.CountDownLatch
 
         def repeat[A](n: Int)(io: IO[A]): IO[A] =

diff --git a/kyo-bench/src/main/scala/kyo/bench/LoggingBench.scala b/kyo-bench/src/main/scala/kyo/bench/LoggingBench.scala
@@ -36,7 +36,6 @@ class LoggingBench extends Bench.SyncAndFork[Unit]:
 
     def zioBench() =
         import zio.*
-        import zio.logging.backend.SLF4J
 
         def loop(i: Int): UIO[Unit] =
             if i > depth then

diff --git a/kyo-bench/src/main/scala/kyo/bench/RendezvousBench.scala b/kyo-bench/src/main/scala/kyo/bench/RendezvousBench.scala
@@ -62,7 +62,6 @@ class RendezvousBench extends Bench.ForkOnly[Int]:
 
     override def kyoBenchFiber() =
         import kyo.*
-        import kyo.*
 
         def produce(waiting: AtomicRef[Any], n: Int = 0): Unit < Fibers =
             if n <= depth then

diff --git a/kyo-core/js/src/main/scala/kyo/queuesStubs.scala b/kyo-core/js/src/main/scala/kyo/queuesStubs.scala
@@ -1,8 +1,6 @@
 package org.jctools.queues
 
 import java.util.ArrayDeque
-import java.util.concurrent.BlockingQueue
-import java.util.concurrent.LinkedBlockingDeque
 
 class StubQueue[T](capacity: Int) extends ArrayDeque[T]:
     def isFull = size() >= capacity

diff --git a/kyo-core/js/src/main/scala/kyo/scheduler/Threads.scala b/kyo-core/js/src/main/scala/kyo/scheduler/Threads.scala
@@ -1,7 +1,6 @@
 package kyo.scheduler
 
 import java.util.concurrent.ThreadFactory
-import java.util.concurrent.atomic.AtomicInteger
 
 object Threads:
 
@@ -11,3 +10,4 @@ object Threads:
     def apply(name: String, create: Runnable => Thread): ThreadFactory =
         new ThreadFactory
 end Threads
+
diff --git a/kyo-core/js/src/main/scala/kyo/stats/internal/ServiceLoader.scala b/kyo-core/js/src/main/scala/kyo/stats/internal/ServiceLoader.scala
@@ -1,8 +1,5 @@
 package java.util
 
-import java.util.ArrayList
-import java.util.Iterator
-
 class ServiceLoader[T]:
     def iterator(): Iterator[T] =
         (new ArrayList[T](0)).iterator()

diff --git a/kyo-core/jvm/src/main/scala/kyo/scheduler/Coordinator.scala b/kyo-core/jvm/src/main/scala/kyo/scheduler/Coordinator.scala
@@ -1,9 +1,8 @@
 package kyo.scheduler
 
 import java.util.concurrent.Executors
-import scala.util.Random
+import jdk.internal.vm.annotation.Contended
 import scala.util.control.NonFatal
-import scala.util.control.NonFatal.apply
 
 private object Coordinator:
 
@@ -15,13 +14,8 @@ private object Coordinator:
     private val cycleTicks = Math.pow(2, cycleExp).intValue()
     private val cycleMask  = cycleTicks - 1
 
-    @volatile private[this] var ticks: Long = 0L
-
-    private val a1, a2, a3, a4, a5, a6, a7 = 0L // paddding
-
-    @volatile private[this] var cycles = 0L
-
-    private val b1, b2, b3, b4, b5, b6, b7 = 0L // paddding
+    @Contended @volatile private[this] var ticks: Long = 0L
+    @Contended @volatile private[this] var cycles      = 0L
 
     private var startNs = 0L
     private val delayNs = new MovingStdDev(cycleExp)

diff --git a/kyo-core/jvm/src/main/scala/kyo/scheduler/MovingStdDev.scala b/kyo-core/jvm/src/main/scala/kyo/scheduler/MovingStdDev.scala
@@ -4,8 +4,8 @@ final private class MovingStdDev(exp: Int):
 
     private val window = 1 << exp
     private val mask   = window - 1
-    private var values = new Array[Long](window)
-    private var devs   = new Array[Long](window)
+    private val values = new Array[Long](window)
+    private val devs   = new Array[Long](window)
     private var idx    = 0
     private var sum    = 0L
     private var sumDev = 0L

diff --git a/kyo-core/jvm/src/main/scala/kyo/scheduler/Scheduler.scala b/kyo-core/jvm/src/main/scala/kyo/scheduler/Scheduler.scala
@@ -2,16 +2,7 @@ package kyo.scheduler
 
 import java.util.concurrent.Executors
 import java.util.concurrent.atomic.AtomicInteger
-import java.util.concurrent.atomic.AtomicReference
-import java.util.concurrent.atomic.LongAdder
-import java.util.concurrent.locks.LockSupport
 import kyo.*
-import kyo.scheduler.Coordinator
-import kyo.scheduler.Flag
-import kyo.scheduler.IOTask
-import kyo.scheduler.Threads
-import kyo.scheduler.Worker
-import kyo.scheduler.XSRandom
 import org.jctools.queues.MpmcUnboundedXaddArrayQueue
 import scala.annotation.tailrec
 

diff --git a/kyo-core/jvm/src/main/scala/kyo/scheduler/Worker.scala b/kyo-core/jvm/src/main/scala/kyo/scheduler/Worker.scala
@@ -1,14 +1,8 @@
 package kyo.scheduler
 
-import java.util.Comparator
-import java.util.PriorityQueue
 import java.util.concurrent.CopyOnWriteArrayList
-import java.util.concurrent.Semaphore
 import java.util.concurrent.locks.LockSupport
 import kyo.iosInternal.*
-import kyo.scheduler.IOTask
-import kyo.scheduler.Queue
-import kyo.scheduler.Scheduler
 
 final private class Worker(r: Runnable)
     extends Thread(r):

diff --git a/kyo-core/jvm/src/test/scala/kyoTest/MonadLawsTest.scala b/kyo-core/jvm/src/test/scala/kyoTest/MonadLawsTest.scala
@@ -2,8 +2,6 @@ package kyoTest
 
 import kyo.*
 import kyo.Flat.unsafe.bypass
-import scala.concurrent.ExecutionContext.Implicits.global
-import scala.concurrent.duration.Duration
 import zio.Trace
 import zio.prelude.Equal
 import zio.prelude.coherent.CovariantDeriveEqual

diff --git a/kyo-core/shared/src/main/scala/kyo/KyoApp.scala b/kyo-core/shared/src/main/scala/kyo/KyoApp.scala
@@ -1,6 +1,6 @@
 package kyo
 
-import scala.annotation.nowarn
+import scala.collection.mutable.ListBuffer
 import scala.concurrent.duration.Duration
 import scala.util.Try
 
@@ -14,15 +14,24 @@ end KyoApp
 
 object KyoApp:
 
-    abstract class Base[S] extends App:
+    abstract class Base[S]:
 
         protected def handle[T](v: T < S)(using f: Flat[T < S]): Unit
 
-        @nowarn
+        final protected def args: Array[String] = _args
+
+        private[this] var _args: Array[String] = _
+
+        private[this] val initCode = new ListBuffer[() => Unit]
+
+        final def main(args: Array[String]) =
+            this._args = args
+            for proc <- initCode do proc()
+
         protected def run[T](v: => T < S)(
             using f: Flat[T < S]
         ): Unit =
-            delayedInit(handle(v))
+            initCode += (() => handle(v))
     end Base
 
     type Effects = Fibers & Resources

diff --git a/kyo-core/shared/src/main/scala/kyo/channels.scala b/kyo-core/shared/src/main/scala/kyo/channels.scala
@@ -35,8 +35,7 @@ end Channel
 
 object Channels:
 
-    private val placeholder = Fibers.unsafeInitPromise[Unit]
-    private val closed      = IOs.fail("Channel closed!")
+    private val closed = IOs.fail("Channel closed!")
 
     def init[T: Flat](
         capacity: Int,

diff --git a/kyo-core/shared/src/main/scala/kyo/internal/FlatImplicits.scala b/kyo-core/shared/src/main/scala/kyo/internal/FlatImplicits.scala
@@ -43,10 +43,10 @@ object FlatImplicits:
         def fail(msg: String) =
             report.errorAndAbort(s"Method doesn't accept nested Kyo computations.\n$msg")
 
-        def canDerive(t: TypeRepr) =
+        def derive(t: TypeRepr) =
             t.asType match
                 case '[nt] =>
-                    Expr.summon[Flat[nt]].isDefined
+                    Expr.summon[Flat[nt]]
 
         def isAny(t: TypeRepr) =
             t.typeSymbol == TypeRepr.of[Any].typeSymbol
@@ -55,10 +55,14 @@ object FlatImplicits:
             t.typeSymbol.isClassDef
 
         def check(t: TypeRepr): Expr[Flat[T]] =
-            if isAny(t) || (!isConcrete(t.dealias) && !canDerive(t)) then
-                fail(
-                    s"Cannot prove ${code(print(t))} isn't nested. Provide an implicit evidence ${code(s"kyo.Flat[${print(t)}]")}."
-                )
+            if isAny(t) || !isConcrete(t.dealias) then
+                derive(t) match
+                    case Some(d) =>
+                        '{ $d.asInstanceOf[Flat[T]] }
+                    case None =>
+                        fail(
+                            s"Cannot prove ${code(print(t))} isn't nested. Provide an implicit evidence ${code(s"kyo.Flat[${print(t)}]")}."
+                        )
             else
                 '{ Flat.unsafe.bypass[T] }
 

diff --git a/kyo-core/shared/src/main/scala/kyo/randoms.scala b/kyo-core/shared/src/main/scala/kyo/randoms.scala
@@ -1,7 +1,5 @@
 package kyo
 
-import scala.Console
-
 abstract class Random:
     def nextInt: Int < IOs
     def nextInt(n: Int): Int < IOs

diff --git a/kyo-core/shared/src/main/scala/kyo/scheduler/IOPromise.scala b/kyo-core/shared/src/main/scala/kyo/scheduler/IOPromise.scala
@@ -2,11 +2,8 @@ package kyo.scheduler
 
 import IOPromise.*
 import java.util.concurrent.atomic.AtomicReference
-import java.util.concurrent.locks.AbstractQueuedSynchronizer
-import java.util.concurrent.locks.Lock
 import java.util.concurrent.locks.LockSupport
 import kyo.*
-import kyo.scheduler.Scheduler
 import scala.annotation.tailrec
 import scala.util.control.NonFatal
 

diff --git a/kyo-core/shared/src/main/scala/kyo/scheduler/IOTask.scala b/kyo-core/shared/src/main/scala/kyo/scheduler/IOTask.scala
@@ -2,7 +2,6 @@ package kyo.scheduler
 
 import java.util.ArrayDeque
 import java.util.Arrays
-import java.util.IdentityHashMap
 import kyo.*
 import kyo.Locals.State
 import kyo.core.*
@@ -177,6 +176,6 @@ private[kyo] class IOTask[T](
                 s"[$f]"
             case arr: ArrayDeque[() => Unit] @unchecked =>
                 Arrays.toString(arr.toArray)
-        s"IOTask(id=${hashCode},preempting=${check()},curr=$curr,ensures=$ensures,runtime=${runtime()},state=${get()})"
+        s"IOTask(id=${hashCode},preempting=${check()},curr=$curr,ensures=$e,runtime=${runtime()},state=${get()})"
     end toString
 end IOTask
diff --git a/kyo-core/shared/src/main/scala/kyo/seqs.scala b/kyo-core/shared/src/main/scala/kyo/seqs.scala
@@ -1,7 +1,6 @@
 package kyo
 
 import kyo.core.*
-import scala.collection.mutable.ListBuffer
 
 sealed abstract class Seqs private[kyo] () extends Effect[Seq, Seqs]:
 

diff --git a/kyo-core/shared/src/test/scala/kyoTest/FlatTest.scala b/kyo-core/shared/src/test/scala/kyoTest/FlatTest.scala
@@ -22,6 +22,7 @@ class FlatTest extends KyoTest:
                 implicitly[Flat[T < Options]]
                 implicitly[Flat[T < Any]]
             end test1
+            test1[Int]
             succeed
         }
         "derived" in {
@@ -30,6 +31,7 @@ class FlatTest extends KyoTest:
                 implicitly[Flat[T < Options]]
                 implicitly[Flat[T < Any]]
             end test2
+            test2[Int]
             succeed
         }
     }

diff --git a/kyo-core/shared/src/test/scala/kyoTest/KyoTest.scala b/kyo-core/shared/src/test/scala/kyoTest/KyoTest.scala
@@ -1,17 +1,12 @@
 package kyoTest
 
-import izumi.reflect.*
 import kyo.*
 import org.scalatest.Assertions
 import org.scalatest.compatible.Assertion
 import org.scalatest.concurrent.ScalaFutures.*
-import org.scalatest.freespec.AnyFreeSpec
 import org.scalatest.freespec.AsyncFreeSpec
-import org.scalatest.time.Seconds
-import org.scalatest.time.Span
 import scala.concurrent.ExecutionContext
 import scala.concurrent.Future
-import scala.concurrent.Promise
 import scala.concurrent.duration.*
 import scala.util.Try
 

diff --git a/kyo-core/shared/src/test/scala/kyoTest/abortsTest.scala b/kyo-core/shared/src/test/scala/kyoTest/abortsTest.scala
@@ -1,11 +1,6 @@
 package kyoTest
 
 import kyo.*
-import org.scalatest.Args
-import org.scalatest.Status
-import scala.util.Failure
-import scala.util.Success
-import scala.util.Try
 
 class abortsTest extends KyoTest:
 

diff --git a/kyo-core/shared/src/test/scala/kyoTest/clocksTest.scala b/kyo-core/shared/src/test/scala/kyoTest/clocksTest.scala
@@ -1,7 +1,6 @@
 package kyoTest
 
 import java.time.Instant
-import java.time.ZoneId
 import kyo.*
 
 class clocksTest extends KyoTest:

diff --git a/kyo-core/shared/src/test/scala/kyoTest/envsTest.scala b/kyo-core/shared/src/test/scala/kyoTest/envsTest.scala
@@ -29,7 +29,6 @@ class envsTest extends KyoTest:
         "one service" in {
             val a =
                 Envs[Service1].get.map(_(1))
-            val b: Int < Envs[Service1] = a
             assert(
                 Envs[Service1].run(service1)(a) ==
                     2
@@ -54,16 +53,10 @@ class envsTest extends KyoTest:
                 )
             }
             "dependent services" in {
-                val s1 = Envs[Service2].get.map(service2 =>
-                    new Service1:
-                        def apply(i: Int) = service2(i * 10)
-                )
-                val v1: Service1 < Envs[Service2] = s1
-                val v2 =
+                val v1 =
                     Envs[Service1].run[Int, Envs[Service2]](service1)(v)
-                val v3: Int < Envs[Service2] = v2
                 assert(
-                    Envs[Service2].run(service2)(v3) ==
+                    Envs[Service2].run(service2)(v1) ==
                         4
                 )
             }
@@ -90,7 +83,6 @@ class envsTest extends KyoTest:
             "continue" in {
                 val a =
                     Envs[Service1].get.map(_(1))
-                val b: Int < (Envs[Service1] & Options) = a
                 assert(
                     Options.run(Envs[Service1].run(service1)(a)) ==
                         Some(2)
@@ -99,7 +91,6 @@ class envsTest extends KyoTest:
             "short circuit" in {
                 val a =
                     Envs[Service1].get.map(_(0))
-                val b: Int < (Envs[Service1] & Options) = a
                 assert(
                     Options.run(Envs[Service1].run(service1)(a)) ==
                         None
@@ -130,11 +121,6 @@ class envsTest extends KyoTest:
                     )
                 }
                 "dependent services" in {
-                    val s1 = Envs[Service2].get.map(service2 =>
-                        new Service1:
-                            def apply(i: Int) = service2(i * 10)
-                    )
-                    val v1: Service1 < Envs[Service2]        = s1
                     val v2: Int < (Envs[Service2] & Options) = Envs[Service1].run(service1)(v)
                     assert(
                         Options.run(Envs[Service2].run(service2)(v2)) ==