goscript 0.1.3 → 0.2.0

package/compiler/override-registry_test.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"slices"
+	"strconv"
 	"strings"
 	"testing"
 )
@@ -80,6 +81,17 @@ func TestOverrideRegistryFactsAreImmutable(t *testing.T) {
 	if len(pkg.files) == 0 || pkg.files[0].data[0] == '!' {
 		t.Fatalf("copy file mutation leaked back into facts")
 	}
+
+	ledger := facts.parityLedger("net/http")
+	if got := ledger.Symbols["ServeFile"].Status; got != overrideParityStatusReal {
+		t.Fatalf("expected net/http ServeFile real parity, got %q", got)
+	}
+	ledger.Symbols["ServeFile"] = overrideParityEntry{Status: overrideParityStatusDeferred}
+
+	ledger = facts.parityLedger("net/http")
+	if got := ledger.Symbols["ServeFile"].Status; got != overrideParityStatusReal {
+		t.Fatalf("parity ledger mutation leaked back into facts: %q", got)
+	}
 }
 
 func TestOverrideRegistryCopiesRuntimeAndOverrides(t *testing.T) {
@@ -384,6 +396,51 @@ func TestCompilePackagesAwaitsOverrideAsyncInterfaceMethodCalls(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesAwaitsNetHTTPServeHTTPOverrideMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/httpserveasync\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"net/http\"",
+			"func Use(h http.Handler, hf http.HandlerFunc, mux *http.ServeMux, w http.ResponseWriter, r *http.Request) {",
+			"  h.ServeHTTP(w, r)",
+			"  hf.ServeHTTP(w, r)",
+			"  mux.ServeHTTP(w, r)",
+			"}",
+			"func main() {}",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "httpserveasync", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export async function Use(",
+		"await $.pointerValue<Exclude<http.Handler, null>>(h).ServeHTTP($.pointerValueOrNil(w)!, r)",
+		"await http.HandlerFunc_ServeHTTP(hf, $.pointerValueOrNil(w)!, r)",
+		"await http.ServeMux.prototype.ServeHTTP.call($.pointerValue<http.ServeMux>(mux), $.pointerValueOrNil(w)!, r)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
 func TestCompilePackagesAwaitsOverrideAsyncFunctions(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/overrideasyncfunc\n\ngo 1.25.3\n",
@@ -430,3 +487,505 @@ func TestCompilePackagesAwaitsOverrideAsyncFunctions(t *testing.T) {
 		t.Fatalf("walk callback was not lowered as async:\n%s", string(content))
 	}
 }
+
+func TestCompilePackagesAwaitsReflectValueCall(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/reflectcallasync\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"reflect\"",
+			"func Use(fn func()) []reflect.Value {",
+			"  return reflect.ValueOf(fn).Call(nil)",
+			"}",
+			"func UseSlice(fn func(...int), args []reflect.Value) []reflect.Value {",
+			"  return reflect.ValueOf(fn).CallSlice(args)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "reflectcallasync", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "export async function Use") {
+		t.Fatalf("reflect.Value.Call caller was not marked async:\n%s", text)
+	}
+	if !strings.Contains(text, "return await ") || !strings.Contains(text, ".Call(null)") {
+		t.Fatalf("reflect.Value.Call was not awaited:\n%s", text)
+	}
+	if !strings.Contains(text, "export async function UseSlice") {
+		t.Fatalf("reflect.Value.CallSlice caller was not marked async:\n%s", text)
+	}
+	if !strings.Contains(text, "return await ") || !strings.Contains(text, ".CallSlice(args)") {
+		t.Fatalf("reflect.Value.CallSlice was not awaited:\n%s", text)
+	}
+}
+
+func TestOverrideParityVerifierResolvesEffectiveTypeScriptExports(t *testing.T) {
+	files := map[string]string{
+		"example.test/lib/index.ts": strings.Join([]string{
+			"export { RenamedSource as Renamed } from './named.js'",
+			"export type { TypeShape } from './types.js'",
+			"export * from './star.js'",
+			"",
+		}, "\n"),
+		"example.test/lib/named.ts": "export function RenamedSource(): void {}\n",
+		"example.test/lib/star.ts":  "export class Star {}\n",
+		"example.test/lib/types.ts": "export interface TypeShape {}\n",
+	}
+	exports := make(map[string]typeScriptExport)
+	if err := collectTypeScriptExports("example.test/lib/index.ts", files, exports, make(map[string]bool)); err != nil {
+		t.Fatal(err.Error())
+	}
+	for _, name := range []string{"Renamed", "TypeShape", "Star"} {
+		if !exports[name].present() {
+			t.Fatalf("effective TypeScript exports missing %s: %v", name, exports)
+		}
+	}
+	if exports["RenamedSource"].present() {
+		t.Fatalf("named re-export source leaked into effective exports: %v", exports)
+	}
+	if !exports["Renamed"].value || exports["Renamed"].typ {
+		t.Fatalf("renamed function export should be value-only: %#v", exports["Renamed"])
+	}
+	if !exports["TypeShape"].typ || exports["TypeShape"].value {
+		t.Fatalf("type re-export should be type-only: %#v", exports["TypeShape"])
+	}
+	if !exports["Star"].value || !exports["Star"].typ {
+		t.Fatalf("class star export should carry value and type shapes: %#v", exports["Star"])
+	}
+}
+
+func TestOverrideParityVerifierValidatesNamedReExportSources(t *testing.T) {
+	files := map[string]string{
+		"example.test/lib/index.ts": "export { Missing } from './named.js'\n",
+		"example.test/lib/named.ts": "export function Present(): void {}\n",
+	}
+	err := collectTypeScriptExports("example.test/lib/index.ts", files, make(map[string]typeScriptExport), make(map[string]bool))
+	if err == nil {
+		t.Fatalf("expected missing named re-export source to fail")
+	}
+	if !strings.Contains(err.Error(), "re-exports missing symbol Missing") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestOverrideParityVerifierValidatesLocalNamedExportSources(t *testing.T) {
+	files := map[string]string{
+		"example.test/lib/index.ts": "export { Missing }\n",
+	}
+	err := collectTypeScriptExports("example.test/lib/index.ts", files, make(map[string]typeScriptExport), make(map[string]bool))
+	if err == nil {
+		t.Fatalf("expected missing local named export source to fail")
+	}
+	if !strings.Contains(err.Error(), "exports missing local value symbol Missing") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestOverrideParityVerifierReportsStrictUnclassifiedSymbol(t *testing.T) {
+	result, err := compileParityFixture(t, map[string]overrideParityEntry{
+		"Present": {Status: overrideParityStatusReal},
+	}, "export function Present(): void {}\n")
+	if err == nil {
+		t.Fatalf("expected compile to fail")
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-unclassified")
+}
+
+func TestOverrideParityVerifierReportsMissingTypeScriptExport(t *testing.T) {
+	result, err := compileParityFixture(t, map[string]overrideParityEntry{
+		"Present": {Status: overrideParityStatusReal},
+		"Missing": {Status: overrideParityStatusReal},
+	}, "export function Present(): void {}\n")
+	if err == nil {
+		t.Fatalf("expected compile to fail")
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-missing-export")
+}
+
+func TestOverrideParityVerifierRejectsTypeOnlyValueExport(t *testing.T) {
+	result, err := compileParityFixture(t, map[string]overrideParityEntry{
+		"Present": {Status: overrideParityStatusReal},
+		"Missing": {Status: overrideParityStatusReal},
+	}, strings.Join([]string{
+		"export function Present(): void {}",
+		"export type Missing = unknown",
+		"",
+	}, "\n"))
+	if err == nil {
+		t.Fatalf("expected compile to fail")
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-missing-export")
+}
+
+func TestOverrideParityVerifierRejectsTypeOnlyStructExport(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/structparity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/structparity/lib\"",
+			"func main() { _ = lib.StructExport{} }",
+			"",
+		}, "\n"),
+		"lib/lib.go": strings.Join([]string{
+			"package lib",
+			"type StructExport struct{}",
+			"",
+		}, "\n"),
+	})
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/structparity/lib/index.ts", "export type StructExport = {}\n")
+	writeFixtureFile(t, overrideDir, "example.test/structparity/lib/parity.json", parityFixtureJSON(t, map[string]overrideParityEntry{
+		"StructExport": {Status: overrideParityStatusReal},
+	}))
+
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		OverrideDirs:    []string{overrideDir},
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err == nil {
+		t.Fatalf("expected compile to fail")
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-missing-export")
+}
+
+func TestOverrideParityVerifierReportsBlockedTypeScriptExport(t *testing.T) {
+	result, err := compileParityFixture(t, map[string]overrideParityEntry{
+		"Present": {Status: overrideParityStatusReal},
+		"Missing": {Status: overrideParityStatusBlocked, Reason: "blocked by fixture"},
+	}, strings.Join([]string{
+		"export function Present(): void {}",
+		"export function Missing(): void {}",
+		"",
+	}, "\n"))
+	if err == nil {
+		t.Fatalf("expected compile to fail")
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-unexpected-export")
+}
+
+func TestOverrideParityVerifierReportsBlockedGoUse(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/blockeduse\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/blockeduse/lib\"",
+			"func main() { lib.Missing() }",
+			"",
+		}, "\n"),
+		"lib/lib.go": strings.Join([]string{
+			"package lib",
+			"func Present() {}",
+			"func Missing() {}",
+			"",
+		}, "\n"),
+	})
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/blockeduse/lib/index.ts", "export function Present(): void {}\n")
+	writeFixtureFile(t, overrideDir, "example.test/blockeduse/lib/parity.json", parityFixtureJSON(t, map[string]overrideParityEntry{
+		"Present": {Status: overrideParityStatusReal},
+		"Missing": {Status: overrideParityStatusBlocked, Reason: "blocked by fixture"},
+	}))
+
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		OverrideDirs:    []string{overrideDir},
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err == nil {
+		t.Fatalf("expected compile to fail")
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-blocked-use")
+}
+
+func TestOverrideParityVerifierAllowsDeferredMissingExports(t *testing.T) {
+	result, err := compileParityFixture(t, map[string]overrideParityEntry{
+		"Present": {Status: overrideParityStatusReal},
+		"Missing": {Status: overrideParityStatusDeferred},
+	}, "export function Present(): void {}\n")
+	if err != nil {
+		t.Fatalf("compile failed: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func TestOverrideParityVerifierReportsDeferredAtPhaseClose(t *testing.T) {
+	owner := NewOverrideRegistryOwner()
+	facts, diagnostics := owner.Facts(context.Background())
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("override facts failed: %#v", diagnostics)
+	}
+
+	diagnostics = NewOverrideParityVerifier().VerifyNoDeferred(facts,
+		"net/http",
+		"net/http/httptest",
+		"encoding/json",
+		"mime",
+		"time",
+		"reflect",
+		"math/bits",
+		"strings",
+		"strconv",
+		"compress/zlib",
+		"io",
+		"go/scanner",
+		"hash",
+		"internal/goarch",
+		"os",
+		"runtime",
+		"runtime/pprof",
+		"runtime/trace",
+	)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("override ledgers still contain deferred entries: %#v", diagnostics)
+	}
+}
+
+func TestOverrideParityVerifierAcceptsPhase4Ledgers(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/phase4parity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import (",
+			"  \"compress/zlib\"",
+			"  \"encoding/json\"",
+			"  \"go/scanner\"",
+			"  \"hash\"",
+			"  \"io\"",
+			"  \"math/bits\"",
+			"  \"mime\"",
+			"  \"os\"",
+			"  \"reflect\"",
+			"  \"strconv\"",
+			"  \"strings\"",
+			"  \"time\"",
+			")",
+			"var _ = json.Valid",
+			"var _ = mime.TypeByExtension",
+			"var _ = time.RFC1123",
+			"var _ = reflect.VisibleFields",
+			"var _ = bits.Rem32",
+			"var _ = strings.ToValidUTF8",
+			"var _ = strconv.FormatComplex",
+			"var _ = zlib.NoCompression",
+			"var _ io.ReadSeekCloser",
+			"var _ = scanner.PrintError",
+			"var _ hash.XOF",
+			"var _ = os.ErrNoHandle",
+			"func main() {}",
+			"",
+		}, "\n"),
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatalf("compile failed: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func TestOverrideParityVerifierAllowsRealFuncOfUse(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/funcparity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"reflect\"",
+			"func main() {",
+			"  _ = reflect.FuncOf(nil, nil, false)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatalf("expected reflect.FuncOf use to compile: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func TestOverrideParityVerifierAllowsRealMakeFuncUse(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/makefuncparity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"reflect\"",
+			"func main() {",
+			"  typ := reflect.FuncOf(nil, nil, false)",
+			"  _ = reflect.MakeFunc(typ, func(args []reflect.Value) []reflect.Value { return nil })",
+			"}",
+			"",
+		}, "\n"),
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatalf("expected reflect.MakeFunc use to compile: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func TestOverrideParityVerifierAllowsRealStructOfUse(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/structofparity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"reflect\"",
+			"func main() {",
+			"  _ = reflect.StructOf([]reflect.StructField{{Name: \"Count\", Type: reflect.TypeFor[int]()}})",
+			"}",
+			"",
+		}, "\n"),
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatalf("expected reflect.StructOf use to compile: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func TestOverrideParityVerifierAllowsRealSliceAtUse(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/sliceatparity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import (",
+			"  \"reflect\"",
+			"  \"unsafe\"",
+			")",
+			"func main() {",
+			"  buf := []byte{1, 2, 3}",
+			"  _ = reflect.SliceAt(reflect.TypeFor[byte](), unsafe.Pointer(&buf[0]), len(buf))",
+			"}",
+			"",
+		}, "\n"),
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatalf("expected reflect.SliceAt use to compile: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func compileParityFixture(
+	t *testing.T,
+	symbols map[string]overrideParityEntry,
+	index string,
+) (*CompilationResult, error) {
+	t.Helper()
+
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/parity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/parity/lib\"",
+			"func main() { lib.Present() }",
+			"",
+		}, "\n"),
+		"lib/lib.go": strings.Join([]string{
+			"package lib",
+			"func Present() {}",
+			"func Missing() {}",
+			"",
+		}, "\n"),
+	})
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/parity/lib/index.ts", index)
+	writeFixtureFile(t, overrideDir, "example.test/parity/lib/parity.json", parityFixtureJSON(t, symbols))
+
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		OverrideDirs:    []string{overrideDir},
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	return comp.CompilePackages(context.Background(), ".")
+}
+
+func parityFixtureJSON(t *testing.T, symbols map[string]overrideParityEntry) string {
+	t.Helper()
+
+	var b strings.Builder
+	b.WriteString("{\"schemaVersion\":1,\"strict\":true,\"symbols\":{")
+	names := make([]string, 0, len(symbols))
+	for name := range symbols {
+		names = append(names, name)
+	}
+	slices.Sort(names)
+	for idx, name := range names {
+		if idx != 0 {
+			b.WriteByte(',')
+		}
+		entry := symbols[name]
+		b.WriteString(strconv.Quote(name))
+		b.WriteString(":{\"status\":")
+		b.WriteString(strconv.Quote(string(entry.Status)))
+		if entry.Reason != "" {
+			b.WriteString(",\"reason\":")
+			b.WriteString(strconv.Quote(entry.Reason))
+		}
+		b.WriteString("}")
+	}
+	b.WriteString("}}\n")
+	return b.String()
+}

package/compiler/package-graph.go

@@ -2,6 +2,7 @@ package compiler
 
 import (
 	"context"
+	"go/ast"
 	"os"
 	"slices"
 	"strings"
@@ -130,6 +131,15 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 		graph.RequestedPackagePaths = append(graph.RequestedPackagePaths, path)
 	}
 	slices.Sort(graph.RequestedPackagePaths)
+	samePackageTestVariants := make(map[string]bool)
+	if req.Tests {
+		for _, pkg := range pkgs {
+			if pkg == nil || pkg.ForTest == "" || strings.HasSuffix(pkg.Name, "_test") {
+				continue
+			}
+			samePackageTestVariants[pkg.ForTest] = true
+		}
+	}
 
 	var diagnostics []Diagnostic
 	seen := make(map[string]bool)
@@ -137,7 +147,7 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 		if isTestMainPackage(pkg) {
 			continue
 		}
-		o.collect(graph, pkg, req.DependencyMode, requested, overrideFacts, seen)
+		o.collect(graph, pkg, req.DependencyMode, requested, samePackageTestVariants, overrideFacts, seen)
 		diagnostics = append(diagnostics, packageDiagnostics(pkg)...)
 	}
 	slices.SortFunc(graph.Nodes, func(a, b *PackageGraphNode) int {
@@ -161,21 +171,33 @@ func (o *PackageGraphOwner) collect(
 	pkg *packages.Package,
 	mode DependencyMode,
 	requested map[string]bool,
+	samePackageTestVariants map[string]bool,
 	overrideFacts *OverrideFacts,
 	seen map[string]bool,
 ) {
 	if pkg == nil || seen[pkg.ID] {
 		return
 	}
+	path := packagePath(pkg)
+	if pkg.ForTest != "" && path != pkg.ForTest && !strings.HasSuffix(pkg.Name, "_test") && samePackageTestVariants[path] {
+		return
+	}
+	if pkg.ForTest == "" && samePackageTestVariants[path] {
+		return
+	}
 	if pkg.ForTest != "" && !requested[pkg.ForTest] {
 		if prod := pkg.Imports[pkg.ForTest]; prod != nil {
-			o.collect(graph, prod, mode, requested, overrideFacts, seen)
+			o.collect(graph, prod, mode, requested, samePackageTestVariants, overrideFacts, seen)
 		}
 		return
 	}
+	if graph.NodesByPackagePath[path] != nil {
+		return
+	}
 	seen[pkg.ID] = true
 
-	path := packagePath(pkg)
+	normalizePackageFileOrder(pkg)
+
 	node := newPackageGraphNode(pkg, requested[path], overrideFacts)
 	graph.Nodes = append(graph.Nodes, node)
 	graph.NodesByPackagePath[path] = node
@@ -190,7 +212,7 @@ func (o *PackageGraphOwner) collect(
 	}
 	slices.Sort(imports)
 	for _, importPath := range imports {
-		o.collect(graph, pkg.Imports[importPath], mode, requested, overrideFacts, seen)
+		o.collect(graph, pkg.Imports[importPath], mode, requested, samePackageTestVariants, overrideFacts, seen)
 	}
 }
 
@@ -223,6 +245,41 @@ func newPackageGraphNode(pkg *packages.Package, requested bool, overrideFacts *O
 	}
 }
 
+func normalizePackageFileOrder(pkg *packages.Package) {
+	if pkg == nil {
+		return
+	}
+	slices.Sort(pkg.GoFiles)
+	if len(pkg.Syntax) == len(pkg.CompiledGoFiles) {
+		type sourceFile struct {
+			name string
+			file *ast.File
+		}
+		files := make([]sourceFile, len(pkg.Syntax))
+		for idx, file := range pkg.Syntax {
+			files[idx] = sourceFile{name: pkg.CompiledGoFiles[idx], file: file}
+		}
+		slices.SortFunc(files, func(a, b sourceFile) int {
+			return strings.Compare(a.name, b.name)
+		})
+		for idx, file := range files {
+			pkg.CompiledGoFiles[idx] = file.name
+			pkg.Syntax[idx] = file.file
+		}
+		return
+	}
+	slices.Sort(pkg.CompiledGoFiles)
+	slices.SortFunc(pkg.Syntax, func(a, b *ast.File) int {
+		if pkg.Fset == nil {
+			return strings.Compare(a.Name.Name, b.Name.Name)
+		}
+		return strings.Compare(
+			pkg.Fset.Position(a.Package).Filename,
+			pkg.Fset.Position(b.Package).Filename,
+		)
+	})
+}
+
 func isTestMainPackage(pkg *packages.Package) bool {
 	return pkg != nil && pkg.ForTest == "" && pkg.Name == "main" && strings.HasSuffix(packagePath(pkg), ".test")
 }