From 2ef62beb3df969013a1b8480f4896fc1b13a95e6 Mon Sep 17 00:00:00 2001
From: Corey Woodfield <cwoodfield@lucidchart.com>
Date: Fri, 6 Jan 2023 15:23:56 -0700
Subject: [PATCH 1/7] Update scala 2 macros to not use reification

Scala 2 macros can be compiled in scala 3 only if they do not use
reification or quasiquotes
---
 macros/src/main/scala-2/enumeratum/EnumMacros.scala | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/macros/src/main/scala-2/enumeratum/EnumMacros.scala b/macros/src/main/scala-2/enumeratum/EnumMacros.scala
index 022e5fbf..baf66cf3 100644
--- a/macros/src/main/scala-2/enumeratum/EnumMacros.scala
+++ b/macros/src/main/scala-2/enumeratum/EnumMacros.scala
@@ -163,13 +163,19 @@ object EnumMacros {
   ) = {
     import c.universe._
     val resultType = weakTypeOf[A]
+    val indexedSeq = Ident(c.mirror.staticModule(classOf[IndexedSeq[A]].getName))
     if (subclassSymbols.isEmpty) {
-      c.Expr[IndexedSeq[A]](reify(IndexedSeq.empty[A]).tree)
+      c.Expr[IndexedSeq[A]](
+        TypeApply(
+          Select(indexedSeq, ContextUtils.termName(c)("empty")),
+          List(TypeTree(resultType))
+        )
+      )
     } else {
       c.Expr[IndexedSeq[A]](
         Apply(
           TypeApply(
-            Select(reify(IndexedSeq).tree, ContextUtils.termName(c)("apply")),
+            Select(indexedSeq, ContextUtils.termName(c)("apply")),
             List(TypeTree(resultType))
           ),
           subclassSymbols.map(Ident(_)).toList

From b69c89af13eebb3ab68714de33c6c39a427ff6f4 Mon Sep 17 00:00:00 2001
From: Corey Woodfield <cwoodfield@lucidchart.com>
Date: Fri, 6 Jan 2023 17:33:58 -0700
Subject: [PATCH 2/7] Mix scala 2 and scala 3 macros

---
 build.sbt                                     | 13 +++++----
 .../main/scala-2/enumeratum/EnumCompat.scala  |  2 ++
 .../enumeratum/values/ValueEnumCompat.scala   |  2 +-
 .../main/scala-3/enumeratum/EnumCompat.scala  |  8 +++++-
 .../enumeratum/values/ValueEnumCompat.scala   | 22 +++++++++++++++
 macros/compat/src/main/scala-3                |  1 +
 .../enumeratum/compat}/EnumMacros.scala       | 27 +++++++++----------
 .../enumeratum/compat}/ValueEnumMacros.scala  | 21 +++++++++------
 .../scala-2/enumeratum/FindValEnums.scala     |  1 +
 9 files changed, 67 insertions(+), 30 deletions(-)
 create mode 120000 macros/compat/src/main/scala-3
 rename macros/src/main/{scala-2/enumeratum => scala/enumeratum/compat}/EnumMacros.scala (93%)
 rename macros/src/main/{scala-2/enumeratum => scala/enumeratum/compat}/ValueEnumMacros.scala (96%)

diff --git a/build.sbt b/build.sbt
index 6a5f653e..3a78147b 100644
--- a/build.sbt
+++ b/build.sbt
@@ -108,11 +108,14 @@ lazy val macros = crossProject(JSPlatform, JVMPlatform, NativePlatform)
     name    := "enumeratum-macros",
     version := Versions.Macros.head,
     crossScalaVersions := scalaVersionsAll, // eventually move this to aggregateProject once more 2.13 libs are out
-    libraryDependencies += {
+    libraryDependencies ++= {
       if (scalaBinaryVersion.value == "3") {
-        "org.scala-lang" %% "scala3-compiler" % scalaVersion.value % Provided
+        Seq(
+          "org.scala-lang" %% "scala3-compiler" % scalaVersion.value % Provided,
+          "org.scala-lang" % "scala-reflect" % scala_2_13Version,
+        )
       } else {
-        "org.scala-lang" % "scala-reflect" % scalaVersion.value
+        Seq("org.scala-lang" % "scala-reflect" % scalaVersion.value)
       }
     },
     libraryDependencies += scalaXmlTest
@@ -141,7 +144,7 @@ lazy val core = crossProject(JSPlatform, JVMPlatform, NativePlatform)
       if (useLocalVersion) {
         Seq.empty
       } else {
-        Seq("com.beachape" %%% "enumeratum-macros" % Versions.Macros.stable)
+        Seq("com.beachape" %%% "enumeratum-macros" % Versions.Macros.head)
       }
     },
     libraryDependencies += scalaXmlTest
@@ -685,7 +688,7 @@ lazy val compilerSettings = Seq(
 
     val base = {
       if (scalaBinaryVersion.value == "3") {
-        minimal :+ "-deprecation"
+        minimal :+ "-Wconf:cat=deprecation:s"
       } else {
         minimal ++ Seq(
           // "-Ywarn-adapted-args",
diff --git a/enumeratum-core/src/main/scala-2/enumeratum/EnumCompat.scala b/enumeratum-core/src/main/scala-2/enumeratum/EnumCompat.scala
index fb7408a7..b8334e4f 100644
--- a/enumeratum-core/src/main/scala-2/enumeratum/EnumCompat.scala
+++ b/enumeratum-core/src/main/scala-2/enumeratum/EnumCompat.scala
@@ -4,6 +4,8 @@ import scala.collection.immutable.IndexedSeq
 
 import scala.language.experimental.macros
 
+import _root_.enumeratum.compat.EnumMacros
+
 private[enumeratum] trait EnumCompat[A <: EnumEntry] { _: Enum[A] =>
 
   /** Returns a Seq of [[A]] objects that the macro was able to find.
diff --git a/enumeratum-core/src/main/scala-2/enumeratum/values/ValueEnumCompat.scala b/enumeratum-core/src/main/scala-2/enumeratum/values/ValueEnumCompat.scala
index 25541c98..95b017ea 100644
--- a/enumeratum-core/src/main/scala-2/enumeratum/values/ValueEnumCompat.scala
+++ b/enumeratum-core/src/main/scala-2/enumeratum/values/ValueEnumCompat.scala
@@ -4,7 +4,7 @@ import scala.language.experimental.macros
 
 import scala.collection.immutable.IndexedSeq
 
-import _root_.enumeratum.{EnumMacros, ValueEnumMacros}
+import _root_.enumeratum.compat.{EnumMacros, ValueEnumMacros}
 
 private[enumeratum] trait IntEnumCompanion {
 
diff --git a/enumeratum-core/src/main/scala-3/enumeratum/EnumCompat.scala b/enumeratum-core/src/main/scala-3/enumeratum/EnumCompat.scala
index c631a8df..ece0c498 100644
--- a/enumeratum-core/src/main/scala-3/enumeratum/EnumCompat.scala
+++ b/enumeratum-core/src/main/scala-3/enumeratum/EnumCompat.scala
@@ -1,5 +1,8 @@
 package enumeratum
 
+import _root_.enumeratum.compat
+import scala.language.experimental.macros
+
 private[enumeratum] trait EnumCompat[A <: EnumEntry] { _enum: Enum[A] =>
 
   // format: off
@@ -8,7 +11,8 @@ private[enumeratum] trait EnumCompat[A <: EnumEntry] { _enum: Enum[A] =>
     * You will want to use this in some way to implement your [[values]] method. In fact, if you
     * aren't using this method... why are you even bothering with this lib?
     */
-  inline def findValues: IndexedSeq[A] = ${ EnumMacros.findValuesImpl[A] }
+  protected inline def findValues: IndexedSeq[A] = ${ EnumMacros.findValuesImpl[A] }
+  protected def findValues: IndexedSeq[A] = macro compat.EnumMacros.findValuesImpl[A]
   // format: on
 
   /** The sequence of values for your [[Enum]]. You will typically want to implement this in your
@@ -26,6 +30,8 @@ private[enumeratum] trait EnumCompanion {
   /** Finds the `Enum` companion object for a particular `EnumEntry`. */
   implicit inline def materializeEnum[A <: EnumEntry]: Enum[A] =
     ${ EnumMacros.materializeEnumImpl[A, Enum[A]] }
+  implicit def materializeEnum[A <: EnumEntry]: Enum[A] = macro
+    compat.EnumMacros.materializeEnumImpl[A]
   // format: on
 
 }
diff --git a/enumeratum-core/src/main/scala-3/enumeratum/values/ValueEnumCompat.scala b/enumeratum-core/src/main/scala-3/enumeratum/values/ValueEnumCompat.scala
index 0dc258d4..d58e18e3 100644
--- a/enumeratum-core/src/main/scala-3/enumeratum/values/ValueEnumCompat.scala
+++ b/enumeratum-core/src/main/scala-3/enumeratum/values/ValueEnumCompat.scala
@@ -3,6 +3,7 @@ package enumeratum.values
 import scala.language.experimental.macros
 
 import _root_.enumeratum.{Enum, EnumMacros, ValueEnumMacros}
+import _root_.enumeratum.compat
 
 private[enumeratum] trait IntEnumCompanion {
 
@@ -10,6 +11,8 @@ private[enumeratum] trait IntEnumCompanion {
   implicit inline def materialiseIntValueEnum[EntryType <: IntEnumEntry]: IntEnum[EntryType] = ${
     EnumMacros.materializeEnumImpl[EntryType, IntEnum[EntryType]]
   }
+  implicit def materialiseIntValueEnum[EntryType <: IntEnumEntry]: IntEnum[EntryType] = macro
+    compat.EnumMacros.materializeEnumImpl[EntryType]
 }
 
 private[enumeratum] trait IntEnumCompat[A <: IntEnumEntry] { _enum: IntEnum[A] =>
@@ -22,6 +25,7 @@ private[enumeratum] trait IntEnumCompat[A <: IntEnumEntry] { _enum: IntEnum[A] =
     */
   protected inline def findValues: IndexedSeq[A] =
     ${ ValueEnumMacros.findIntValueEntriesImpl[A] }
+  protected def findValues: IndexedSeq[A] = macro compat.ValueEnumMacros.findIntValueEntriesImpl[A]
   // format: on
 }
 
@@ -32,6 +36,8 @@ private[enumeratum] trait LongEnumCompanion {
   implicit inline def materialiseLongValueEnum[EntryType <: LongEnumEntry]: LongEnum[EntryType] = ${
     EnumMacros.materializeEnumImpl[EntryType, LongEnum[EntryType]]
   }
+  implicit def materialiseLongValueEnum[EntryType <: LongEnumEntry]: LongEnum[EntryType] = macro
+    compat.EnumMacros.materializeEnumImpl[EntryType]
 }
 
 private[enumeratum] trait LongEnumCompat[A <: LongEnumEntry] { _enum: LongEnum[A] =>
@@ -43,6 +49,7 @@ private[enumeratum] trait LongEnumCompat[A <: LongEnumEntry] { _enum: LongEnum[A
     * aren't using this method...why are you even bothering with this lib?
     */
   protected inline def findValues: IndexedSeq[A] = ${ ValueEnumMacros.findLongValueEntriesImpl[A] }
+  protected def findValues: IndexedSeq[A] = macro compat.ValueEnumMacros.findLongValueEntriesImpl[A]
   // format: on
 }
 
@@ -54,6 +61,8 @@ private[enumeratum] trait ShortEnumCompanion {
     ${
       EnumMacros.materializeEnumImpl[EntryType, ShortEnum[EntryType]]
     }
+  implicit def materialiseShortValueEnum[EntryType <: ShortEnumEntry]: ShortEnum[EntryType] = macro
+    compat.EnumMacros.materializeEnumImpl[EntryType]
 }
 
 private[enumeratum] trait ShortEnumCompat[A <: ShortEnumEntry] { _enum: ShortEnum[A] =>
@@ -66,6 +75,8 @@ private[enumeratum] trait ShortEnumCompat[A <: ShortEnumEntry] { _enum: ShortEnu
   protected inline def findValues: IndexedSeq[A] = ${
     ValueEnumMacros.findShortValueEntriesImpl[A]
   }
+  protected def findValues: IndexedSeq[A] = macro
+    compat.ValueEnumMacros.findShortValueEntriesImpl[A]
 }
 
 private[enumeratum] trait StringEnumCompanion {
@@ -76,6 +87,9 @@ private[enumeratum] trait StringEnumCompanion {
       : StringEnum[EntryType] = ${
     EnumMacros.materializeEnumImpl[EntryType, StringEnum[EntryType]]
   }
+  implicit def materialiseStringValueEnum[EntryType <: StringEnumEntry]: StringEnum[
+    EntryType
+  ] = macro compat.EnumMacros.materializeEnumImpl[EntryType]
 }
 
 private[enumeratum] trait StringEnumCompat[A <: StringEnumEntry] { _enum: StringEnum[A] =>
@@ -89,6 +103,8 @@ private[enumeratum] trait StringEnumCompat[A <: StringEnumEntry] { _enum: String
   protected inline def findValues: IndexedSeq[A] = ${
     ValueEnumMacros.findStringValueEntriesImpl[A]
   }
+  protected def findValues: IndexedSeq[A] = macro
+    compat.ValueEnumMacros.findStringValueEntriesImpl[A]
   // format: on
 }
 
@@ -99,6 +115,8 @@ private[enumeratum] trait ByteEnumCompanion {
   implicit inline def materialiseByteValueEnum[EntryType <: ByteEnumEntry]: ByteEnum[EntryType] = ${
     EnumMacros.materializeEnumImpl[EntryType, ByteEnum[EntryType]]
   }
+  implicit def materialiseByteValueEnum[EntryType <: ByteEnumEntry]: ByteEnum[EntryType] = macro
+    compat.EnumMacros.materializeEnumImpl[EntryType]
 }
 
 private[enumeratum] trait ByteEnumCompat[A <: ByteEnumEntry] { _enum: ByteEnum[A] =>
@@ -112,6 +130,7 @@ private[enumeratum] trait ByteEnumCompat[A <: ByteEnumEntry] { _enum: ByteEnum[A
   protected inline def findValues: IndexedSeq[A] = ${
     ValueEnumMacros.findByteValueEntriesImpl[A]
   }
+  protected def findValues: IndexedSeq[A] = macro compat.ValueEnumMacros.findByteValueEntriesImpl[A]
   // format: on
 }
 
@@ -122,6 +141,8 @@ private[enumeratum] trait CharEnumCompanion {
   implicit inline def materialiseCharValueEnum[EntryType <: CharEnumEntry]: CharEnum[EntryType] = ${
     EnumMacros.materializeEnumImpl[EntryType, CharEnum[EntryType]]
   }
+  implicit def materialiseCharValueEnum[EntryType <: CharEnumEntry]: CharEnum[EntryType] = macro
+    compat.EnumMacros.materializeEnumImpl[EntryType]
 }
 
 private[enumeratum] trait CharEnumCompat[A <: CharEnumEntry] { _enum: CharEnum[A] =>
@@ -135,5 +156,6 @@ private[enumeratum] trait CharEnumCompat[A <: CharEnumEntry] { _enum: CharEnum[A
   protected inline def findValues: IndexedSeq[A] = ${
     ValueEnumMacros.findCharValueEntriesImpl[A]
   }
+  protected def findValues: IndexedSeq[A] = macro compat.ValueEnumMacros.findCharValueEntriesImpl[A]
   // format: on
 }
diff --git a/macros/compat/src/main/scala-3 b/macros/compat/src/main/scala-3
new file mode 120000
index 00000000..609602e5
--- /dev/null
+++ b/macros/compat/src/main/scala-3
@@ -0,0 +1 @@
+scala-2.13
\ No newline at end of file
diff --git a/macros/src/main/scala-2/enumeratum/EnumMacros.scala b/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
similarity index 93%
rename from macros/src/main/scala-2/enumeratum/EnumMacros.scala
rename to macros/src/main/scala/enumeratum/compat/EnumMacros.scala
index baf66cf3..ac197726 100644
--- a/macros/src/main/scala-2/enumeratum/EnumMacros.scala
+++ b/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
@@ -1,4 +1,5 @@
 package enumeratum
+package compat
 
 import ContextUtils.Context
 
@@ -10,7 +11,7 @@ object EnumMacros {
 
   /** Finds any [A] in the current scope and returns an expression for a list of them
     */
-  def findValuesImpl[A: c.WeakTypeTag](c: Context): c.Expr[IndexedSeq[A]] = {
+  def findValuesImpl[A: c.WeakTypeTag](c: Context): c.Tree = {
     import c.universe._
     val typeSymbol = weakTypeOf[A].typeSymbol
     validateType(c)(typeSymbol)
@@ -160,26 +161,22 @@ object EnumMacros {
   @SuppressWarnings(Array("org.wartremover.warts.AsInstanceOf"))
   private[enumeratum] def buildSeqExpr[A: c.WeakTypeTag](c: Context)(
       subclassSymbols: Seq[c.universe.Symbol]
-  ) = {
+  ): c.Tree = {
     import c.universe._
     val resultType = weakTypeOf[A]
     val indexedSeq = Ident(c.mirror.staticModule(classOf[IndexedSeq[A]].getName))
     if (subclassSymbols.isEmpty) {
-      c.Expr[IndexedSeq[A]](
-        TypeApply(
-          Select(indexedSeq, ContextUtils.termName(c)("empty")),
-          List(TypeTree(resultType))
-        )
+      TypeApply(
+        Select(indexedSeq, ContextUtils.termName(c)("empty")),
+        List(TypeTree(resultType))
       )
     } else {
-      c.Expr[IndexedSeq[A]](
-        Apply(
-          TypeApply(
-            Select(indexedSeq, ContextUtils.termName(c)("apply")),
-            List(TypeTree(resultType))
-          ),
-          subclassSymbols.map(Ident(_)).toList
-        )
+      Apply(
+        TypeApply(
+          Select(indexedSeq, ContextUtils.termName(c)("apply")),
+          List(TypeTree(resultType))
+        ),
+        subclassSymbols.map(Ident(_)).toList
       )
     }
   }
diff --git a/macros/src/main/scala-2/enumeratum/ValueEnumMacros.scala b/macros/src/main/scala/enumeratum/compat/ValueEnumMacros.scala
similarity index 96%
rename from macros/src/main/scala-2/enumeratum/ValueEnumMacros.scala
rename to macros/src/main/scala/enumeratum/compat/ValueEnumMacros.scala
index 6eb13bef..2a66167d 100644
--- a/macros/src/main/scala-2/enumeratum/ValueEnumMacros.scala
+++ b/macros/src/main/scala/enumeratum/compat/ValueEnumMacros.scala
@@ -1,4 +1,5 @@
 package enumeratum
+package compat
 
 import ContextUtils.Context
 
@@ -15,7 +16,7 @@ object ValueEnumMacros {
     */
   def findIntValueEntriesImpl[ValueEntryType: c.WeakTypeTag](
       c: Context
-  ): c.Expr[IndexedSeq[ValueEntryType]] = {
+  ): c.Tree = {
     findValueEntriesImpl[ValueEntryType, ContextUtils.CTInt, Int](c)(identity)
   }
 
@@ -25,7 +26,7 @@ object ValueEnumMacros {
     */
   def findLongValueEntriesImpl[ValueEntryType: c.WeakTypeTag](
       c: Context
-  ): c.Expr[IndexedSeq[ValueEntryType]] = {
+  ): c.Tree = {
     findValueEntriesImpl[ValueEntryType, ContextUtils.CTLong, Long](c)(identity)
   }
 
@@ -38,7 +39,7 @@ object ValueEnumMacros {
     */
   def findShortValueEntriesImpl[ValueEntryType: c.WeakTypeTag](
       c: Context
-  ): c.Expr[IndexedSeq[ValueEntryType]] = {
+  ): c.Tree = {
     findValueEntriesImpl[ValueEntryType, ContextUtils.CTInt, Short](c)(
       _.toShort
     ) // do a transform because there is no such thing as Short literals
@@ -52,7 +53,7 @@ object ValueEnumMacros {
     */
   def findStringValueEntriesImpl[ValueEntryType: c.WeakTypeTag](
       c: Context
-  ): c.Expr[IndexedSeq[ValueEntryType]] = {
+  ): c.Tree = {
     findValueEntriesImpl[ValueEntryType, String, String](c)(identity)
   }
 
@@ -64,7 +65,7 @@ object ValueEnumMacros {
     */
   def findByteValueEntriesImpl[ValueEntryType: c.WeakTypeTag](
       c: Context
-  ): c.Expr[IndexedSeq[ValueEntryType]] = {
+  ): c.Tree = {
     findValueEntriesImpl[ValueEntryType, ContextUtils.CTInt, Byte](c)(_.toByte)
   }
 
@@ -76,7 +77,7 @@ object ValueEnumMacros {
     */
   def findCharValueEntriesImpl[ValueEntryType: c.WeakTypeTag](
       c: Context
-  ): c.Expr[IndexedSeq[ValueEntryType]] = {
+  ): c.Tree = {
     findValueEntriesImpl[ValueEntryType, ContextUtils.CTChar, Char](c)(identity)
   }
 
@@ -88,7 +89,7 @@ object ValueEnumMacros {
       ProcessedValue
   ](c: Context)(
       processFoundValues: ValueType => ProcessedValue
-  ): c.Expr[IndexedSeq[ValueEntryType]] = {
+  ): c.Tree = {
     import c.universe._
     val typeSymbol = weakTypeOf[ValueEntryType].typeSymbol
     EnumMacros.validateType(c)(typeSymbol)
@@ -104,7 +105,11 @@ object ValueEnumMacros {
       processFoundValues
     )
 
-    if (weakTypeOf[ValueEntryType] <:< c.typeOf[AllowAlias]) {
+    if (
+      weakTypeOf[ValueEntryType].baseClasses.contains(
+        c.mirror.staticClass(classOf[AllowAlias].getName)
+      )
+    ) {
       // Skip the uniqueness check
     } else {
       // Make sure the processed found value implementations are unique
diff --git a/macros/src/test/scala-2/enumeratum/FindValEnums.scala b/macros/src/test/scala-2/enumeratum/FindValEnums.scala
index 1a80d94e..35cd3ace 100644
--- a/macros/src/test/scala-2/enumeratum/FindValEnums.scala
+++ b/macros/src/test/scala-2/enumeratum/FindValEnums.scala
@@ -1,5 +1,6 @@
 package enumeratum
 
+import enumeratum.compat.ValueEnumMacros
 import scala.language.experimental.macros
 
 /** Created by Lloyd on 1/4/17.

From 02b74d3fb61aa33370e3d1881b7999f2f19b7fc3 Mon Sep 17 00:00:00 2001
From: Gregg Hernandez <gregg@lucidchart.com>
Date: Fri, 20 Sep 2024 14:39:24 -0700
Subject: [PATCH 3/7] Update dependencies to fix builds

---
 .../main/scala/enumeratum/values/Cats.scala    |  4 ++--
 .../enumeratum/values/CatsValueEnum.scala      |  2 +-
 .../src/main/scala/enumeratum/EnumEntry.scala  | 18 +++++++++---------
 .../enumeratum/values/ValueEnumEntry.scala     |  2 +-
 .../main/scala/enumeratum/values/Forms.scala   |  2 +-
 .../main/scala-3/enumeratum/EnumMacros.scala   |  4 ++--
 .../scala-3/enumeratum/ValueEnumMacros.scala   |  2 +-
 .../scala/enumeratum/compat/EnumMacros.scala   |  4 ++--
 .../enumeratum/compat/ValueEnumMacros.scala    | 14 +++++++-------
 9 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/enumeratum-cats/src/main/scala/enumeratum/values/Cats.scala b/enumeratum-cats/src/main/scala/enumeratum/values/Cats.scala
index 29f02317..38a25564 100644
--- a/enumeratum-cats/src/main/scala/enumeratum/values/Cats.scala
+++ b/enumeratum-cats/src/main/scala/enumeratum/values/Cats.scala
@@ -7,7 +7,7 @@ object Cats {
   /** Builds an `Eq` instance which differentiates all enum values as it's based on universal
     * equals.
     */
-  def eqForEnum[A <: ValueEnumEntry[_]]: Eq[A] = Eq.fromUniversalEquals[A]
+  def eqForEnum[A <: ValueEnumEntry[?]]: Eq[A] = Eq.fromUniversalEquals[A]
 
   /** Builds an `Eq` instance which acts accordingly to the given `Eq` on the value type. Allows to
     * implement different behaviour than [[eqForEnum]], for example grouping several enum values in
@@ -17,7 +17,7 @@ object Cats {
 
   /** Builds a `Show` instance based on `toString`.
     */
-  def showForEnum[A <: ValueEnumEntry[_]]: Show[A] = Show.fromToString[A]
+  def showForEnum[A <: ValueEnumEntry[?]]: Show[A] = Show.fromToString[A]
 
   /** Builds a `Show` instance from the given `Show` on the value type.
     */
diff --git a/enumeratum-cats/src/main/scala/enumeratum/values/CatsValueEnum.scala b/enumeratum-cats/src/main/scala/enumeratum/values/CatsValueEnum.scala
index 3d1dfe4c..7923082c 100644
--- a/enumeratum-cats/src/main/scala/enumeratum/values/CatsValueEnum.scala
+++ b/enumeratum-cats/src/main/scala/enumeratum/values/CatsValueEnum.scala
@@ -25,7 +25,7 @@ trait CatsCustomOrderValueEnum[ValueType, EntryType <: ValueEnumEntry[ValueType]
   /** Builds a `Order` instance from the given `Order` (see [[valueTypeOrder]] on the value type.
     */
   implicit val orderInstance: Order[EntryType] =
-    Cats.valueOrderForEnum[EntryType, ValueType](valueTypeOrder)
+    Cats.valueOrderForEnum[EntryType, ValueType](using valueTypeOrder)
 
 }
 
diff --git a/enumeratum-core/src/main/scala/enumeratum/EnumEntry.scala b/enumeratum-core/src/main/scala/enumeratum/EnumEntry.scala
index 7bc11f38..f2f8d777 100644
--- a/enumeratum-core/src/main/scala/enumeratum/EnumEntry.scala
+++ b/enumeratum-core/src/main/scala/enumeratum/EnumEntry.scala
@@ -19,7 +19,7 @@ trait EnumEntry {
     */
   def entryName: String = stableEntryName
 
-  private[this] lazy val stableEntryName: String = toString
+  private lazy val stableEntryName: String = toString
 
 }
 
@@ -62,7 +62,7 @@ object EnumEntry {
   trait CapitalSnakecase extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private[this] lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString("_")
+    private lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString("_")
   }
 
   /** Stackable trait to convert the entryName to Capital-Hyphen-Case.
@@ -70,7 +70,7 @@ object EnumEntry {
   trait CapitalHyphencase extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private[this] lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString("-")
+    private lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString("-")
   }
 
   /** Stackable trait to convert the entryName to Capital.Dot.Case.
@@ -78,7 +78,7 @@ object EnumEntry {
   trait CapitalDotcase extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private[this] lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString(".")
+    private lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString(".")
   }
 
   /** Stackable trait to convert the entryName to Capital Words.
@@ -86,7 +86,7 @@ object EnumEntry {
   trait CapitalWords extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private[this] lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString(" ")
+    private lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString(" ")
   }
 
   /** Stackable trait to convert the entryName to CamelCase.
@@ -94,7 +94,7 @@ object EnumEntry {
   trait Camelcase extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private[this] lazy val stableEntryName: String =
+    private lazy val stableEntryName: String =
       camel2WordArray(super.entryName).map(s => capitalise(s.toLowerCase)).mkString
   }
 
@@ -103,7 +103,7 @@ object EnumEntry {
   trait Uppercase extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private[this] lazy val stableEntryName: String = super.entryName.toUpperCase
+    private lazy val stableEntryName: String = super.entryName.toUpperCase
   }
 
   /** Stackable trait to convert the entryName to lowercase.
@@ -111,7 +111,7 @@ object EnumEntry {
   trait Lowercase extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private[this] lazy val stableEntryName: String = super.entryName.toLowerCase
+    private lazy val stableEntryName: String = super.entryName.toLowerCase
   }
 
   /** Stackable trait to uncapitalise the first letter of the entryName.
@@ -119,7 +119,7 @@ object EnumEntry {
   trait Uncapitalised extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private[this] lazy val stableEntryName: String = uncapitalise(super.entryName)
+    private lazy val stableEntryName: String = uncapitalise(super.entryName)
   }
 
   /** Stackable trait to convert the entryName to snake_case.
diff --git a/enumeratum-core/src/main/scala/enumeratum/values/ValueEnumEntry.scala b/enumeratum-core/src/main/scala/enumeratum/values/ValueEnumEntry.scala
index 8875076e..0321d594 100644
--- a/enumeratum-core/src/main/scala/enumeratum/values/ValueEnumEntry.scala
+++ b/enumeratum-core/src/main/scala/enumeratum/values/ValueEnumEntry.scala
@@ -14,7 +14,7 @@ sealed trait ValueEnumEntry[ValueType] {
 
 object ValueEnumEntry {
 
-  implicit class ValueEnumOps[A <: ValueEnumEntry[_]](val enumEntry: A) extends AnyVal {
+  implicit class ValueEnumOps[A <: ValueEnumEntry[?]](val enumEntry: A) extends AnyVal {
 
     /** Checks if the current enum value is contained by the set of enum values in the parameter
       * list.
diff --git a/enumeratum-play/src/main/scala/enumeratum/values/Forms.scala b/enumeratum-play/src/main/scala/enumeratum/values/Forms.scala
index 0d13040e..540b02ac 100644
--- a/enumeratum-play/src/main/scala/enumeratum/values/Forms.scala
+++ b/enumeratum-play/src/main/scala/enumeratum/values/Forms.scala
@@ -9,7 +9,7 @@ import play.api.data.{FormError, Mapping, Forms => PlayForms}
   */
 object Forms extends FormsCompat {
 
-  protected[this] def formatter[ValueType, EntryType <: ValueEnumEntry[
+  protected def formatter[ValueType, EntryType <: ValueEnumEntry[
     ValueType
   ], EnumType <: ValueEnum[ValueType, EntryType]](
       baseFormatter: Formatter[ValueType]
diff --git a/macros/src/main/scala-3/enumeratum/EnumMacros.scala b/macros/src/main/scala-3/enumeratum/EnumMacros.scala
index 465feb14..0e65f72e 100644
--- a/macros/src/main/scala-3/enumeratum/EnumMacros.scala
+++ b/macros/src/main/scala-3/enumeratum/EnumMacros.scala
@@ -77,7 +77,7 @@ object EnumMacros:
 
     val repr = TypeRepr.of[T](using tpe)
 
-    if (!repr.classSymbol.exists(_.flags is Flags.Sealed)) {
+    if (!repr.classSymbol.exists(_.flags.is(Flags.Sealed))) {
       report.errorAndAbort(
         "You can only use findValues on sealed traits or classes"
       )
@@ -201,7 +201,7 @@ object EnumMacros:
       val values = Expr.ofSeq(valueExprs)
 
       '{
-        IndexedSeq[T](${ values }: _*)
+        IndexedSeq[T](${ values }*)
       }
     }
   }
diff --git a/macros/src/main/scala-3/enumeratum/ValueEnumMacros.scala b/macros/src/main/scala-3/enumeratum/ValueEnumMacros.scala
index d3f856dc..a9257116 100644
--- a/macros/src/main/scala-3/enumeratum/ValueEnumMacros.scala
+++ b/macros/src/main/scala-3/enumeratum/ValueEnumMacros.scala
@@ -220,7 +220,7 @@ In SBT settings:
 
             Left(s"Values value are not discriminated subtypes: ${details}")
           } else {
-            Right(Expr ofList instances.reverse)
+            Right(Expr.ofList(instances.reverse))
           }
         }
       }
diff --git a/macros/src/main/scala/enumeratum/compat/EnumMacros.scala b/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
index ac197726..bd542b0d 100644
--- a/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
+++ b/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
@@ -186,7 +186,7 @@ object EnumMacros {
     * It's a bit of a hack, but I don't think it's much worse than pulling in scala-compiler for the
     * sake of getting access to this class and doing an `isInstanceOf`
     */
-  private[this] def isDocCompiler(c: Context): Boolean = {
+  private def isDocCompiler(c: Context): Boolean = {
     c.universe.getClass.toString.contains("doc.DocFactory")
   }
 
@@ -194,7 +194,7 @@ object EnumMacros {
     *
     * DocDefs are not part of the public API, so we try to hack around it here.
     */
-  private[this] def isDocDef(c: Context)(t: c.universe.Tree): Boolean = {
+  private def isDocDef(c: Context)(t: c.universe.Tree): Boolean = {
     t.getClass.toString.contains("DocDef")
   }
 }
diff --git a/macros/src/main/scala/enumeratum/compat/ValueEnumMacros.scala b/macros/src/main/scala/enumeratum/compat/ValueEnumMacros.scala
index 2a66167d..2ba5a36b 100644
--- a/macros/src/main/scala/enumeratum/compat/ValueEnumMacros.scala
+++ b/macros/src/main/scala/enumeratum/compat/ValueEnumMacros.scala
@@ -83,7 +83,7 @@ object ValueEnumMacros {
 
   /** The method that does the heavy lifting.
     */
-  private[this] def findValueEntriesImpl[
+  private def findValueEntriesImpl[
       ValueEntryType: c.WeakTypeTag,
       ValueType: ClassTag,
       ProcessedValue
@@ -128,7 +128,7 @@ object ValueEnumMacros {
     * Will abort compilation if not all the trees provided have a literal value member/constructor
     * argument
     */
-  private[this] def findValuesForSubclassTrees[ValueType: ClassTag, ProcessedValueType](
+  private def findValuesForSubclassTrees[ValueType: ClassTag, ProcessedValueType](
       c: Context
   )(
       valueEntryCTorsParams: List[List[c.universe.Name]],
@@ -169,7 +169,7 @@ object ValueEnumMacros {
     *
     * Aborts compilation if the value declaration/constructor is of the wrong type,
     */
-  private[this] def toTreeWithMaybeVals[ValueType: ClassTag, ProcessedValueType](c: Context)(
+  private def toTreeWithMaybeVals[ValueType: ClassTag, ProcessedValueType](c: Context)(
       valueEntryCTorsParams: List[List[c.universe.Name]],
       memberTrees: Seq[c.universe.ModuleDef],
       processFoundValues: ValueType => ProcessedValueType
@@ -249,7 +249,7 @@ object ValueEnumMacros {
 
   /** Given a type, finds the constructor params lists for it
     */
-  private[this] def findConstructorParamsLists[ValueEntryType: c.WeakTypeTag](
+  private def findConstructorParamsLists[ValueEntryType: c.WeakTypeTag](
       c: Context
   ): List[List[c.universe.Name]] = {
     val valueEntryTypeTpe        = implicitly[c.WeakTypeTag[ValueEntryType]].tpe
@@ -260,7 +260,7 @@ object ValueEnumMacros {
   /** Ensures that we have unique values for trees, aborting otherwise with a message indicating
     * which trees have the same symbol
     */
-  private[this] def ensureUnique[A](c: Context)(
+  private def ensureUnique[A](c: Context)(
       treeWithVals: Seq[TreeWithVal[c.universe.ModuleDef, A]]
   ): Unit = {
     val membersWithValues = treeWithVals.map { treeWithVal =>
@@ -291,7 +291,7 @@ object ValueEnumMacros {
   }
 
   // Helper case classes
-  private[this] case class TreeWithMaybeVal[CTree, T](tree: CTree, maybeValue: Option[T])
-  private[this] case class TreeWithVal[CTree, T](tree: CTree, value: T)
+  private case class TreeWithMaybeVal[CTree, T](tree: CTree, maybeValue: Option[T])
+  private case class TreeWithVal[CTree, T](tree: CTree, value: T)
 
 }

From b33b46282947e4a3da7dab160b79d5676d99a461 Mon Sep 17 00:00:00 2001
From: Gregg Hernandez <gregg@lucidchart.com>
Date: Fri, 25 Oct 2024 13:54:53 -0700
Subject: [PATCH 4/7] Suppress deprecation warning

---
 macros/src/main/scala/enumeratum/compat/EnumMacros.scala | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/macros/src/main/scala/enumeratum/compat/EnumMacros.scala b/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
index bd542b0d..802d6455 100644
--- a/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
+++ b/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
@@ -3,6 +3,7 @@ package compat
 
 import ContextUtils.Context
 
+import scala.annotation.nowarn
 import scala.collection.immutable._
 import scala.util.control.NonFatal
 
@@ -106,7 +107,7 @@ object EnumMacros {
     import c.universe._
     val enclosingBodySubClassTrees: List[Tree] =
       try {
-        val enclosingModule = c.enclosingClass match {
+        val enclosingModule = (c.enclosingClass: @nowarn) match {
           case md @ ModuleDef(_, _, _) => md
           case _ =>
             c.abort(

From 650fd7c651aff365b0feb3dc28fad86c46243613 Mon Sep 17 00:00:00 2001
From: Gregg Hernandez <gregg@lucidchart.com>
Date: Thu, 31 Oct 2024 09:11:28 -0700
Subject: [PATCH 5/7] Removes protected

---
 enumeratum-core/src/main/scala-3/enumeratum/EnumCompat.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/enumeratum-core/src/main/scala-3/enumeratum/EnumCompat.scala b/enumeratum-core/src/main/scala-3/enumeratum/EnumCompat.scala
index ece0c498..cee985c7 100644
--- a/enumeratum-core/src/main/scala-3/enumeratum/EnumCompat.scala
+++ b/enumeratum-core/src/main/scala-3/enumeratum/EnumCompat.scala
@@ -11,8 +11,8 @@ private[enumeratum] trait EnumCompat[A <: EnumEntry] { _enum: Enum[A] =>
     * You will want to use this in some way to implement your [[values]] method. In fact, if you
     * aren't using this method... why are you even bothering with this lib?
     */
-  protected inline def findValues: IndexedSeq[A] = ${ EnumMacros.findValuesImpl[A] }
-  protected def findValues: IndexedSeq[A] = macro compat.EnumMacros.findValuesImpl[A]
+  inline def findValues: IndexedSeq[A] = ${ EnumMacros.findValuesImpl[A] }
+  def findValues: IndexedSeq[A] = macro compat.EnumMacros.findValuesImpl[A]
   // format: on
 
   /** The sequence of values for your [[Enum]]. You will typically want to implement this in your

From 36321718a86a05cc98ca022c2c5facfd5ff351ce Mon Sep 17 00:00:00 2001
From: Jaden Peterson <jpeterson@lucidchart.com>
Date: Thu, 18 Sep 2025 16:53:14 -0400
Subject: [PATCH 6/7] Revert "Update dependencies to fix builds"

This reverts commit 02b74d3fb61aa33370e3d1881b7999f2f19b7fc3.
---
 .../main/scala/enumeratum/values/Cats.scala    |  4 ++--
 .../enumeratum/values/CatsValueEnum.scala      |  2 +-
 .../src/main/scala/enumeratum/EnumEntry.scala  | 18 +++++++++---------
 .../enumeratum/values/ValueEnumEntry.scala     |  2 +-
 .../main/scala/enumeratum/values/Forms.scala   |  2 +-
 .../main/scala-3/enumeratum/EnumMacros.scala   |  4 ++--
 .../scala-3/enumeratum/ValueEnumMacros.scala   |  2 +-
 .../scala/enumeratum/compat/EnumMacros.scala   |  4 ++--
 .../enumeratum/compat/ValueEnumMacros.scala    | 14 +++++++-------
 9 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/enumeratum-cats/src/main/scala/enumeratum/values/Cats.scala b/enumeratum-cats/src/main/scala/enumeratum/values/Cats.scala
index 38a25564..29f02317 100644
--- a/enumeratum-cats/src/main/scala/enumeratum/values/Cats.scala
+++ b/enumeratum-cats/src/main/scala/enumeratum/values/Cats.scala
@@ -7,7 +7,7 @@ object Cats {
   /** Builds an `Eq` instance which differentiates all enum values as it's based on universal
     * equals.
     */
-  def eqForEnum[A <: ValueEnumEntry[?]]: Eq[A] = Eq.fromUniversalEquals[A]
+  def eqForEnum[A <: ValueEnumEntry[_]]: Eq[A] = Eq.fromUniversalEquals[A]
 
   /** Builds an `Eq` instance which acts accordingly to the given `Eq` on the value type. Allows to
     * implement different behaviour than [[eqForEnum]], for example grouping several enum values in
@@ -17,7 +17,7 @@ object Cats {
 
   /** Builds a `Show` instance based on `toString`.
     */
-  def showForEnum[A <: ValueEnumEntry[?]]: Show[A] = Show.fromToString[A]
+  def showForEnum[A <: ValueEnumEntry[_]]: Show[A] = Show.fromToString[A]
 
   /** Builds a `Show` instance from the given `Show` on the value type.
     */
diff --git a/enumeratum-cats/src/main/scala/enumeratum/values/CatsValueEnum.scala b/enumeratum-cats/src/main/scala/enumeratum/values/CatsValueEnum.scala
index 7923082c..3d1dfe4c 100644
--- a/enumeratum-cats/src/main/scala/enumeratum/values/CatsValueEnum.scala
+++ b/enumeratum-cats/src/main/scala/enumeratum/values/CatsValueEnum.scala
@@ -25,7 +25,7 @@ trait CatsCustomOrderValueEnum[ValueType, EntryType <: ValueEnumEntry[ValueType]
   /** Builds a `Order` instance from the given `Order` (see [[valueTypeOrder]] on the value type.
     */
   implicit val orderInstance: Order[EntryType] =
-    Cats.valueOrderForEnum[EntryType, ValueType](using valueTypeOrder)
+    Cats.valueOrderForEnum[EntryType, ValueType](valueTypeOrder)
 
 }
 
diff --git a/enumeratum-core/src/main/scala/enumeratum/EnumEntry.scala b/enumeratum-core/src/main/scala/enumeratum/EnumEntry.scala
index f2f8d777..7bc11f38 100644
--- a/enumeratum-core/src/main/scala/enumeratum/EnumEntry.scala
+++ b/enumeratum-core/src/main/scala/enumeratum/EnumEntry.scala
@@ -19,7 +19,7 @@ trait EnumEntry {
     */
   def entryName: String = stableEntryName
 
-  private lazy val stableEntryName: String = toString
+  private[this] lazy val stableEntryName: String = toString
 
 }
 
@@ -62,7 +62,7 @@ object EnumEntry {
   trait CapitalSnakecase extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString("_")
+    private[this] lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString("_")
   }
 
   /** Stackable trait to convert the entryName to Capital-Hyphen-Case.
@@ -70,7 +70,7 @@ object EnumEntry {
   trait CapitalHyphencase extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString("-")
+    private[this] lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString("-")
   }
 
   /** Stackable trait to convert the entryName to Capital.Dot.Case.
@@ -78,7 +78,7 @@ object EnumEntry {
   trait CapitalDotcase extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString(".")
+    private[this] lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString(".")
   }
 
   /** Stackable trait to convert the entryName to Capital Words.
@@ -86,7 +86,7 @@ object EnumEntry {
   trait CapitalWords extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString(" ")
+    private[this] lazy val stableEntryName: String = camel2WordArray(super.entryName).mkString(" ")
   }
 
   /** Stackable trait to convert the entryName to CamelCase.
@@ -94,7 +94,7 @@ object EnumEntry {
   trait Camelcase extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private lazy val stableEntryName: String =
+    private[this] lazy val stableEntryName: String =
       camel2WordArray(super.entryName).map(s => capitalise(s.toLowerCase)).mkString
   }
 
@@ -103,7 +103,7 @@ object EnumEntry {
   trait Uppercase extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private lazy val stableEntryName: String = super.entryName.toUpperCase
+    private[this] lazy val stableEntryName: String = super.entryName.toUpperCase
   }
 
   /** Stackable trait to convert the entryName to lowercase.
@@ -111,7 +111,7 @@ object EnumEntry {
   trait Lowercase extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private lazy val stableEntryName: String = super.entryName.toLowerCase
+    private[this] lazy val stableEntryName: String = super.entryName.toLowerCase
   }
 
   /** Stackable trait to uncapitalise the first letter of the entryName.
@@ -119,7 +119,7 @@ object EnumEntry {
   trait Uncapitalised extends EnumEntry {
     override def entryName: String = stableEntryName
 
-    private lazy val stableEntryName: String = uncapitalise(super.entryName)
+    private[this] lazy val stableEntryName: String = uncapitalise(super.entryName)
   }
 
   /** Stackable trait to convert the entryName to snake_case.
diff --git a/enumeratum-core/src/main/scala/enumeratum/values/ValueEnumEntry.scala b/enumeratum-core/src/main/scala/enumeratum/values/ValueEnumEntry.scala
index 0321d594..8875076e 100644
--- a/enumeratum-core/src/main/scala/enumeratum/values/ValueEnumEntry.scala
+++ b/enumeratum-core/src/main/scala/enumeratum/values/ValueEnumEntry.scala
@@ -14,7 +14,7 @@ sealed trait ValueEnumEntry[ValueType] {
 
 object ValueEnumEntry {
 
-  implicit class ValueEnumOps[A <: ValueEnumEntry[?]](val enumEntry: A) extends AnyVal {
+  implicit class ValueEnumOps[A <: ValueEnumEntry[_]](val enumEntry: A) extends AnyVal {
 
     /** Checks if the current enum value is contained by the set of enum values in the parameter
       * list.
diff --git a/enumeratum-play/src/main/scala/enumeratum/values/Forms.scala b/enumeratum-play/src/main/scala/enumeratum/values/Forms.scala
index 540b02ac..0d13040e 100644
--- a/enumeratum-play/src/main/scala/enumeratum/values/Forms.scala
+++ b/enumeratum-play/src/main/scala/enumeratum/values/Forms.scala
@@ -9,7 +9,7 @@ import play.api.data.{FormError, Mapping, Forms => PlayForms}
   */
 object Forms extends FormsCompat {
 
-  protected def formatter[ValueType, EntryType <: ValueEnumEntry[
+  protected[this] def formatter[ValueType, EntryType <: ValueEnumEntry[
     ValueType
   ], EnumType <: ValueEnum[ValueType, EntryType]](
       baseFormatter: Formatter[ValueType]
diff --git a/macros/src/main/scala-3/enumeratum/EnumMacros.scala b/macros/src/main/scala-3/enumeratum/EnumMacros.scala
index 0e65f72e..465feb14 100644
--- a/macros/src/main/scala-3/enumeratum/EnumMacros.scala
+++ b/macros/src/main/scala-3/enumeratum/EnumMacros.scala
@@ -77,7 +77,7 @@ object EnumMacros:
 
     val repr = TypeRepr.of[T](using tpe)
 
-    if (!repr.classSymbol.exists(_.flags.is(Flags.Sealed))) {
+    if (!repr.classSymbol.exists(_.flags is Flags.Sealed)) {
       report.errorAndAbort(
         "You can only use findValues on sealed traits or classes"
       )
@@ -201,7 +201,7 @@ object EnumMacros:
       val values = Expr.ofSeq(valueExprs)
 
       '{
-        IndexedSeq[T](${ values }*)
+        IndexedSeq[T](${ values }: _*)
       }
     }
   }
diff --git a/macros/src/main/scala-3/enumeratum/ValueEnumMacros.scala b/macros/src/main/scala-3/enumeratum/ValueEnumMacros.scala
index a9257116..d3f856dc 100644
--- a/macros/src/main/scala-3/enumeratum/ValueEnumMacros.scala
+++ b/macros/src/main/scala-3/enumeratum/ValueEnumMacros.scala
@@ -220,7 +220,7 @@ In SBT settings:
 
             Left(s"Values value are not discriminated subtypes: ${details}")
           } else {
-            Right(Expr.ofList(instances.reverse))
+            Right(Expr ofList instances.reverse)
           }
         }
       }
diff --git a/macros/src/main/scala/enumeratum/compat/EnumMacros.scala b/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
index 802d6455..f0ec6d50 100644
--- a/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
+++ b/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
@@ -187,7 +187,7 @@ object EnumMacros {
     * It's a bit of a hack, but I don't think it's much worse than pulling in scala-compiler for the
     * sake of getting access to this class and doing an `isInstanceOf`
     */
-  private def isDocCompiler(c: Context): Boolean = {
+  private[this] def isDocCompiler(c: Context): Boolean = {
     c.universe.getClass.toString.contains("doc.DocFactory")
   }
 
@@ -195,7 +195,7 @@ object EnumMacros {
     *
     * DocDefs are not part of the public API, so we try to hack around it here.
     */
-  private def isDocDef(c: Context)(t: c.universe.Tree): Boolean = {
+  private[this] def isDocDef(c: Context)(t: c.universe.Tree): Boolean = {
     t.getClass.toString.contains("DocDef")
   }
 }
diff --git a/macros/src/main/scala/enumeratum/compat/ValueEnumMacros.scala b/macros/src/main/scala/enumeratum/compat/ValueEnumMacros.scala
index 2ba5a36b..2a66167d 100644
--- a/macros/src/main/scala/enumeratum/compat/ValueEnumMacros.scala
+++ b/macros/src/main/scala/enumeratum/compat/ValueEnumMacros.scala
@@ -83,7 +83,7 @@ object ValueEnumMacros {
 
   /** The method that does the heavy lifting.
     */
-  private def findValueEntriesImpl[
+  private[this] def findValueEntriesImpl[
       ValueEntryType: c.WeakTypeTag,
       ValueType: ClassTag,
       ProcessedValue
@@ -128,7 +128,7 @@ object ValueEnumMacros {
     * Will abort compilation if not all the trees provided have a literal value member/constructor
     * argument
     */
-  private def findValuesForSubclassTrees[ValueType: ClassTag, ProcessedValueType](
+  private[this] def findValuesForSubclassTrees[ValueType: ClassTag, ProcessedValueType](
       c: Context
   )(
       valueEntryCTorsParams: List[List[c.universe.Name]],
@@ -169,7 +169,7 @@ object ValueEnumMacros {
     *
     * Aborts compilation if the value declaration/constructor is of the wrong type,
     */
-  private def toTreeWithMaybeVals[ValueType: ClassTag, ProcessedValueType](c: Context)(
+  private[this] def toTreeWithMaybeVals[ValueType: ClassTag, ProcessedValueType](c: Context)(
       valueEntryCTorsParams: List[List[c.universe.Name]],
       memberTrees: Seq[c.universe.ModuleDef],
       processFoundValues: ValueType => ProcessedValueType
@@ -249,7 +249,7 @@ object ValueEnumMacros {
 
   /** Given a type, finds the constructor params lists for it
     */
-  private def findConstructorParamsLists[ValueEntryType: c.WeakTypeTag](
+  private[this] def findConstructorParamsLists[ValueEntryType: c.WeakTypeTag](
       c: Context
   ): List[List[c.universe.Name]] = {
     val valueEntryTypeTpe        = implicitly[c.WeakTypeTag[ValueEntryType]].tpe
@@ -260,7 +260,7 @@ object ValueEnumMacros {
   /** Ensures that we have unique values for trees, aborting otherwise with a message indicating
     * which trees have the same symbol
     */
-  private def ensureUnique[A](c: Context)(
+  private[this] def ensureUnique[A](c: Context)(
       treeWithVals: Seq[TreeWithVal[c.universe.ModuleDef, A]]
   ): Unit = {
     val membersWithValues = treeWithVals.map { treeWithVal =>
@@ -291,7 +291,7 @@ object ValueEnumMacros {
   }
 
   // Helper case classes
-  private case class TreeWithMaybeVal[CTree, T](tree: CTree, maybeValue: Option[T])
-  private case class TreeWithVal[CTree, T](tree: CTree, value: T)
+  private[this] case class TreeWithMaybeVal[CTree, T](tree: CTree, maybeValue: Option[T])
+  private[this] case class TreeWithVal[CTree, T](tree: CTree, value: T)
 
 }

From 18c59d809ac1dc4de9131fe047001401e12de91c Mon Sep 17 00:00:00 2001
From: Jaden Peterson <jpeterson@lucidchart.com>
Date: Thu, 18 Sep 2025 16:57:20 -0400
Subject: [PATCH 7/7] Revert "Suppress deprecation warning"

This reverts commit b33b46282947e4a3da7dab160b79d5676d99a461.
---
 macros/src/main/scala/enumeratum/compat/EnumMacros.scala | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/macros/src/main/scala/enumeratum/compat/EnumMacros.scala b/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
index f0ec6d50..ac197726 100644
--- a/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
+++ b/macros/src/main/scala/enumeratum/compat/EnumMacros.scala
@@ -3,7 +3,6 @@ package compat
 
 import ContextUtils.Context
 
-import scala.annotation.nowarn
 import scala.collection.immutable._
 import scala.util.control.NonFatal
 
@@ -107,7 +106,7 @@ object EnumMacros {
     import c.universe._
     val enclosingBodySubClassTrees: List[Tree] =
       try {
-        val enclosingModule = (c.enclosingClass: @nowarn) match {
+        val enclosingModule = c.enclosingClass match {
           case md @ ModuleDef(_, _, _) => md
           case _ =>
             c.abort(