From e24621e7a59ac838103bb549f688833bf2c5b449 Mon Sep 17 00:00:00 2001
From: Georgi Krastev <joro.kr.21@gmail.com>
Date: Thu, 2 May 2024 22:33:38 +0200
Subject: [PATCH] Remove unused annotations

---
 build.sbt                                     |   2 +-
 .../main/scala-2/cats/derived/package.scala   | 102 +++++++++---------
 2 files changed, 51 insertions(+), 53 deletions(-)

diff --git a/build.sbt b/build.sbt
index 2a365e5d..d53cd15f 100644
--- a/build.sbt
+++ b/build.sbt
@@ -27,7 +27,7 @@ lazy val commonSettings = Seq(
   ),
   scalacOptions ++= CrossVersion.partialVersion(scalaVersion.value).toList.flatMap {
     case (3, _) => List("-source:future", "-Xmax-inlines", "64", "-Wunused:all", "-Wvalue-discard")
-    case (2, 12) => List("-Ypartial-unification", "-Xlint")
+    case (2, 12) => List("-Ypartial-unification", "-Xlint", "-Wconf:cat=unused&src=.*/derived/package.scala:silent")
     case _ => List("-Xlint:_,-byname-implicit", "-Wconf:cat=deprecation&site=.*SequenceSuite:silent")
   },
   resolvers ++= Resolver.sonatypeOssRepos("releases"),
diff --git a/core/src/main/scala-2/cats/derived/package.scala b/core/src/main/scala-2/cats/derived/package.scala
index 45e72c87..b7bd3f52 100644
--- a/core/src/main/scala-2/cats/derived/package.scala
+++ b/core/src/main/scala-2/cats/derived/package.scala
@@ -6,8 +6,6 @@ import cats.derived.util.VersionSpecific.Lazy
 import cats.kernel.{CommutativeMonoid, CommutativeSemigroup}
 import shapeless.{Cached, Refute}
 
-import scala.annotation.nowarn
-
 /** Fully automatically derive the instance, note that this derivation is not cached, so it will re-derive every time an
   * instance is needed in the application, which could significantly impact the compilation time.
   */
@@ -20,175 +18,175 @@ object auto {
 
   object empty {
     implicit def kittensMkEmpty[A](implicit
-        @nowarn("cat=unused") refute: Refute[Empty[A]],
+        refute: Refute[Empty[A]],
         ev: Lazy[MkEmpty[A]]
     ): Empty[A] = ev.value
   }
 
   object emptyK {
     implicit def kittensMkEmptyK[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[EmptyK[F]],
+        refute: Refute[EmptyK[F]],
         F: MkEmptyK[F]
     ): EmptyK[F] = F
   }
 
   object eq {
     implicit def kittensMkEq[A](implicit
-        @nowarn("cat=unused") refute: Refute[Eq[A]],
+        refute: Refute[Eq[A]],
         ev: Lazy[MkEq[A]]
     ): Eq[A] = ev.value
   }
 
   object partialOrder {
     implicit def kittensMkPartialOrder[A](implicit
-        @nowarn("cat=unused") refute: Refute[PartialOrder[A]],
+        refute: Refute[PartialOrder[A]],
         ev: Lazy[MkPartialOrder[A]]
     ): PartialOrder[A] = ev.value
   }
 
   object order {
     implicit def kittensMkOrder[A](implicit
-        @nowarn("cat=unused") refute: Refute[Order[A]],
+        refute: Refute[Order[A]],
         ev: Lazy[MkOrder[A]]
     ): Order[A] = ev.value
   }
 
   object hash {
     implicit def kittensMkHash[A](implicit
-        @nowarn("cat=unused") refute: Refute[Hash[A]],
+        refute: Refute[Hash[A]],
         ev: Lazy[MkHash[A]]
     ): Hash[A] = ev.value
   }
 
   object invariant {
     implicit def kittensMkInvariant[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Invariant[F]],
+        refute: Refute[Invariant[F]],
         F: MkInvariant[F]
     ): Invariant[F] = F
   }
 
   object contravariant {
     implicit def kittensMkContravariant[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Contravariant[F]],
+        refute: Refute[Contravariant[F]],
         F: MkContravariant[F]
     ): Contravariant[F] = F
   }
 
   object functor {
     implicit def kittensMkFunctor[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Functor[F]],
+        refute: Refute[Functor[F]],
         F: MkFunctor[F]
     ): Functor[F] = F
   }
 
   object apply {
     implicit def kittensMkApply[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Apply[F]],
+        refute: Refute[Apply[F]],
         F: MkApply[F]
     ): Apply[F] = F
   }
 
   object applicative {
     implicit def kittensMkApplicative[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Applicative[F]],
+        refute: Refute[Applicative[F]],
         F: MkApplicative[F]
     ): Applicative[F] = F
   }
 
   object show {
     implicit def kittensMkShow[A](implicit
-        @nowarn("cat=unused") refute: Refute[Show[A]],
+        refute: Refute[Show[A]],
         ev: Lazy[MkShow[A]]
     ): Show[A] = ev.value
   }
 
   object showPretty {
     implicit def kittensMkShowPretty[A](implicit
-        @nowarn("cat=unused") refute: Refute[Show[A]],
+        refute: Refute[Show[A]],
         ev: Lazy[MkShowPretty[A]]
     ): ShowPretty[A] = ev.value
   }
 
   object semigroup {
     implicit def kittensMkSemigroup[A](implicit
-        @nowarn("cat=unused") refute: Refute[Semigroup[A]],
+        refute: Refute[Semigroup[A]],
         ev: Lazy[MkSemigroup[A]]
     ): Semigroup[A] = ev.value
   }
 
   object commutativeSemigroup {
     implicit def kittensMkCommutativeSemigroup[A](implicit
-        @nowarn("cat=unused") refute: Refute[CommutativeSemigroup[A]],
+        refute: Refute[CommutativeSemigroup[A]],
         ev: Lazy[MkCommutativeSemigroup[A]]
     ): CommutativeSemigroup[A] = ev.value
   }
 
   object monoid {
     implicit def kittensMkMonoid[A](implicit
-        @nowarn("cat=unused") refute: Refute[Monoid[A]],
+        refute: Refute[Monoid[A]],
         ev: Lazy[MkMonoid[A]]
     ): Monoid[A] = ev.value
   }
 
   object commutativeMonoid {
     implicit def kittensMkCommutativeMonoid[A](implicit
-        @nowarn("cat=unused") refute: Refute[CommutativeMonoid[A]],
+        refute: Refute[CommutativeMonoid[A]],
         ev: Lazy[MkCommutativeMonoid[A]]
     ): CommutativeMonoid[A] = ev.value
   }
 
   object semigroupK {
     implicit def kittensMkSemigroupK[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[SemigroupK[F]],
+        refute: Refute[SemigroupK[F]],
         F: MkSemigroupK[F]
     ): SemigroupK[F] = F
   }
 
   object monoidK {
     implicit def kittensMkMonoidK[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[MonoidK[F]],
+        refute: Refute[MonoidK[F]],
         F: MkMonoidK[F]
     ): MonoidK[F] = F
   }
 
   object foldable {
     implicit def kittensMkFoldable[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Foldable[F]],
+        refute: Refute[Foldable[F]],
         F: MkFoldable[F]
     ): Foldable[F] = F
   }
 
   object reducible {
     implicit def kittensMkReducible[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Reducible[F]],
+        refute: Refute[Reducible[F]],
         F: MkReducible[F]
     ): Reducible[F] = F
   }
 
   object traverse {
     implicit def kittensMkTraverse[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Traverse[F]],
+        refute: Refute[Traverse[F]],
         F: MkTraverse[F]
     ): Traverse[F] = F
   }
 
   object nonEmptyTraverse {
     implicit def kittensMkNonEmptyTraverse[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[NonEmptyTraverse[F]],
+        refute: Refute[NonEmptyTraverse[F]],
         F: MkNonEmptyTraverse[F]
     ): NonEmptyTraverse[F] = F
   }
 
   object pure {
     implicit def kittensMkPure[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Pure[F]],
+        refute: Refute[Pure[F]],
         F: MkPure[F]
     ): Pure[F] = F
   }
 
   object consK {
     implicit def kittensMkConsK[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[ConsK[F]],
+        refute: Refute[ConsK[F]],
         F: MkConsK[F, F]
     ): ConsK[F] = MkConsK.consK(F)
   }
@@ -201,175 +199,175 @@ object cached {
 
   object empty {
     implicit def kittensMkEmpty[A](implicit
-        @nowarn("cat=unused") refute: Refute[Empty[A]],
+        refute: Refute[Empty[A]],
         cached: Cached[MkEmpty[A]]
     ): Empty[A] = cached.value
   }
 
   object emptyK {
     implicit def kittensMkEmptyK[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[EmptyK[F]],
+        refute: Refute[EmptyK[F]],
         cached: Cached[MkEmptyK[F]]
     ): EmptyK[F] = cached.value
   }
 
   object pure {
     implicit def kittensMkPure[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Pure[F]],
+        refute: Refute[Pure[F]],
         cached: Cached[MkPure[F]]
     ): Pure[F] = cached.value
   }
 
   object eq {
     implicit def kittensMkEq[A](implicit
-        @nowarn("cat=unused") refute: Refute[Eq[A]],
+        refute: Refute[Eq[A]],
         cached: Cached[MkEq[A]]
     ): Eq[A] = cached.value
   }
 
   object partialOrder {
     implicit def kittensMkPartialOrder[A](implicit
-        @nowarn("cat=unused") refute: Refute[PartialOrder[A]],
+        refute: Refute[PartialOrder[A]],
         cached: Cached[MkPartialOrder[A]]
     ): PartialOrder[A] = cached.value
   }
 
   object order {
     implicit def kittensMkOrder[A](implicit
-        @nowarn("cat=unused") refute: Refute[Order[A]],
+        refute: Refute[Order[A]],
         cached: Cached[MkOrder[A]]
     ): Order[A] = cached.value
   }
 
   object hash {
     implicit def kittensMkHash[A](implicit
-        @nowarn("cat=unused") refute: Refute[Hash[A]],
+        refute: Refute[Hash[A]],
         cached: Cached[MkHash[A]]
     ): Hash[A] = cached.value
   }
 
   object contravariant {
     implicit def kittensMkContravariant[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Contravariant[F]],
+        refute: Refute[Contravariant[F]],
         cached: Cached[MkContravariant[F]]
     ): Contravariant[F] = cached.value
   }
 
   object functor {
     implicit def kittensMkFunctor[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Functor[F]],
+        refute: Refute[Functor[F]],
         cached: Cached[MkFunctor[F]]
     ): Functor[F] = cached.value
   }
 
   object apply {
     implicit def kittensMkApply[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Apply[F]],
+        refute: Refute[Apply[F]],
         cached: Cached[MkApply[F]]
     ): Apply[F] = cached.value
   }
 
   object applicative {
     implicit def kittensMkApplicative[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Applicative[F]],
+        refute: Refute[Applicative[F]],
         cached: Cached[MkApplicative[F]]
     ): Applicative[F] = cached.value
   }
 
   object foldable {
     implicit def kittensMkFoldable[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Foldable[F]],
+        refute: Refute[Foldable[F]],
         cached: Cached[MkFoldable[F]]
     ): Foldable[F] = cached.value
   }
 
   object reducible {
     implicit def kittensMkReducible[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Reducible[F]],
+        refute: Refute[Reducible[F]],
         cached: Cached[MkReducible[F]]
     ): Reducible[F] = cached.value
   }
 
   object invariant {
     implicit def kittensMkInvariant[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Invariant[F]],
+        refute: Refute[Invariant[F]],
         cached: Cached[MkInvariant[F]]
     ): Invariant[F] = cached.value
   }
 
   object traverse {
     implicit def kittensMkTraverse[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[Traverse[F]],
+        refute: Refute[Traverse[F]],
         cached: Cached[MkTraverse[F]]
     ): Traverse[F] = cached.value
   }
 
   object nonEmptyTraverse {
     implicit def kittensMkNonEmptyTraverse[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[NonEmptyTraverse[F]],
+        refute: Refute[NonEmptyTraverse[F]],
         cached: Cached[MkNonEmptyTraverse[F]]
     ): NonEmptyTraverse[F] = cached.value
   }
 
   object show {
     implicit def kittensMkshow[A](implicit
-        @nowarn("cat=unused") refute: Refute[Show[A]],
+        refute: Refute[Show[A]],
         cached: Cached[MkShow[A]]
     ): Show[A] = cached.value
   }
 
   object showPretty {
     implicit def kittensMkShowPretty[A](implicit
-        @nowarn("cat=unused") refute: Refute[Show[A]],
+        refute: Refute[Show[A]],
         cached: Cached[MkShowPretty[A]]
     ): ShowPretty[A] = cached.value
   }
 
   object monoidK {
     implicit def kittensMkMonoidK[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[MonoidK[F]],
+        refute: Refute[MonoidK[F]],
         cached: Cached[MkMonoidK[F]]
     ): MonoidK[F] = cached.value
   }
 
   object semigroup {
     implicit def kittensMkSemigroup[A](implicit
-        @nowarn("cat=unused") refute: Refute[Semigroup[A]],
+        refute: Refute[Semigroup[A]],
         cached: Cached[MkSemigroup[A]]
     ): Semigroup[A] = cached.value
   }
 
   object commutativeSemigroup {
     implicit def kittensMkCommutativeSemigroup[A](implicit
-        @nowarn("cat=unused") refute: Refute[CommutativeSemigroup[A]],
+        refute: Refute[CommutativeSemigroup[A]],
         cached: Cached[MkCommutativeSemigroup[A]]
     ): CommutativeSemigroup[A] = cached.value
   }
 
   object monoid {
     implicit def kittensMkMonoid[A](implicit
-        @nowarn("cat=unused") refute: Refute[Monoid[A]],
+        refute: Refute[Monoid[A]],
         cached: Cached[MkMonoid[A]]
     ): Monoid[A] = cached.value
   }
 
   object commutativeMonoid {
     implicit def kittensMkCommutativeMonoid[A](implicit
-        @nowarn("cat=unused") refute: Refute[CommutativeMonoid[A]],
+        refute: Refute[CommutativeMonoid[A]],
         cached: Cached[MkCommutativeMonoid[A]]
     ): CommutativeMonoid[A] = cached.value
   }
 
   object semigroupK {
     implicit def kittensMkSemigroupK[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[SemigroupK[F]],
+        refute: Refute[SemigroupK[F]],
         cached: Cached[MkSemigroupK[F]]
     ): SemigroupK[F] = cached.value
   }
 
   object consK {
     implicit def kittensMkConsK[F[_]](implicit
-        @nowarn("cat=unused") refute: Refute[ConsK[F]],
+        refute: Refute[ConsK[F]],
         cached: Cached[MkConsK[F, F]]
     ): ConsK[F] = MkConsK.consK(cached.value)
   }