Based on #37418 (comment), we want to try to enable something like:

depends_on("geant4-data@{my.version}", when="@10:")

You can think of {my.version} as an expression template that expands out the depends_on() to all possible values of some spec attribute. my here is like a proxy for this package's spec, with a limited set of allowed attributes: basically the ones we know how to expand all values of. I think this makes it intuitive to filter by the when= clause (to be consistent with other directives). It also enables you to, e.g., only do version matching only on certain versions (10 or higher here).

Expressions could be more complex:

depends_on("geant4-data@{my.version.up_to(2)}", when="@10:")

And you could use this on variants as well:

depends_on("hdf5 mpi={my.variants['mpi'].value}")

The final advantage here is that we can push logic down to the solver instead of doing a for loop at the package level. Not all versions, variant values, etc. are known at package definition time. They can come in from the CLI, config, externals, and other places, so only the solver really knows all the values at setup time. Similarly, for variants with infinite legal values (e.g,. ints, strings) we only know the values at solver setup time, and we can't explode the solve to include all possible strings/ints/whatever.

@greenc-FNAL: this is a proof of concept to give you an idea of what parts of the code you'd need to touch to get something like this working. I have some ideas for how you could propagate an actual version/variant expressions from the depends_on() directive, through the spec, down to the solver. Ultimately I think those need to be evaluated in define_version_constraints (or a similar location for variants). That is, they should be run at the end of setup after all values from all specs in the solve are known.

The amount of concretizer logic required here is surprisingly small. It's basically one new type of fact in the encoding:

attr("sync", "dep_name", "node_version_satisfies", attr("version", "pkg_name"))

That says that you should take Version in any derived attr("version", Package, Version) and create a rule like attr("node_version_satisfies", Dependency, Version) to force the dependency to use the same version. The implementation of that is just:

attr(DepAttrName, DepNode, Value)
   :- depends_on(node(X, Package), DepNode),
      attr(PackageAttrName, node(X, Package), Value),
      attr("sync", DepNode, DepAttrName, attr(PackageAttrName, Package)).