Passing for gazelle

Author: fmeum

MODULE.bazel

@@ -25,6 +25,7 @@ use_repo(
     "go_toolchains",
     # This name is ugly on purpose to avoid a conflict with a user-named SDK.
     "io_bazel_rules_nogo",
+    go_sdk = "go_default_sdk",
 )
 
 register_toolchains("@go_toolchains//:all")

go/tools/bazel_testing/BUILD.bazel

@@ -4,9 +4,17 @@ load("//go:def.bzl", "go_library")
 go_library(
     name = "bazel_testing",
     srcs = ["bazel_testing.go"],
+    data = [
+        "@go_sdk//:ROOT",
+        "@go_sdk//:files",
+    ],
     importpath = "github.com/bazelbuild/rules_go/go/tools/bazel_testing",
     visibility = ["//visibility:public"],
+    x_defs = {
+        "goRootFile": "$(rlocationpath @go_sdk//:ROOT)",
+    },
     deps = [
+        "//go/runfiles",
         "//go/tools/bazel",
         "//go/tools/internal/txtar",
     ],

go/tools/bazel_testing/bazel_testing.go

@@ -30,19 +30,22 @@ import (
 	"os"
 	"os/exec"
 	"os/signal"
-	"path"
 	"path/filepath"
 	"regexp"
 	"runtime"
-	"sort"
 	"strings"
 	"testing"
 	"text/template"
 
+	"github.com/bazelbuild/rules_go/go/runfiles"
 	"github.com/bazelbuild/rules_go/go/tools/bazel"
 	"github.com/bazelbuild/rules_go/go/tools/internal/txtar"
 )
 
+// Set via x_defs.
+var goRootFile = ""
+var testedModuleName = ""
+
 const (
 	// Standard Bazel exit codes.
 	// A subset of codes in https://cs.opensource.google/bazel/bazel/+/master:src/main/java/com/google/devtools/build/lib/util/ExitCode.java.
@@ -317,6 +320,30 @@ func setupWorkspace(args Args, files []string) (dir string, cleanup func() error
 	}
 	cleanups = append(cleanups, func() error { return os.RemoveAll(execDir) })
 
+	// Copy or link the files for the tested repository.
+	testedRepoDir := filepath.Join(execDir, "tested_repo")
+	for _, f := range files {
+		if !strings.HasPrefix(f, "_main/") {
+			return "", cleanup, fmt.Errorf("unexpected data file from a non-main repo: %s", f)
+		}
+		srcPath, err := runfiles.Rlocation(f)
+		if err != nil {
+			return "", cleanup, fmt.Errorf("unknown runfile %s: %v", f, err)
+		}
+		dstPath := filepath.Join(testedRepoDir, strings.TrimPrefix(f, "_main/"))
+		if err := copyOrLink(dstPath, srcPath); err != nil {
+			return "", cleanup, fmt.Errorf("copying %s to %s: %v", srcPath, dstPath, err)
+		}
+	}
+	testedRepoWorkspacePath := filepath.Join(testedRepoDir, "WORKSPACE")
+	testedModuleRepoName := testedModuleName
+	if _, err = os.Stat(testedRepoWorkspacePath); err == nil {
+		testedModuleRepoName, err = loadWorkspaceName(filepath.Join(testedRepoDir, "WORKSPACE"))
+		if err != nil {
+			return "", cleanup, fmt.Errorf("loading workspace name: %v", err)
+		}
+	}
+
 	// Create the workspace directory.
 	mainDir := filepath.Join(execDir, "main")
 	if err := os.MkdirAll(mainDir, 0777); err != nil {
@@ -337,71 +364,11 @@ func setupWorkspace(args Args, files []string) (dir string, cleanup func() error
 		return "", cleanup, err
 	}
 
-	// Extract test files for the main workspace.
+	// Extract test files for the main repository.
 	if err := extractTxtar(mainDir, args.Main); err != nil {
 		return "", cleanup, fmt.Errorf("building main workspace: %v", err)
 	}
 
-	// If some of the path arguments are missing an explicit workspace,
-	// read the workspace name from WORKSPACE. We need this to map arguments
-	// to runfiles in specific workspaces.
-	haveDefaultWorkspace := false
-	var defaultWorkspaceName string
-	for _, argPath := range files {
-		workspace, _, err := parseLocationArg(argPath)
-		if err == nil && workspace == "" {
-			haveDefaultWorkspace = true
-			cleanPath := path.Clean(argPath)
-			if cleanPath == "WORKSPACE" {
-				defaultWorkspaceName, err = loadWorkspaceName(cleanPath)
-				if err != nil {
-					return "", cleanup, fmt.Errorf("could not load default workspace name: %v", err)
-				}
-				break
-			}
-		}
-	}
-	if haveDefaultWorkspace && defaultWorkspaceName == "" {
-		return "", cleanup, fmt.Errorf("found files from default workspace, but not WORKSPACE")
-	}
-
-	// Index runfiles by workspace and short path. We need this to determine
-	// destination paths when we copy or link files.
-	runfiles, err := bazel.ListRunfiles()
-	if err != nil {
-		return "", cleanup, err
-	}
-
-	type runfileKey struct{ workspace, short string }
-	runfileMap := make(map[runfileKey]string)
-	for _, rf := range runfiles {
-		runfileMap[runfileKey{rf.Workspace, rf.ShortPath}] = rf.Path
-	}
-
-	// Copy or link file arguments from runfiles into fake workspace dirctories.
-	// Keep track of the workspace names we see, since we'll generate a WORKSPACE
-	// with local_repository rules later.
-	workspaceNames := make(map[string]bool)
-	for _, argPath := range files {
-		workspace, shortPath, err := parseLocationArg(argPath)
-		if err != nil {
-			return "", cleanup, err
-		}
-		if workspace == "" {
-			workspace = defaultWorkspaceName
-		}
-		workspaceNames[workspace] = true
-
-		srcPath, ok := runfileMap[runfileKey{workspace, shortPath}]
-		if !ok {
-			return "", cleanup, fmt.Errorf("unknown runfile: %s", argPath)
-		}
-		dstPath := filepath.Join(execDir, workspace, shortPath)
-		if err := copyOrLink(dstPath, srcPath); err != nil {
-			return "", cleanup, err
-		}
-	}
-
 	// If there's no WORKSPACE file, create one.
 	workspacePath := filepath.Join(mainDir, "WORKSPACE")
 	if _, err = os.Stat(workspacePath); os.IsNotExist(err) {
@@ -415,25 +382,24 @@ func setupWorkspace(args Args, files []string) (dir string, cleanup func() error
 				err = cerr
 			}
 		}()
-		info := workspaceTemplateInfo{
-			Prefix:       args.WorkspacePrefix,
-			Suffix:       args.WorkspaceSuffix,
-			Nogo:         args.Nogo,
-			NogoIncludes: args.NogoIncludes,
-			NogoExcludes: args.NogoExcludes,
+		goRootFilePath, err := runfiles.Rlocation(goRootFile)
+		if err != nil {
+			return "", cleanup, fmt.Errorf("unknown runfile %s: %v", goRootFile, err)
 		}
-		for name := range workspaceNames {
-			info.WorkspaceNames = append(info.WorkspaceNames, name)
+		// TODO: This is only necessary because of https://github.com/golang/go/issues/59924.
+		goRootFileRealPath, err := filepath.EvalSymlinks(goRootFilePath)
+		if err != nil {
+			return "", cleanup, fmt.Errorf("unknown runfile %s: %v", goRootFile, err)
 		}
-		sort.Strings(info.WorkspaceNames)
-		if outBaseDir != "" {
-			goSDKPath := filepath.Join(outBaseDir, "external", "go_sdk")
-			rel, err := filepath.Rel(mainDir, goSDKPath)
-			if err != nil {
-				return "", cleanup, fmt.Errorf("could not find relative path from %q to %q for go_sdk", mainDir, goSDKPath)
-			}
-			rel = filepath.ToSlash(rel)
-			info.GoSDKPath = rel
+		info := workspaceTemplateInfo{
+			TestedModuleRepoName: testedModuleRepoName,
+			TestedModulePath:     testedRepoDir,
+			Prefix:               args.WorkspacePrefix,
+			Suffix:               args.WorkspaceSuffix,
+			Nogo:                 args.Nogo,
+			NogoIncludes:         args.NogoIncludes,
+			NogoExcludes:         args.NogoExcludes,
+			GoSDKPath:            filepath.Dir(goRootFileRealPath),
 		}
 		if err := defaultWorkspaceTpl.Execute(w, info); err != nil {
 			return "", cleanup, err
@@ -456,14 +422,10 @@ func setupWorkspace(args Args, files []string) (dir string, cleanup func() error
 				err = cerr
 			}
 		}()
-		rulesGoAbsPath := filepath.Join(execDir, "io_bazel_rules_go")
-		rulesGoPath, err := filepath.Rel(mainDir, rulesGoAbsPath)
-		if err != nil {
-			return "", cleanup, fmt.Errorf("could not find relative path from %q to %q for io_bazel_rules_go", mainDir, rulesGoAbsPath)
-		}
-		rulesGoPath = filepath.ToSlash(rulesGoPath)
 		info := moduleFileTemplateInfo{
-			RulesGoPath: rulesGoPath,
+			TestedModuleName:     testedModuleName,
+			TestedModuleRepoName: testedModuleRepoName,
+			TestedModulePath:     testedRepoDir,
 			Suffix:      args.ModuleFileSuffix,
 		}
 		if err := defaultModuleBazelTpl.Execute(w, info); err != nil {
@@ -489,33 +451,8 @@ func extractTxtar(dir, txt string) error {
 	return nil
 }
 
-func parseLocationArg(arg string) (workspace, shortPath string, err error) {
-	cleanPath := path.Clean(arg)
-	// Support both states of --legacy_external_runfiles.
-	if !strings.HasPrefix(cleanPath, "../") && !strings.HasPrefix(cleanPath, "external/") {
-		return "", cleanPath, nil
-	}
-	var trimmedPath string
-	if strings.HasPrefix(cleanPath, "../") {
-		trimmedPath = cleanPath[len("../"):]
-	} else {
-		trimmedPath = cleanPath[len("external/"):]
-	}
-	i := strings.IndexByte(trimmedPath, '/')
-	if i < 0 {
-		return "", "", fmt.Errorf("unexpected file (missing / after ../): %s", arg)
-	}
-	workspace = trimmedPath[:i]
-	shortPath = trimmedPath[i+1:]
-	return workspace, shortPath, nil
-}
-
 func loadWorkspaceName(workspacePath string) (string, error) {
-	runfilePath, err := bazel.Runfile(workspacePath)
-	if err == nil {
-		workspacePath = runfilePath
-	}
-	workspaceData, err := ioutil.ReadFile(workspacePath)
+	workspaceData, err := os.ReadFile(workspacePath)
 	if err != nil {
 		return "", err
 	}
@@ -532,7 +469,8 @@ func loadWorkspaceName(workspacePath string) (string, error) {
 }
 
 type workspaceTemplateInfo struct {
-	WorkspaceNames []string
+	TestedModuleRepoName string
+	TestedModulePath     string
 	GoSDKPath      string
 	Nogo           string
 	NogoIncludes   []string
@@ -542,25 +480,17 @@ type workspaceTemplateInfo struct {
 }
 
 var defaultWorkspaceTpl = template.Must(template.New("").Parse(`
-{{range .WorkspaceNames}}
 local_repository(
-    name = "{{.}}",
-    path = "../{{.}}",
+    name = "{{.TestedModuleRepoName}}",
+    path = "{{.TestedModulePath}}",
 )
-{{end}}
 
 {{.Prefix}}
 
-{{if not .GoSDKPath}}
-load("@io_bazel_rules_go//go:deps.bzl", "go_rules_dependencies", "go_register_toolchains")
-
-go_rules_dependencies()
-
-go_register_toolchains(go_version = "host")
-{{else}}
-local_repository(
+new_local_repository(
     name = "local_go_sdk",
     path = "{{.GoSDKPath}}",
+    build_file_content = "",
 )
 
 load("@io_bazel_rules_go//go:deps.bzl", "go_rules_dependencies", "go_register_toolchains", "go_wrap_sdk", "go_register_nogo")
@@ -595,20 +525,22 @@ go_register_nogo(
 	{{ end}}
 )
 {{end}}
-{{end}}
 {{.Suffix}}
 `))
 
 type moduleFileTemplateInfo struct {
-	RulesGoPath string
+	TestedModuleName     string
+	TestedModuleRepoName string
+	TestedModulePath     string
 	Suffix      string
 }
 
+// TODO: Also reuse the current Go SDK as in the WORKSPACE file.
 var defaultModuleBazelTpl = template.Must(template.New("").Parse(`
-bazel_dep(name = "rules_go", version = "", repo_name = "io_bazel_rules_go")
+bazel_dep(name = "{{.TestedModuleName}}", repo_name = "{{.TestedModuleRepoName}}")
 local_path_override(
-    module_name = "rules_go",
-    path = "{{.RulesGoPath}}",
+    module_name = "{{.TestedModuleName}}",
+    path = "{{.TestedModulePath}}",
 )
 {{.Suffix}}
 `))

go/tools/bazel_testing/def.bzl

@@ -21,7 +21,8 @@ def go_bazel_test(rule_files = None, **kwargs):
     """
 
     if not rule_files:
-        rule_files = [Label("//:all_files")]
+        # Resolve the //:all_files target in the repo using this rule.
+        rule_files = ["//:all_files"]
 
     # Add dependency on bazel_testing library.
     kwargs.setdefault("deps", [])
@@ -39,7 +40,7 @@ def go_bazel_test(rule_files = None, **kwargs):
     # these files.
     kwargs.setdefault("args", [])
     kwargs["args"] = (["-begin_files"] +
-                      ["$(locations {})".format(t) for t in rule_files] +
+                      ["$(rlocationpaths {})".format(t) for t in rule_files] +
                       ["-end_files"] +
                       kwargs["args"])
 
@@ -59,4 +60,8 @@ def go_bazel_test(rule_files = None, **kwargs):
     if "exclusive" not in kwargs["tags"]:
         kwargs["tags"].append("exclusive")
 
+    kwargs.setdefault("x_defs", {}).update({
+        "github.com/bazelbuild/rules_go/go/tools/bazel_testing.testedModuleName": native.module_name(),
+    })
+
     go_test(**kwargs)