feat: add platform-aware D toolchain selection and pin default versions

Author: dcarp

MODULE.bazel

@@ -19,12 +19,10 @@ bazel_dep(name = "buildifier_prebuilt", version = "8.2.1", dev_dependency = True
 bazel_dep(name = "gazelle", version = "0.42.0", dev_dependency = True, repo_name = "bazel_gazelle")
 bazel_dep(name = "stardoc", version = "0.7.1", dev_dependency = True)
 
-# NOTE:
-# It is recommended to specify the exact d_version (ex. "dmd-2.111.0") for reproducible builds.
-# Setting d_version = "auto" here ensures aarch64 CI works out of the box,
-# but using "auto" may lead to non-reproducible builds and is not recommended.
+# Select first d toolchain available for the current platform.
 d = use_extension("//d:extensions.bzl", "d")
-d.toolchain(d_version = "auto")
+d.toolchain(d_version = "dmd-2.111.0")
+d.toolchain(d_version = "ldc-1.41.0")
 use_repo(d, "d_toolchains")
 
 register_toolchains("@d_toolchains//:all")

d/extensions.bzl

@@ -10,7 +10,7 @@ names (the latest version will be picked for each name) and can register them as
 effectively overriding the default named toolchain due to toolchain resolution precedence.
 """
 
-load(":repositories.bzl", "d_register_toolchains")
+load(":repositories.bzl", "d_register_toolchains", "select_compiler_by_os")
 
 _DEFAULT_NAME = "d"
 
@@ -20,10 +20,9 @@ Base name for generated repositories, allowing more than one d toolchain to be r
 Overriding the default is only permitted in the root module.
 """, default = _DEFAULT_NAME),
     "d_version": attr.string(doc = """\
-Version of the compiler. "auto" will select latest known dmd or ldc compiler available for
-the current platform. "dmd" or "ldc" will select the latest known version of the respective
-compiler. If a specific version is desired, it can be specified as "dmd-2.100.0" or
-"ldc-1.30.0".
+Fully qualified compiler version, for example "dmd-2.111.0" or "ldc-1.41.0".
+The extension selects the first supplied version compatible with the current platform
+and fails if none match.
 """, mandatory = True),
 })
 
@@ -40,18 +39,9 @@ def _toolchain_extension(module_ctx):
                 registrations[toolchain.name] = []
             registrations[toolchain.name].append(toolchain.d_version)
     for name, versions in registrations.items():
-        if len(versions) > 1:
-            # TODO: should be semver-aware, using MVS
-            selected = sorted(versions, reverse = True)[0]
-
-            # buildifier: disable=print
-            print("NOTE: d toolchain {} has multiple versions {}, selected {}".format(name, versions, selected))
-        else:
-            selected = versions[0]
-
         d_register_toolchains(
             name = name,
-            d_version = selected,
+            d_version = select_compiler_by_os(versions, module_ctx.os),
             register = False,
         )
 

d/repositories.bzl

@@ -41,7 +41,7 @@ def rules_d_dependencies():
 ########
 _DOC = "Fetch external tools needed for d toolchain"
 _ATTRS = {
-    "d_version": attr.string(mandatory = True, values = ["auto", "dmd", "ldc"] + SDK_VERSIONS.keys()),
+    "d_version": attr.string(mandatory = True, values = SDK_VERSIONS.keys()),
     "platform": attr.string(mandatory = True, values = PLATFORMS.keys()),
 }
 
@@ -61,20 +61,6 @@ def _d_repo_impl(repository_ctx):
     d_version = repository_ctx.attr.d_version
     platform = repository_ctx.attr.platform
 
-    if d_version == "auto":
-        for compiler in ["dmd", "ldc"]:
-            for version, platforms in SDK_VERSIONS.items():
-                if version.startswith(compiler) and platform in platforms:
-                    d_version = compiler
-                    break
-            if d_version != "auto":
-                break
-
-    if d_version in ["dmd", "ldc"]:
-        sdks = [version for version, platforms in SDK_VERSIONS.items() if version.startswith(d_version) and platform in platforms]
-        sdks = sorted(sdks, key = lambda x: [int(v) if v.isdigit() else v for v in x[4:].split(".")], reverse = True)
-        d_version = sdks[0] if sdks else d_version
-
     if d_version not in SDK_VERSIONS:
         fail("Unknown d_version: %s" % d_version)
     if platform not in SDK_VERSIONS[d_version]:
@@ -107,12 +93,15 @@ def d_register_toolchains(name, register = True, **kwargs):
     Users can avoid this macro and do these steps themselves, if they want more control.
 
     Args:
-        name: base name for all created repos, like "d1_14"
+        name: base name for all created repositories
         register: whether to call through to native.register_toolchains.
             Should be True for WORKSPACE users, but false when used under bzlmod extension
         **kwargs: passed to each d_repositories call
     """
     for platform in PLATFORMS.keys():
+        d_version = kwargs.get("d_version")
+        if not d_version or d_version not in SDK_VERSIONS or platform not in SDK_VERSIONS[d_version]:
+            continue
         d_repositories(name = name + "_" + platform, platform = platform, **kwargs)
         if register:
             native.register_toolchains("@%s_toolchains//:%s_toolchain" % (name, platform))
@@ -121,3 +110,36 @@ def d_register_toolchains(name, register = True, **kwargs):
         name = name + "_toolchains",
         user_repository_name = name,
     )
+
+def _get_platform_id(os):
+    """Get the platform id for the given os repository_os information."""
+    if os.name == "linux":
+        if os.arch in ["amd64", "x86_64"]:
+            return "x86_64-unknown-linux-gnu"
+        elif os.arch in ["aarch64", "arm64"]:
+            return "aarch64-unknown-linux-gnu"
+    elif os.name in ["darwin", "mac os x", "macos", "osx"]:
+        if os.arch in ["amd64", "x86_64"]:
+            return "x86_64-apple-darwin"
+        elif os.arch in ["aarch64", "arm64"]:
+            return "aarch64-apple-darwin"
+    elif "windows" in os.name:
+        if os.arch in ["amd64", "x86_64"]:
+            return "x86_64-pc-windows-msvc"
+    fail("Unsupported OS/arch combination: %s/%s" % (os.name, os.arch))
+
+def select_compiler_by_os(versions, os):
+    """Select the most appropriate compiler version for the given OS.
+
+    Args:
+        versions: list of compiler versions
+        os: repository_os information
+
+    Returns:
+        selected compiler version
+    """
+    platform_id = _get_platform_id(os)
+    for version in versions:
+        if platform_id in SDK_VERSIONS.get(version, {}):
+            return version
+    fail("No suitable d compiler found for OS %s among versions: %s." % (os, ", ".join(versions)))

e2e/smoke/WORKSPACE.bazel

@@ -87,6 +87,11 @@ load("@rules_d//d:repositories.bzl", "d_register_toolchains", "rules_d_dependenc
 rules_d_dependencies()
 
 d_register_toolchains(
-    "d_toolchain",
-    d_version = "auto",
+    "dmd_toolchain",
+    d_version = "dmd-2.111.0",
+)
+
+d_register_toolchains(
+    "ldc_toolchain",
+    d_version = "ldc-1.41.0",
 )