A small macro-annotation library that lets a single source file carry code for multiple
Spark versions. You annotate a member (def / class / object) with a version range, and at *
compile time* the macro keeps it, drops it, or tweaks it based on the version the build is
targeting.

The problem it solves

Version-specific code used to live in parallel source folders (src/main/spark-3.4/…, spark-3.5/…, spark-4.0/…) - so a whole file got copied per version just because one method differed, or because a type like WindowGroupLimitExec only exists in Spark 3.5+. @enableIfVer lets those differences live inline, in one file: no duplication, and the version logic sits right next to the code it gates.

How you use it

The targeted versions are supplied by the build per "dimension" (spark). You write a semver range

import org.apache.comet.enableIfVer

// keep this method only on Spark 3.5+
@enableIfVer(spark = ">=3.5.0")
def onlyOn35Plus(): Unit =
...

// two same-named methods, one per version range - exactly one survives per build
@enableIfVer(spark = "<3.5.0") def isWGL(p: SparkPlan): Boolean = false
@enableIfVer(spark = ">=3.5.0") def isWGL(p: SparkPlan): Boolean = p.isInstanceOf[WindowGroupLimitExec]

The four behaviors

Ranges

Matched by semver4j: full major.minor.patch versions with > >= < <= = !=, space = AND, || = OR, A - B hyphen ranges, x-ranges / partials and more (FYI, it supports package.json format)

What it gives us

• No more per-version source-folder duplication for small differences.
• One file, version logic inline - easier to read and maintain.
• Compile-time safety: non-matching code (and its references to types that don't exist in that
  version) is removed before type-checking, so each build only ever sees valid code.
• Extensible & general: any number of dimensions, combined with AND/OR, plus an explicit
  "not enabled" state - all from one unified @enableIfVer namespace.

Caveats

• @enableIfVer annotates definitions only - not statements (e.g. a bare test(...) call). To
  gate a statement, wrap it in a def and annotate that.
• It cannot be applied to a top-level class that has a companion object (a macro-paradise
  limitation). For whole top-level classes that are entirely version-specific, the version-specific
  source folder is still the right tool.

Apache Auron (Blaze)

most of the annotation code taken from Blaze/auron in sparkver.scala but updated the syntax of matching versions and replace @sparkverEnableMembers with @implementIfVer that remove the inheritance as well - useful for abstract class

Blaze uses / to split between supported versions so for example like this:

@sparkver("3.0 / 3.1 / 3.2 / 3.3 / 3.4 / 3.5 / 4.0 / 4.1")
override def simpleString(maxFields: Int): String =
  s"$nodeName (${basedHiveScan.simpleString(maxFields)})"

This however use semver match syntax that is more widely known so the same code for us will be:

@enableIfVer(spark = ">=3.0.0 <4.2.0")
override def simpleString(maxFields: Int): String =
  s"$nodeName (${basedHiveScan.simpleString(maxFields)})"

and if you want to automatically have this function for every spark version above 3.0 and not only until 4.1, you can do:

@enableIfVer(spark = ">=3.0.0")
override def simpleString(maxFields: Int): String =
  s"$nodeName (${basedHiveScan.simpleString(maxFields)})"

the syntax is matching the one used in package.json

also, Auron name is sparkver, I named enableIfVer instead so future shims (like iceberg/delta/etc) can use the same infra