remove <none> and the *Any* and *All* variants

Author: rluvaton

enable-if-version-annotation-macros/src/main/scala/org/apache/comet/enableIfVer.scala

@@ -26,65 +26,34 @@ import scala.reflect.macros.whitebox
 import org.semver4j.{RangesListFactory, Semver}
 
 /**
- * Shared machinery behind the conditional compilation based on version annotation families:
- *   - single dimension: [[enableIfVer]] (exactly one dimension, e.g. `@enableIfVer(spark =
- *     ">=3.5.0")`)
- *   - multi-dimension combinators: [[enableIfAllVer]] (every listed dimension must match) and
- *     [[enableIfAnyVer]] (at least one must match).
+ * Shared machinery behind the version annotations [[enableIfVer]], [[implementIfVer]] and
+ * [[enableOverrideIfVer]].
  *
- * Every annotation performs the same compile-time tree rewrite (drop / empty-body-except-marked /
- * strip-`override`). the ONLY thing that differs is a single `Boolean` - does the build's
- * targeted version(s) satisfy the given range(s)? So the match decision is computed per
- * annotation and handed to the shared expansions here.
+ * Every annotation performs the same compile-time tree rewrite (drop / empty-body / strip
+ * `override`). the ONLY thing that differs is a single `Boolean` - does the build's targeted
+ * version satisfy the given range? So the match decision is computed per annotation and handed to
+ * the shared expansions here.
  *
  * The build feeds the targeted version of each dimension to the macro via
  * `-Xmacro-settings:enableIfVer.<dimension>=<version>`, read at expansion time from `c.settings`
  * (see [[versionOf]]). Adding a dimension is therefore just one more build entry - no generated
- * sources. Comet currently configures a single dimension, `spark`. A dimension may be configured
- * as `<none>` ([[NONE_VERSION]]) meaning "known to the build but not enabled".
+ * sources. Comet currently configures a single dimension, `spark`.
  *
  * Ranges are matched by <a href="https://github.com/semver4j/semver4j">semver4j</a>: full
  * `major.minor.patch` versions with `>` `>=` `<` `<=` `=` `!=`, space = AND, `||` = OR, `A - B`
- * hyphen ranges and more. The literal range `"<none>"` is special - it matches iff the dimension
- * is configured but disabled (see [[satisfies]]).
+ * hyphen ranges and more.
  */
 object EnableIfVerSupport {
 
-  /**
-   * Sentinel for a dimension that is known to the build but not enabled. As a configured value it
-   * resolves to `None`. as a range (`@enableIfVer(spark = "<none>")`) it matches only such
-   * disabled dimensions.
-   */
-  val NONE_VERSION = "<none>"
-
-  /**
-   * Does the configured `version` satisfy `range`?
-   *   - `range == "<none>"` matches iff the dimension is disabled (`version` is `None`).
-   *   - any other range never matches a disabled dimension.
-   *   - otherwise semver logic.
-   */
-  def satisfies(c: whitebox.Context, range: String, version: Option[String]): Boolean =
-    (range.trim, version) match {
-      case (NONE_VERSION, None) => true
-      case (NONE_VERSION, Some(_)) => false
-      case (_, None) => false
-      case (range, _) if range.contains(NONE_VERSION) =>
-        c.abort(
-          c.enclosingPosition,
-          s"$NONE_VERSION is not supported with ranges, use semverAny* and " +
-            s"""pass $NONE_VERSION explicitly (e.g. """ +
-            s"""@enableIfAnyVer(spark = "<3.5.0", spark = "$NONE_VERSION"))""")
-      case (range, Some(version)) =>
-        val rangeList = RangesListFactory.create(range)
-
-        new Semver(version).satisfies(rangeList)
-    }
+  /** Does the configured `version` satisfy the semver `range`? */
+  def satisfies(range: String, version: String): Boolean =
+    new Semver(version).satisfies(RangesListFactory.create(range.trim))
 
   /** Prefix of the `-Xmacro-settings` keys this macro understands. */
   private val SettingPrefix = "enableIfVer."
 
   /** Parse `enableIfVer.<dimension>=<version>` entries out of `-Xmacro-settings`. */
-  private def configuredVersions(c: whitebox.Context): Map[String, Option[String]] =
+  private def configuredVersions(c: whitebox.Context): Map[String, String] =
     c.settings.collect {
       case s if s.startsWith(SettingPrefix) =>
         s.stripPrefix(SettingPrefix).split("=", 2) match {
@@ -97,20 +66,18 @@ object EnableIfVerSupport {
         }
     }.toMap
 
-  private def parseVersionFromSetting(name: String, version: String): Option[String] = {
-    if (version == NONE_VERSION) return None
-
+  private def parseVersionFromSetting(name: String, version: String): String = {
     try {
       // Not using Semver.parse as it will return null instead of giving us meaningful
       // exceptions on invalid input
       new Semver(version)
 
-      Some(version)
+      version
     } catch {
       case e: Throwable =>
         sys.error(
-          s"malformed version passed in macro setting for '$name', expected either a valid " +
-            s"SemVer or '$NONE_VERSION' got '$version' (error: ${e.toString})")
+          s"malformed version passed in macro setting for '$name', expected a valid " +
+            s"SemVer got '$version' (error: ${e.toString})")
     }
   }
 
@@ -119,14 +86,13 @@ object EnableIfVerSupport {
    * extensibility seam: to add a dimension, pass
    * `-Xmacro-settings:${SettingPrefix}<dimension>=<version>` from the build.
    *
-   * Returns `None` when the dimension is configured as `<none>` (known but disabled), and aborts
-   * compilation when the dimension was not configured at all.
+   * Aborts compilation when the dimension was not configured at all.
    */
-  private def versionOf(c: whitebox.Context, dimension: String): Option[String] = {
+  private def versionOf(c: whitebox.Context, dimension: String): String = {
     val versions = configuredVersions(c)
     versions.getOrElse(
       dimension,
-      // we do not treat missing dimension as None since we want to avoid having silent failures
+      // we do not treat a missing dimension as a match since we want to avoid silent failures
       c.abort(
         c.enclosingPosition,
         s"@enableIfVer: no version configured for dimension '$dimension'" +
@@ -138,10 +104,10 @@ object EnableIfVerSupport {
   object Macros {
 
     /**
-     * Extract the named `dimension = range` arguments of a combined annotation. A named argument
-     * is `name = value`, whose immediate children are `[Ident(name), value]` - matched
-     * structurally so this works on both Scala 2.12 (`AssignOrNamedArg`) and 2.13 (`NamedArg`). A
-     * positional arg (e.g. a bare literal) has no such children and is rejected.
+     * Extract the named `dimension = range` argument of a version annotation. A named argument is
+     * `name = value`, whose immediate children are `[Ident(name), value]` - matched structurally
+     * so this works on both Scala 2.12 (`AssignOrNamedArg`) and 2.13 (`NamedArg`). A positional
+     * arg (e.g. a bare literal) has no such children and is rejected.
      */
     private def namedRanges(c: whitebox.Context): List[(String, String)] = {
       import c.universe._
@@ -162,33 +128,18 @@ object EnableIfVerSupport {
       }
     }
 
-    /** Single dimension: require exactly one named arg and match it. */
+    /** Require exactly one named dimension arg and return whether the build matches its range. */
     def singleKeep(c: whitebox.Context, specificMacroPrefix: String): Boolean = {
       val ranges = namedRanges(c)
       if (ranges.size != 1) {
         val ifCase = if (specificMacroPrefix.isEmpty) "enableIf" else "If"
         c.abort(
           c.enclosingPosition,
           s"@${specificMacroPrefix}${ifCase}Ver accepts exactly one dimension " +
-            s"(got ${ranges.size}). use @${specificMacroPrefix}${ifCase}AllVer / " +
-            s"@${specificMacroPrefix}${ifCase}AnyVer for multiple dimensions.")
+            s"(got ${ranges.size}).")
       }
       val (dim, range) = ranges.head
-      satisfies(c, range, versionOf(c, dim))
-    }
-
-    /** Combined AND: keep iff every provided dimension matches (requires at least one). */
-    def allKeep(c: whitebox.Context): Boolean = {
-      val ranges = namedRanges(c)
-      ranges.nonEmpty && ranges.forall { case (dim, range) =>
-        satisfies(c, range, versionOf(c, dim))
-      }
-    }
-
-    /** Combined OR: keep iff at least one provided dimension matches. */
-    def anyKeep(c: whitebox.Context): Boolean = {
-      val ranges = namedRanges(c)
-      ranges.exists { case (dim, range) => satisfies(c, range, versionOf(c, dim)) }
+      satisfies(range, versionOf(c, dim))
     }
 
     // ----- generic tree-rewrite expansions (take a precomputed keep) ---------------------------
@@ -245,10 +196,6 @@ object EnableIfVerSupport {
   }
 }
 
-// =================================================================================================
-// Single dimension
-// =================================================================================================
-
 object enableIfVer {
   object Macros {
     def verEnable(c: whitebox.Context)(annottees: c.Expr[Any]*): c.Expr[Any] =
@@ -264,9 +211,8 @@ object enableIfVer {
 
 /**
  * Keep the annotated member only when the build matches a single dimension's range. otherwise
- * drop it entirely. Exactly one dimension must be given as a named semver range (use
- * [[enableIfAllVer]] / [[enableIfAnyVer]] for multiple). Known dimensions are whatever the build
- * configures via `-Xmacro-settings` (currently `spark`).
+ * drop it entirely. Exactly one dimension must be given as a named semver range. Known dimensions
+ * are whatever the build configures via `-Xmacro-settings` (currently `spark`).
  *
  * Example:
  * {{{
@@ -351,96 +297,3 @@ final class implementIfVer(spark: String = "") extends StaticAnnotation {
 final class enableOverrideIfVer(spark: String = "") extends StaticAnnotation {
   def macroTransform(annottees: Any*): Any = macro enableIfVer.Macros.verEnableOverride
 }
-
-// =================================================================================================
-// Combined: ALL dimensions must match (AND)
-// =================================================================================================
-
-object enableIfAllVer {
-  object Macros {
-    def verEnable(c: whitebox.Context)(annottees: c.Expr[Any]*): c.Expr[Any] =
-      EnableIfVerSupport.Macros.enable(c)(annottees)(EnableIfVerSupport.Macros.allKeep(c))
-    def verImplementIf(c: whitebox.Context)(annottees: c.Expr[Any]*): c.Expr[Any] =
-      EnableIfVerSupport.Macros.implementIf(c)(annottees)(EnableIfVerSupport.Macros.allKeep(c))
-    def verEnableOverride(c: whitebox.Context)(annottees: c.Expr[Any]*): c.Expr[Any] =
-      EnableIfVerSupport.Macros.enableOverride(c)(annottees)(EnableIfVerSupport.Macros.allKeep(c))
-  }
-}
-
-/**
- * Keep the annotated member only when the build matches EVERY listed dimension (logical AND).
- * Dimensions are named semver ranges. omitted dimensions are not constrained, and within a single
- * dimension you can still use `||` for OR. Arguments must be named. Comet currently configures
- * only the `spark` dimension; this combinator exists for builds that add more.
- *
- * Example:
- * {{{
- * @enableIfAllVer(spark = ">=3.5.0")   // keep on Spark 3.5+
- * def needsSpark35(): Unit = ...
- * }}}
- */
-@nowarn("cat=unused") // params are used by the macro
-@compileTimeOnly("enable macro paradise to expand macro annotations")
-final class enableIfAllVer(spark: String = "") extends StaticAnnotation {
-  def macroTransform(annottees: Any*): Any = macro enableIfAllVer.Macros.verEnable
-}
-
-/** Like [[implementIfVer]] but with all condition like [[enableIfAllVer]]. */
-@nowarn("cat=unused") // params are used by the macro
-@compileTimeOnly("enable macro paradise to expand macro annotations")
-final class implementIfAllVer(spark: String = "") extends StaticAnnotation {
-  def macroTransform(annottees: Any*): Any = macro enableIfAllVer.Macros.verImplementIf
-}
-
-/** Like [[enableIfAllVer]], but strips the `override` modifier on a non-matching combination. */
-@nowarn("cat=unused") // params are used by the macro
-@compileTimeOnly("enable macro paradise to expand macro annotations")
-final class enableOverrideIfAllVer(spark: String = "") extends StaticAnnotation {
-  def macroTransform(annottees: Any*): Any = macro enableIfAllVer.Macros.verEnableOverride
-}
-
-// =================================================================================================
-// Combined: ANY dimension matches (OR)
-// =================================================================================================
-
-object enableIfAnyVer {
-  object Macros {
-    def verEnable(c: whitebox.Context)(annottees: c.Expr[Any]*): c.Expr[Any] =
-      EnableIfVerSupport.Macros.enable(c)(annottees)(EnableIfVerSupport.Macros.anyKeep(c))
-    def implementIf(c: whitebox.Context)(annottees: c.Expr[Any]*): c.Expr[Any] =
-      EnableIfVerSupport.Macros.implementIf(c)(annottees)(EnableIfVerSupport.Macros.anyKeep(c))
-    def verEnableOverride(c: whitebox.Context)(annottees: c.Expr[Any]*): c.Expr[Any] =
-      EnableIfVerSupport.Macros.enableOverride(c)(annottees)(EnableIfVerSupport.Macros.anyKeep(c))
-  }
-}
-
-/**
- * Keep the annotated member when the build matches AT LEAST ONE listed dimension (logical OR).
- * Arguments must be named. Comet currently configures only the `spark` dimension; this combinator
- * exists for builds that add more.
- *
- * Example:
- * {{{
- * @enableIfAnyVer(spark = ">=4.0.0")   // keep on Spark 4+
- * def newApi(): Unit = ...
- * }}}
- */
-@nowarn("cat=unused") // params are used by the macro
-@compileTimeOnly("enable macro paradise to expand macro annotations")
-final class enableIfAnyVer(spark: String = "") extends StaticAnnotation {
-  def macroTransform(annottees: Any*): Any = macro enableIfAnyVer.Macros.verEnable
-}
-
-/** Like [[implementIfVer]] but with any condition like [[enableIfAnyVer]]. */
-@nowarn("cat=unused") // params are used by the macro
-@compileTimeOnly("enable macro paradise to expand macro annotations")
-final class implementIfAnyVer(spark: String = "") extends StaticAnnotation {
-  def macroTransform(annottees: Any*): Any = macro enableIfAnyVer.Macros.implementIf
-}
-
-/** Like [[enableIfAnyVer]], but strips the `override` modifier on a non-matching combination. */
-@nowarn("cat=unused") // params are used by the macro
-@compileTimeOnly("enable macro paradise to expand macro annotations")
-final class enableOverrideIfAnyVer(spark: String = "") extends StaticAnnotation {
-  def macroTransform(annottees: Any*): Any = macro enableIfAnyVer.Macros.verEnableOverride
-}