perf: custom loader (up to 70x+ improvements)

cmd/wire/cache_cmd.go

@@ -19,46 +19,162 @@ import (
 	"flag"
 	"fmt"
 	"log"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
 
-	"github.com/goforj/wire/internal/wire"
 	"github.com/google/subcommands"
 )
 
+const (
+	loaderArtifactDirEnv = "WIRE_LOADER_ARTIFACT_DIR"
+	outputCacheDirEnv    = "WIRE_OUTPUT_CACHE_DIR"
+	semanticCacheDirEnv  = "WIRE_SEMANTIC_CACHE_DIR"
+)
+
+var osUserCacheDir = os.UserCacheDir
+
 type cacheCmd struct {
 	clear bool
 }
 
-// Name returns the subcommand name.
+type cacheTarget struct {
+	name string
+	path string
+}
+
 func (*cacheCmd) Name() string { return "cache" }
 
-// Synopsis returns a short summary of the subcommand.
 func (*cacheCmd) Synopsis() string {
 	return "inspect or clear the wire cache"
 }
 
-// Usage returns the help text for the subcommand.
 func (*cacheCmd) Usage() string {
-	return `cache [-clear]
+	return `cache
+cache clear
+cache -clear
 
-  By default, prints the cache directory. With -clear, removes all cache files.
+  By default, prints the cache directory. With -clear or clear, removes all
+  Wire-managed cache files.
 `
 }
 
-// SetFlags registers flags for the subcommand.
 func (cmd *cacheCmd) SetFlags(f *flag.FlagSet) {
-	f.BoolVar(&cmd.clear, "clear", false, "remove all cached data")
+	f.BoolVar(&cmd.clear, "clear", false, "clear Wire caches")
 }
 
-// Execute runs the subcommand.
 func (cmd *cacheCmd) Execute(ctx context.Context, f *flag.FlagSet, args ...interface{}) subcommands.ExitStatus {
-	if cmd.clear {
-		if err := wire.ClearCache(); err != nil {
-			log.Printf("failed to clear cache: %v\n", err)
-			return subcommands.ExitFailure
+	_ = ctx
+	clearRequested := cmd.clear
+	switch extra := f.Args(); len(extra) {
+	case 0:
+		if !clearRequested {
+			root, err := wireCacheRoot(os.Environ())
+			if err != nil {
+				log.Println(err)
+				return subcommands.ExitFailure
+			}
+			fmt.Fprintln(os.Stdout, root)
+			return subcommands.ExitSuccess
+		}
+	case 1:
+		if extra[0] == "clear" {
+			clearRequested = true
+			break
 		}
-		log.Printf("cleared cache at %s\n", wire.CacheDir())
+		log.Printf("unknown cache action %q", extra[0])
+		log.Println(strings.TrimSpace(cmd.Usage()))
+		return subcommands.ExitFailure
+	default:
+		log.Println(strings.TrimSpace(cmd.Usage()))
+		return subcommands.ExitFailure
+	}
+	if !clearRequested {
+		log.Println(strings.TrimSpace(cmd.Usage()))
+		return subcommands.ExitFailure
+	}
+	cleared, err := clearWireCaches(os.Environ())
+	if err != nil {
+		log.Printf("failed to clear cache: %v\n", err)
+		return subcommands.ExitFailure
+	}
+	root, err := wireCacheRoot(os.Environ())
+	if err != nil {
+		log.Println(err)
+		return subcommands.ExitFailure
+	}
+	if len(cleared) == 0 {
+		log.Printf("cleared cache at %s\n", root)
 		return subcommands.ExitSuccess
 	}
-	fmt.Println(wire.CacheDir())
+	log.Printf("cleared cache at %s\n", root)
 	return subcommands.ExitSuccess
 }
+
+func wireCacheRoot(env []string) (string, error) {
+	base, err := osUserCacheDir()
+	if err != nil {
+		return "", fmt.Errorf("resolve user cache dir: %w", err)
+	}
+	return filepath.Join(base, "wire"), nil
+}
+
+func clearWireCaches(env []string) ([]string, error) {
+	base, err := wireCacheRoot(env)
+	if err != nil {
+		return nil, err
+	}
+	targets := wireCacheTargets(env, filepath.Dir(base))
+	cleared := make([]string, 0, len(targets))
+	for _, target := range targets {
+		info, err := os.Stat(target.path)
+		if os.IsNotExist(err) {
+			continue
+		}
+		if err != nil {
+			return cleared, fmt.Errorf("stat %s cache: %w", target.name, err)
+		}
+		if !info.IsDir() {
+			if err := os.Remove(target.path); err != nil {
+				return cleared, fmt.Errorf("remove %s cache: %w", target.name, err)
+			}
+		} else if err := os.RemoveAll(target.path); err != nil {
+			return cleared, fmt.Errorf("remove %s cache: %w", target.name, err)
+		}
+		cleared = append(cleared, target.name)
+	}
+	return cleared, nil
+}
+
+func wireCacheTargets(env []string, userCacheDir string) []cacheTarget {
+	baseWire := filepath.Join(userCacheDir, "wire")
+	targets := []cacheTarget{
+		{name: "loader-artifacts", path: envValueDefault(env, loaderArtifactDirEnv, filepath.Join(baseWire, "loader-artifacts"))},
+		{name: "discovery-cache", path: filepath.Join(baseWire, "discovery-cache")},
+		{name: "output-cache", path: envValueDefault(env, outputCacheDirEnv, filepath.Join(baseWire, "output-cache"))},
+	}
+	seen := make(map[string]bool, len(targets))
+	deduped := make([]cacheTarget, 0, len(targets))
+	for _, target := range targets {
+		cleaned := filepath.Clean(target.path)
+		if seen[cleaned] {
+			continue
+		}
+		seen[cleaned] = true
+		target.path = cleaned
+		deduped = append(deduped, target)
+	}
+	sort.Slice(deduped, func(i, j int) bool { return deduped[i].name < deduped[j].name })
+	return deduped
+}
+
+func envValueDefault(env []string, key, fallback string) string {
+	for i := len(env) - 1; i >= 0; i-- {
+		parts := strings.SplitN(env[i], "=", 2)
+		if len(parts) == 2 && parts[0] == key && parts[1] != "" {
+			return parts[1]
+		}
+	}
+	return fallback
+}

cmd/wire/cache_cmd_test.go

@@ -0,0 +1,92 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestWireCacheTargetsDefault(t *testing.T) {
+	base := filepath.Join(t.TempDir(), "cache")
+	got := wireCacheTargets(nil, base)
+	want := map[string]string{
+		"discovery-cache":  filepath.Join(base, "wire", "discovery-cache"),
+		"loader-artifacts": filepath.Join(base, "wire", "loader-artifacts"),
+		"output-cache":     filepath.Join(base, "wire", "output-cache"),
+	}
+	if len(got) != len(want) {
+		t.Fatalf("targets len = %d, want %d", len(got), len(want))
+	}
+	for _, target := range got {
+		if target.path != want[target.name] {
+			t.Fatalf("%s path = %q, want %q", target.name, target.path, want[target.name])
+		}
+	}
+}
+
+func TestWireCacheRoot(t *testing.T) {
+	base := filepath.Join(t.TempDir(), "cache")
+	old := osUserCacheDir
+	osUserCacheDir = func() (string, error) { return base, nil }
+	defer func() { osUserCacheDir = old }()
+
+	got, err := wireCacheRoot(nil)
+	if err != nil {
+		t.Fatalf("wireCacheRoot() error = %v", err)
+	}
+	want := filepath.Join(base, "wire")
+	if got != want {
+		t.Fatalf("wireCacheRoot() = %q, want %q", got, want)
+	}
+}
+
+func TestWireCacheTargetsRespectOverrides(t *testing.T) {
+	base := filepath.Join(t.TempDir(), "cache")
+	env := []string{
+		loaderArtifactDirEnv + "=" + filepath.Join(base, "loader"),
+		outputCacheDirEnv + "=" + filepath.Join(base, "output"),
+	}
+	got := wireCacheTargets(env, base)
+	want := map[string]string{
+		"discovery-cache":  filepath.Join(base, "wire", "discovery-cache"),
+		"loader-artifacts": filepath.Join(base, "loader"),
+		"output-cache":     filepath.Join(base, "output"),
+	}
+	for _, target := range got {
+		if target.path != want[target.name] {
+			t.Fatalf("%s path = %q, want %q", target.name, target.path, want[target.name])
+		}
+	}
+}
+
+func TestClearWireCachesRemovesTargets(t *testing.T) {
+	base := filepath.Join(t.TempDir(), "cache")
+	env := []string{
+		loaderArtifactDirEnv + "=" + filepath.Join(base, "loader"),
+		outputCacheDirEnv + "=" + filepath.Join(base, "output"),
+	}
+	for _, target := range wireCacheTargets(env, base) {
+		if err := os.MkdirAll(target.path, 0o755); err != nil {
+			t.Fatalf("MkdirAll(%q): %v", target.path, err)
+		}
+		if err := os.WriteFile(filepath.Join(target.path, "marker"), []byte("x"), 0o644); err != nil {
+			t.Fatalf("WriteFile(%q): %v", target.path, err)
+		}
+	}
+	old := osUserCacheDir
+	osUserCacheDir = func() (string, error) { return base, nil }
+	defer func() { osUserCacheDir = old }()
+
+	cleared, err := clearWireCaches(env)
+	if err != nil {
+		t.Fatalf("clearWireCaches() error = %v", err)
+	}
+	if len(cleared) != 3 {
+		t.Fatalf("cleared len = %d, want 3", len(cleared))
+	}
+	for _, target := range wireCacheTargets(env, base) {
+		if _, err := os.Stat(target.path); !os.IsNotExist(err) {
+			t.Fatalf("%s still exists after clear, stat err = %v", target.path, err)
+		}
+	}
+}

cmd/wire/gen_cmd.go

@@ -19,9 +19,7 @@ import (
 	"flag"
 	"log"
 	"os"
-	"time"
 
-	"github.com/goforj/wire/internal/wire"
 	"github.com/google/subcommands"
 )
 
@@ -66,7 +64,6 @@ func (cmd *genCmd) Execute(ctx context.Context, f *flag.FlagSet, args ...interfa
 		return subcommands.ExitFailure
 	}
 	defer stop()
-	totalStart := time.Now()
 	ctx = withTiming(ctx, cmd.profile.timings)
 
 	wd, err := os.Getwd()
@@ -83,42 +80,8 @@ func (cmd *genCmd) Execute(ctx context.Context, f *flag.FlagSet, args ...interfa
 	opts.PrefixOutputFile = cmd.prefixFileName
 	opts.Tags = cmd.tags
 
-	genStart := time.Now()
-	outs, errs := wire.Generate(ctx, wd, os.Environ(), packages(f), opts)
-	logTiming(cmd.profile.timings, "wire.Generate", genStart)
-	if len(errs) > 0 {
-		logErrors(errs)
-		log.Println("generate failed")
+	if !runGenerateCommand(ctx, wd, os.Environ(), packages(f), opts, cmd.profile.timings) {
 		return subcommands.ExitFailure
 	}
-	if len(outs) == 0 {
-		logTiming(cmd.profile.timings, "total", totalStart)
-		return subcommands.ExitSuccess
-	}
-	success := true
-	writeStart := time.Now()
-	for _, out := range outs {
-		if len(out.Errs) > 0 {
-			logErrors(out.Errs)
-			log.Printf("%s: generate failed\n", out.PkgPath)
-			success = false
-		}
-		if len(out.Content) == 0 {
-			// No Wire output. Maybe errors, maybe no Wire directives.
-			continue
-		}
-		if err := out.Commit(); err == nil {
-			log.Printf("%s: wrote %s (%s)\n", out.PkgPath, out.OutputPath, formatDuration(time.Since(totalStart)))
-		} else {
-			log.Printf("%s: failed to write %s: %v\n", out.PkgPath, out.OutputPath, err)
-			success = false
-		}
-	}
-	if !success {
-		log.Println("at least one generate failure")
-		return subcommands.ExitFailure
-	}
-	logTiming(cmd.profile.timings, "writes", writeStart)
-	logTiming(cmd.profile.timings, "total", totalStart)
 	return subcommands.ExitSuccess
 }

cmd/wire/generate_runner.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/goforj/wire/internal/wire"
+)
+
+func runGenerateCommand(ctx context.Context, wd string, env []string, patterns []string, opts *wire.GenerateOptions, timings bool) bool {
+	totalStart := time.Now()
+	genStart := time.Now()
+	outs, errs := wire.Generate(ctx, wd, env, patterns, opts)
+	logTiming(timings, "wire.Generate", genStart)
+	if len(errs) > 0 {
+		logErrors(errs)
+		log.Println("generate failed")
+		return false
+	}
+	if len(outs) == 0 {
+		logTiming(timings, "total", totalStart)
+		return true
+	}
+	success := true
+	writeStart := time.Now()
+	for _, out := range outs {
+		if len(out.Errs) > 0 {
+			logErrors(out.Errs)
+			log.Printf("%s: generate failed\n", out.PkgPath)
+			success = false
+		}
+		if len(out.Content) == 0 {
+			continue
+		}
+		if wrote, err := out.CommitWithStatus(); err == nil {
+			if wrote {
+				logSuccessf("%s: wrote %s (%s)", out.PkgPath, out.OutputPath, formatDuration(time.Since(totalStart)))
+			} else {
+				logSuccessf("%s: unchanged %s (%s)", out.PkgPath, out.OutputPath, formatDuration(time.Since(totalStart)))
+			}
+		} else {
+			log.Printf("%s: failed to write %s: %v\n", out.PkgPath, out.OutputPath, err)
+			success = false
+		}
+	}
+	if !success {
+		log.Println("at least one generate failure")
+		return false
+	}
+	logTiming(timings, "writes", writeStart)
+	logTiming(timings, "total", totalStart)
+	return true
+}
+
+func formatDuration(d time.Duration) string {
+	return fmt.Sprintf("%.2fms", float64(d)/float64(time.Millisecond))
+}