goscript 0.1.0 → 0.1.1

package/compiler/package-graph.go

@@ -3,9 +3,9 @@ package compiler
 import (
 	"context"
 	"os"
-	"sort"
+	"slices"
+	"strings"
 
-	gs "github.com/aperturerobotics/goscript"
 	"golang.org/x/tools/go/packages"
 )
 
@@ -35,6 +35,8 @@ type PackageGraphNode struct {
 	ModulePath string
 	// ModuleDir is the owning module directory when known.
 	ModuleDir string
+	// ForTest is the package path under test for Go test variants.
+	ForTest string
 	// GoFiles are the package source files.
 	GoFiles []string
 	// CompiledGoFiles are files selected by build constraints.
@@ -48,11 +50,17 @@ type PackageGraphNode struct {
 }
 
 // PackageGraphOwner owns Go package loading and graph identity.
-type PackageGraphOwner struct{}
+type PackageGraphOwner struct {
+	overrideOwner *OverrideRegistryOwner
+}
 
 // NewPackageGraphOwner creates the package graph owner.
-func NewPackageGraphOwner() *PackageGraphOwner {
-	return &PackageGraphOwner{}
+func NewPackageGraphOwner(overrideOwners ...*OverrideRegistryOwner) *PackageGraphOwner {
+	overrideOwner := NewOverrideRegistryOwner()
+	if len(overrideOwners) != 0 && overrideOwners[0] != nil {
+		overrideOwner = overrideOwners[0]
+	}
+	return &PackageGraphOwner{overrideOwner: overrideOwner}
 }
 
 // Load builds the package graph for a validated request.
@@ -69,8 +77,8 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 		Context:    ctx,
 		Dir:        req.Dir,
 		Env:        append(os.Environ(), "GOOS=js", "GOARCH=wasm"),
-		BuildFlags: append([]string(nil), req.BuildFlags...),
-		Tests:      false,
+		BuildFlags: goScriptBuildFlags(req.BuildFlags),
+		Tests:      req.Tests,
 		Mode: packages.NeedName |
 			packages.NeedFiles |
 			packages.NeedCompiledGoFiles |
@@ -81,6 +89,7 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 			packages.NeedSyntax |
 			packages.NeedTypesInfo |
 			packages.NeedTypesSizes |
+			packages.NeedForTest |
 			packages.NeedModule,
 	}
 	pkgs, err := packages.Load(cfg, req.Patterns...)
@@ -99,6 +108,10 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 			Message:  "package patterns did not match any packages",
 		}}
 	}
+	overrideFacts, overrideDiagnostics := o.overrideOwner.Facts(ctx)
+	if diagnosticsHaveErrors(overrideDiagnostics) {
+		return nil, overrideDiagnostics
+	}
 
 	graph := &PackageGraph{
 		RequestedPatterns:     append([]string(nil), req.Patterns...),
@@ -109,23 +122,29 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 
 	requested := make(map[string]bool)
 	for _, pkg := range pkgs {
+		if isTestMainPackage(pkg) {
+			continue
+		}
 		path := packagePath(pkg)
 		requested[path] = true
 		graph.RequestedPackagePaths = append(graph.RequestedPackagePaths, path)
 	}
-	sort.Strings(graph.RequestedPackagePaths)
+	slices.Sort(graph.RequestedPackagePaths)
 
 	var diagnostics []Diagnostic
 	seen := make(map[string]bool)
 	for _, pkg := range pkgs {
-		o.collect(graph, pkg, req.DependencyMode, requested, seen)
+		if isTestMainPackage(pkg) {
+			continue
+		}
+		o.collect(graph, pkg, req.DependencyMode, requested, overrideFacts, seen)
 		diagnostics = append(diagnostics, packageDiagnostics(pkg)...)
 	}
-	sort.Slice(graph.Nodes, func(i, j int) bool {
-		if graph.Nodes[i].PkgPath == graph.Nodes[j].PkgPath {
-			return graph.Nodes[i].ID < graph.Nodes[j].ID
+	slices.SortFunc(graph.Nodes, func(a, b *PackageGraphNode) int {
+		if a.PkgPath == b.PkgPath {
+			return strings.Compare(a.ID, b.ID)
 		}
-		return graph.Nodes[i].PkgPath < graph.Nodes[j].PkgPath
+		return strings.Compare(a.PkgPath, b.PkgPath)
 	})
 	if len(graph.Nodes) == 0 {
 		diagnostics = append(diagnostics, Diagnostic{
@@ -142,15 +161,22 @@ func (o *PackageGraphOwner) collect(
 	pkg *packages.Package,
 	mode DependencyMode,
 	requested map[string]bool,
+	overrideFacts *OverrideFacts,
 	seen map[string]bool,
 ) {
 	if pkg == nil || seen[pkg.ID] {
 		return
 	}
+	if pkg.ForTest != "" && !requested[pkg.ForTest] {
+		if prod := pkg.Imports[pkg.ForTest]; prod != nil {
+			o.collect(graph, prod, mode, requested, overrideFacts, seen)
+		}
+		return
+	}
 	seen[pkg.ID] = true
 
 	path := packagePath(pkg)
-	node := newPackageGraphNode(pkg, requested[path])
+	node := newPackageGraphNode(pkg, requested[path], overrideFacts)
 	graph.Nodes = append(graph.Nodes, node)
 	graph.NodesByPackagePath[path] = node
 	graph.packagesByPath[path] = pkg
@@ -162,18 +188,18 @@ func (o *PackageGraphOwner) collect(
 	for importPath := range pkg.Imports {
 		imports = append(imports, importPath)
 	}
-	sort.Strings(imports)
+	slices.Sort(imports)
 	for _, importPath := range imports {
-		o.collect(graph, pkg.Imports[importPath], mode, requested, seen)
+		o.collect(graph, pkg.Imports[importPath], mode, requested, overrideFacts, seen)
 	}
 }
 
-func newPackageGraphNode(pkg *packages.Package, requested bool) *PackageGraphNode {
+func newPackageGraphNode(pkg *packages.Package, requested bool, overrideFacts *OverrideFacts) *PackageGraphNode {
 	imports := make([]string, 0, len(pkg.Imports))
 	for importPath := range pkg.Imports {
 		imports = append(imports, importPath)
 	}
-	sort.Strings(imports)
+	slices.Sort(imports)
 
 	var modulePath string
 	var moduleDir string
@@ -188,14 +214,19 @@ func newPackageGraphNode(pkg *packages.Package, requested bool) *PackageGraphNod
 		Name:              pkg.Name,
 		ModulePath:        modulePath,
 		ModuleDir:         moduleDir,
+		ForTest:           pkg.ForTest,
 		GoFiles:           append([]string(nil), pkg.GoFiles...),
 		CompiledGoFiles:   append([]string(nil), pkg.CompiledGoFiles...),
 		Imports:           imports,
 		Requested:         requested,
-		OverrideCandidate: hasOverrideCandidate(packagePath(pkg)),
+		OverrideCandidate: overrideFacts.HasPackage(packagePath(pkg)),
 	}
 }
 
+func isTestMainPackage(pkg *packages.Package) bool {
+	return pkg != nil && pkg.ForTest == "" && pkg.Name == "main" && strings.HasSuffix(packagePath(pkg), ".test")
+}
+
 func packagePath(pkg *packages.Package) string {
 	if pkg == nil {
 		return ""
@@ -221,11 +252,3 @@ func packageDiagnostics(pkg *packages.Package) []Diagnostic {
 	}
 	return diagnostics
 }
-
-func hasOverrideCandidate(pkgPath string) bool {
-	if pkgPath == "" {
-		return false
-	}
-	_, err := gs.GsOverrides.ReadFile("gs/" + pkgPath + "/index.ts")
-	return err == nil
-}

package/compiler/package-graph_test.go

@@ -176,6 +176,37 @@ func TestPackageGraphHonorsBuildFlags(t *testing.T) {
 	}
 }
 
+func TestPackageGraphAddsGoScriptBuildTag(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":       "module example.test/goscripttag\n\ngo 1.25.3\n",
+		"default.go":   "package goscripttag\nconst Selected = \"default\"\n",
+		"goscript.go":  "//go:build goscript\n\npackage goscripttag\nconst GoScript = true\n",
+		"excluded.go":  "//go:build !goscript\n\npackage goscripttag\nconst Excluded = true\n",
+		"customtag.go": "//go:build customtag\n\npackage goscripttag\nconst Custom = true\n",
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		BuildFlags:          []string{"-tags=customtag"},
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+
+	var compiled []string
+	for _, file := range graph.Nodes[0].CompiledGoFiles {
+		compiled = append(compiled, filepath.Base(file))
+	}
+	for _, expected := range []string{"default.go", "goscript.go", "customtag.go"} {
+		if !slices.Contains(compiled, expected) {
+			t.Fatalf("expected %s in compiled files: %v", expected, compiled)
+		}
+	}
+	if slices.Contains(compiled, "excluded.go") {
+		t.Fatalf("did not expect excluded.go in compiled files: %v", compiled)
+	}
+}
+
 func TestPackageGraphLoadsLocalReplacement(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": strings.Join([]string{
@@ -230,11 +261,15 @@ func TestPackageGraphDetectsOverrideCandidates(t *testing.T) {
 func TestPackageGraphOverrideCandidatesRequirePackageIndex(t *testing.T) {
 	parent := "github.com/aperturerobotics/wasivm/wazero/kernel"
 	child := parent + "/runtime"
+	facts, diagnostics := NewOverrideRegistryOwner().Facts(context.Background())
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("override facts failed: %#v", diagnostics)
+	}
 
-	if hasOverrideCandidate(parent) {
+	if facts.HasPackage(parent) {
 		t.Fatalf("parent directory without an override index was detected as an override candidate")
 	}
-	if !hasOverrideCandidate(child) {
+	if !facts.HasPackage(child) {
 		t.Fatalf("nested package with an override index was not detected as an override candidate")
 	}
 }

package/compiler/package-test-function.go

@@ -0,0 +1,9 @@
+package compiler
+
+// PackageTestFunction describes one discovered ordinary Go test function.
+type PackageTestFunction struct {
+	// Name is the Go TestXxx function name.
+	Name string
+	// PackagePath is the package variant that exports the function.
+	PackagePath string
+}

package/compiler/package-test-graph-package.go

@@ -0,0 +1,40 @@
+package compiler
+
+import "golang.org/x/tools/go/packages"
+
+// PackageTestGraphPackage describes one requested package under test.
+type PackageTestGraphPackage struct {
+	// PackagePath is the package under test.
+	PackagePath string
+	// PackageName is the base package name.
+	PackageName string
+	// PackageID is the go/packages package identity for the package under test.
+	PackageID string
+	// GoFiles are the package source files.
+	GoFiles []string
+	// CompiledGoFiles are files selected by build constraints.
+	CompiledGoFiles []string
+	// SamePackageTests is the same-package test variant when present.
+	SamePackageTests *PackageTestGraphVariant
+	// ExternalPackageTests is the external-package test variant when present.
+	ExternalPackageTests *PackageTestGraphVariant
+	// Diagnostics are package or variant load diagnostics attached to this package.
+	Diagnostics []Diagnostic
+}
+
+// HasTests returns true when the package has any loaded test variant.
+func (p *PackageTestGraphPackage) HasTests() bool {
+	return p != nil && (p.SamePackageTests != nil || p.ExternalPackageTests != nil)
+}
+
+func (p *PackageTestGraphPackage) appendDiagnostics(diagnostics []Diagnostic) {
+	p.Diagnostics = append(p.Diagnostics, diagnostics...)
+}
+
+func (p *PackageTestGraphPackage) setPackage(pkg *packages.Package) {
+	p.PackagePath = packagePath(pkg)
+	p.PackageName = pkg.Name
+	p.PackageID = pkg.ID
+	p.GoFiles = append([]string(nil), pkg.GoFiles...)
+	p.CompiledGoFiles = append([]string(nil), pkg.CompiledGoFiles...)
+}

package/compiler/package-test-graph-variant.go

@@ -0,0 +1,105 @@
+package compiler
+
+import (
+	"go/ast"
+	"go/types"
+	"slices"
+	"strings"
+	"unicode"
+
+	"golang.org/x/tools/go/packages"
+)
+
+// PackageTestGraphVariant describes one Go test package variant.
+type PackageTestGraphVariant struct {
+	// ID is the go/packages package identity.
+	ID string
+	// PkgPath is the stable Go package path for this variant.
+	PkgPath string
+	// Name is the Go package name for this variant.
+	Name string
+	// ForTest is the package path this variant tests.
+	ForTest string
+	// GoFiles are the package source files.
+	GoFiles []string
+	// CompiledGoFiles are files selected by build constraints.
+	CompiledGoFiles []string
+	// Imports are packages imported directly by this test variant.
+	Imports []string
+	// Diagnostics are load diagnostics attached to this variant.
+	Diagnostics []Diagnostic
+	// Tests are ordinary TestXxx functions discovered in this variant.
+	Tests []PackageTestFunction
+}
+
+func newPackageTestGraphVariant(pkg *packages.Package, diagnostics []Diagnostic) *PackageTestGraphVariant {
+	imports := make([]string, 0, len(pkg.Imports))
+	for importPath := range pkg.Imports {
+		imports = append(imports, importPath)
+	}
+	slices.Sort(imports)
+	return &PackageTestGraphVariant{
+		ID:              pkg.ID,
+		PkgPath:         packagePath(pkg),
+		Name:            pkg.Name,
+		ForTest:         pkg.ForTest,
+		GoFiles:         append([]string(nil), pkg.GoFiles...),
+		CompiledGoFiles: append([]string(nil), pkg.CompiledGoFiles...),
+		Imports:         imports,
+		Diagnostics:     append([]Diagnostic(nil), diagnostics...),
+		Tests:           discoverPackageTestFunctions(pkg),
+	}
+}
+
+func discoverPackageTestFunctions(pkg *packages.Package) []PackageTestFunction {
+	if pkg == nil {
+		return nil
+	}
+	var tests []PackageTestFunction
+	for _, file := range pkg.Syntax {
+		for _, decl := range file.Decls {
+			fn, ok := decl.(*ast.FuncDecl)
+			if !ok || fn.Recv != nil || !isTestName(fn.Name.Name) {
+				continue
+			}
+			obj, _ := pkg.TypesInfo.Defs[fn.Name].(*types.Func)
+			if !isOrdinaryTestFunc(obj) {
+				continue
+			}
+			tests = append(tests, PackageTestFunction{
+				Name:        fn.Name.Name,
+				PackagePath: packagePath(pkg),
+			})
+		}
+	}
+	return tests
+}
+
+func isOrdinaryTestFunc(fn *types.Func) bool {
+	if fn == nil {
+		return false
+	}
+	sig, _ := fn.Type().(*types.Signature)
+	if sig == nil || sig.Params().Len() != 1 || sig.Results().Len() != 0 {
+		return false
+	}
+	ptr, _ := sig.Params().At(0).Type().(*types.Pointer)
+	if ptr == nil {
+		return false
+	}
+	named, _ := ptr.Elem().(*types.Named)
+	if named == nil || named.Obj() == nil || named.Obj().Pkg() == nil {
+		return false
+	}
+	return named.Obj().Name() == "T" && named.Obj().Pkg().Path() == "testing"
+}
+
+func isTestName(name string) bool {
+	if !strings.HasPrefix(name, "Test") || name == "Test" {
+		return false
+	}
+	for _, r := range strings.TrimPrefix(name, "Test") {
+		return !unicode.IsLower(r)
+	}
+	return false
+}

package/compiler/package-test-graph.go

@@ -0,0 +1,117 @@
+package compiler
+
+import (
+	"context"
+	"os"
+	"slices"
+	"strings"
+
+	"golang.org/x/tools/go/packages"
+)
+
+// PackageTestGraph is the package-scoped graph used by GoScript test runners.
+type PackageTestGraph struct {
+	// RequestedPatterns are the package patterns from the compile request.
+	RequestedPatterns []string
+	// Packages are deterministic package-test facts keyed by package under test.
+	Packages []*PackageTestGraphPackage
+
+	packagesByPath map[string]*PackageTestGraphPackage
+}
+
+// PackageByPath returns the package facts for a package under test.
+func (g *PackageTestGraph) PackageByPath(path string) *PackageTestGraphPackage {
+	if g == nil {
+		return nil
+	}
+	return g.packagesByPath[path]
+}
+
+// LoadTestGraph builds package-scoped test graph facts for a validated request.
+func (o *PackageGraphOwner) LoadTestGraph(ctx context.Context, req *CompileRequest) (*PackageTestGraph, []Diagnostic) {
+	if err := ctx.Err(); err != nil {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/context:canceled",
+			Message:  err.Error(),
+		}}
+	}
+
+	cfg := &packages.Config{
+		Context:    ctx,
+		Dir:        req.Dir,
+		Env:        append(os.Environ(), "GOOS=js", "GOARCH=wasm"),
+		BuildFlags: goScriptBuildFlags(req.BuildFlags),
+		Tests:      true,
+		Mode: packages.NeedName |
+			packages.NeedFiles |
+			packages.NeedCompiledGoFiles |
+			packages.NeedImports |
+			packages.NeedDeps |
+			packages.NeedExportFile |
+			packages.NeedTypes |
+			packages.NeedSyntax |
+			packages.NeedTypesInfo |
+			packages.NeedTypesSizes |
+			packages.NeedForTest |
+			packages.NeedModule,
+	}
+	pkgs, err := packages.Load(cfg, req.Patterns...)
+	if err != nil {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/package-graph:load",
+			Message:  "failed to load Go test packages",
+			Detail:   err.Error(),
+		}}
+	}
+
+	graph := &PackageTestGraph{
+		RequestedPatterns: append([]string(nil), req.Patterns...),
+		packagesByPath:    make(map[string]*PackageTestGraphPackage),
+	}
+	var diagnostics []Diagnostic
+	for _, pkg := range pkgs {
+		if pkg == nil || isTestMainPackage(pkg) {
+			continue
+		}
+		pkgDiagnostics := packageDiagnostics(pkg)
+		diagnostics = append(diagnostics, pkgDiagnostics...)
+		if pkg.ForTest == "" {
+			facts := graph.packageFacts(packagePath(pkg))
+			facts.setPackage(pkg)
+			facts.appendDiagnostics(pkgDiagnostics)
+			continue
+		}
+		facts := graph.packageFacts(pkg.ForTest)
+		variant := newPackageTestGraphVariant(pkg, pkgDiagnostics)
+		if strings.HasSuffix(pkg.Name, "_test") {
+			facts.ExternalPackageTests = variant
+		} else {
+			facts.SamePackageTests = variant
+		}
+		facts.appendDiagnostics(pkgDiagnostics)
+	}
+	if len(graph.Packages) == 0 {
+		diagnostics = append(diagnostics, Diagnostic{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/package-graph:no-test-packages",
+			Message:  "package patterns did not match any test packages",
+		})
+	}
+	slices.SortFunc(graph.Packages, func(a, b *PackageTestGraphPackage) int {
+		return strings.Compare(a.PackagePath, b.PackagePath)
+	})
+	return graph, diagnostics
+}
+
+func (g *PackageTestGraph) packageFacts(path string) *PackageTestGraphPackage {
+	facts := g.packagesByPath[path]
+	if facts != nil {
+		return facts
+	}
+	facts = &PackageTestGraphPackage{PackagePath: path}
+	g.packagesByPath[path] = facts
+	g.Packages = append(g.Packages, facts)
+	return facts
+}

package/compiler/package-test-graph_test.go

@@ -0,0 +1,144 @@
+package compiler
+
+import (
+	"context"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestPackageGraphOwnerLoadTestGraphFacts(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/testgraph\n\ngo 1.25.3\n",
+		"same/value.go": strings.Join([]string{
+			"package same",
+			"",
+			"func Add(a int, b int) int {",
+			"\treturn a + b",
+			"}",
+			"",
+		}, "\n"),
+		"same/value_test.go": strings.Join([]string{
+			"package same",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestAdd(t *testing.T) {}",
+			"",
+		}, "\n"),
+		"external/value.go": strings.Join([]string{
+			"package external",
+			"",
+			"func Name() string {",
+			"\treturn \"external\"",
+			"}",
+			"",
+		}, "\n"),
+		"external/value_test.go": strings.Join([]string{
+			"package external_test",
+			"",
+			"import (",
+			"\t\"testing\"",
+			"",
+			"\texternal \"example.test/testgraph/external\"",
+			")",
+			"",
+			"func TestName(t *testing.T) {",
+			"\t_ = external.Name()",
+			"}",
+			"",
+		}, "\n"),
+		"notests/value.go": "package notests\nconst Value = 1\n",
+	})
+
+	graph, diagnostics := loadPackageTestGraph(t, &CompileRequest{
+		Patterns:            []string{"./..."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("test graph load failed: %#v", diagnostics)
+	}
+
+	if len(graph.Packages) != 3 {
+		t.Fatalf("expected three requested packages, got %#v", graph.Packages)
+	}
+	same := graph.PackageByPath("example.test/testgraph/same")
+	if same == nil || same.SamePackageTests == nil || same.ExternalPackageTests != nil || !same.HasTests() {
+		t.Fatalf("unexpected same-package facts: %#v", same)
+	}
+	external := graph.PackageByPath("example.test/testgraph/external")
+	if external == nil || external.ExternalPackageTests == nil || external.SamePackageTests != nil || !external.HasTests() {
+		t.Fatalf("unexpected external-package facts: %#v", external)
+	}
+	notests := graph.PackageByPath("example.test/testgraph/notests")
+	if notests == nil || notests.HasTests() {
+		t.Fatalf("unexpected no-test package facts: %#v", notests)
+	}
+}
+
+func TestPackageGraphOwnerLoadTestGraphScopesDiagnostics(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/testgraphdiag\n\ngo 1.25.3\n",
+		"clean/value.go": strings.Join([]string{
+			"package clean",
+			"",
+			"func Value() int {",
+			"\treturn 1",
+			"}",
+			"",
+		}, "\n"),
+		"clean/value_test.go": strings.Join([]string{
+			"package clean",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestValue(t *testing.T) {}",
+			"",
+		}, "\n"),
+		"broken/value.go": "package broken\nconst Value = 1\n",
+		"broken/value_test.go": strings.Join([]string{
+			"package broken",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestBroken(t *testing.T) {",
+			"\tMissing()",
+			"}",
+			"",
+		}, "\n"),
+	})
+
+	graph, diagnostics := loadPackageTestGraph(t, &CompileRequest{
+		Patterns:            []string{"./..."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	requireDiagnosticCode(t, diagnostics, "goscript/package-graph:load-error")
+
+	clean := graph.PackageByPath("example.test/testgraphdiag/clean")
+	if clean == nil || len(clean.Diagnostics) != 0 {
+		t.Fatalf("clean package should not inherit broken diagnostics: %#v", clean)
+	}
+	broken := graph.PackageByPath("example.test/testgraphdiag/broken")
+	if broken == nil || len(broken.Diagnostics) == 0 {
+		t.Fatalf("broken package should carry load diagnostics: %#v", broken)
+	}
+	if broken.SamePackageTests == nil || len(broken.SamePackageTests.Diagnostics) == 0 {
+		t.Fatalf("broken same-package test variant should carry diagnostics: %#v", broken)
+	}
+}
+
+func loadPackageTestGraph(t *testing.T, req *CompileRequest) (*PackageTestGraph, []Diagnostic) {
+	t.Helper()
+
+	diagnostics := NewCompileRequestOwner().Validate(req)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("request validation failed: %#v", diagnostics)
+	}
+	return NewPackageGraphOwner().LoadTestGraph(context.Background(), req)
+}