Update sbt-tpolecat to 0.4.4

build.sbt

@@ -41,6 +41,7 @@ lazy val commonSettings = Seq(
     "org.scalatest" %%% "scalatest" % "3.2.17" % Test,
   ),
   /* scalacOptions --= Seq("-Xfatal-warnings"), // overwrite option from https://github.com/DavidGregory084/sbt-tpolecat */
+  Test / scalacOptions --= Seq("-Wnonunit-statement"), // otherwise there is a warning for every test-assertion
 )
 
 lazy val colibri = project

colibri/src/main/scala/colibri/Cancelable.scala

@@ -44,7 +44,7 @@ object Cancelable {
     def unsafeAdd(subscription: () => Cancelable): Unit = if (buffer != null) {
       val cancelable = subscription()
       if (buffer == null) cancelable.unsafeCancel()
-      else buffer.push(cancelable)
+      else buffer.push(cancelable): Unit
       ()
     }
 
@@ -106,7 +106,7 @@ object Cancelable {
         val nextCancelable = subscriptions(0)
         val variable       = Cancelable.variable()
         latest = variable
-        subscriptions.splice(0, deleteCount = 1)
+        subscriptions.splice(0, deleteCount = 1): Unit
         variable.unsafeAdd(nextCancelable)
         variable.unsafeFreeze()
         ()
@@ -124,8 +124,7 @@ object Cancelable {
         variable.unsafeAdd(subscription)
         variable.unsafeFreeze()
       } else {
-        subscriptions.push(subscription)
-        ()
+        subscriptions.push(subscription): Unit
       }
     }
 
@@ -231,11 +230,10 @@ object Cancelable {
     }
 
     def unsafeAdd(subscription: () => Cancelable): Unit = if (buffer != null) {
-      buffer.push(subscription)
+      buffer.push(subscription): Unit
       if (currentCancelables != null) {
-        currentCancelables.push(subscription())
+        currentCancelables.push(subscription()): Unit
       }
-      ()
     }
 
     def unsafeFreeze(): Unit = {

colibri/src/main/scala/colibri/Observable.scala

@@ -417,7 +417,7 @@ object Observable    {
           Observer.create(
             { input =>
               val index = tasks.length
-              tasks.push(null)
+              tasks.push(null): Unit
 
               val effect = f(input)
 
@@ -943,7 +943,7 @@ object Observable    {
           source.unsafeSubscribe(
             Observer.create[A](
               { value =>
-                seqA.push(value)
+                seqA.push(value): Unit
                 send()
               },
               sink.unsafeOnError,
@@ -952,7 +952,7 @@ object Observable    {
           sourceB.unsafeSubscribe(
             Observer.create[B](
               { value =>
-                seqB.push(value)
+                seqB.push(value): Unit
                 send()
               },
               sink.unsafeOnError,

colibri/src/main/scala/colibri/Observer.scala

@@ -54,8 +54,8 @@ object Observer    {
 
   def createFromPromise[A](promise: Promise[A]): Observer[A] =
     new Observer[A] {
-      def unsafeOnNext(value: A): Unit          = { promise.trySuccess(value); () }
-      def unsafeOnError(error: Throwable): Unit = { promise.tryFailure(error); () }
+      def unsafeOnNext(value: A): Unit          = promise.trySuccess(value): Unit
+      def unsafeOnError(error: Throwable): Unit = promise.tryFailure(error): Unit
     }
 
   def product[A, B](fa: Observer[A], fb: Observer[B]): Observer[(A, B)] = new Observer[(A, B)] {
@@ -133,7 +133,7 @@ object Observer    {
     }
 
     def contracollect[B](f: PartialFunction[B, A]): Observer[B] = new Observer[B] {
-      def unsafeOnNext(value: B): Unit          = recovered({ f.runWith(sink.unsafeOnNext)(value); () }, unsafeOnError)
+      def unsafeOnNext(value: B): Unit          = recovered(f.runWith(sink.unsafeOnNext)(value): Unit, unsafeOnError)
       def unsafeOnError(error: Throwable): Unit = sink.unsafeOnError(error)
     }
 

colibri/src/main/scala/colibri/Subject.scala

@@ -102,7 +102,7 @@ final class PublishSubject[A] extends Observer[A] with Observable[A] {
 
   def unsafeSubscribe(sink: Observer[A]): Cancelable = {
     val observer = Observer.lift(sink)
-    subscribers.push(observer)
+    subscribers.push(observer): Unit
     Cancelable { () =>
       if (isRunning) subscribers = JSArrayHelper.removeElementCopied(subscribers)(observer)
       else JSArrayHelper.removeElement(subscribers)(observer)

colibri/src/main/scala/colibri/effect/RunEffectExecution.scala

@@ -18,8 +18,7 @@ private[colibri] object RunEffectExecution {
 
     Cancelable.withIsEmpty(isCancel) { () =>
       isCancel = true
-      cancelRun()
-      ()
+      cancelRun(): Unit
     }
   }
 }

colibri/src/main/scala/colibri/helpers/JSArrayHelper.scala

@@ -5,8 +5,7 @@ import scala.scalajs.js
 private[colibri] object JSArrayHelper {
   def removeElement[T](array: js.Array[T])(element: T): Unit = {
     val index = array.indexOf(element)
-    if (index != -1) array.splice(index, deleteCount = 1)
-    ()
+    if (index != -1) array.splice(index, deleteCount = 1): Unit
   }
 
   def removeElementCopied[T](array: js.Array[T])(element: T): js.Array[T] = {
@@ -15,7 +14,7 @@ private[colibri] object JSArrayHelper {
       val newArray = js.Array[T]()
       var i        = 0
       while (i < array.length) {
-        if (i != index) newArray.push(array(i))
+        if (i != index) newArray.push(array(i)): Unit
         i += 1
       }
       newArray

project/plugins.sbt

@@ -5,6 +5,6 @@ addSbtPlugin("ch.epfl.scala" % "sbt-scalajs-bundler" % "0.21.1")
 addSbtPlugin("com.github.sbt" % "sbt-ci-release" % "1.5.12")
 
 // sane scalac options
-addSbtPlugin("io.github.davidgregory084" % "sbt-tpolecat" % "0.3.1")
+addSbtPlugin("io.github.davidgregory084" % "sbt-tpolecat" % "0.4.4")
 
 addSbtPlugin("com.thoughtworks.sbt-scala-js-map" % "sbt-scala-js-map" % "4.1.1")

zio/src/main/scala/colibri/ext/zio/package.scala

@@ -47,30 +47,25 @@ package object zio extends ZioLowPrio {
 }
 
 private final class SinkZIOWithRuntime[Env](runtime: Runtime[Env]) extends Sink[zio.RSink[Env, *]] {
-  override def unsafeOnNext[A](sink: zio.RSink[Env, A])(value: A): Unit = {
-    Unsafe.unsafe(implicit u => runtime.unsafe.run(ZStream.succeed(value).run(sink)))
-    ()
-  }
+  override def unsafeOnNext[A](sink: zio.RSink[Env, A])(value: A): Unit =
+    Unsafe.unsafe(implicit u => runtime.unsafe.run(ZStream.succeed(value).run(sink)).getOrThrow())
 
-  override def unsafeOnError[A](sink: zio.RSink[Env, A])(error: Throwable): Unit = {
-    Unsafe.unsafe(implicit u => runtime.unsafe.run(ZStream.fail(error).run(sink)))
-    ()
-  }
+  override def unsafeOnError[A](sink: zio.RSink[Env, A])(error: Throwable): Unit =
+    Unsafe.unsafe(implicit u => runtime.unsafe.run(ZStream.fail(error).run(sink)).getOrThrow())
 }
 
 private final class SourceZIOWithRuntime[Env](runtime: Runtime[Env]) extends Source[zio.RStream[Env, *]] {
   override def unsafeSubscribe[A](source: zio.RStream[Env, A])(sink: Observer[A]): Cancelable = {
-    val canceler = Unsafe.unsafe(implicit u =>
-      runtime.unsafe.runToFuture(
+    Unsafe.unsafe { implicit u =>
+      val canceler = runtime.unsafe.runToFuture(
         source
           .onError(cause => ZIO.succeed(sink.unsafeOnError(cause.squash)))
           .foreach(value => ZIO.succeed(sink.unsafeOnNext(value))),
-      ),
-    )
+      )
 
-    Cancelable.withIsEmpty(canceler.isCompleted) { () =>
-      canceler.cancel()
-      ()
+      Cancelable.withIsEmpty(canceler.isCompleted) { () =>
+        canceler.cancel(): Unit
+      }
     }
   }
 }