Scala3/kernel+core

.scalafix.conf

@@ -2,4 +2,4 @@ OrganizeImports {
   removeUnused = true
   groups = ["re:javax?\\.", "scala.", "tofu." "*"]
   groupedImports = AggressiveMerge
-}
+}

.scalafmt.conf

@@ -4,7 +4,15 @@ maxColumn = 120
 includeCurlyBraceInSelectChains = false
 align.preset = most
 version = "3.7.11"
-runner.dialect = scala213
+runner.dialect = scala213source3
 trailingCommas = preserve
 newlines.penalizeSingleSelectMultiArgList = false
 newlines.alwaysBeforeMultilineDef = false
+fileOverride {
+  "glob:**/scala-2.12/**.scala" {
+     runner.dialect = scala212source3
+  }
+  "glob:**/scala-3/**.scala" {
+     runner.dialect = scala3
+  }
+}

build.sbt

@@ -1,5 +1,7 @@
 import Publish._, Dependencies._
 import sbt.ModuleID
+import org.typelevel.scalacoptions.{ScalacOption, ScalaVersion, ScalacOptions}
+import scala.Ordering.Implicits._
 
 lazy val setMinorVersion = minorVersion := {
   CrossVersion.partialVersion(scalaVersion.value) match {
@@ -9,38 +11,50 @@ lazy val setMinorVersion = minorVersion := {
 }
 
 lazy val defaultSettings = Seq(
-  scalaVersion       := Version.scala213,
-  crossScalaVersions := Vector(Version.scala212, Version.scala213),
+  scalaVersion       := Version.scala3,
   setMinorVersion,
-  defaultScalacOptions,
   scalacWarningConfig,
-  Compile / doc / scalacOptions -= "-Xfatal-warnings",
-  libraryDependencies ++= Seq(
-    compilerPlugin(kindProjector),
-    compilerPlugin(betterMonadicFor),
-    scalatest,
-    collectionCompat,
-    scalaOrganization.value % "scala-reflect" % scalaVersion.value % Provided
-  )
-) ++ macros
+  Test / tpolecatExcludeOptions += ScalacOptions.warnNonUnitStatement,
+  Compile / doc / tpolecatExcludeOptions += ScalacOptions.fatalWarnings,
+  crossScalaVersions := Vector(Version.scala212, Version.scala213),
+  libraryDependencies ++= {
+    (CrossVersion.partialVersion(scalaVersion.value) match {
+      case Some((2, n)) =>
+        Seq(
+          compilerPlugin(betterMonadicFor),
+          compilerPlugin(kindProjector),
+          scalaOrganization.value % "scala-reflect" % scalaVersion.value % Provided
+        )
+      case _            => Seq()
+    }) ++ Seq(scalatest, collectionCompat)
+  }
+) ++ macros ++ defaultScalacOptions
 
 val modules = file("modules")
 
 lazy val higherKindCore = project
   .in(modules / "kernel" / "higherKind")
   .settings(
     defaultSettings,
-    name := "tofu-core-higher-kind",
-    libraryDependencies ++= Seq(catsCore, catsFree, catsTagless),
+    crossScalaVersions := Vector(Version.scala212, Version.scala213, Version.scala3),
+    name               := "tofu-core-higher-kind",
+    libraryDependencies ++= {
+      CrossVersion.partialVersion(scalaVersion.value) match {
+        case Some((2, n)) =>
+          Seq(catsCore, catsFree, catsTaglessMacros)
+        case _            =>
+          Seq(catsCore, catsFree, catsTaglessCore)
+      }
+    },
   )
 
 lazy val kernel = project
   .in(modules / "kernel")
-  .settings(defaultSettings)
   .dependsOn(higherKindCore)
   .settings(
     defaultSettings,
-    name := "tofu-kernel",
+    crossScalaVersions := Vector(Version.scala212, Version.scala213, Version.scala3),
+    name               := "tofu-kernel",
     libraryDependencies += glassCore
   )
 
@@ -49,7 +63,8 @@ lazy val coreCE2 = project
   .dependsOn(kernel)
   .settings(
     defaultSettings,
-    name := "tofu-core-ce2",
+    crossScalaVersions := Vector(Version.scala212, Version.scala213, Version.scala3),
+    name               := "tofu-core-ce2",
     libraryDependencies += catsEffect2
   )
 
@@ -59,7 +74,7 @@ lazy val concurrentCE2 =
     .dependsOn(coreCE2, derivation % "compile->test")
     .settings(
       defaultSettings,
-      libraryDependencies ++= Seq(catsEffect2, catsTagless),
+      libraryDependencies ++= Seq(catsEffect2, catsTaglessMacros),
       libraryDependencies ++= Seq(simulacrum, derevoTagless, glassMacro).map(_ % Test),
       name := "tofu-concurrent-ce2",
     )
@@ -69,7 +84,8 @@ lazy val coreCE3 = project
   .dependsOn(kernel)
   .settings(
     defaultSettings,
-    name := "tofu-core-ce3",
+    crossScalaVersions := Vector(Version.scala212, Version.scala213, Version.scala3),
+    name               := "tofu-core-ce3",
     libraryDependencies += catsEffect3
   )
 
@@ -96,7 +112,7 @@ lazy val loggingStr = project
       alleycats,
       scalatest,
       derevo,
-      catsTagless
+      catsTaglessMacros
     ),
   )
   .dependsOn(kernel)
@@ -238,7 +254,7 @@ lazy val derivation =
     .in(modules / "derivation")
     .settings(
       defaultSettings,
-      libraryDependencies ++= Seq(magnolia, derevo, catsTagless),
+      libraryDependencies ++= Seq(magnolia, derevo, catsTaglessMacros),
       name := "tofu-derivation",
     )
     .dependsOn(kernel)
@@ -440,24 +456,24 @@ lazy val tofu = project
   )
   .dependsOn(coreModules.map(x => x: ClasspathDep[ProjectReference]): _*)
 
-lazy val defaultScalacOptions = scalacOptions := {
-  val tpolecatOptions = scalacOptions.value
-
-  val dropLints = Set(
-    "-Ywarn-dead-code",
-    "-Wdead-code" // ignore dead code paths where `Nothing` is involved
+lazy val defaultScalacOptions =
+  Seq(
+    tpolecatScalacOptions ++= Set(
+      ScalacOption("-Ykind-projector:underscores", _ >= ScalaVersion.V3_0_0),
+      ScalacOption("-P:kind-projector:underscore-placeholders", _ < ScalaVersion.V3_0_0),
+      ScalacOptions.source3,
+      ScalacOption("-Xmigration", _ < ScalaVersion.V3_0_0)
+    ),
+    tpolecatExcludeOptions ++= Set(ScalacOptions.warnDeadCode, ScalacOptions.privateWarnDeadCode),
+    tpolecatExcludeOptions ++= (
+      if (!sys.env.get("CI").contains("true") || (minorVersion.value == 12))
+        Set(ScalacOptions.fatalWarnings)
+      else
+        Set.empty
+    )
   )
 
-  val opts = tpolecatOptions.filterNot(dropLints)
-
-  // drop `-Xfatal-warnings` on dev and 2.12 CI
-  if (!sys.env.get("CI").contains("true") || (minorVersion.value == 12))
-    opts.filterNot(Set("-Xfatal-warnings"))
-  else
-    opts
-}
-
-lazy val scalacWarningConfig = scalacOptions += {
+lazy val scalacWarningConfig = tpolecatScalacOptions ++= {
   // // ignore unused imports that cannot be removed due to cross-compilation
   // val suppressUnusedImports = Seq(
   //   "scala/tofu/config/typesafe.scala"
@@ -469,13 +485,19 @@ lazy val scalacWarningConfig = scalacOptions += {
   val contextDeprecationInfo = "cat=deprecation&msg=^(.*((Has)|(With)|(Logging)).*)$:silent"
   val verboseWarnings        = "any:wv"
 
-  s"-Wconf:$contextDeprecationInfo,$verboseWarnings"
+  Set(
+    ScalacOption(s"-Wconf:$contextDeprecationInfo", _ >= ScalaVersion.V3_0_0),
+    ScalacOption(s"-Wconf:$contextDeprecationInfo,$verboseWarnings", _ < ScalaVersion.V3_0_0)
+  )
 }
 
 ThisBuild / libraryDependencySchemes += "io.circe" %% "circe-core" % "early-semver"
 
 lazy val macros = Seq(
-  scalacOptions ++= { if (minorVersion.value == 13) Seq("-Ymacro-annotations") else Seq() },
+  tpolecatScalacOptions += ScalacOption(
+    "-Ymacro-annotations",
+    _.isBetween(ScalaVersion.V2_13_0, ScalaVersion.V3_0_0)
+  ),
   libraryDependencies ++= { if (minorVersion.value == 12) Seq(compilerPlugin(macroParadise)) else Seq() }
 )
 

modules/core/ce2/src/main/scala-2/tofu/interop/CE2Agents.scala → modules/core/ce2/src/main/scala/tofu/interop/CE2Agents.scala

@@ -42,7 +42,11 @@ final case class SerialSemRef[F[_]: Monad, A](ref: Ref[F, A], sem: Semaphore[F])
   * `G[_]`, but can be created for some `F[_]`, for which an instance of [[tofu.lift.Lift]] `Lift[F, G]` is present,
   * this implementation can be used
   */
-final case class UnderlyingSemRef[F[_]: Functor, G[_]: Monad: Lift[F, *[_]], A](ref: Ref[F, A], sem: Semaphore[F])
+final case class UnderlyingSemRef[
+    F[_]: Functor,
+    G[_]: Monad: ({ type L[x[_]] = Lift[F, x] })#L,
+    A
+](ref: Ref[F, A], sem: Semaphore[F])
     extends SerialAgent[G, A] {
   override def get: G[A] = ref.get.lift[G]
 

modules/core/ce2/src/main/scala-2/tofu/interop/CE2Kernel.scala → modules/core/ce2/src/main/scala/tofu/interop/CE2Kernel.scala

@@ -2,31 +2,20 @@ package tofu
 package interop
 
 import java.util.concurrent.TimeUnit
+
 import scala.concurrent.duration.FiniteDuration
 import scala.concurrent.{ExecutionContext, Future}
+
+import cats.effect._
 import cats.effect.concurrent.{MVar, Ref}
-import cats.effect.{
-  Async,
-  Blocker,
-  Bracket,
-  Concurrent,
-  ConcurrentEffect,
-  ContextShift,
-  Effect,
-  ExitCase,
-  Fiber,
-  IO,
-  Sync,
-  Timer
-}
 import cats.{Functor, Id, Monad, Parallel, Traverse, ~>}
 import tofu.compat.unused
 import tofu.concurrent._
 import tofu.internal.NonTofu
 import tofu.internal.carriers._
+import tofu.internal.instances.PerformViaUnlift
 import tofu.lift.Lift
 import tofu.syntax.monadic._
-import tofu.internal.instances.PerformViaUnlift
 
 object CE2Kernel {
   // 2.12 sometimes gets mad on Const partial alias during implicit search
@@ -51,8 +40,8 @@ object CE2Kernel {
 
   final implicit def finallyFromBracket[F[_], E](implicit
       F: Bracket[F, E]
-  ): FinallyCarrier2.Aux[F, E, CEExit[E, *]] =
-    new FinallyCarrier2.Impl[F, E, CEExit[E, *]] {
+  ): FinallyCarrier2.Aux[F, E, CEExit[E, _]] =
+    new FinallyCarrier2.Impl[F, E, CEExit[E, _]] {
       def finallyCase[A, B, C](init: F[A])(action: A => F[B])(release: (A, CEExit[E, B]) => F[C]): F[B] =
         F.bracketCase(init)(action) { case (a, exit) =>
           F.void(release(a, exit))
@@ -67,8 +56,8 @@ object CE2Kernel {
   final def startFromConcurrent[F[_]](implicit
       F: Concurrent[F],
       @unused _nonTofu: NonTofu[F]
-  ): FibersCarrier2.Aux[F, Id, Fiber[F, *]] =
-    new FibersCarrier2.Impl[F, Id, Fiber[F, *]] {
+  ): FibersCarrier2.Aux[F, Id, Fiber[F, _]] =
+    new FibersCarrier2.Impl[F, Id, Fiber[F, _]] {
       def start[A](fa: F[A]): F[Fiber[F, A]]                                                = F.start(fa)
       def fireAndForget[A](fa: F[A]): F[Unit]                                               = F.void(start(fa))
       def racePair[A, B](fa: F[A], fb: F[B]): F[Either[(A, Fiber[F, B]), (Fiber[F, A], B)]] = F.racePair(fa, fb)
@@ -133,7 +122,7 @@ object CE2Kernel {
       F: ContextConcurrentEffect[F],
       @unused _nt: NonTofu[F]
   ): PerformCarrier2Context[F] =
-    new PerformViaUnlift[F, F.Base, PerformOf.ExitCont[Throwable, *], Unit]()(
+    new PerformViaUnlift[F, F.Base, PerformOf.ExitCont[Throwable, _], Unit]()(
       performConcurrentEffect[F.Base](F.concurrentEffect, NonTofu.refute),
       F.unlift,
       F.apply

modules/core/ce2/src/main/scala-2/tofu/interop/ContextConcurrentEffect.scala → modules/core/ce2/src/main/scala/tofu/interop/ContextConcurrentEffect.scala

@@ -22,6 +22,6 @@ object ContextConcurrentEffect {
     final type Base[A] = B[A]
   }
 
-  implicit def resolveReaderTConcurrentEffect[F[_]: ConcurrentEffect, C]: Impl[ReaderT[F, C, *], F] =
-    new Impl[ReaderT[F, C, *], F]
+  implicit def resolveReaderTConcurrentEffect[F[_]: ConcurrentEffect, C]: Impl[ReaderT[F, C, _], F] =
+    new Impl[ReaderT[F, C, _], F]
 }

modules/core/ce2/src/main/scala-2/tofu/package.scala → modules/core/ce2/src/main/scala/tofu/package.scala

@@ -1,16 +1,15 @@
 import cats.effect.Bracket
 import cats.effect.Fiber
 import cats.data.Ior
-import tofu.kernel.KernelTypes
 import cats.Id
 
-package object tofu extends KernelTypes {
+package object tofu extends tofu.kernel.KernelTypes {
 
   type BracketThrow[F[_]] = Bracket[F, Throwable]
 
   type IorC[C[_], E, A] = Ior[C[E], C[A]]
 
-  type Start[F[_]] = Fibers[F, Id, Fiber[F, *]]
+  type Start[F[_]] = Fibers[F, Id, Fiber[F, _]]
 
   type Timeout[F[_]] = tofu.time.Timeout[F]