internal/task: update x/tools dependency and create a CL for review

updateXToolsDependency will drop the replace directive in gopls sub
module and pin the x/tools version to the head of the current gopls
release branch.

A local relui screenshot is at https://go.dev/issue/57643#issuecomment-2263725465

For golang/go#57643

Change-Id: I0d9f4462b71b394ff432bc65142cf35e70977e6a
Reviewed-on: https://go-review.googlesource.com/c/build/+/602516
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Auto-Submit: Hongxiang Jiang <hxjiang@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

internal/task/releasegopls.go

diff --git a/internal/task/releasegopls.go b/internal/task/releasegopls.go
index 243d527..e763299 100644
--- a/internal/task/releasegopls.go
+++ b/internal/task/releasegopls.go
@@ -8,6 +8,7 @@
 	"errors"
 	"fmt"
 	"slices"
+	"strconv"
 	"strings"
 	"time"
 
@@ -34,7 +35,9 @@
 	semversion := wf.Task1(wd, "validating input version", r.isValidVersion, version)
 	branchCreated := wf.Action1(wd, "creating new branch if minor release", r.createBranchIfMinor, semversion)
 	changeID := wf.Task2(wd, "updating branch's codereview.cfg", r.updateCodeReviewConfig, semversion, reviewers, wf.After(branchCreated))
-	_ = wf.Action1(wd, "await config CL submission", r.AwaitSubmission, changeID)
+	submitted := wf.Action1(wd, "await config CL submission", r.AwaitSubmission, changeID)
+	changeID = wf.Task2(wd, "updating gopls' x/tools dependency", r.updateXToolsDependency, semversion, reviewers, wf.After(submitted))
+	_ = wf.Action1(wd, "await gopls' x/tools dependency CL submission", r.AwaitSubmission, changeID)
 	return wd
 }
 
@@ -73,10 +76,29 @@
 	return err
 }
 
-// updateCodeReviewConfig ensures codereview.cfg contains the expected
-// configuration.
+// openCL checks if an open CL with the given title exists in the specified
+// branch.
 //
-// It returns the change ID, or "" if the CL was not created.
+// It returns an empty string if no such CL is found, otherwise it returns the
+// CL's change ID.
+func (r *ReleaseGoplsTasks) openCL(ctx *wf.TaskContext, branch, title string) (string, error) {
+	// Query for an existing pending config CL, to avoid duplication.
+	query := fmt.Sprintf(`message:%q status:open owner:gobot@golang.org repo:tools branch:%q -age:7d`, title, branch)
+	changes, err := r.Gerrit.QueryChanges(ctx, query)
+	if err != nil {
+		return "", err
+	}
+	if len(changes) == 0 {
+		return "", nil
+	}
+
+	return changes[0].ChangeID, nil
+}
+
+// updateCodeReviewConfig checks if codereview.cfg has the desired configuration.
+//
+// It returns the change ID required to update the config if changes are needed,
+// otherwise it returns an empty string indicating no update is necessary.
 func (r *ReleaseGoplsTasks) updateCodeReviewConfig(ctx *wf.TaskContext, semv semversion, reviewers []string) (string, error) {
 	const configFile = "codereview.cfg"
 	const configFmt = `issuerepo: golang/go
@@ -87,15 +109,13 @@
 	branch := goplsReleaseBranchName(semv)
 	clTitle := fmt.Sprintf("all: update %s for %s", configFile, branch)
 
-	// Query for an existing pending config CL, to avoid duplication.
-	query := fmt.Sprintf(`message:%q status:open owner:gobot@golang.org repo:tools branch:%q -age:7d`, clTitle, branch)
-	changes, err := r.Gerrit.QueryChanges(ctx, query)
+	openCL, err := r.openCL(ctx, branch, clTitle)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("failed to find the open CL of title %q in branch %q: %w", clTitle, branch, err)
 	}
-	if len(changes) > 0 {
-		ctx.Printf("not creating CL: found existing CL %d", changes[0].ChangeNumber)
-		return changes[0].ChangeID, nil
+	if openCL != "" {
+		ctx.Printf("not creating CL: found existing CL %s", openCL)
+		return openCL, nil
 	}
 
 	head, err := r.Gerrit.ReadBranchHead(ctx, "tools", branch)
@@ -128,6 +148,110 @@
 	return r.Gerrit.CreateAutoSubmitChange(ctx, changeInput, reviewers, files)
 }
 
+// nextPrerelease go through the tags in tools repo that matches with the given
+// version and find the next pre-release version.
+func (r *ReleaseGoplsTasks) nextPrerelease(ctx *wf.TaskContext, semv semversion) (int, error) {
+	tags, err := r.Gerrit.ListTags(ctx, "tools")
+	if err != nil {
+		return -1, fmt.Errorf("failed to list tags for tools repo: %w", err)
+	}
+
+	max := 0
+	for _, tag := range tags {
+		v, ok := strings.CutPrefix(tag, "gopls/")
+		if !ok {
+			continue
+		}
+		cur, ok := parseSemver(v)
+		if !ok {
+			continue
+		}
+		if cur.Major != semv.Major || cur.Minor != semv.Minor || cur.Patch != semv.Patch {
+			continue
+		}
+		pre, err := cur.prereleaseVersion()
+		if err != nil {
+			continue
+		}
+
+		if pre > max {
+			max = pre
+		}
+	}
+
+	return max + 1, nil
+}
+
+// updateXToolsDependency ensures gopls sub module have the correct x/tools
+// version as dependency.
+//
+// It returns the change ID, or "" if the CL was not created.
+func (r *ReleaseGoplsTasks) updateXToolsDependency(ctx *wf.TaskContext, semv semversion, reviewers []string) (string, error) {
+	const scriptFmt = `cp gopls/go.mod gopls/go.mod.before
+cp gopls/go.sum gopls/go.sum.before
+cd gopls
+go mod edit -dropreplace=golang.org/x/tools
+go get -u golang.org/x/tools@%s
+go mod tidy -compat=1.19
+`
+
+	pre, err := r.nextPrerelease(ctx, semv)
+	if err != nil {
+		return "", fmt.Errorf("failed to find the next prerelease version: %w", err)
+	}
+
+	branch := goplsReleaseBranchName(semv)
+	clTitle := fmt.Sprintf("gopls: update go.mod for v%v.%v.%v-pre.%v", semv.Major, semv.Minor, semv.Patch, pre)
+	openCL, err := r.openCL(ctx, branch, clTitle)
+	if err != nil {
+		return "", fmt.Errorf("failed to find the open CL of title %q in branch %q: %w", clTitle, branch, err)
+	}
+	if openCL != "" {
+		ctx.Printf("not creating CL: found existing CL %s", openCL)
+		return openCL, nil
+	}
+
+	outputFiles := []string{"gopls/go.mod.before", "gopls/go.mod", "gopls/go.sum.before", "gopls/go.sum"}
+	// TODO(hxjiang): Replacing branch with the latest non-pinned commit in the
+	// release branch. Rationale:
+	// 1. Module proxy might return an outdated commit when using the branch name
+	// (to be confirmed with samthanawalla@).
+	// 2. Pinning x/tools using the latest commit from a branch isn't idempotent.
+	// It's best to avoid pinning x/tools to a version that's effectively another
+	// pin.
+	build, err := r.CloudBuild.RunScript(ctx, fmt.Sprintf(scriptFmt, branch), "tools", outputFiles)
+	if err != nil {
+		return "", err
+	}
+
+	outputs, err := buildToOutputs(ctx, r.CloudBuild, build)
+	if err != nil {
+		return "", err
+	}
+
+	changedFiles := map[string]string{}
+	for i := 0; i < len(outputFiles); i += 2 {
+		before, after := outputs[outputFiles[i]], outputs[outputFiles[i+1]]
+		if before != after {
+			changedFiles[outputFiles[i+1]] = after
+		}
+	}
+
+	// Skip CL creation as nothing changed.
+	if len(changedFiles) == 0 {
+		return "", nil
+	}
+
+	changeInput := gerrit.ChangeInput{
+		Project: "tools",
+		Branch:  branch,
+		Subject: fmt.Sprintf("%s\n\nThis is an automated CL which updates the go.mod go.sum.", clTitle),
+	}
+
+	ctx.Printf("creating auto-submit change under branch %q in x/tools repo.", branch)
+	return r.Gerrit.CreateAutoSubmitChange(ctx, changeInput, reviewers, changedFiles)
+}
+
 // AwaitSubmission waits for the CL with the given change ID to be submitted.
 //
 // The return value is the submitted commit hash, or "" if changeID is "".
@@ -179,6 +303,24 @@
 	return parsed, ok
 }
 
+func (s *semversion) prereleaseVersion() (int, error) {
+	parts := strings.Split(s.Pre, ".")
+	if len(parts) == 1 {
+		return -1, fmt.Errorf(`prerelease version does not contain any "."`)
+	}
+
+	if len(parts) > 2 {
+		return -1, fmt.Errorf(`prerelease version contains %v "."`, len(parts)-1)
+	}
+
+	pre, err := strconv.Atoi(parts[1])
+	if err != nil {
+		return -1, fmt.Errorf("failed to convert prerelease version to int %q: %w", pre, err)
+	}
+
+	return pre, nil
+}
+
 // possibleGoplsVersions identifies suitable versions for the upcoming release
 // based on the current tags in the repo.
 func (r *ReleaseGoplsTasks) possibleGoplsVersions(ctx *wf.TaskContext) ([]string, error) {

internal/task/releasegopls_test.go

diff --git a/internal/task/releasegopls_test.go b/internal/task/releasegopls_test.go
index ebe33a6..6c4d6aa 100644
--- a/internal/task/releasegopls_test.go
+++ b/internal/task/releasegopls_test.go
@@ -312,3 +312,65 @@
 		})
 	}
 }
+
+func TestNextPrerelease(t *testing.T) {
+	ctx := context.Background()
+	testcases := []struct {
+		name    string
+		tags    []string
+		version string
+		want    int
+	}{
+		{
+			name:    "next pre-release is 2",
+			tags:    []string{"gopls/v0.16.0-pre.0", "gopls/v0.16.0-pre.1"},
+			version: "v0.16.0",
+			want:    2,
+		},
+		{
+			name:    "next pre-release is 2 regardless of other minor or patch version",
+			tags:    []string{"gopls/v0.16.0-pre.0", "gopls/v0.16.0-pre.1", "gopls/v0.16.1-pre.1", "gopls/v0.2.0-pre.3"},
+			version: "v0.16.0",
+			want:    2,
+		},
+		{
+			name:    "next pre-release is 2 regardless of non-int prerelease version",
+			tags:    []string{"gopls/v0.16.0-pre.0", "gopls/v0.16.0-pre.1", "gopls/v0.16.0-pre.foo", "gopls/v0.16.0-pre.bar"},
+			version: "v0.16.0",
+			want:    2,
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			tools := NewFakeRepo(t, "tools")
+			commit := tools.Commit(map[string]string{
+				"go.mod": "module golang.org/x/tools\n",
+				"go.sum": "\n",
+			})
+
+			for _, tag := range tc.tags {
+				tools.Tag(tag, commit)
+			}
+
+			gerrit := NewFakeGerrit(t, tools)
+
+			tasks := &ReleaseGoplsTasks{
+				Gerrit: gerrit,
+			}
+
+			semv, ok := parseSemver(tc.version)
+			if !ok {
+				t.Fatalf("parseSemver(%q) should success", tc.version)
+			}
+			got, err := tasks.nextPrerelease(&workflow.TaskContext{Context: ctx, Logger: &testLogger{t, ""}}, semv)
+			if err != nil {
+				t.Fatalf("nextPrerelease(%q) should not return error: %v", tc.version, err)
+			}
+
+			if tc.want != got {
+				t.Errorf("nextPrerelease(%q) = %v want %v", tc.version, got, tc.want)
+			}
+		})
+	}
+}