goscript 0.0.84 → 0.1.1

package/compiler/override-facts.go

@@ -0,0 +1,307 @@
+package compiler
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"io"
+	"io/fs"
+	"maps"
+	"path"
+	"slices"
+	"strings"
+
+	gs "github.com/aperturerobotics/goscript"
+	jsoniter "github.com/aperturerobotics/json-iterator-lite"
+)
+
+// OverrideFacts is the immutable compiler-visible view of GoScript overrides.
+type OverrideFacts struct {
+	packages map[string]overridePackageFacts
+}
+
+type overridePackageFacts struct {
+	metadata     OverrideMetadata
+	copyPackage  overrideCopyPackage
+	dependencies []string
+}
+
+// HasPackage returns true when pkgPath has a GoScript override package.
+func (f *OverrideFacts) HasPackage(pkgPath string) bool {
+	if f == nil || pkgPath == "" {
+		return false
+	}
+	_, ok := f.packages[pkgPath]
+	return ok
+}
+
+// Metadata returns compiler-visible override metadata for a package path.
+func (f *OverrideFacts) Metadata(pkgPath string) OverrideMetadata {
+	if f == nil {
+		return newOverrideMetadata()
+	}
+	pkg := f.packages[pkgPath]
+	return cloneOverrideMetadata(pkg.metadata)
+}
+
+// IsMethodAsync returns true when override metadata marks a method async.
+func (f *OverrideFacts) IsMethodAsync(pkgPath, method string) bool {
+	if f == nil {
+		return false
+	}
+	pkg := f.packages[pkgPath]
+	return pkg.metadata.AsyncMethods[method]
+}
+
+// IsFunctionAsync returns true when override metadata marks a package-level function async.
+func (f *OverrideFacts) IsFunctionAsync(pkgPath, function string) bool {
+	if f == nil {
+		return false
+	}
+	pkg := f.packages[pkgPath]
+	return pkg.metadata.AsyncFunctions[function]
+}
+
+func (f *OverrideFacts) copyPackage(pkgPath string) (overrideCopyPackage, []string, bool) {
+	if f == nil {
+		return overrideCopyPackage{}, nil, false
+	}
+	pkg, ok := f.packages[pkgPath]
+	if !ok {
+		return overrideCopyPackage{}, nil, false
+	}
+	return cloneOverrideCopyPackage(pkg.copyPackage), slices.Clone(pkg.dependencies), true
+}
+
+func (f *OverrideFacts) importPackageRoot(importPath string) (string, bool) {
+	if f == nil {
+		return "", false
+	}
+	importPath = strings.TrimPrefix(importPath, "@goscript/")
+	importPath = strings.TrimSuffix(importPath, ".js")
+	importPath = strings.TrimSuffix(importPath, ".ts")
+	if before, ok := strings.CutSuffix(importPath, "/index"); ok {
+		importPath = before
+	}
+	parts := strings.Split(importPath, "/")
+	for idx := len(parts); idx > 0; idx-- {
+		candidate := strings.Join(parts[:idx], "/")
+		if f.HasPackage(candidate) {
+			return candidate, true
+		}
+	}
+	return "", false
+}
+
+func buildOverrideFacts(ctx context.Context) (*OverrideFacts, []Diagnostic) {
+	roots, err := discoverOverridePackageRoots()
+	if err != nil {
+		return nil, []Diagnostic{overrideError("discover override packages", "", err)}
+	}
+	paths := make([]string, 0, len(roots))
+	for pkgPath := range roots {
+		paths = append(paths, pkgPath)
+	}
+	slices.Sort(paths)
+
+	facts := &OverrideFacts{packages: make(map[string]overridePackageFacts, len(paths))}
+	var diagnostics []Diagnostic
+	for _, pkgPath := range paths {
+		if err := ctx.Err(); err != nil {
+			return facts, []Diagnostic{contextCanceledDiagnostic(err)}
+		}
+		metadata, err := loadOverrideMetadata(pkgPath)
+		if err != nil {
+			diagnostics = append(diagnostics, overrideError("read override metadata", pkgPath, err))
+			continue
+		}
+		copyPackage, dependencies, packageDiagnostics := loadOverrideCopyPackage(pkgPath, roots, metadata)
+		diagnostics = append(diagnostics, packageDiagnostics...)
+		if diagnosticsHaveErrors(packageDiagnostics) {
+			continue
+		}
+		facts.packages[pkgPath] = overridePackageFacts{
+			metadata:     cloneOverrideMetadata(metadata),
+			copyPackage:  copyPackage,
+			dependencies: dependencies,
+		}
+	}
+	if diagnosticsHaveErrors(diagnostics) {
+		return facts, diagnostics
+	}
+	return facts, diagnostics
+}
+
+func discoverOverridePackageRoots() (map[string]bool, error) {
+	roots := make(map[string]bool)
+	if err := fs.WalkDir(gs.GsOverrides, "gs", func(filePath string, entry fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if entry.IsDir() || path.Base(filePath) != "index.ts" {
+			return nil
+		}
+		pkgPath := strings.TrimPrefix(path.Dir(filePath), "gs/")
+		if pkgPath != "." && pkgPath != "" {
+			roots[pkgPath] = true
+		}
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+	return roots, nil
+}
+
+func loadOverrideMetadata(pkgPath string) (OverrideMetadata, error) {
+	metadata := newOverrideMetadata()
+	data, err := gs.GsOverrides.ReadFile("gs/" + pkgPath + "/meta.json")
+	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			return metadata, nil
+		}
+		return OverrideMetadata{}, err
+	}
+
+	iter := jsoniter.ParseBytes(data)
+	for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
+		switch field {
+		case "dependencies":
+			for iter.ReadArray() {
+				metadata.Dependencies = append(metadata.Dependencies, iter.ReadString())
+			}
+		case "asyncMethods":
+			for method := iter.ReadObject(); method != ""; method = iter.ReadObject() {
+				metadata.AsyncMethods[method] = iter.ReadBool()
+			}
+		case "asyncFunctions":
+			for function := iter.ReadObject(); function != ""; function = iter.ReadObject() {
+				metadata.AsyncFunctions[function] = iter.ReadBool()
+			}
+		default:
+			iter.Skip()
+		}
+	}
+	if iter.Error != nil && !errors.Is(iter.Error, io.EOF) {
+		return OverrideMetadata{}, iter.Error
+	}
+	return metadata, nil
+}
+
+func loadOverrideCopyPackage(
+	pkgPath string,
+	roots map[string]bool,
+	metadata OverrideMetadata,
+) (overrideCopyPackage, []string, []Diagnostic) {
+	if !roots[pkgPath] {
+		return overrideCopyPackage{}, nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/overrides:missing-package",
+			Message:  "override package does not exist",
+			Detail:   pkgPath,
+		}}
+	}
+
+	facts := &OverrideFacts{packages: make(map[string]overridePackageFacts, len(roots))}
+	for root := range roots {
+		facts.packages[root] = overridePackageFacts{}
+	}
+
+	copyPackage := overrideCopyPackage{path: pkgPath}
+	dependencySet := make(map[string]bool)
+	for _, dependency := range metadata.Dependencies {
+		dependency = strings.TrimSpace(dependency)
+		if dependency != "" && dependency != pkgPath {
+			dependencySet[dependency] = true
+		}
+	}
+
+	root := "gs/" + pkgPath
+	err := fs.WalkDir(gs.GsOverrides, root, func(filePath string, entry fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		if entry.IsDir() {
+			nestedPkg := strings.TrimPrefix(filePath, "gs/")
+			if nestedPkg != pkgPath && roots[nestedPkg] {
+				return fs.SkipDir
+			}
+			return nil
+		}
+		if !isOverrideSourceFile(filePath) {
+			return nil
+		}
+		data, readErr := gs.GsOverrides.ReadFile(filePath)
+		if readErr != nil {
+			return readErr
+		}
+		rel := strings.TrimPrefix(filePath, "gs/")
+		copyPackage.files = append(copyPackage.files, overrideCopyFile{
+			path: rel,
+			data: data,
+		})
+		for _, imported := range scanOverrideImports(string(data)) {
+			dependency, ok := facts.importPackageRoot(imported)
+			if ok && dependency != "builtin" && dependency != pkgPath {
+				dependencySet[dependency] = true
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return overrideCopyPackage{}, nil, []Diagnostic{overrideError("read override package", pkgPath, err)}
+	}
+
+	if len(copyPackage.files) == 0 {
+		return overrideCopyPackage{}, nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/overrides:empty-package",
+			Message:  "override package does not contain TypeScript source files",
+			Detail:   pkgPath,
+		}}
+	}
+	slices.SortFunc(copyPackage.files, func(a, b overrideCopyFile) int {
+		return strings.Compare(a.path, b.path)
+	})
+
+	dependencies := make([]string, 0, len(dependencySet))
+	for dependency := range dependencySet {
+		dependencies = append(dependencies, dependency)
+	}
+	slices.Sort(dependencies)
+	return copyPackage, dependencies, nil
+}
+
+func newOverrideMetadata() OverrideMetadata {
+	return OverrideMetadata{
+		AsyncFunctions: make(map[string]bool),
+		AsyncMethods:   make(map[string]bool),
+	}
+}
+
+func cloneOverrideMetadata(metadata OverrideMetadata) OverrideMetadata {
+	return OverrideMetadata{
+		Dependencies:   slices.Clone(metadata.Dependencies),
+		AsyncFunctions: cloneBoolMap(metadata.AsyncFunctions),
+		AsyncMethods:   cloneBoolMap(metadata.AsyncMethods),
+	}
+}
+
+func cloneBoolMap(values map[string]bool) map[string]bool {
+	cloned := make(map[string]bool, len(values))
+	maps.Copy(cloned, values)
+	return cloned
+}
+
+func cloneOverrideCopyPackage(pkg overrideCopyPackage) overrideCopyPackage {
+	cloned := overrideCopyPackage{
+		path:  pkg.path,
+		files: make([]overrideCopyFile, 0, len(pkg.files)),
+	}
+	for _, file := range pkg.files {
+		cloned.files = append(cloned.files, overrideCopyFile{
+			path: file.path,
+			data: bytes.Clone(file.data),
+		})
+	}
+	return cloned
+}

package/compiler/override-registry.go

@@ -0,0 +1,283 @@
+package compiler
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+)
+
+// OverrideMetadata describes compiler-visible facts from a package override.
+type OverrideMetadata struct {
+	// Dependencies are override package dependencies.
+	Dependencies []string
+	// AsyncFunctions maps package-level function names to async status.
+	AsyncFunctions map[string]bool
+	// AsyncMethods maps Type.Method keys to async status.
+	AsyncMethods map[string]bool
+}
+
+// OverrideRegistryOwner owns GoScript override package metadata and copy plans.
+type OverrideRegistryOwner struct {
+	facts *OverrideFacts
+}
+
+// NewOverrideRegistryOwner creates the override registry owner.
+func NewOverrideRegistryOwner() *OverrideRegistryOwner {
+	return &OverrideRegistryOwner{}
+}
+
+// Facts returns the immutable compiler-visible override facts.
+func (o *OverrideRegistryOwner) Facts(ctx context.Context) (*OverrideFacts, []Diagnostic) {
+	if o == nil {
+		o = NewOverrideRegistryOwner()
+	}
+	if o.facts != nil {
+		return o.facts, nil
+	}
+	facts, diagnostics := buildOverrideFacts(ctx)
+	if diagnosticsHaveErrors(diagnostics) {
+		return facts, diagnostics
+	}
+	o.facts = facts
+	return facts, diagnostics
+}
+
+// Metadata returns compiler-visible override metadata for a package path.
+func (o *OverrideRegistryOwner) Metadata(pkgPath string) (*OverrideMetadata, error) {
+	facts, diagnostics := o.Facts(context.Background())
+	if diagnosticsHaveErrors(diagnostics) {
+		return nil, NewCompileError(diagnostics)
+	}
+	metadata := facts.Metadata(pkgPath)
+	return &metadata, nil
+}
+
+// CopyPlan builds the ordered override package copy plan for a request.
+func (o *OverrideRegistryOwner) CopyPlan(
+	ctx context.Context,
+	req *CompileRequest,
+	graph *PackageGraph,
+) (*overrideCopyPlan, []Diagnostic) {
+	if o == nil {
+		o = NewOverrideRegistryOwner()
+	}
+	if err := ctx.Err(); err != nil {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/context:canceled",
+			Message:  err.Error(),
+		}}
+	}
+	plan := &overrideCopyPlan{}
+	if req == nil || req.RuntimeEmissionMode == RuntimeEmissionModeReference {
+		return plan, nil
+	}
+	if graph == nil {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/overrides:no-graph",
+			Message:  "override copy planning requires a package graph",
+		}}
+	}
+	facts, diagnostics := o.Facts(ctx)
+	if diagnosticsHaveErrors(diagnostics) {
+		return nil, diagnostics
+	}
+
+	visiting := make(map[string]bool)
+	visited := make(map[string]bool)
+	diagnostics = append(diagnostics, o.addPackageToPlan(ctx, facts, plan, "builtin", visiting, visited)...)
+	for _, node := range graph.Nodes {
+		if node.OverrideCandidate {
+			diagnostics = append(diagnostics, o.addPackageToPlan(ctx, facts, plan, node.PkgPath, visiting, visited)...)
+		}
+	}
+	if diagnosticsHaveErrors(diagnostics) {
+		return nil, diagnostics
+	}
+	return plan, diagnostics
+}
+
+// CopyPackages writes override packages from a copy plan to the request output tree.
+func (o *OverrideRegistryOwner) CopyPackages(
+	ctx context.Context,
+	req *CompileRequest,
+	plan *overrideCopyPlan,
+) ([]string, []Diagnostic) {
+	if err := ctx.Err(); err != nil {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/context:canceled",
+			Message:  err.Error(),
+		}}
+	}
+	if req == nil {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/overrides:no-request",
+			Message:  "override package copying requires a compile request",
+		}}
+	}
+	if plan == nil || len(plan.packages) == 0 {
+		return nil, nil
+	}
+
+	var copied []string
+	var diagnostics []Diagnostic
+	for _, pkg := range plan.packages {
+		if err := ctx.Err(); err != nil {
+			diagnostics = append(diagnostics, Diagnostic{
+				Severity: DiagnosticSeverityError,
+				Code:     "goscript/context:canceled",
+				Message:  err.Error(),
+			})
+			break
+		}
+		for _, file := range pkg.files {
+			dest := filepath.Join(req.OutputPath, "@goscript", filepath.FromSlash(file.path))
+			if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
+				diagnostics = append(diagnostics, overrideError("create override output", file.path, err))
+				continue
+			}
+			if err := os.WriteFile(dest, file.data, 0o644); err != nil {
+				diagnostics = append(diagnostics, overrideError("write override file", file.path, err))
+			}
+		}
+		copied = append(copied, pkg.path)
+	}
+	if diagnosticsHaveErrors(diagnostics) {
+		return copied, diagnostics
+	}
+	return copied, diagnostics
+}
+
+// IsMethodAsync returns true when override metadata marks a method async.
+func (o *OverrideRegistryOwner) IsMethodAsync(pkgPath, method string) (bool, error) {
+	facts, diagnostics := o.Facts(context.Background())
+	if diagnosticsHaveErrors(diagnostics) {
+		return false, NewCompileError(diagnostics)
+	}
+	return facts.IsMethodAsync(pkgPath, method), nil
+}
+
+// IsFunctionAsync returns true when override metadata marks a package-level function async.
+func (o *OverrideRegistryOwner) IsFunctionAsync(pkgPath, function string) (bool, error) {
+	facts, diagnostics := o.Facts(context.Background())
+	if diagnosticsHaveErrors(diagnostics) {
+		return false, NewCompileError(diagnostics)
+	}
+	return facts.IsFunctionAsync(pkgPath, function), nil
+}
+
+type overrideCopyPlan struct {
+	packages []overrideCopyPackage
+}
+
+type overrideCopyPackage struct {
+	path  string
+	files []overrideCopyFile
+}
+
+type overrideCopyFile struct {
+	path string
+	data []byte
+}
+
+func (o *OverrideRegistryOwner) addPackageToPlan(
+	ctx context.Context,
+	facts *OverrideFacts,
+	plan *overrideCopyPlan,
+	pkgPath string,
+	visiting map[string]bool,
+	visited map[string]bool,
+) []Diagnostic {
+	if err := ctx.Err(); err != nil {
+		return []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/context:canceled",
+			Message:  err.Error(),
+		}}
+	}
+	if visited[pkgPath] {
+		return nil
+	}
+	if visiting[pkgPath] {
+		return []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/overrides:dependency-cycle",
+			Message:  "override package dependencies contain a cycle",
+			Detail:   pkgPath,
+		}}
+	}
+
+	pkg, dependencies, ok := facts.copyPackage(pkgPath)
+	if !ok {
+		return []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/overrides:missing-package",
+			Message:  "override package does not exist",
+			Detail:   pkgPath,
+		}}
+	}
+	visiting[pkgPath] = true
+	var diagnostics []Diagnostic
+	for _, dependency := range dependencies {
+		diagnostics = append(diagnostics, o.addPackageToPlan(ctx, facts, plan, dependency, visiting, visited)...)
+	}
+	delete(visiting, pkgPath)
+	if diagnosticsHaveErrors(diagnostics) {
+		return diagnostics
+	}
+
+	visited[pkgPath] = true
+	plan.packages = append(plan.packages, pkg)
+	return diagnostics
+}
+
+func isOverrideSourceFile(filePath string) bool {
+	return strings.HasSuffix(filePath, ".ts") && !strings.HasSuffix(filePath, ".test.ts")
+}
+
+func scanOverrideImports(data string) []string {
+	imports := make(map[string]bool)
+	for line := range strings.SplitSeq(data, "\n") {
+		line = strings.TrimSpace(line)
+		if strings.HasPrefix(line, "//") {
+			continue
+		}
+		for _, quote := range []string{"\"", "'"} {
+			prefix := quote + "@goscript/"
+			remaining := line
+			for {
+				idx := strings.Index(remaining, prefix)
+				if idx < 0 {
+					break
+				}
+				remaining = remaining[idx+len(quote):]
+				end := strings.Index(remaining, quote)
+				if end < 0 {
+					break
+				}
+				imports[remaining[:end]] = true
+				remaining = remaining[end+len(quote):]
+			}
+		}
+	}
+	result := make([]string, 0, len(imports))
+	for imported := range imports {
+		result = append(result, imported)
+	}
+	slices.Sort(result)
+	return result
+}
+
+func overrideError(action, detail string, err error) Diagnostic {
+	return Diagnostic{
+		Severity: DiagnosticSeverityError,
+		Code:     "goscript/overrides:io",
+		Message:  "failed to " + action,
+		Detail:   strings.TrimSpace(detail + " " + err.Error()),
+	}
+}