Cleaning things up

build.sbt

@@ -1,3 +1,5 @@
+import org.typelevel.scalacoptions.ScalacOptions
+
 val Scala34  = "3.4.1"
 val Scala33  = "3.3.3"
 val Scala213 = "2.13.13"
@@ -10,12 +12,19 @@ lazy val buildSettings: Seq[Setting[_]] =
     scalaVersion       := Scala33,
     crossScalaVersions := Seq(Scala34, Scala33, Scala213, Scala212),
     releaseCrossBuild  := true,
-    scalacOptions ~= (_.filterNot(_ == "-Xfatal-warnings")),
     scalacOptions ++= {
       CrossVersion.partialVersion(scalaVersion.value) match {
-        case Some((3, minor)) => Seq("-Xtarget:8")
-        case _                => Seq("-target:jvm-1.8", "-Xsource:3")
+        case Some((3, minor)) => Seq("-release:8")
+        case _                => Seq("-release:8", "-Xsource:3")
       }
+    },
+    tpolecatExcludeOptions ++= {
+      Set(ScalacOptions.lintImplicitRecursion, ScalacOptions.warnUnusedImports)
+    },
+    Test / tpolecatExcludeOptions ++= {
+      Set(
+        ScalacOptions.warnNonUnitStatement
+      )
     }
   )
 
@@ -132,4 +141,4 @@ lazy val treeLog = (project in file("."))
       )
   )
 
-addCommandAlias("testAll", ";clean;+test")
+addCommandAlias("testAll", "clean;+test")

src/main/scala-3/treelog/ScalaCompat.scala

@@ -1,7 +1,10 @@
 package treelog
 
+import scala.annotation.nowarn
+
 private[treelog] object ScalaCompat:
 
+  @nowarn
   implicit class LazyListCompanionOps(private val lc: LazyList.type):
     def apply[T](xs: T*): LazyList[T] = xs.toLazyList
 

src/main/scala/treelog/LogTreeSyntaxWithoutAnnotations.scala

@@ -1,9 +1,11 @@
 package treelog
 
 import cats.{Functor, Monad, Show}
+import scala.annotation.nowarn
 
 object LogTreeSyntaxWithoutAnnotations extends LogTreeSyntax[Nothing] {
 
+  @nowarn
   implicit object NothingShow extends Show[Nothing] {
     override def show(n: Nothing): String = ""
   }

src/main/scala/treelog/Tree.scala

@@ -2,7 +2,7 @@ package treelog
 
 import cats._
 import cats.free.Trampoline
-import cats.implicits._
+import cats.syntax.all._
 import treelog.ScalaCompat._
 
 /** Partially copied from Scalaz. */
@@ -35,26 +35,19 @@ sealed abstract class Tree[A] {
     val trunk  = "  |" // "|  ".reverse
 
     def drawSubTrees(s: LazyList[Tree[A]]): Trampoline[Vector[StringBuilder]] =
-      s match {
-        case ts if ts.isEmpty       => done(Vector.empty[StringBuilder])
-        case t #:: ts if ts.isEmpty =>
-          defer(t.draw).map(subtree => new StringBuilder("|") +: shift(stem, "   ", subtree))
-        case t #:: ts               =>
-          for {
-            subtree       <- defer(t.draw)
-            otherSubtrees <- defer(drawSubTrees(ts))
-          } yield new StringBuilder("|") +: (shift(branch, trunk, subtree) ++ otherSubtrees)
-      }
-
-    def shift(first: String, other: String, s: Vector[StringBuilder]): Vector[StringBuilder] = {
-      var i = 0
-      while (i < s.length) {
-        if (i == 0) s(i).append(first)
-        else s(i).append(other)
-        i += 1
+      if (s.isEmpty) done(Vector.empty[StringBuilder])
+      else if (s.length == 1) defer(s.head.draw).map(subtree => new StringBuilder("|") +: shift(stem, "   ", subtree))
+      else
+        for {
+          subtree       <- defer(s.head.draw)
+          otherSubtrees <- defer(drawSubTrees(s.tail))
+        } yield new StringBuilder("|") +: (shift(branch, trunk, subtree) ++ otherSubtrees)
+
+    def shift(first: String, other: String, s: Vector[StringBuilder]): Vector[StringBuilder] =
+      s.zipWithIndex.map { case (sb, i) =>
+        if (i == 0) sb.append(first)
+        else sb.append(other)
       }
-      s
-    }
 
     drawSubTrees(subForest).map(subtrees => new StringBuilder(sh.show(rootLabel).reverse) +: subtrees)
   }

src/test/scala/SerializationExample.scala

@@ -51,8 +51,6 @@ object Codecs {
       } yield UndescribedLogTreeLabel(success, annotations)
   }
 
-  implicit val logTreeLabelCodec: CodecJson[LogTreeLabel[Int]] = CodecJson.derived[LogTreeLabel[Int]]
-
   implicit val serializableTreeEncoder: EncodeJson[SerializableTree[Int]] = EncodeJson { t =>
     ("label"      := t.label) ->:
       ("children" := t.children) ->:
@@ -65,8 +63,6 @@ object Codecs {
       children <- (c --\ "children").as[List[SerializableTree[Int]]]
     } yield SerializableTree(label, children)
   }
-
-  implicit val serializableTreeCodec: CodecJson[SerializableTree[Int]] = CodecJson.derived[SerializableTree[Int]]
 }
 
 object SerializationExample extends App with LogTreeSyntax[Int] {