always produce .a files at the beginning of a build

WORKSPACE

@@ -6,9 +6,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 
 go_rules_dependencies()
 
-go_register_toolchains(
-    version = "1.19.4",
-)
+go_register_toolchains(version = "1.19.4")
 
 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")
 
@@ -10,6 +11,7 @@ filegroup(
     srcs = glob(
         ["pkg/{goos}_{goarch}/**/*.a"],
         exclude = ["pkg/{goos}_{goarch}/**/cmd/**"],
+        allow_empty = True,
     ),
 )
 
@@ -43,6 +45,7 @@ go_sdk(
     root_file = "ROOT",
     experiments = {experiments},
     tools = [":tools"],
+    version = "{version}",
 )
 
 go_tool_binary(
@@ -51,6 +54,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(
@@ -61,7 +69,7 @@ package_list(
 )
 
 declare_go_toolchains(
-    builder = ":builder",
+    builder = ":builder_reset",
     host_goos = "{goos}",
     sdk = ":go_sdk",
 )

go/private/actions/stdlib.bzl

@@ -44,7 +44,8 @@ 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 (go.sdk.libs and  # go.sdk.libs is non-empty if sdk ships with precompiled .a files
+            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

go/private/providers.bzl

@@ -55,6 +55,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

@@ -33,6 +33,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(
@@ -61,7 +62,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"),
         ),
@@ -87,6 +91,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

@@ -203,6 +203,7 @@ go_transition = transition(
 )
 
 _common_reset_transition_dict = dict({
+    "@io_bazel_rules_go//go/private:request_nogo": False,
     "@io_bazel_rules_go//go/config:static": False,
     "@io_bazel_rules_go//go/config:msan": False,
     "@io_bazel_rules_go//go/config:race": False,
@@ -219,6 +220,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 +274,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

@@ -350,6 +350,14 @@ def _sdk_build_file(ctx, platform, version, experiments):
     ctx.file("ROOT")
     goos, _, goarch = platform.partition("_")
 
+    pv = _parse_version(version)
+    if pv != None and pv[1] >= 20:
+        # Turn off coverageredesign GOEXPERIMENT on 1.20+
+        # until rules_go is updated to work with the
+        # coverage redesign.
+        if not "nocoverageredesign" in experiments and not "coverageredesign" in experiments:
+            experiments = experiments + ["nocoverageredesign"]
+
     ctx.template(
         "BUILD.bazel",
         Label("//go/private:BUILD.sdk.bazel"),
@@ -359,6 +367,7 @@ def _sdk_build_file(ctx, platform, version, experiments):
             "{goarch}": goarch,
             "{exe}": ".exe" if goos == "windows" else "",
             "{rules_go_repo_name}": "io_bazel_rules_go",
+            "{version}": version,
             "{experiments}": repr(experiments),
         },
     )

go/tools/builders/stdlib.go

@@ -110,6 +110,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")
 
 	if len(experiments) > 0 {
 		os.Setenv("GOEXPERIMENT", strings.Join(experiments, ","))

tests/core/build_stdlib/BUILD.bazel

@@ -0,0 +1,6 @@
+load("@io_bazel_rules_go//go/tools/bazel_testing:def.bzl", "go_bazel_test")
+
+go_bazel_test(
+    name = "build_stdlib_test",
+    srcs = ["build_stdlib_test.go"],
+)

tests/core/build_stdlib/README.rst

@@ -0,0 +1,11 @@
+Building with standard libraries with missing .a files
+===========
+
+Tests to ensure that building with Go 1.20 and later versions of Go, which no longer
+include precompiled standard library .a files, continues to work
+
+build_stdlib_test
+--------------
+
+Test that a simple binary depending on a simple library can build when the WORKSPACE's
+go version is set to 1.20rc1.

tests/core/build_stdlib/build_stdlib_test.go

@@ -0,0 +1,97 @@
+// Copyright 2022 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.
+
+package build_stdlib_test
+
+import (
+	"bytes"
+	"os"
+	"testing"
+
+	"github.com/bazelbuild/rules_go/go/tools/bazel_testing"
+)
+
+func TestMain(m *testing.M) {
+	bazel_testing.TestMain(m, bazel_testing.Args{
+		Main: `
+-- BUILD.bazel --
+load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library")
+
+go_binary(
+    name = "program",
+    srcs = ["main.go"],
+	deps = [":library"],
+	visibility = ["//visibility:public"],
+)
+
+go_library(
+	name = "library",
+	srcs = ["library.go"],
+	importpath = "example.com/library"
+)
+-- main.go --
+package main
+
+import "example.com/library"
+
+func main() {
+	library.F()
+}
+-- library.go --
+package library
+
+func F() {}
+`,
+	})
+}
+
+const origWrapSDK = `go_wrap_sdk(
+    name = "go_sdk",
+    root_file = "@local_go_sdk//:ROOT",
+)
+
+go_register_toolchains()`
+
+const toolchain120 = `go_register_toolchains(version = "1.20rc1")`
+
+func TestBoringcryptoExperimentPresent(t *testing.T) {
+	mustReplaceInFile(t, "WORKSPACE", origWrapSDK, toolchain120)
+	defer mustReplaceInFile(t, "WORKSPACE", toolchain120, origWrapSDK)
+
+	cmd := bazel_testing.BazelCmd("build", "//:program")
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stdout
+	if err := cmd.Run(); err != nil {
+		t.Fatal("failed to run bazel build: ", err)
+	}
+
+}
+
+func mustReplaceInFile(t *testing.T, path, old, new string) {
+	t.Helper()
+	if old == new {
+		return
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Contains(data, []byte(old)) {
+		t.Fatalf("bytes to replace %q not found in file %q with contents, %q", old, path, data)
+	}
+	data = bytes.ReplaceAll(data, []byte(old), []byte(new))
+	if err := os.WriteFile(path, data, 0666); err != nil {
+		t.Fatal(err)
+	}
+}