goscript 0.0.84 → 0.1.0

package/compiler/package-graph.go

@@ -0,0 +1,231 @@
+package compiler
+
+import (
+	"context"
+	"os"
+	"sort"
+
+	gs "github.com/aperturerobotics/goscript"
+	"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
+	// 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{}
+
+// NewPackageGraphOwner creates the package graph owner.
+func NewPackageGraphOwner() *PackageGraphOwner {
+	return &PackageGraphOwner{}
+}
+
+// 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: append([]string(nil), req.BuildFlags...),
+		Tests:      false,
+		Mode: packages.NeedName |
+			packages.NeedFiles |
+			packages.NeedCompiledGoFiles |
+			packages.NeedImports |
+			packages.NeedDeps |
+			packages.NeedExportFile |
+			packages.NeedTypes |
+			packages.NeedSyntax |
+			packages.NeedTypesInfo |
+			packages.NeedTypesSizes |
+			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",
+		}}
+	}
+
+	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 {
+		path := packagePath(pkg)
+		requested[path] = true
+		graph.RequestedPackagePaths = append(graph.RequestedPackagePaths, path)
+	}
+	sort.Strings(graph.RequestedPackagePaths)
+
+	var diagnostics []Diagnostic
+	seen := make(map[string]bool)
+	for _, pkg := range pkgs {
+		o.collect(graph, pkg, req.DependencyMode, requested, 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
+		}
+		return graph.Nodes[i].PkgPath < graph.Nodes[j].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,
+	seen map[string]bool,
+) {
+	if pkg == nil || seen[pkg.ID] {
+		return
+	}
+	seen[pkg.ID] = true
+
+	path := packagePath(pkg)
+	node := newPackageGraphNode(pkg, requested[path])
+	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)
+	}
+	sort.Strings(imports)
+	for _, importPath := range imports {
+		o.collect(graph, pkg.Imports[importPath], mode, requested, seen)
+	}
+}
+
+func newPackageGraphNode(pkg *packages.Package, requested bool) *PackageGraphNode {
+	imports := make([]string, 0, len(pkg.Imports))
+	for importPath := range pkg.Imports {
+		imports = append(imports, importPath)
+	}
+	sort.Strings(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,
+		GoFiles:           append([]string(nil), pkg.GoFiles...),
+		CompiledGoFiles:   append([]string(nil), pkg.CompiledGoFiles...),
+		Imports:           imports,
+		Requested:         requested,
+		OverrideCandidate: hasOverrideCandidate(packagePath(pkg)),
+	}
+}
+
+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
+}
+
+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

@@ -0,0 +1,281 @@
+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 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"
+
+	if hasOverrideCandidate(parent) {
+		t.Fatalf("parent directory without an override index was detected as an override candidate")
+	}
+	if !hasOverrideCandidate(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/result.go

@@ -0,0 +1,13 @@
+package compiler
+
+// CompilationResult describes a compiler run after adapter normalization.
+type CompilationResult struct {
+	// CompiledPackages contains package paths compiled to TypeScript.
+	CompiledPackages []string
+	// CopiedPackages contains package paths copied from override packages.
+	CopiedPackages []string
+	// OriginalPackages contains the package patterns or package paths requested.
+	OriginalPackages []string
+	// Diagnostics contains all diagnostics produced by the compile request.
+	Diagnostics []Diagnostic
+}