Mix scala 2 and 3 macros

.github/workflows/ci.yml

@@ -13,9 +13,9 @@ jobs:
           - java: 11
             scala: 2.12.18
           - java: 11
-            scala: 2.13.11
+            scala: 2.13.13
           - java: 11
-            scala: 3.3.0
+            scala: 3.3.4
     runs-on: ubuntu-latest
     env:
       SCALAJS_TEST_OPT: full
@@ -36,7 +36,7 @@ jobs:
         shell: bash
         run: |
           case ${{ matrix.scala }} in
-            2.13.11)
+            2.13.13)
               sbt -v "++${{ matrix.scala }} scalafmtCheck" "++${{ matrix.scala }} scalafmtSbtCheck" "++${{ matrix.scala }} test:compile" "++${{ matrix.scala }} test:doc"
               sbt -v "coverage" "++${{ matrix.scala }} test" "++${{ matrix.scala }} coverageReport"
               sbt -v "++${{ matrix.scala }} coverageAggregate"
@@ -52,7 +52,7 @@ jobs:
           find $HOME/.cache/coursier/v1         -name "ivydata-*.properties" -delete || true
           find $HOME/.sbt                       -name "*.lock"               -delete || true
       - name: Upload coverage to Codecov
-        if: ${{ matrix.scala == '2.13.11' }}
+        if: ${{ matrix.scala == '2.13.13' }}
         uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = 3.7.8
+version = 3.7.10
 runner.dialect = Scala213Source3
 style = defaultWithAlign
 maxColumn = 100

build.sbt

@@ -3,8 +3,8 @@ import sbtbuildinfo.BuildInfoPlugin.autoImport._
 import sbtcrossproject.CrossPlugin.autoImport.{CrossType, crossProject}
 
 lazy val scala_2_12Version = "2.12.18"
-lazy val scala_2_13Version = "2.13.11"
-lazy val scala_3Version    = "3.3.0"
+lazy val scala_2_13Version = "2.13.13"
+lazy val scala_3Version    = "3.3.4"
 lazy val scalaVersionsAll  = Seq(scala_2_12Version, scala_2_13Version, scala_3Version)
 
 lazy val theScalaVersion = scala_2_12Version
@@ -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
@@ -461,7 +464,7 @@ lazy val enumeratumScalacheck = crossProject(JSPlatform, JVMPlatform, NativePlat
     version            := Versions.Core.head,
     crossScalaVersions := scalaVersionsAll,
     libraryDependencies ++= {
-      val (ver, mod, ver2) = ("1.18.0", "scalacheck-1-18", "3.2.19.0")
+      val (ver, mod, ver2) = ("1.18.1", "scalacheck-1-18", "3.2.19.0")
 
       Seq(
         "org.scalacheck"    %%% "scalacheck" % ver,
@@ -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",

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.
     */

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)
 
 }
 

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.

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 {
 

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
@@ -9,6 +12,7 @@ private[enumeratum] trait EnumCompat[A <: EnumEntry] { _enum: Enum[A] =>
     * aren't using this method... why are you even bothering with this lib?
     */
   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
@@ -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
 
 }

enumeratum-core/src/main/scala-3/enumeratum/values/ValueEnumCompat.scala

@@ -3,13 +3,16 @@ package enumeratum.values
 import scala.language.experimental.macros
 
 import _root_.enumeratum.{Enum, EnumMacros, ValueEnumMacros}
+import _root_.enumeratum.compat
 
 private[enumeratum] trait IntEnumCompanion {
 
   /** Materializes an `IntEnum` for a given `IntEnumEntry`. */
   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
 }

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,39 +62,39 @@ 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.
     */
   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.
     */
   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.
     */
   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.
     */
   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,23 +103,23 @@ 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.
     */
   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.
     */
   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.

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.

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]

macros/compat/src/main/scala-3

@@ -0,0 +1 @@
+scala-2.13

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 }*)
       }
     }
   }