goscript 0.0.84 → 0.1.1

package/compiler/override-registry_test.go

@@ -0,0 +1,254 @@
+package compiler
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"testing"
+)
+
+func TestOverrideRegistryPlansRuntimeAndOverrideDependencies(t *testing.T) {
+	owner := NewOverrideRegistryOwner()
+	plan, diagnostics := owner.CopyPlan(context.Background(), &CompileRequest{
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	}, &PackageGraph{Nodes: []*PackageGraphNode{{
+		PkgPath:           "fmt",
+		OverrideCandidate: true,
+	}}})
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("copy plan failed: %#v", diagnostics)
+	}
+
+	var packages []string
+	for _, pkg := range plan.packages {
+		packages = append(packages, pkg.path)
+	}
+	for _, pkg := range []string{"builtin", "errors", "fmt"} {
+		if !slices.Contains(packages, pkg) {
+			t.Fatalf("missing %s in copy plan: %v", pkg, packages)
+		}
+	}
+	if slices.Index(packages, "errors") > slices.Index(packages, "fmt") {
+		t.Fatalf("dependency order is wrong: %v", packages)
+	}
+}
+
+func TestOverrideRegistryFactsAreImmutable(t *testing.T) {
+	owner := NewOverrideRegistryOwner()
+	facts, diagnostics := owner.Facts(context.Background())
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("override facts failed: %#v", diagnostics)
+	}
+
+	metadata := facts.Metadata("sync")
+	if !metadata.AsyncMethods["Map.Load"] {
+		t.Fatalf("expected sync Map.Load async metadata")
+	}
+	metadata.AsyncMethods["Map.Load"] = false
+	metadata.Dependencies = append(metadata.Dependencies, "mutated")
+
+	metadata = facts.Metadata("sync")
+	if !metadata.AsyncMethods["Map.Load"] {
+		t.Fatalf("override metadata mutation leaked back into facts")
+	}
+	if slices.Contains(metadata.Dependencies, "mutated") {
+		t.Fatalf("override dependency mutation leaked back into facts: %v", metadata.Dependencies)
+	}
+
+	pkg, dependencies, ok := facts.copyPackage("fmt")
+	if !ok {
+		t.Fatalf("missing fmt copy package facts")
+	}
+	if !slices.Contains(dependencies, "errors") {
+		t.Fatalf("expected fmt dependency on errors, got %v", dependencies)
+	}
+	dependencies = append(dependencies, "mutated")
+	if len(pkg.files) == 0 {
+		t.Fatalf("expected fmt copy files")
+	}
+	pkg.files[0].data[0] = '!'
+
+	pkg, dependencies, ok = facts.copyPackage("fmt")
+	if !ok {
+		t.Fatalf("missing fmt copy package facts after mutation")
+	}
+	if slices.Contains(dependencies, "mutated") {
+		t.Fatalf("copy dependency mutation leaked back into facts: %v", dependencies)
+	}
+	if len(pkg.files) == 0 || pkg.files[0].data[0] == '!' {
+		t.Fatalf("copy file mutation leaked back into facts")
+	}
+}
+
+func TestOverrideRegistryCopiesRuntimeAndOverrides(t *testing.T) {
+	owner := NewOverrideRegistryOwner()
+	req := &CompileRequest{
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	}
+	plan, diagnostics := owner.CopyPlan(context.Background(), req, &PackageGraph{Nodes: []*PackageGraphNode{{
+		PkgPath:           "fmt",
+		OverrideCandidate: true,
+	}}})
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("copy plan failed: %#v", diagnostics)
+	}
+	copied, diagnostics := owner.CopyPackages(context.Background(), req, plan)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("copy failed: %#v", diagnostics)
+	}
+	for _, pkg := range []string{"builtin", "errors", "fmt"} {
+		if !slices.Contains(copied, pkg) {
+			t.Fatalf("missing copied package %s in %v", pkg, copied)
+		}
+	}
+	for _, path := range []string{
+		"@goscript/builtin/index.ts",
+		"@goscript/errors/index.ts",
+		"@goscript/fmt/index.ts",
+	} {
+		if _, err := os.Stat(filepath.Join(req.OutputPath, filepath.FromSlash(path))); err != nil {
+			t.Fatalf("expected copied file %s: %v", path, err)
+		}
+	}
+	if _, err := os.Stat(filepath.Join(req.OutputPath, "@goscript", "fmt", "fmt.test.ts")); !os.IsNotExist(err) {
+		t.Fatalf("override copy should not include test files")
+	}
+}
+
+func TestOverrideRegistryReportsMissingOverridePackage(t *testing.T) {
+	_, diagnostics := NewOverrideRegistryOwner().CopyPlan(context.Background(), &CompileRequest{
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	}, &PackageGraph{Nodes: []*PackageGraphNode{{
+		PkgPath:           "does/not/exist",
+		OverrideCandidate: true,
+	}}})
+	requireDiagnosticCode(t, diagnostics, "goscript/overrides:missing-package")
+}
+
+func TestOverrideRegistryPlansOsOverrideDependencies(t *testing.T) {
+	owner := NewOverrideRegistryOwner()
+	plan, diagnostics := owner.CopyPlan(context.Background(), &CompileRequest{
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	}, &PackageGraph{Nodes: []*PackageGraphNode{{
+		PkgPath:           "os",
+		OverrideCandidate: true,
+	}}})
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("copy plan failed: %#v", diagnostics)
+	}
+
+	var packages []string
+	for _, pkg := range plan.packages {
+		packages = append(packages, pkg.path)
+	}
+	if !slices.Contains(packages, "os") {
+		t.Fatalf("missing os in copy plan: %v", packages)
+	}
+	if slices.Contains(packages, "internal/poll") {
+		t.Fatalf("os copy plan includes stale internal/poll dependency: %v", packages)
+	}
+}
+
+func TestOverrideRegistryPlansNestedOverrideMetadataDependencies(t *testing.T) {
+	owner := NewOverrideRegistryOwner()
+	plan, diagnostics := owner.CopyPlan(context.Background(), &CompileRequest{
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	}, &PackageGraph{Nodes: []*PackageGraphNode{{
+		PkgPath:           "github.com/aperturerobotics/wasivm/wazero/kernel/runtime/browser",
+		OverrideCandidate: true,
+	}}})
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("copy plan failed: %#v", diagnostics)
+	}
+
+	var packages []string
+	for _, pkg := range plan.packages {
+		packages = append(packages, pkg.path)
+	}
+
+	runtimePkg := "github.com/aperturerobotics/wasivm/wazero/kernel/runtime"
+	browserPkg := "github.com/aperturerobotics/wasivm/wazero/kernel/runtime/browser"
+	for _, pkg := range []string{"builtin", runtimePkg, browserPkg} {
+		if !slices.Contains(packages, pkg) {
+			t.Fatalf("missing %s in copy plan: %v", pkg, packages)
+		}
+	}
+	if slices.Index(packages, runtimePkg) > slices.Index(packages, browserPkg) {
+		t.Fatalf("nested override dependency order is wrong: %v", packages)
+	}
+}
+
+func TestCompilePackagesCopiesRuntimeOverrides(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":  "module example.test/overridecopy\n\ngo 1.25.3\n",
+		"main.go": "package main\nimport \"fmt\"\nfunc main() { fmt.Println(\"ok\") }\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())
+	}
+
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatalf("compile failed: %v\n%#v", err, result.Diagnostics)
+	}
+	for _, pkg := range []string{"builtin", "errors", "fmt"} {
+		if !slices.Contains(result.CopiedPackages, pkg) {
+			t.Fatalf("missing copied package %s in %#v", pkg, result.CopiedPackages)
+		}
+	}
+	for _, path := range []string{
+		"@goscript/example.test/overridecopy/main.gs.ts",
+		"@goscript/builtin/index.ts",
+		"@goscript/fmt/index.ts",
+	} {
+		if _, err := os.Stat(filepath.Join(out, filepath.FromSlash(path))); err != nil {
+			t.Fatalf("expected output file %s: %v", path, err)
+		}
+	}
+}
+
+func TestCompilePackagesAwaitsOverrideAsyncMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/overrideasync\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"sync\"",
+			"func main() {",
+			"  var m sync.Map",
+			"  if value, ok := m.Load(\"key\"); ok {",
+			"    println(value)",
+			"  }",
+			"}",
+			"",
+		}, "\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", "overrideasync", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !strings.Contains(string(content), "let [value, ok] = await m.value.Load(\"key\")") {
+		t.Fatalf("override async method call was not awaited:\n%s", string(content))
+	}
+}

package/compiler/package-graph.go

@@ -0,0 +1,254 @@
+package compiler
+
+import (
+	"context"
+	"os"
+	"slices"
+	"strings"
+
+	"golang.org/x/tools/go/packages"
+)
+
+// PackageGraph is the immutable package graph produced for a compile request.
+type PackageGraph struct {
+	// RequestedPatterns are the package patterns from the compile request.
+	RequestedPatterns []string
+	// RequestedPackagePaths are the loaded package paths for requested patterns.
+	RequestedPackagePaths []string
+	// Nodes are the deterministic package graph nodes.
+	Nodes []*PackageGraphNode
+	// NodesByPackagePath maps package path to graph node.
+	NodesByPackagePath map[string]*PackageGraphNode
+
+	packagesByPath map[string]*packages.Package
+}
+
+// PackageGraphNode is one package in the loaded graph.
+type PackageGraphNode struct {
+	// ID is the go/packages package identity.
+	ID string
+	// PkgPath is the stable Go package path.
+	PkgPath string
+	// Name is the Go package name.
+	Name string
+	// ModulePath is the owning module path when known.
+	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.
+	CompiledGoFiles []string
+	// Imports are imported package paths.
+	Imports []string
+	// Requested marks packages matched by request patterns.
+	Requested bool
+	// OverrideCandidate marks packages with a matching GoScript override package.
+	OverrideCandidate bool
+}
+
+// PackageGraphOwner owns Go package loading and graph identity.
+type PackageGraphOwner struct {
+	overrideOwner *OverrideRegistryOwner
+}
+
+// NewPackageGraphOwner creates the package graph owner.
+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.
+func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*PackageGraph, []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:      req.Tests,
+		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 packages",
+			Detail:   err.Error(),
+		}}
+	}
+	if len(pkgs) == 0 {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/package-graph:no-packages",
+			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...),
+		NodesByPackagePath:    make(map[string]*PackageGraphNode),
+		packagesByPath:        make(map[string]*packages.Package),
+		RequestedPackagePaths: make([]string, 0, len(pkgs)),
+	}
+
+	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)
+	}
+	slices.Sort(graph.RequestedPackagePaths)
+
+	var diagnostics []Diagnostic
+	seen := make(map[string]bool)
+	for _, pkg := range pkgs {
+		if isTestMainPackage(pkg) {
+			continue
+		}
+		o.collect(graph, pkg, req.DependencyMode, requested, overrideFacts, seen)
+		diagnostics = append(diagnostics, packageDiagnostics(pkg)...)
+	}
+	slices.SortFunc(graph.Nodes, func(a, b *PackageGraphNode) int {
+		if a.PkgPath == b.PkgPath {
+			return strings.Compare(a.ID, b.ID)
+		}
+		return strings.Compare(a.PkgPath, b.PkgPath)
+	})
+	if len(graph.Nodes) == 0 {
+		diagnostics = append(diagnostics, Diagnostic{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/package-graph:no-nodes",
+			Message:  "package graph did not contain any package nodes",
+		})
+	}
+	return graph, diagnostics
+}
+
+func (o *PackageGraphOwner) collect(
+	graph *PackageGraph,
+	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], overrideFacts)
+	graph.Nodes = append(graph.Nodes, node)
+	graph.NodesByPackagePath[path] = node
+	graph.packagesByPath[path] = pkg
+
+	if mode != DependencyModeAll || node.OverrideCandidate {
+		return
+	}
+	imports := make([]string, 0, len(pkg.Imports))
+	for importPath := range pkg.Imports {
+		imports = append(imports, importPath)
+	}
+	slices.Sort(imports)
+	for _, importPath := range imports {
+		o.collect(graph, pkg.Imports[importPath], mode, requested, overrideFacts, seen)
+	}
+}
+
+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)
+	}
+	slices.Sort(imports)
+
+	var modulePath string
+	var moduleDir string
+	if pkg.Module != nil {
+		modulePath = pkg.Module.Path
+		moduleDir = pkg.Module.Dir
+	}
+
+	return &PackageGraphNode{
+		ID:                pkg.ID,
+		PkgPath:           packagePath(pkg),
+		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: 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 ""
+	}
+	if pkg.PkgPath != "" {
+		return pkg.PkgPath
+	}
+	return pkg.ID
+}
+
+func packageDiagnostics(pkg *packages.Package) []Diagnostic {
+	if pkg == nil || len(pkg.Errors) == 0 {
+		return nil
+	}
+	diagnostics := make([]Diagnostic, 0, len(pkg.Errors))
+	for _, pkgErr := range pkg.Errors {
+		diagnostics = append(diagnostics, Diagnostic{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/package-graph:load-error",
+			Message:  "Go package contains load errors",
+			Detail:   pkgErr.Msg,
+		})
+	}
+	return diagnostics
+}