goscript 0.0.84 → 0.1.1

package/compiler/package-graph_test.go

@@ -0,0 +1,316 @@
+package compiler
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"testing"
+)
+
+func TestCompileRequestValidation(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":  "module example.test/request\n\ngo 1.25.3\n",
+		"main.go": "package main\nfunc main() {}\n",
+	})
+	owner := NewCompileRequestOwner()
+
+	tests := []struct {
+		name string
+		req  *CompileRequest
+		code string
+	}{
+		{
+			name: "empty package",
+			req: &CompileRequest{
+				Patterns:            []string{""},
+				Dir:                 moduleDir,
+				OutputPath:          filepath.Join(t.TempDir(), "out"),
+				DependencyMode:      DependencyModeRequested,
+				RuntimeEmissionMode: RuntimeEmissionModeEmit,
+			},
+			code: "goscript/request:empty-package",
+		},
+		{
+			name: "single file",
+			req: &CompileRequest{
+				Patterns:            []string{"main.go"},
+				Dir:                 moduleDir,
+				OutputPath:          filepath.Join(t.TempDir(), "out"),
+				DependencyMode:      DependencyModeRequested,
+				RuntimeEmissionMode: RuntimeEmissionModeEmit,
+			},
+			code: "goscript/request:single-file-unsupported",
+		},
+		{
+			name: "no output",
+			req: &CompileRequest{
+				Patterns:            []string{"."},
+				Dir:                 moduleDir,
+				DependencyMode:      DependencyModeRequested,
+				RuntimeEmissionMode: RuntimeEmissionModeEmit,
+			},
+			code: "goscript/request:no-output",
+		},
+		{
+			name: "no module",
+			req: &CompileRequest{
+				Patterns:            []string{"."},
+				Dir:                 t.TempDir(),
+				OutputPath:          filepath.Join(t.TempDir(), "out"),
+				DependencyMode:      DependencyModeRequested,
+				RuntimeEmissionMode: RuntimeEmissionModeEmit,
+			},
+			code: "goscript/request:no-module",
+		},
+		{
+			name: "empty build flag",
+			req: &CompileRequest{
+				Patterns:            []string{"."},
+				Dir:                 moduleDir,
+				OutputPath:          filepath.Join(t.TempDir(), "out"),
+				BuildFlags:          []string{" "},
+				DependencyMode:      DependencyModeRequested,
+				RuntimeEmissionMode: RuntimeEmissionModeEmit,
+			},
+			code: "goscript/request:empty-build-flag",
+		},
+		{
+			name: "dependency mode",
+			req: &CompileRequest{
+				Patterns:            []string{"."},
+				Dir:                 moduleDir,
+				OutputPath:          filepath.Join(t.TempDir(), "out"),
+				DependencyMode:      DependencyMode("invalid"),
+				RuntimeEmissionMode: RuntimeEmissionModeEmit,
+			},
+			code: "goscript/request:dependency-mode",
+		},
+		{
+			name: "runtime emission mode",
+			req: &CompileRequest{
+				Patterns:            []string{"."},
+				Dir:                 moduleDir,
+				OutputPath:          filepath.Join(t.TempDir(), "out"),
+				DependencyMode:      DependencyModeRequested,
+				RuntimeEmissionMode: RuntimeEmissionMode("invalid"),
+			},
+			code: "goscript/request:runtime-emission-mode",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			diagnostics := owner.Validate(tt.req)
+			requireDiagnosticCode(t, diagnostics, tt.code)
+		})
+	}
+}
+
+func TestPackageGraphLoadsRequestedPackage(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":  "module example.test/graph\n\ngo 1.25.3\n",
+		"main.go": "package main\nfunc main() {}\n",
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+
+	if len(graph.Nodes) != 1 {
+		t.Fatalf("expected one requested node, got %d", len(graph.Nodes))
+	}
+	node := graph.Nodes[0]
+	if node.PkgPath != "example.test/graph" || !node.Requested {
+		t.Fatalf("unexpected node: %#v", node)
+	}
+	if node.ModulePath != "example.test/graph" {
+		t.Fatalf("unexpected module path: %q", node.ModulePath)
+	}
+}
+
+func TestPackageGraphReportsLoadErrors(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":  "module example.test/loaderr\n\ngo 1.25.3\n",
+		"main.go": "package main\nimport \"missing.invalid/pkg\"\nfunc main() { _ = pkg.Value }\n",
+	})
+	_, diagnostics := NewPackageGraphOwner().Load(context.Background(), &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	requireDiagnosticCode(t, diagnostics, "goscript/package-graph:load-error")
+}
+
+func TestPackageGraphHonorsBuildFlags(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":      "module example.test/tags\n\ngo 1.25.3\n",
+		"default.go":  "package tags\nconst Selected = \"default\"\n",
+		"tagged.go":   "//go:build customtag\n\npackage tags\nconst Tagged = true\n",
+		"excluded.go": "//go:build !customtag\n\npackage tags\nconst Excluded = 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))
+	}
+	if !slices.Contains(compiled, "tagged.go") {
+		t.Fatalf("expected tagged.go in compiled files: %v", compiled)
+	}
+	if slices.Contains(compiled, "excluded.go") {
+		t.Fatalf("did not expect excluded.go in compiled files: %v", compiled)
+	}
+}
+
+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{
+			"module example.test/app",
+			"",
+			"go 1.25.3",
+			"",
+			"require example.test/lib v0.0.0",
+			"replace example.test/lib => ./lib",
+			"",
+		}, "\n"),
+		"main.go":       "package main\nimport \"example.test/lib\"\nfunc main() { lib.Value() }\n",
+		"lib/go.mod":    "module example.test/lib\n\ngo 1.25.3\n",
+		"lib/value.go":  "package lib\nfunc Value() int { return 1 }\n",
+		"lib/unused.go": "package lib\n",
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+
+	if graph.NodesByPackagePath["example.test/lib"] == nil {
+		t.Fatalf("expected local replacement dependency in graph")
+	}
+}
+
+func TestPackageGraphDetectsOverrideCandidates(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":  "module example.test/override\n\ngo 1.25.3\n",
+		"main.go": "package main\nimport \"fmt\"\nfunc main() { fmt.Println(\"ok\") }\n",
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+
+	node := graph.NodesByPackagePath["fmt"]
+	if node == nil {
+		t.Fatalf("expected fmt node in graph")
+	}
+	if !node.OverrideCandidate {
+		t.Fatalf("expected fmt to be detected as an override candidate")
+	}
+}
+
+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 facts.HasPackage(parent) {
+		t.Fatalf("parent directory without an override index was detected as an override candidate")
+	}
+	if !facts.HasPackage(child) {
+		t.Fatalf("nested package with an override index was not detected as an override candidate")
+	}
+}
+
+func loadPackageGraph(t *testing.T, req *CompileRequest) *PackageGraph {
+	t.Helper()
+
+	diagnostics := NewCompileRequestOwner().Validate(req)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("request validation failed: %#v", diagnostics)
+	}
+	graph, diagnostics := NewPackageGraphOwner().Load(context.Background(), req)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("package graph load failed: %#v", diagnostics)
+	}
+	return graph
+}
+
+func writePackageGraphFixture(t *testing.T, files map[string]string) string {
+	t.Helper()
+
+	dir := t.TempDir()
+	for name, contents := range files {
+		path := filepath.Join(dir, name)
+		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+			t.Fatal(err.Error())
+		}
+		if err := os.WriteFile(path, []byte(contents), 0o644); err != nil {
+			t.Fatal(err.Error())
+		}
+	}
+	return dir
+}
+
+func requireDiagnosticCode(t *testing.T, diagnostics []Diagnostic, code string) {
+	t.Helper()
+
+	for _, diagnostic := range diagnostics {
+		if diagnostic.Code == code {
+			return
+		}
+	}
+	t.Fatalf("missing diagnostic %q in %#v", code, diagnostics)
+}

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
+}