Fix multibuild with a package path

Builds with a specified package path were failing at source discovery
time. We need to scan the list of inputs to find the source dir, and
build the sources list from that, also prepending the package path to
each source path so that subsequently scanning for configuration can
work.

Note that for the time being we explicitly disallow building multiple
paths, as that requires more work. See #14.

Fixes: #13

Author: rburchell

cmd/multibuild/integration_test.go

@@ -17,7 +17,6 @@ func TestHelp(t *testing.T) {
 	cmd := exec.Command("go", "build", "-o", bin)
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
-	cmd.Env = append(os.Environ(), "CGO_ENABLED=0")
 	if err := cmd.Run(); err != nil {
 		t.Fatalf("build failed: %v", err)
 	}
@@ -36,7 +35,6 @@ multibuild-specific options:
 	for _, test := range []string{"-h", "--help"} {
 		t.Run(test, func(t *testing.T) {
 			cmd = exec.Command(bin, test)
-			cmd.Env = append(os.Environ(), "CGO_ENABLED=0")
 
 			out, err := cmd.CombinedOutput()
 			if err != nil {
@@ -58,14 +56,13 @@ multibuild-specific options:
 	}
 }
 
-func TestMultibuild(t *testing.T) {
+func TestMultibuildWithConfiguration(t *testing.T) {
 	binTmp := t.TempDir()
 	bin := filepath.Join(binTmp, "multibuild")
 
 	cmd := exec.Command("go", "build", "-o", bin)
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
-	cmd.Env = append(os.Environ(), "CGO_ENABLED=0")
 	if err := cmd.Run(); err != nil {
 		t.Fatalf("build failed: %v", err)
 	}
@@ -196,3 +193,173 @@ func main() {
 		})
 	}
 }
+
+func TestMultibuildDifferentStyles(t *testing.T) {
+	type testCase struct {
+		name              string
+		numPackages       int
+		numBinariesPerPkg int
+		runDir            string
+		args              []string
+		expectErr         bool
+		expectedBinaries  []string
+	}
+
+	goos := runtime.GOOS
+	goarch := runtime.GOARCH
+
+	// TODO: A little too much magic generation in this test, but unsure how else to structure it.
+	// TODO: We presently only test building inside a single module. That's probably OK, or do we need to test more?
+	// TODO: We don't have tests to cover multiple source files that aren't binaries, and we should.
+	testCases := []testCase{
+		{
+			// tests "multibuild" with no arguments should produce binaries
+			name:              "build in source dir",
+			numPackages:       1,
+			numBinariesPerPkg: 1,
+			runDir:            "pkg1",
+			args:              []string{},
+			expectErr:         false,
+			expectedBinaries: []string{
+				fmt.Sprintf("pkg1-%s-%s", goos, goarch),
+			},
+		},
+		{
+			// tests "multibuild pkg/" should produce binaries
+			name:              "build via path/",
+			numPackages:       1,
+			numBinariesPerPkg: 1,
+			runDir:            ".",
+			args:              []string{"./pkg1"},
+			expectErr:         false,
+			expectedBinaries: []string{
+				fmt.Sprintf("pkg1-%s-%s", goos, goarch),
+			},
+		},
+		{
+			// tests "multibuild pkg/main1.go" should produce binaries
+			name:              "build via single .go file",
+			numPackages:       1,
+			numBinariesPerPkg: 1,
+			runDir:            ".",
+			args:              []string{"pkg1/main1.go"},
+			expectErr:         false,
+			expectedBinaries: []string{
+				fmt.Sprintf("pkg1-%s-%s", goos, goarch),
+			},
+		},
+		{
+			// tests that currently, building two binaries should fail
+			name:              "build two binaries by file",
+			numPackages:       1,
+			numBinariesPerPkg: 2,
+			runDir:            ".",
+			args:              []string{"pkg1/main1.go", "pkg1/main2.go"},
+			expectErr:         true,
+			expectedBinaries:  []string{},
+		},
+		{
+			// tests that currently, building two packages should fail
+			name:              "build two packages by path/",
+			numPackages:       2,
+			numBinariesPerPkg: 1,
+			runDir:            ".",
+			args:              []string{"pkg1", "pkg2"},
+			expectErr:         true,
+			expectedBinaries:  []string{},
+		},
+	}
+
+	tmpRoot := t.TempDir()
+	bin := filepath.Join(tmpRoot, "multibuild")
+
+	cmd := exec.Command("go", "build", "-o", bin)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		t.Fatalf("build failed: %v", err)
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Setup packages and binaries
+			gover := runtime.Version() // "go1.24..."
+			if gover[0:2] != "go" {    // check for, and skip the "go" prefix
+				t.Fatalf("unexpected go version: %s", gover)
+			}
+			gover = gover[2:]
+			baseMod := fmt.Sprintf("module %s\n\ngo %s\n", "testmod", gover)
+			if err := os.WriteFile(filepath.Join(tmpRoot, "go.mod"), []byte(baseMod), 0644); err != nil {
+				t.Fatalf("failed to write go.mod: %v", err)
+			}
+
+			for p := 1; p <= tc.numPackages; p++ {
+				pkgDir := filepath.Join(tmpRoot, fmt.Sprintf("pkg%d", p))
+				os.RemoveAll(pkgDir)
+
+				if err := os.Mkdir(pkgDir, 0755); err != nil {
+					t.Fatalf("failed to mkdir: %v", err)
+				}
+				for b := 1; b <= tc.numBinariesPerPkg; b++ {
+					mainSource := fmt.Sprintf(`package main
+import "fmt"
+func main() { fmt.Println("Hello from main%d in pkg%d") }
+`, b, p)
+
+					mainPath := filepath.Join(pkgDir, fmt.Sprintf("main%d.go", b))
+					if err := os.WriteFile(mainPath, []byte(mainSource), 0644); err != nil {
+						t.Fatalf("failed to write %s: %v", mainPath, err)
+					}
+					// Add multibuild config to the first file in each package
+					if b == 1 {
+						config := `//go:multibuild:include=` + goos + `/` + goarch + "\n"
+						config += "//go:multibuild:output=${TARGET}-${GOOS}-${GOARCH}\n"
+						buf, err := os.ReadFile(mainPath)
+						if err != nil {
+							t.Fatalf("failed to read file to inject config")
+						}
+						if err := os.WriteFile(mainPath, []byte(config+string(buf)), 0644); err != nil {
+							t.Fatalf("failed to write config: %v", err)
+						}
+					}
+				}
+			}
+
+			var runDir string
+			if tc.runDir == "." {
+				runDir = tmpRoot
+			} else {
+				runDir = filepath.Join(tmpRoot, tc.runDir)
+			}
+
+			cmd := exec.Command(bin, tc.args...)
+			cmd.Dir = runDir
+			out, err := cmd.CombinedOutput()
+
+			if tc.expectErr {
+				if err == nil {
+					t.Fatalf("expected error, got success:\nOutput:\n%s", string(out))
+				}
+			} else {
+				if err != nil {
+					t.Fatalf("expected success, got error: %s\nOutput:\n%s", err, string(out))
+				}
+
+				if err != nil {
+					t.Fatalf("expected success, got error: %v\nOutput:\n%s", err, string(out))
+				}
+				for _, binRel := range tc.expectedBinaries {
+					var binPath string
+					if tc.runDir == "." {
+						binPath = filepath.Join(tmpRoot, binRel)
+					} else {
+						binPath = filepath.Join(runDir, binRel)
+					}
+					if _, err := os.Stat(binPath); err != nil {
+						t.Errorf("expected binary %q not found", binPath)
+					}
+				}
+			}
+		})
+	}
+}

cmd/multibuild/multibuild.go

@@ -16,15 +16,15 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"slices"
 	"strings"
 	"sync"
 )
 
 // Discovers all source files for this package.
 // This is smarter than Walk() looking for *.go, because it will obey build constraints.
-func sourcesList() ([]string, error) {
-	cmd := exec.Command("go", "list", "-compiled", "-json=CompiledGoFiles")
+func sourcesList(packagePath string) ([]string, error) {
+	cmd := exec.Command("go", "list", "-compiled", "-json=CompiledGoFiles", packagePath)
+
 	var buf bytes.Buffer
 	cmd.Stdout = &buf
 	cmd.Stderr = os.Stderr
@@ -40,6 +40,13 @@ func sourcesList() ([]string, error) {
 		return nil, fmt.Errorf("unmarshal: %w", err)
 	}
 
+	// We must prepend packagePath to each of the paths to scan, so that
+	// we can actually find the paths in the case where we are building
+	// a package from an unexpected location.
+	for idx, p := range v.CompiledGoFiles {
+		v.CompiledGoFiles[idx] = filepath.Join(packagePath, p)
+	}
+
 	return v.CompiledGoFiles, nil
 }
 
@@ -60,44 +67,6 @@ func targetList() ([]target, error) {
 	}), nil
 }
 
-// Returns the binary name/path that `go build` would produce.
-func determineTargetName(args []string) (string, error) {
-	for i := range args {
-		arg := args[i]
-
-		if arg == "-o" && i+1 < len(args) {
-			return args[i+1], nil
-		}
-
-		if after, ok := strings.CutPrefix(arg, "-o="); ok {
-			return after, nil
-		}
-	}
-
-	var nonflags []string
-	for _, arg := range args {
-		if !strings.HasPrefix(arg, "-") {
-			nonflags = append(nonflags, arg)
-		}
-	}
-
-	if len(nonflags) == 1 {
-		target := nonflags[0]
-
-		if strings.HasSuffix(target, ".go") {
-			return strings.TrimSuffix(filepath.Base(target), ".go"), nil
-		}
-
-		return filepath.Base(target), nil
-	}
-
-	wd, err := os.Getwd()
-	if err != nil {
-		return "", err
-	}
-	return filepath.Base(wd), nil
-}
-
 func displayUsageAndExit(self string) {
 	fmt.Fprintf(os.Stderr, "usage: %s [-o output] [build flags] [packages]\n", self)
 	fmt.Fprintln(os.Stderr, "multibuild is a thin wrapper around 'go build'.")
@@ -126,14 +95,25 @@ func displayTargetsAndExit(targets []target) {
 }
 
 func main() {
-	self := filepath.Base(os.Args[0])
-	args := os.Args[1:]
+	self := filepath.Base(os.Args[0]) // current binary name
+	args := os.Args[1:]               // remaining args
+	expectOutput := false             // seen -o, waiting for the rest
+	output := ""                      // -o or -o=
+	var nonflags []string             // non-flag arguments
 	displayConfig := false
 	displayTargets := false
 	verbose := false
 
 	for _, arg := range args {
 		switch {
+		case expectOutput:
+			output = arg
+			expectOutput = false
+		case arg == "-o":
+			expectOutput = true
+		case strings.HasPrefix(arg, "-o="):
+			output = strings.TrimPrefix(arg, "-o=")
+
 		case arg == "-h" || arg == "--help":
 			displayUsageAndExit(self)
 		case arg == "-v":
@@ -144,18 +124,59 @@ func main() {
 			displayTargets = true
 		case strings.HasPrefix(arg, "--multibuild"):
 			fatal("multibuild: unrecognized argument %q", arg)
+		case !strings.HasPrefix(arg, "-"):
+			nonflags = append(nonflags, arg)
 		}
 	}
 
-	output, err := determineTargetName(args)
-	if err != nil {
-		fatal("multibuild: failed to get target name: %s", err)
+	var sources []string
+	packagePath := "" // the path being built
+	if output == "" {
+		switch len(nonflags) {
+		case 0:
+			// implicit case: multibuild on the current dir -> multibuild .
+			packagePath = "."
+			wd, err := os.Getwd()
+			if err != nil {
+				fatal("multibuild: failed to get cwd: %s", err)
+			}
+			output = filepath.Base(wd)
+		case 1:
+			t := nonflags[0]
+			if strings.HasSuffix(t, ".go") {
+				// multibuild cmd/foo.go
+				packagePath = filepath.Dir(t)
+				output = strings.TrimSuffix(filepath.Base(t), ".go")
+				sources = append(sources, t)
+			} else {
+				// multibuild cmd/foo
+				packagePath = t
+				output = filepath.Base(t)
+			}
+		default:
+			// For now, I'm cowardly refusing to handle this.
+			// I think we need to refactor some to handle two cases:
+			// - specifying a list of .go sources in a single ultimate package
+			// - specifying a list of packages
+			//
+			// The former is handled quite easily I think, the latter will
+			// require some additional thought and handling, as it's essentially
+			// another level of looping on top of what we have now.
+			//
+			// We will need to discover sources for each package, scan independently,
+			// and build independently.
+			fatal("multibuild: cannot build multiple packages")
+		}
 	}
 
-	sources, err := sourcesList()
-	if err != nil {
-		fatal("multibuild: failed to discover sources: %s", err)
+	if len(sources) == 0 {
+		var err error
+		sources, err = sourcesList(packagePath)
+		if err != nil {
+			fatal("multibuild: failed to discover sources: %s", err)
+		}
 	}
+
 	opts, err := scanBuildDir(sources)
 	if err != nil {
 		fatal("multibuild: failed to scan sources: %s", err)
@@ -203,8 +224,8 @@ func main() {
 			out += ".exe"
 		}
 
-		buildArgs := slices.Clone(args)
-		buildArgs = append(buildArgs, "-o", out)
+		buildArgs := []string{"-o", out}
+		buildArgs = append(buildArgs, args...)
 
 		wg.Add(1) // acquire for global
 		go func(goos, goarch string, buildArgs []string) {