Use Typelevel scalac options

build.sbt

@@ -1,18 +1,20 @@
+import org.scalajs.jsenv.nodejs.*
+import org.typelevel.scalacoptions.{ScalaVersion, ScalacOption, ScalacOptions}
+
 val scala3Version   = "3.4.2"
 val scala212Version = "2.12.19"
 val scala213Version = "2.13.14"
 
 val zioVersion       = "2.1.2"
 val scalaTestVersion = "3.2.18"
 
-val compilerOptions = Seq(
-    "-encoding",
-    "utf8",
-    "-feature",
-    "-unchecked",
-    "-deprecation",
-    "-Wvalue-discard",
-    "-language:strictEquality"
+val compilerOptions = Set(
+    ScalacOptions.encoding("utf8"),
+    ScalacOptions.feature,
+    ScalacOptions.unchecked,
+    ScalacOptions.deprecation,
+    ScalacOptions.warnValueDiscard,
+    ScalacOptions.languageStrictEquality
 )
 
 ThisBuild / scalaVersion           := scala3Version
@@ -25,7 +27,7 @@ lazy val `kyo-settings` = Seq(
     fork               := true,
     scalaVersion       := scala3Version,
     crossScalaVersions := List(scala3Version),
-    scalacOptions ++= compilerOptions,
+    scalacOptions ++= scalacOptionTokens(compilerOptions).value,
     scalafmtOnCompile := false,
     organization      := "io.getkyo",
     homepage          := Some(url("https://getkyo.io")),
@@ -43,7 +45,7 @@ lazy val `kyo-settings` = Seq(
     sonatypeProfileName                := "io.getkyo",
     Test / testOptions += Tests.Argument("-oDG"),
     ThisBuild / versionScheme := Some("early-semver"),
-    scalacOptions ++= Seq("-release:11"),
+    scalacOptions ++= scalacOptionToken(ScalacOptions.release("11")).value,
     libraryDependencies += "org.scalatest" %%% "scalatest" % scalaTestVersion % Test,
     Test / javaOptions += "--add-opens=java.base/java.lang=ALL-UNNAMED"
 )
@@ -97,12 +99,8 @@ lazy val `kyo-scheduler` =
         .in(file("kyo-scheduler"))
         .settings(
             `kyo-settings`,
-            scalacOptions --= Seq(
-                "-Wvalue-discard",
-                "-Wunused:all",
-                "-language:strictEquality"
-            ),
-            scalacOptions += "-Xsource:3",
+            scalacOptions ++= scalacOptionToken(ScalacOptions.source3).value,
+            Test / scalacOptions --= scalacOptionToken(ScalacOptions.languageStrictEquality).value,
             crossScalaVersions                      := List(scala3Version, scala212Version, scala213Version),
             libraryDependencies += "org.scalatest" %%% "scalatest"       % scalaTestVersion % Test,
             libraryDependencies += "ch.qos.logback"  % "logback-classic" % "1.5.6"          % Test
@@ -118,16 +116,11 @@ lazy val `kyo-scheduler-zio` = sbtcrossproject.CrossProject("kyo-scheduler-zio",
     .dependsOn(`kyo-scheduler`)
     .settings(
         `kyo-settings`,
-        scalacOptions --= Seq(
-            "-Wvalue-discard",
-            "-Wunused:all",
-            "-language:strictEquality"
-        ),
         libraryDependencies += "dev.zio"       %%% "zio"       % zioVersion,
         libraryDependencies += "org.scalatest" %%% "scalatest" % scalaTestVersion % Test
     )
     .settings(
-        scalacOptions ++= (if (CrossVersion.partialVersion(scalaVersion.value).exists(_._1 == 2)) Seq("-Xsource:3") else Nil),
+        scalacOptions ++= scalacOptionToken(ScalacOptions.source3).value,
         crossScalaVersions := List(scala3Version, scala212Version, scala213Version)
     )
 
@@ -181,12 +174,8 @@ lazy val `kyo-stats-registry` =
         .in(file("kyo-stats-registry"))
         .settings(
             `kyo-settings`,
-            scalacOptions --= Seq(
-                "-Wvalue-discard",
-                "-Wunused:all",
-                "-language:strictEquality"
-            ),
-            scalacOptions += "-Xsource:3",
+            scalacOptions ++= scalacOptionToken(ScalacOptions.source3).value,
+            scalacOptions --= scalacOptionToken(ScalacOptions.languageStrictEquality).value,
             libraryDependencies += "org.hdrhistogram" % "HdrHistogram" % "2.2.2",
             libraryDependencies += "org.scalatest"  %%% "scalatest"    % scalaTestVersion % Test,
             crossScalaVersions                       := List(scala3Version, scala212Version, scala213Version)
@@ -402,11 +391,17 @@ lazy val readme =
             libraryDependencies += "com.softwaremill.sttp.tapir" %% "tapir-json-zio" % "1.10.7"
         )
 
-import org.scalajs.jsenv.nodejs.*
-
 lazy val `js-settings` = Seq(
     Compile / doc / sources                     := Seq.empty,
     fork                                        := false,
     jsEnv                                       := new NodeJSEnv(NodeJSEnv.Config().withArgs(List("--max_old_space_size=5120"))),
     libraryDependencies += "io.github.cquiroz" %%% "scala-java-time" % "2.5.0" % "provided"
 )
+
+def scalacOptionToken(proposedScalacOption: ScalacOption) =
+    scalacOptionTokens(Set(proposedScalacOption))
+
+def scalacOptionTokens(proposedScalacOptions: Set[ScalacOption]) = Def.setting {
+    val version = ScalaVersion.fromString(scalaVersion.value).right.get
+    ScalacOptions.tokensForVersion(version, proposedScalacOptions)
+}

kyo-core/shared/src/main/scala/kyo/package.scala

@@ -61,10 +61,6 @@ package object kyo:
     )(using Trace): (T1, T2, T3, T4) < S =
         v1.map(t1 => v2.map(t2 => v3.map(t3 => v4.map(t4 => (t1, t2, t3, t4)))))
 
-    inline def discard[T](v: T): Unit =
-        val _ = v
-        ()
-
     private[kyo] inline def isNull[T](v: T): Boolean =
         v.asInstanceOf[AnyRef] eq null
 

kyo-scheduler-zio/jvm/src/main/scala/kyo/KyoSchedulerZIORuntime.scala

@@ -3,7 +3,6 @@ package kyo
 import kyo.scheduler.*
 import zio.*
 import zio.internal.ExecutionMetrics
-import zio.internal.FiberRuntime
 
 object KyoSchedulerZIORuntime {
     private[kyo] lazy val layer = {

kyo-scheduler/jvm/src/main/scala/kyo/discard.scala

@@ -0,0 +1,5 @@
+package kyo
+
+inline def discard[T](v: T): Unit =
+    val _ = v
+    ()

kyo-scheduler/jvm/src/main/scala/kyo/scheduler/InternalClock.scala

@@ -1,5 +1,7 @@
 package kyo.scheduler
 
+import kyo.discard
+
 import java.util.concurrent.Executor
 import java.util.concurrent.locks.LockSupport
 
@@ -32,6 +34,5 @@ final private[kyo] case class InternalClock(executor: Executor) {
     def stop(): Unit =
         _stop = true
 
-    private val gauge =
-        statsScope.scope("clock").gauge("skew")((System.currentTimeMillis() - millis).toDouble)
+    discard(statsScope.scope("clock").gauge("skew")((System.currentTimeMillis() - millis).toDouble))
 }

kyo-scheduler/jvm/src/main/scala/kyo/scheduler/Queue.scala

@@ -2,7 +2,6 @@ package kyo.scheduler
 
 import java.lang.invoke.VarHandle
 import java.util.concurrent.atomic.AtomicBoolean
-import kyo.*
 import scala.collection.mutable.PriorityQueue
 
 final private class Queue[T](implicit ord: Ordering[T]) extends AtomicBoolean {

kyo-scheduler/jvm/src/main/scala/kyo/scheduler/Scheduler.scala

@@ -1,12 +1,14 @@
 package kyo.scheduler
 
 import Scheduler.*
+
 import java.util.concurrent.Executor
 import java.util.concurrent.Executors
 import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.ThreadPoolExecutor
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.LongAdder
+import kyo.discard
 import kyo.scheduler.regulator.Admission
 import kyo.scheduler.regulator.Concurrency
 import kyo.scheduler.top.Reporter
@@ -15,9 +17,8 @@ import kyo.scheduler.util.Flag
 import kyo.scheduler.util.LoomSupport
 import kyo.scheduler.util.Threads
 import kyo.scheduler.util.XSRandom
-import scala.annotation.tailrec
+
 import scala.concurrent.ExecutionContext
-import scala.concurrent.duration.*
 import scala.util.control.NonFatal
 
 final class Scheduler(
@@ -105,7 +106,6 @@ final class Scheduler(
     }
 
     private def steal(thief: Worker): Task = {
-        val nowMs          = clock.currentMillis()
         val currentWorkers = this.currentWorkers
         var worker: Worker = null
         var maxLoad        = 1
@@ -194,7 +194,7 @@ final class Scheduler(
                 if (worker ne null) {
                     if (position >= currentWorkers)
                         worker.drain()
-                    worker.checkAvailability(nowMs)
+                    val _ = worker.checkAvailability(nowMs)
                 }
                 position += 1
             }
@@ -204,13 +204,14 @@ final class Scheduler(
         }
     }
 
-    private val gauges =
+    discard(
         List(
             statsScope.gauge("current_workers")(currentWorkers),
             statsScope.gauge("allocated_workers")(allocatedWorkers),
             statsScope.gauge("load_avg")(loadAvg()),
             statsScope.gauge("flushes")(flushes.sum().toDouble)
         )
+    )
 
     def status(): Status = {
         def workerStatus(i: Int) =

kyo-scheduler/jvm/src/main/scala/kyo/scheduler/Worker.scala

@@ -1,10 +1,10 @@
 package kyo.scheduler
 
-import java.lang.StackWalker.StackFrame
 import java.lang.invoke.MethodHandles
 import java.lang.invoke.VarHandle
 import java.util.concurrent.Executor
 import java.util.concurrent.atomic.LongAdder
+import kyo.discard
 import kyo.scheduler.top.WorkerStatus
 import scala.util.control.NonFatal
 
@@ -155,7 +155,7 @@ abstract private class Worker(
         }
     }
 
-    private val gauges =
+    discard(
         List(
             statsScope.gauge("queue_size")(queue.size()),
             statsScope.counterGauge("executions")(executions),
@@ -165,6 +165,7 @@ abstract private class Worker(
             statsScope.counterGauge("stolen_tasks")(stolenTasks),
             statsScope.counterGauge("lost_tasks")(lostTasks.sum())
         )
+    )
 
     def status(): WorkerStatus = {
         val (thread, frame) =

kyo-scheduler/jvm/src/main/scala/kyo/scheduler/package.scala

@@ -1,7 +1,5 @@
 package kyo
 
-import java.io.PrintWriter
-import java.io.StringWriter
 import java.util.logging.*
 import kyo.stats.internal.StatsRegistry
 

kyo-scheduler/jvm/src/main/scala/kyo/scheduler/regulator/Admission.scala

@@ -2,6 +2,7 @@ package kyo.scheduler.regulator
 
 import java.util.concurrent.ThreadLocalRandom
 import java.util.concurrent.atomic.LongAdder
+import kyo.discard
 import kyo.scheduler.*
 import kyo.scheduler.InternalTimer
 import kyo.scheduler.top.AdmissionStatus
@@ -52,12 +53,13 @@ final class Admission(
     protected def update(diff: Int): Unit =
         admissionPercent = Math.max(0, Math.min(100, admissionPercent + diff))
 
-    private val gauges =
+    discard(
         List(
             statsScope.gauge("percent")(admissionPercent),
             statsScope.counterGauge("allowed")(allowed.sum()),
             statsScope.counterGauge("rejected")(rejected.sum())
         )
+    )
 
     def status(): AdmissionStatus =
         AdmissionStatus(

kyo-scheduler/jvm/src/main/scala/kyo/scheduler/regulator/Concurrency.scala

@@ -1,7 +1,6 @@
 package kyo.scheduler.regulator
 
 import kyo.scheduler.*
-import kyo.scheduler.top.AdmissionStatus
 import kyo.scheduler.top.ConcurrencyStatus
 import kyo.scheduler.util.Flag
 import scala.concurrent.duration.*

kyo-scheduler/jvm/src/main/scala/kyo/scheduler/regulator/Regulator.scala

@@ -76,7 +76,7 @@ abstract class Regulator(
 
     def stop(): Unit = {
         collectTask.cancel()
-        regulateTask.cancel()
+        val _ = regulateTask.cancel()
     }
 
     protected val statsScope = kyo.scheduler.statsScope.scope("regulator", getClass.getSimpleName().toLowerCase())

kyo-scheduler/jvm/src/main/scala/kyo/scheduler/top/Client.scala

@@ -1,12 +1,9 @@
 package kyo.scheduler.top
 
-import java.io.PrintWriter
 import javax.management.MBeanServerConnection
 import javax.management.ObjectName
-import javax.management.remote
 import javax.management.remote.JMXConnectorFactory
 import javax.management.remote.JMXServiceURL
-import kyo.scheduler.Scheduler
 import scala.concurrent.duration.*
 
 object Client {

kyo-scheduler/jvm/src/main/scala/kyo/scheduler/top/Console.scala

@@ -1,7 +1,6 @@
 package kyo.scheduler.top
 
 import scala.annotation.nowarn
-import scala.concurrent.duration.*
 
 @nowarn
 object Console extends App {

kyo-scheduler/jvm/src/main/scala/kyo/scheduler/top/Reporter.scala

@@ -1,17 +1,11 @@
 package kyo.scheduler.top
 
 import java.lang.management.ManagementFactory
-import javax.management.Attribute
 import javax.management.MBeanServer
 import javax.management.ObjectName
 import javax.management.StandardMBean
-import javax.management.remote.JMXConnectorFactory
-import javax.management.remote.JMXServiceURL
 import kyo.scheduler.InternalTimer
-import kyo.scheduler.Scheduler
-import scala.annotation.nowarn
 import scala.concurrent.duration.*
-import scala.io.StdIn
 
 class Reporter(
     status: () => Status,
@@ -25,18 +19,19 @@ class Reporter(
 
     private var lastConsoleStatus: Status = null
 
-    if (enableTopConsoleMs > 0)
-        timer.schedule(enableTopConsoleMs.millis) {
+    if (enableTopConsoleMs > 0) {
+        val _ = timer.schedule(enableTopConsoleMs.millis) {
             val currentStatus = status()
             if (lastConsoleStatus ne null) {
                 println(Printer(currentStatus - lastConsoleStatus))
             }
             lastConsoleStatus = currentStatus
         }
+    }
 
     if (enableTopJMX) {
         close()
-        mBeanServer.registerMBean(new StandardMBean(this, classOf[TopMBean]), objectName)
+        val _ = mBeanServer.registerMBean(new StandardMBean(this, classOf[TopMBean]), objectName)
     }
 
     def getStatus() = status()

kyo-stats-registry/js/src/main/scala/kyo/stats/internal/StatsRefresh.scala

@@ -1,9 +1,5 @@
 package kyo.stats.internal
 
-import java.util.concurrent.Executors
-import java.util.concurrent.ThreadFactory
-import java.util.concurrent.TimeUnit
-
 trait StatsRefresh {
     def refresh(): Unit
 }

kyo-stats-registry/js/src/main/scala/kyo/stats/internal/UnsafeHistogram.scala

@@ -1,7 +1,5 @@
 package kyo.stats.internal
 
-import org.HdrHistogram.ConcurrentDoubleHistogram as HdrHistogram
-
 class UnsafeHistogram(numberOfSignificantValueDigits: Int, highestToLowestValueRatio: Long) {
 
     def observe(v: Long): Unit = {}

kyo-stats-registry/jvm/src/main/scala/kyo/stats/internal/StatsRefresh.scala

@@ -22,5 +22,7 @@ trait StatsRefresh {
     Executors.newSingleThreadScheduledExecutor(threadFactory)
         .scheduleAtFixedRate(() => refresh(), refreshInterval, refreshInterval, TimeUnit.MILLISECONDS)
 
-    ServiceLoader.load(classOf[StatsExporter]).iterator().forEachRemaining(exporters.add(_))
+    ServiceLoader.load(classOf[StatsExporter]).iterator().forEachRemaining { exporter =>
+        val _ = exporters.add(exporter)
+    }
 }