Update (redo) after sync.

Author: helly25

README.md

@@ -123,6 +123,20 @@ See [bazel
 tutorial](https://docs.bazel.build/versions/main/tutorial/cc-toolchain-config.html)
 for how CC toolchains work in general.
 
+### Requirements
+
+Version attributes can be requirements of the form `latest:<condition>` or `first:<condition>`.
+
+In case of `latest`, the latest distribution matching the `condition` will be selected.
+
+In case of `first`, the first distribution matching the `condition` will be selected.
+
+The condition consists of a commpara separated list of semver version comparisons supporting `<`, `<=`, `>`, `>=`, `==`, `!=`. Examples:
+
+- `latest:<=20.1.0`
+- `latest:<=20.1.0,>17.0.4,!=19.1.7`
+- `first:>=15.0.6,<16`
+
 ### Selecting Toolchains
 
 If toolchains are registered (see Quickstart section above), you do not need to

toolchain/internal/BUILD.bazel

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 load("@bazel_skylib//rules:diff_test.bzl", "diff_test")
-load("llvm_distributions.bzl", "distributions_test_writer", "requirements_test_writer")
+load("llvm_distributions.bzl", "requirements_test_writer", "write_distributions")
 
 exports_files(["template.modulemap"])
 
@@ -25,14 +25,6 @@ write_distributions(
     visibility = ["//visibility:private"],
 )
 
-requirements_test_writer(
-    name = "llvm_requirements_test_output",
-    testonly = True,
-    output = "llvm_distributions.out.txt",
-    select = "llvm_distributions.sel.txt",
-    visibility = ["//visibility:private"],
-)
-
 diff_test(
     name = "llvm_distributions_output_test",
     file1 = "llvm_distributions.golden.out.txt",
@@ -58,3 +50,16 @@ sh_test(
         "//conditions:default": ["@platforms//:incompatible"],
     }),
 )
+
+requirements_test_writer(
+    name = "llvm_requirements_test_output",
+    testonly = True,
+    result = "llvm_requirements_test.output.txt",
+    visibility = ["//visibility:private"],
+)
+
+diff_test(
+    name = "llvm_requirements_test",
+    file1 = "llvm_requirements_test.golden.txt",
+    file2 = "llvm_requirements_test.output.txt",
+)

toolchain/internal/llvm_distributions.bzl

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 load("@bazel_tools//tools/build_defs/repo:utils.bzl", "read_netrc", "use_netrc")
+load("@helly25_bzl//bzl/versions:versions.bzl", "versions")
 load(
     "//toolchain/internal:common.bzl",
     "attr_dict",
@@ -978,14 +979,59 @@ def _find_llvm_basename_or_error(llvm_version, all_llvm_distributions, host_info
 
     return basenames[0], None
 
+def _parse_version_requirements(version_requirements):
+    if version_requirements in ["latest", "first"]:
+        return []
+    for prefix in ["latest:", "first:"]:
+        if version_requirements.startswith(prefix):
+            return versions.parse_requirements(version_requirements.removeprefix(prefix))
+    fail("ERROR: Invalid version requirements: '{version_requirements}'.".format(
+        version_requirements = version_requirements,
+    ))
+
+def _get_llvm_versions(*, version_requirements, all_llvm_distributions):
+    llvm_versions = {}
+    for distribution in all_llvm_distributions.keys():
+        version = distribution.split("-")[1]
+        llvm_versions[version] = None
+    if version_requirements.startswith("latest:"):
+        return reversed(llvm_versions.keys())
+    else:
+        return llvm_versions.keys()
+
+def _required_llvm_release_name(*, version_requirements, all_llvm_distributions, host_info):
+    llvm_versions = _get_llvm_versions(version_requirements = version_requirements, all_llvm_distributions = all_llvm_distributions)
+    requires = _parse_version_requirements(version_requirements)
+    for llvm_version in llvm_versions:
+        if not versions.check_all_requirements(llvm_version, requires):
+            continue
+        basenames = _find_llvm_basename_list(llvm_version, all_llvm_distributions, host_info)
+        if len(basenames) == 1:
+            return llvm_version, basenames[0], None
+    return None, None, "ERROR: No matching distribution found."
+
+def _contains_any(str, chars):
+    for c in chars:
+        if c in str:
+            return True
+    return False
+
 def _distribution_urls(rctx):
     """Return LLVM `urls`, `shha256` and `strip_prefix` for the given context."""
     llvm_version = _get_llvm_version(rctx)
     all_llvm_distributions = _get_all_llvm_distributions(rctx)
     _, sha256, strip_prefix, _ = _key_attrs(rctx)
 
     if rctx.attr.distribution == "auto":
-        basename, error = _find_llvm_basename_or_error(llvm_version, all_llvm_distributions, host_info(rctx))
+        rctx_host_info = host_info(rctx)
+        if _contains_any(llvm_version, ",:<>!="):
+            llvm_version, basename, error = _required_llvm_release_name(
+                version_requirements = _parse_version_requirements(llvm_version),
+                all_llvm_distributions = all_llvm_distributions,
+                host_info = rctx_host_info,
+            )
+        else:
+            basename, error = _find_llvm_basename_or_error(llvm_version, all_llvm_distributions, rctx_host_info)
         if error:
             fail(error)
         if sha256 and sha256 != all_llvm_distributions[basename]:
@@ -1032,7 +1078,7 @@ def _parse_version(v):
 def _version_string(version):
     return ".".join([str(v) for v in version])
 
-def _distributions_test_writer_impl(ctx):
+def _write_distributions_impl(ctx):
     """Analyze the configured versions and write to a file for test consumption.
 
     The test generated file '<rule_name>.out' contains the following lines:
@@ -1221,3 +1267,80 @@ write_distributions = rule(
         "select": attr.output(mandatory = True),
     },
 )
+
+def _requirements_test_writer_impl(ctx):
+    """Analyze the configured versions and write to a file for test consumption.
+    The test generated file '<rule_name>.out' contains the following lines:
+    [<arch>,<os>,<requirement>]: <llvm_distribution_basename>
+    """
+    all_llvm_distributions = _llvm_distributions
+    requirement_list = [
+        "latest:<=20.1.0",
+        "latest:<=20.1.0,>17.0.4,!=19.1.7",
+        "latest:<20.1.0,>17.0.4,!=19.1.7",
+        "latest:<20.1.0,>17.0.4",
+        "latest:>=15.0.6,<16",
+        "first:>=15.0.6,<16",
+    ]
+    arch_list = [
+        "aarch64",
+        "armv7a",
+        "x86_64",
+    ]
+    os_list = [
+        "darwin",
+        "linux",
+        "windows",
+    ]
+    ANY_VERSION = "0"  # Version does not matter, but must be a valid integer
+    dist_dict_list = {
+        "linux": [
+            # keep sorted
+            struct(name = "ubuntu", version = ANY_VERSION),
+            struct(name = "raspbian", version = ANY_VERSION),
+            struct(name = "rhel", version = ANY_VERSION),
+        ],
+    }
+    result = []
+    for arch in arch_list:
+        for os in os_list:
+            dist_list = dist_dict_list.get(os, [struct(name = os, version = "")])
+            for dist in dist_list:
+                for requirement in requirement_list:
+                    host_info = struct(
+                        arch = arch,
+                        os = os,
+                        dist = dist,
+                    )
+                    llvm_version, basename, error = _required_llvm_release_name(
+                        version_requirements = requirement,
+                        all_llvm_distributions = all_llvm_distributions,
+                        host_info = host_info,
+                    )
+                    if llvm_version and basename:
+                        result.append("[{arch},{os}{dist_name}{dist_version},'{requirement}']: {llvm_version} = {basename}".format(
+                            arch = arch,
+                            os = os,
+                            dist_name = "," + dist.name if os == "linux" else "",
+                            dist_version = "," + dist.version if os == "linux" else "",
+                            requirement = requirement,
+                            llvm_version = llvm_version,
+                            basename = basename,
+                        ))
+                    else:
+                        result.append("[{arch},{os},\"{requirement}\"]: {error}".format(
+                            arch = arch,
+                            os = os,
+                            requirement = requirement,
+                            llvm_version = llvm_version,
+                            basename = basename,
+                            error = error or "ERROR: N/A",
+                        ))
+    ctx.actions.write(ctx.outputs.result, "\n".join(result) + "\n")
+
+requirements_test_writer = rule(
+    implementation = _requirements_test_writer_impl,
+    attrs = {
+        "result": attr.output(mandatory = True),
+    },
+)