Add go_sdk.from_file to read the SDK version from go.mod. (#4305)

jaqx0r · web-flow · commit 3d7141d9d02e · 2025-04-11T12:36:51.000+02:00
**What type of PR is this?** Feature **What does this PR do? Why is it needed?** Adds a `go_sdk.from_file` rule to the extension that allows modules to say that their SDK version should be read from their `go.mod` file. This allows callers to avoid repeating themselves and stay within the Go tool environment for version specification, allowing better integration with other tools. **Which issues(s) does this PR fix?** Fixes #4292 **Other notes for review** The toolchain version is selected based on the rules in https://go.dev/doc/toolchain This change copies parts of the `go_mod.bzl` parser from the Gazelle repository: https://github.com/bazel-contrib/bazel-gazelle/blob/master/internal/bzlmod/go_mod.bzl A test based on the `go_download_sdk` test sets up a module-under-test with a `go.mod` and checks that the version specified in it is used to run the test in that repo-under-test.
diff --git a/MODULE.bazel b/MODULE.bazel
@@ -16,9 +16,9 @@ bazel_dep(name = "protobuf", version = "3.19.2", repo_name = "com_google_protobu
 bazel_dep(name = "rules_shell", version = "0.3.0")
 
 go_sdk = use_extension("//go:extensions.bzl", "go_sdk")
-go_sdk.download(
+go_sdk.from_file(
     name = "go_default_sdk",
-    version = "1.23.6",
+    go_mod = "//:go.mod",
 )
 use_repo(
     go_sdk,
diff --git a/docs/go/core/bzlmod.md b/docs/go/core/bzlmod.md
@@ -30,7 +30,12 @@ To register a particular version of the Go SDK, use the `go_sdk` module extensio
 ```starlark
 go_sdk = use_extension("@rules_go//go:extensions.bzl", "go_sdk")
 
-# Download an SDK for the host OS & architecture as well as common remote execution platforms.
+# Download an SDK for the host OS & architecture as well as common remote execution
+# platforms, using the version given from the `go.mod` file.
+go_sdk.from_file(go_mod = "//:go.mod")
+
+# Download an SDK for the host OS & architecture as well as common remote execution
+# platforms, with a specific version.
 go_sdk.download(version = "1.23.1")
 
 # Alternatively, download an SDK for a fixed OS/architecture.
diff --git a/go/private/extensions.bzl b/go/private/extensions.bzl
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 load("@io_bazel_rules_go_bazel_features//:features.bzl", "bazel_features")
+load("//go/private:go_mod.bzl", "version_from_go_mod")
 load("//go/private:nogo.bzl", "DEFAULT_NOGO", "NOGO_DEFAULT_EXCLUDES", "NOGO_DEFAULT_INCLUDES", "go_register_nogo")
 load("//go/private:sdk.bzl", "detect_host_platform", "go_download_sdk_rule", "go_host_sdk_rule", "go_multiple_toolchains", "go_wrap_sdk_rule")
 
@@ -35,25 +36,29 @@ host_compatible_toolchain = repository_rule(
     doc = "An external repository to expose the first host compatible toolchain",
 )
 
+_COMMON_TAG_ATTRS = {
+    "name": attr.string(),
+    "goos": attr.string(),
+    "goarch": attr.string(),
+    "sdks": attr.string_list_dict(),
+    "experiments": attr.string_list(
+        doc = "Go experiments to enable via GOEXPERIMENT",
+    ),
+    "urls": attr.string_list(default = ["https://dl.google.com/go/{}"]),
+    "patches": attr.label_list(
+        doc = "A list of patches to apply to the SDK after downloading it",
+    ),
+    "patch_strip": attr.int(
+        default = 0,
+        doc = "The number of leading path segments to be stripped from the file name in the patches.",
+    ),
+    "strip_prefix": attr.string(default = "go"),
+}
+
 _download_tag = tag_class(
-    attrs = {
-        "name": attr.string(),
-        "goos": attr.string(),
-        "goarch": attr.string(),
-        "sdks": attr.string_list_dict(),
-        "experiments": attr.string_list(
-            doc = "Go experiments to enable via GOEXPERIMENT",
-        ),
-        "urls": attr.string_list(default = ["https://dl.google.com/go/{}"]),
+    doc = """Download a specific Go SDK at the optional GOOS, GOARCH, and version, from a customisable URL.  Optionally apply local customisations to the SDK by applying patches and setting experiments.""",
+    attrs = _COMMON_TAG_ATTRS | {
         "version": attr.string(),
-        "patches": attr.label_list(
-            doc = "A list of patches to apply to the SDK after downloading it",
-        ),
-        "patch_strip": attr.int(
-            default = 0,
-            doc = "The number of leading path segments to be stripped from the file name in the patches.",
-        ),
-        "strip_prefix": attr.string(default = "go"),
     },
 )
 
@@ -112,6 +117,15 @@ _wrap_tag = tag_class(
     },
 )
 
+_from_file_tag = tag_class(
+    doc = """Use a specific Go SDK version described by a `go.mod` file.  Optionally supply GOOS, GOARCH, and download from a customisable URL, and apply local patches or set experiments.""",
+    attrs = _COMMON_TAG_ATTRS | {
+        "go_mod": attr.label(
+            doc = "The go.mod file to read the SDK version from.",
+        ),
+    },
+)
+
 # A list of (goos, goarch) pairs that are commonly used for remote executors in cross-platform
 # builds (where host != exec platform). By default, we register toolchains for all of these
 # platforms in addition to the host platform.
@@ -201,7 +215,22 @@ def _go_sdk_impl(ctx):
                 sdk_version = wrap_tag.version,
             ))
 
-        for index, download_tag in enumerate(module.tags.download):
+        additional_download_tags = []
+
+        # If the module suggests to read the toolchain version from a `go.mod` file, use that.
+        for index, from_file_tag in enumerate(module.tags.from_file):
+            version = version_from_go_mod(ctx, from_file_tag.go_mod)
+
+            # Synthesize a `download` tag so we can reuse the selection logic below.
+            download_tag = {
+                key: getattr(from_file_tag, key)
+                for key in dir(from_file_tag)
+                if key not in ["go_mod"]
+            }
+            download_tag["version"] = version
+            additional_download_tags += [struct(**download_tag)]
+
+        for index, download_tag in enumerate(module.tags.download + additional_download_tags):
             # SDKs without an explicit version are fetched even when not selected by toolchain
             # resolution. This is acceptable if brought in by the root module, but transitive
             # dependencies should not slow down the build in this way.
@@ -223,7 +252,7 @@ def _go_sdk_impl(ctx):
                 index = index,
             )
 
-            # Keep in sync with the other call to go_download_sdk_rule below.
+            # Keep in sync with the other calls to `go_download_sdk_rule` above and below.
             go_download_sdk_rule(
                 name = name,
                 goos = download_tag.goos,
@@ -267,6 +296,8 @@ def _go_sdk_impl(ctx):
                         index = index,
                         suffix = "_{}_{}".format(goos, goarch),
                     )
+
+                    # Keep in sync with the other calls to `go_download_sdk_rule` above.
                     go_download_sdk_rule(
                         name = default_name,
                         goos = goos,
@@ -383,6 +414,7 @@ go_sdk = module_extension(
         "host": _host_tag,
         "nogo": _nogo_tag,
         "wrap": _wrap_tag,
+        "from_file": _from_file_tag,
     },
     **go_sdk_extra_kwargs
 )
diff --git a/go/private/go_mod.bzl b/go/private/go_mod.bzl
@@ -0,0 +1,146 @@
+# Copyright 2025 The Bazel Authors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+def version_from_go_mod(module_ctx, go_mod_label):
+    """Returns a version string from a go.mod file.
+
+    Args:
+       module_ctx: a https://bazel.build/rules/lib/module_ctx object passed
+            from the MODULE.bazel call.
+       go_mod_label: a Label for a `go.mod` file.
+
+    Returns:
+      a string containing the version of the Go SDK defined in go.mod
+    """
+    _check_go_mod_name(go_mod_label.name)
+    go_mod_path = module_ctx.path(go_mod_label)
+    go_mod_content = module_ctx.read(go_mod_path)
+
+    state = {
+        "toolchain": None,
+        "go": None,
+    }
+
+    current_directive = None
+    for line_no, line in enumerate(go_mod_content.splitlines(), 1):
+        tokens, _ = _tokenize_line(line, go_mod_path, line_no)
+        if not tokens:
+            continue
+
+        if not current_directive:
+            if tokens[0] == "go":
+                _validate_go_version(go_mod_path, state, tokens, line_no)
+                state["go"] = tokens[1]
+
+            if tokens[0] == "toolchain":
+                _validate_toolchain_version(go_mod_path, state, tokens, line_no)
+                state["toolchain"] = tokens[1][len("go"):].strip()
+
+            if tokens[1] == "(":
+                current_directive = tokens[0]
+                if len(tokens) > 2:
+                    fail("{}:{}: unexpected token '{}' after '('".format(go_mod_path, line_no, tokens[2]))
+                continue
+        elif tokens[0] == ")":
+            current_directive = None
+            if len(tokens) > 1:
+                fail("{}:{}: unexpected token '{}' after ')'".format(go_mod_path, line_no, tokens[1]))
+            continue
+
+    version = state["toolchain"]
+    if not version:
+        # https://go.dev/doc/toolchain: "a go.mod that says go 1.21.0 with no toolchain line is interpreted as if it had a toolchain go1.21.0 line."
+        version = state["go"]
+    if not version:
+        # "As of the Go 1.17 release, if the go directive is missing, go 1.16 is assumed."
+        version = "1.16"
+
+    return version
+
+def _tokenize_line(line, path, line_no):
+    tokens = []
+    r = line
+    for _ in range(len(line)):
+        r = r.strip()
+        if not r:
+            break
+
+        if r[0] == "`":
+            end = r.find("`", 1)
+            if end == -1:
+                fail("{}:{}: unterminated raw string".format(path, line_no))
+
+            tokens.append(r[1:end])
+            r = r[end + 1:]
+
+        elif r[0] == "\"":
+            value = ""
+            escaped = False
+            found_end = False
+            pos = 0
+            for pos in range(1, len(r)):
+                c = r[pos]
+
+                if escaped:
+                    value += c
+                    escaped = False
+                    continue
+
+                if c == "\\":
+                    escaped = True
+                    continue
+
+                if c == "\"":
+                    found_end = True
+                    break
+
+                value += c
+
+            if not found_end:
+                fail("{}:{}: unterminated interpreted string".format(path, line_no))
+
+            tokens.append(value)
+            r = r[pos + 1:]
+
+        elif r.startswith("//"):
+            # A comment always ends the current line
+            return tokens, r[len("//"):].strip()
+
+        else:
+            token, _, r = r.partition(" ")
+            tokens.append(token)
+
+    return tokens, None
+
+def _check_go_mod_name(name):
+    if name != "go.mod":
+        fail("go_sdk.from_file requires a 'go.mod' file, not '{}'".format(name))
+
+def _validate_go_version(path, state, tokens, line_no):
+    if len(tokens) == 1:
+        fail("{}:{}: expected another token after 'go'".format(path, line_no))
+    if state["go"] != None:
+        fail("{}:{}: unexpected second 'go' directive".format(path, line_no))
+    if len(tokens) > 2:
+        fail("{}:{}: unexpected token '{}' after '{}'".format(path, line_no, tokens[2], tokens[1]))
+
+def _validate_toolchain_version(path, state, tokens, line_no):
+    if len(tokens) == 1:
+        fail("{}:{}: expected another token after 'toolchain'".format(path, line_no))
+    if state["toolchain"] != None:
+        fail("{}:{}: unexpected second 'toolchain' directive".format(path, line_no))
+    if len(tokens) > 2:
+        fail("{}:{}: unexpected token '{}' after '{}'".format(path, line_no, tokens[2], tokens[1]))
+    if not tokens[1].startswith("go"):
+        fail("{}:{}: expected toolchain version to start with 'go', not '{}'".format(path, line_no, tokens[1]))
diff --git a/tests/core/from_go_mod_file/BUILD.bazel b/tests/core/from_go_mod_file/BUILD.bazel
@@ -0,0 +1,6 @@
+load("@io_bazel_rules_go//go/tools/bazel_testing:def.bzl", "go_bazel_test")
+
+go_bazel_test(
+    name = "from_go_mod_file_test",
+    srcs = ["from_go_mod_file_test.go"],
+)
diff --git a/tests/core/from_go_mod_file/README.rst b/tests/core/from_go_mod_file/README.rst
@@ -0,0 +1,7 @@
+from_go_mod_file
+================
+
+from_go_mod_file_test
+---------------------
+Verifies that ``go_sdk.from_file`` can be used to fetch the Go SDK version
+that is described by the toolchain in ``go.mod``.
diff --git a/tests/core/from_go_mod_file/from_go_mod_file_test.go b/tests/core/from_go_mod_file/from_go_mod_file_test.go
