always produce .a files at the beginning of a build

WORKSPACE

@@ -6,7 +6,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 
 go_rules_dependencies()
 
-go_register_toolchains(version = "1.18.3")
+go_register_toolchains(version = "1.20rc1")
 
 http_archive(
     name = "com_google_protobuf",

go/private/BUILD.sdk.bazel

@@ -1,5 +1,6 @@
 load("@{rules_go_repo_name}//go/private/rules:binary.bzl", "go_tool_binary")
 load("@{rules_go_repo_name}//go/private/rules:sdk.bzl", "package_list")
+load("@{rules_go_repo_name}//go/private/rules:transition.bzl", "non_go_reset_target")
 load("@{rules_go_repo_name}//go/private:go_toolchain.bzl", "declare_go_toolchains")
 load("@{rules_go_repo_name}//go:def.bzl", "go_sdk")
 
@@ -42,6 +43,7 @@ go_sdk(
     package_list = ":package_list",
     root_file = "ROOT",
     tools = [":tools"],
+    version = "{version}",
 )
 
 go_tool_binary(
@@ -50,6 +52,11 @@ go_tool_binary(
     sdk = ":go_sdk",
 )
 
+non_go_reset_target(
+    name = "builder_reset",
+    dep = ":builder"
+)
+
 # TODO(jayconrod): Gazelle depends on this file directly. This dependency
 # should be broken, and this rule should be folded into go_sdk.
 package_list(
@@ -60,7 +67,7 @@ package_list(
 )
 
 declare_go_toolchains(
-    builder = ":builder",
+    builder = ":builder_reset",
     host_goos = "{goos}",
     sdk = ":go_sdk",
 )

go/private/actions/stdlib.bzl

@@ -44,13 +44,29 @@ def _stdlib_library_to_source(go, attr, source, merge):
         source["stdlib"] = _build_stdlib(go)
 
 def _should_use_sdk_stdlib(go):
-    return (go.mode.goos == go.sdk.goos and
+    return (_has_precompiled_stdlib(go.sdk.version) and
+            go.mode.goos == go.sdk.goos and
             go.mode.goarch == go.sdk.goarch and
             not go.mode.race and  # TODO(jayconrod): use precompiled race
             not go.mode.msan and
             not go.mode.pure and
             go.mode.link == LINKMODE_NORMAL)
 
+def _has_precompiled_stdlib(version_string):
+    if version_string[:2] != "1.":
+        return False
+    minor = version_string[2:]
+    dot = minor.find(".")
+    if dot != -1:
+        minor = minor[:dot]
+    rc = minor.find("rc")
+    if rc != -1:
+        minor = minor[:rc]
+    beta = minor.find("beta")
+    if beta != -1:
+        minor = minor[:beta]
+    return int(minor) < 20
+
 def _build_stdlib_list_json(go):
     out = go.declare_file(go, "stdlib.pkg.json")
     args = go.builder_args(go, "stdliblist")

go/private/providers.bzl

@@ -54,6 +54,7 @@ GoSDK = provider(
         "tools": ("List of executable files in the SDK built for " +
                   "the execution platform, excluding the go binary file"),
         "go": "The go binary file",
+        "version": "The Go SDK version",
     },
 )
 

go/private/rules/binary.bzl

@@ -415,11 +415,15 @@ def _go_tool_binary_impl(ctx):
     if sdk.goos == "windows":
         name += ".exe"
 
-    cout = ctx.actions.declare_file(name + ".a")
+    out = ctx.actions.declare_file(name)
     if sdk.goos == "windows":
-        cmd = "@echo off\n {go} tool compile -o {cout} -trimpath=%cd% {srcs}".format(
+        gopath = ctx.actions.declare_directory("gopath")
+        gocache = ctx.actions.declare_directory("gocache")
+        cmd = "@echo off\nset GOCACHE=%cd%\\{gocache}\nset GOPATH=%cd%\\{gopath}\n{go} build -o {out} -trimpath {srcs}".format(
+            gopath = gopath.path,
+            gocache = gocache.path,
             go = sdk.go.path.replace("/", "\\"),
-            cout = cout.path,
+            out = out.path,
             srcs = " ".join([f.path for f in ctx.files.srcs]),
         )
         bat = ctx.actions.declare_file(name + ".bat")
@@ -429,39 +433,24 @@ def _go_tool_binary_impl(ctx):
         )
         ctx.actions.run(
             executable = bat,
-            inputs = sdk.libs + sdk.headers + sdk.tools + ctx.files.srcs + [sdk.go],
-            outputs = [cout],
-            env = {"GOROOT": sdk.root_file.dirname},  # NOTE(#2005): avoid realpath in sandbox
-            mnemonic = "GoToolchainBinaryCompile",
+            inputs = sdk.headers + sdk.tools + sdk.srcs + ctx.files.srcs + [sdk.go],
+            outputs = [out, gopath, gocache],
+            mnemonic = "GoToolchainBinaryBuild",
         )
     else:
-        cmd = "{go} tool compile -o {cout} -trimpath=$PWD {srcs}".format(
+        # Note: GOPATH is needed for Go 1.16.
+        cmd = "GOCACHE=$(mktemp -d) GOPATH=$(mktemp -d) {go} build -o {out} -trimpath {srcs}".format(
             go = sdk.go.path,
-            cout = cout.path,
+            out = out.path,
             srcs = " ".join([f.path for f in ctx.files.srcs]),
         )
         ctx.actions.run_shell(
             command = cmd,
-            inputs = sdk.libs + sdk.headers + sdk.tools + ctx.files.srcs + [sdk.go],
-            outputs = [cout],
-            env = {"GOROOT": sdk.root_file.dirname},  # NOTE(#2005): avoid realpath in sandbox
-            mnemonic = "GoToolchainBinaryCompile",
+            inputs = sdk.headers + sdk.tools + sdk.srcs + sdk.libs + ctx.files.srcs + [sdk.go],
+            outputs = [out],
+            mnemonic = "GoToolchainBinaryBuild",
         )
 
-    out = ctx.actions.declare_file(name)
-    largs = ctx.actions.args()
-    largs.add_all(["tool", "link"])
-    largs.add("-o", out)
-    largs.add(cout)
-    ctx.actions.run(
-        executable = sdk.go,
-        arguments = [largs],
-        inputs = sdk.libs + sdk.headers + sdk.tools + [cout],
-        outputs = [out],
-        env = {"GOROOT_FINAL": "GOROOT"},  # Suppress go root paths to keep the output reproducible.
-        mnemonic = "GoToolchainBinary",
-    )
-
     return [DefaultInfo(
         files = depset([out]),
         executable = out,

go/private/rules/sdk.bzl

@@ -32,6 +32,7 @@ def _go_sdk_impl(ctx):
         srcs = ctx.files.srcs,
         tools = ctx.files.tools,
         go = ctx.executable.go,
+        version = ctx.attr.version,
     )]
 
 go_sdk = rule(
@@ -56,7 +57,10 @@ go_sdk = rule(
                    "standard library that may be imported."),
         ),
         "libs": attr.label_list(
-            allow_files = [".a"],
+            # allow_files is not set to [".a"] because that wouldn't allow
+            # for zero files to be present, as is the case in Go 1.20+.
+            # See also https://github.com/bazelbuild/bazel/issues/7516
+            allow_files = True,
             doc = ("Pre-compiled .a files for the standard library, " +
                    "built for the execution platform"),
         ),
@@ -82,6 +86,9 @@ go_sdk = rule(
             cfg = "exec",
             doc = "The go binary",
         ),
+        "version": attr.string(
+            doc = "The version of the Go SDK.",
+        ),
     },
     doc = ("Collects information about a Go SDK. The SDK must have a normal " +
            "GOROOT directory structure."),

go/private/rules/stdlib.bzl

@@ -25,6 +25,10 @@ load(
     "CgoContextInfo",
     "GoConfigInfo",
 )
+load(
+    "//go/private/rules:transition.bzl",
+    "go_stdlib_transition",
+)
 
 def _stdlib_impl(ctx):
     go = go_context(ctx)
@@ -33,12 +37,16 @@ def _stdlib_impl(ctx):
 
 stdlib = rule(
     implementation = _stdlib_impl,
+    cfg = go_stdlib_transition,
     attrs = {
         "cgo_context_data": attr.label(providers = [CgoContextInfo]),
         "_go_config": attr.label(
             default = "//:go_config",
             providers = [GoConfigInfo],
         ),
+        "_allowlist_function_transition": attr.label(
+            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
+        ),
     },
     doc = """stdlib builds the standard library for the target configuration
 or uses the precompiled standard library from the SDK if it is suitable.""",

go/private/rules/transition.bzl

@@ -219,6 +219,13 @@ _reset_transition_dict = dict(_common_reset_transition_dict, **{
 
 _reset_transition_keys = sorted([filter_transition_label(label) for label in _reset_transition_dict.keys()])
 
+_stdlib_keep_keys = sorted([
+    "@io_bazel_rules_go//go/config:msan",
+    "@io_bazel_rules_go//go/config:race",
+    "@io_bazel_rules_go//go/config:pure",
+    "@io_bazel_rules_go//go/config:linkmode",
+])
+
 def _go_tool_transition_impl(settings, attr):
     """Sets most Go settings to default values (use for external Go tools).
 
@@ -266,6 +273,27 @@ non_go_tool_transition = transition(
     outputs = _reset_transition_keys,
 )
 
+def _go_stdlib_transition_impl(settings, attr):
+    """Sets all Go settings to their default values, except for those affecting the Go SDK.
+
+    This transition is similar to _non_go_tool_transition except that it keeps the
+    parts of the configuration that determine how to build the standard library.
+    It's used to consolidate the configurations used to build the standard library to limit
+    the number built.
+    """
+    settings = dict(settings)
+    for label, value in _reset_transition_dict.items():
+        if label not in _stdlib_keep_keys:
+            settings[filter_transition_label(label)] = value
+    settings[filter_transition_label("@io_bazel_rules_go//go/private:bootstrap_nogo")] = False
+    return settings
+
+go_stdlib_transition = transition(
+    implementation = _go_stdlib_transition_impl,
+    inputs = _reset_transition_keys,
+    outputs = _reset_transition_keys,
+)
+
 def _go_reset_target_impl(ctx):
     t = ctx.attr.dep[0]  # [0] seems to be necessary with the transition
     providers = [t[p] for p in [GoLibrary, GoSource, GoArchive] if p in t]

go/private/sdk.bzl

@@ -347,6 +347,7 @@ def _sdk_build_file(ctx, platform, version):
             "{goarch}": goarch,
             "{exe}": ".exe" if goos == "windows" else "",
             "{rules_go_repo_name}": "io_bazel_rules_go",
+            "{version}": version,
         },
     )
 

go/tools/builders/stdlib.go

@@ -108,6 +108,7 @@ You may need to use the flags --cpu=x64_windows --compiler=mingw-gcc.`)
 		}
 	}
 	os.Setenv("CGO_LDFLAGS_ALLOW", b.String())
+	os.Setenv("GODEBUG", "installgoroot=all")
 
 	// Build the commands needed to build the std library in the right mode
 	// NOTE: the go command stamps compiled .a files with build ids, which are