goscript 0.2.3 → 0.2.5

package/compiler/lowering_bench_test.go

@@ -47,6 +47,8 @@ func BenchmarkLoweringPackage(b *testing.B) {
 			fixture.model,
 			fixture.semPkg,
 			make(map[string]map[types.Object]bool),
+			make(map[*types.Func]bool),
+			make(map[*types.Func]bool),
 			make(runtimeMethodSetCache),
 			LoweringOptions{},
 		); diagnosticsHaveErrors(diagnostics) {
@@ -86,6 +88,8 @@ func BenchmarkLoweringFile(b *testing.B) {
 			fixture.file.outputNames,
 			fixture.file.lazyPackageVars,
 			fixture.lazyPackageVarsByPkg,
+			make(map[*types.Func]bool),
+			make(map[*types.Func]bool),
 			make(runtimeMethodSetCache),
 			false,
 			"",

package/compiler/override-facts.go

@@ -13,8 +13,8 @@ import (
 	"slices"
 	"strings"
 
-	gs "github.com/aperturerobotics/goscript"
 	jsoniter "github.com/aperturerobotics/json-iterator-lite"
+	gs "github.com/s4wave/goscript"
 )
 
 // OverrideFacts is the immutable compiler-visible view of GoScript overrides.

package/compiler/override-registry_test.go

@@ -488,6 +488,131 @@ func TestCompilePackagesAwaitsOverrideAsyncFunctions(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesAwaitsIOFSStatOverride(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/iofsstat\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"io/fs\"",
+			"type memFS struct{}",
+			"func (memFS) Open(name string) (fs.File, error) { return nil, fs.ErrNotExist }",
+			"func Use(fsys fs.FS) error {",
+			"  _, err := fs.Stat(fsys, \"pkg\")",
+			"  return err",
+			"}",
+			"func main() { _ = Use(memFS{}) }",
+			"",
+		}, "\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", "iofsstat", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "export async function Use(") {
+		t.Fatalf("fs.Stat caller was not marked async:\n%s", text)
+	}
+	if !strings.Contains(text, "await fs.Stat(") {
+		t.Fatalf("io/fs Stat override call was not awaited:\n%s", text)
+	}
+}
+
+func TestCompilePackagesAwaitsIOFSLstatOverride(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/iofslstat\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"io/fs\"",
+			"type memFS struct{}",
+			"func (memFS) Open(name string) (fs.File, error) { return nil, fs.ErrNotExist }",
+			"func Use(fsys fs.FS) error {",
+			"  _, err := fs.Lstat(fsys, \"pkg\")",
+			"  return err",
+			"}",
+			"func main() { _ = Use(memFS{}) }",
+			"",
+		}, "\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", "iofslstat", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "export async function Use(") {
+		t.Fatalf("fs.Lstat caller was not marked async:\n%s", text)
+	}
+	if !strings.Contains(text, "await fs.Lstat(") {
+		t.Fatalf("io/fs Lstat override call was not awaited:\n%s", text)
+	}
+}
+
+func TestCompilePackagesAwaitsIOFSSubOverride(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/iofssub\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"io/fs\"",
+			"type memFS struct{}",
+			"func (memFS) Open(name string) (fs.File, error) { return nil, fs.ErrNotExist }",
+			"func Use(fsys fs.FS) (fs.FS, error) {",
+			"  return fs.Sub(fsys, \"pkg\")",
+			"}",
+			"func main() { _, _ = Use(memFS{}) }",
+			"",
+		}, "\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", "iofssub", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "export async function Use(") {
+		t.Fatalf("fs.Sub caller was not marked async:\n%s", text)
+	}
+	if !strings.Contains(text, "return await fs.Sub(") {
+		t.Fatalf("io/fs Sub override call was not awaited:\n%s", text)
+	}
+}
+
 func TestCompilePackagesAwaitsAsyncSlicesSortFuncComparator(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/slicesasyncsort\n\ngo 1.25.3\n",

package/compiler/package-graph.go

@@ -5,6 +5,7 @@ import (
 	"go/ast"
 	"os"
 	"slices"
+	"strconv"
 	"strings"
 
 	"golang.org/x/tools/go/packages"
@@ -163,6 +164,9 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 			Message:  "package graph did not contain any package nodes",
 		})
 	}
+	if len(req.PackageBlocklist) != 0 {
+		diagnostics = append(diagnostics, packageBlocklistDiagnostics(graph, req.PackageBlocklist)...)
+	}
 	return graph, diagnostics
 }
 
@@ -245,6 +249,94 @@ func newPackageGraphNode(pkg *packages.Package, requested bool, overrideFacts *O
 	}
 }
 
+func packageBlocklistDiagnostics(graph *PackageGraph, blocklist []string) []Diagnostic {
+	chain := packageBlocklistChain(graph, blocklist)
+	if len(chain) == 0 {
+		return nil
+	}
+	blocked := chain[len(chain)-1]
+	return []Diagnostic{{
+		Severity: DiagnosticSeverityError,
+		Code:     "goscript/package-graph:blocklisted-package",
+		Message:  "package graph contains blocklisted package " + strconv.Quote(blocked),
+		Detail:   "import chain: " + strings.Join(chain, " -> "),
+	}}
+}
+
+func packageBlocklistChain(graph *PackageGraph, blocklist []string) []string {
+	if graph == nil || len(graph.RequestedPackagePaths) == 0 {
+		return nil
+	}
+
+	roots := slices.Clone(graph.RequestedPackagePaths)
+	slices.Sort(roots)
+
+	type queueEntry struct {
+		path  string
+		chain []string
+	}
+	queue := make([]queueEntry, 0, len(roots))
+	seen := make(map[string]bool)
+	for _, root := range roots {
+		if graph.NodesByPackagePath[root] == nil || seen[root] {
+			continue
+		}
+		seen[root] = true
+		queue = append(queue, queueEntry{
+			path:  root,
+			chain: []string{root},
+		})
+	}
+
+	for len(queue) != 0 {
+		entry := queue[0]
+		queue = queue[1:]
+		if packagePathBlocklisted(entry.path, blocklist) {
+			return entry.chain
+		}
+
+		node := graph.NodesByPackagePath[entry.path]
+		if node == nil {
+			continue
+		}
+		// Override candidates are compiled from their GoScript override, whose
+		// TypeScript imports replace the native Go imports. collect prunes their
+		// native dependencies from the graph, so the blocklist walk must treat
+		// them as leaves; otherwise an overridden package (for example a
+		// reflect-free encoding/json override) would falsely chain to a
+		// blocklisted package it no longer imports in the compiled output.
+		if node.OverrideCandidate {
+			continue
+		}
+		imports := slices.Clone(node.Imports)
+		slices.Sort(imports)
+		for _, importPath := range imports {
+			if graph.NodesByPackagePath[importPath] == nil || seen[importPath] {
+				continue
+			}
+			seen[importPath] = true
+			nextChain := slices.Clone(entry.chain)
+			nextChain = append(nextChain, importPath)
+			queue = append(queue, queueEntry{
+				path:  importPath,
+				chain: nextChain,
+			})
+		}
+	}
+	return nil
+}
+
+func packagePathBlocklisted(path string, blocklist []string) bool {
+	for _, blocked := range blocklist {
+		// Match the package exactly or any subpackage, on a path-segment
+		// boundary so "crypto" blocks "crypto/ecdsa" but not "cryptobyte".
+		if path == blocked || strings.HasPrefix(path, blocked+"/") {
+			return true
+		}
+	}
+	return false
+}
+
 func normalizePackageFileOrder(pkg *packages.Package) {
 	if pkg == nil {
 		return

package/compiler/package-graph_test.go

@@ -266,6 +266,119 @@ func TestPackageGraphLoadsLocalReplacement(t *testing.T) {
 	}
 }
 
+func TestPackageBlocklistAllowsCleanFixture(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":       "module example.test/blockclean\n\ngo 1.25.3\n",
+		"main.go":      "package blockclean\nimport \"example.test/blockclean/dep\"\nfunc Value() int { return dep.Value() }\n",
+		"dep/dep.go":   "package dep\nfunc Value() int { return 1 }\n",
+		"other/doc.go": "package other\n",
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:              moduleDir,
+		OutputPath:       filepath.Join(t.TempDir(), "out"),
+		AllDependencies:  true,
+		PackageBlocklist: []string{"example.test/blockclean/other"},
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatalf("compile with clean blocklist failed: %v", err)
+	}
+}
+
+func TestPackageBlocklistReportsShortestImportChain(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":                 "module example.test/blockchain\n\ngo 1.25.3\n",
+		"main.go":                "package blockchain\nimport \"example.test/blockchain/dep\"\nfunc Value() int { return dep.Value() }\n",
+		"dep/dep.go":             "package dep\nimport \"example.test/blockchain/mid/blocked\"\nfunc Value() int { return blocked.Value() }\n",
+		"mid/leaf.go":            "package mid\nimport \"example.test/blockchain/mid/blocked\"\nfunc Leaf() int { return blocked.Value() }\n",
+		"mid/blocked/blocked.go": "package blocked\nfunc Value() int { return 1 }\n",
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:              moduleDir,
+		OutputPath:       filepath.Join(t.TempDir(), "out"),
+		AllDependencies:  true,
+		PackageBlocklist: []string{"example.test/blockchain/mid/blocked"},
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	_, err = comp.CompilePackages(context.Background(), ".")
+	if err == nil {
+		t.Fatal("expected blocklisted package diagnostic")
+	}
+	text := err.Error()
+	if !strings.Contains(text, "goscript/package-graph:blocklisted-package") {
+		t.Fatalf("expected blocklist diagnostic, got %q", text)
+	}
+	if !strings.Contains(text, `package graph contains blocklisted package "example.test/blockchain/mid/blocked"`) {
+		t.Fatalf("expected blocklisted package name, got %q", text)
+	}
+	expected := "example.test/blockchain -> example.test/blockchain/dep -> example.test/blockchain/mid/blocked"
+	if !strings.Contains(text, expected) {
+		t.Fatalf("expected shortest import chain %q, got %q", expected, text)
+	}
+}
+
+func TestPackageBlocklistIgnoresOverrideCandidateImports(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": strings.Join([]string{
+			"module example.test/blockoverride",
+			"",
+			"go 1.25.3",
+			"",
+			"require example.test/over v0.0.0",
+			"replace example.test/over => ./over",
+			"",
+		}, "\n"),
+		"main.go":                "package blockoverride\nimport (\n\t\"example.test/over\"\n\t\"example.test/blockoverride/dep\"\n)\nfunc Value() int { return over.Value() + dep.Value() }\n",
+		"dep/dep.go":             "package dep\nimport \"example.test/blockoverride/mid\"\nfunc Value() int { return mid.Value() }\n",
+		"mid/mid.go":             "package mid\nimport \"example.test/blockoverride/mid/blocked\"\nfunc Value() int { return blocked.Value() }\n",
+		"mid/blocked/blocked.go": "package blocked\nfunc Value() int { return 1 }\n",
+		"over/go.mod": strings.Join([]string{
+			"module example.test/over",
+			"",
+			"go 1.25.3",
+			"",
+			"require example.test/blockoverride v0.0.0",
+			"replace example.test/blockoverride => ../",
+			"",
+		}, "\n"),
+		"over/over.go": "package over\nimport \"example.test/blockoverride/mid/blocked\"\nfunc Value() int { return blocked.Value() }\n",
+	})
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/over/index.ts", "export function Value(): number { return 0 }\n")
+
+	overrideOwner := NewOverrideRegistryOwner(overrideDir)
+	req := &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+		PackageBlocklist:    []string{"example.test/blockoverride/mid/blocked"},
+	}
+	graph, diagnostics := NewPackageGraphOwner(overrideOwner).Load(context.Background(), req)
+	if diagnosticsHaveErrors(diagnostics) {
+		chain := packageBlocklistChain(graph, req.PackageBlocklist)
+		if slices.Contains(chain, "example.test/over") {
+			t.Fatalf("blocklist chain routed through override candidate: %v", chain)
+		}
+		expected := []string{
+			"example.test/blockoverride",
+			"example.test/blockoverride/dep",
+			"example.test/blockoverride/mid",
+			"example.test/blockoverride/mid/blocked",
+		}
+		if !slices.Equal(chain, expected) {
+			t.Fatalf("expected real import chain %v, got %v", expected, chain)
+		}
+	} else {
+		t.Fatal("expected blocklisted package diagnostic via the real import path")
+	}
+}
+
 func TestPackageGraphDetectsOverrideCandidates(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod":  "module example.test/override\n\ngo 1.25.3\n",

package/compiler/runtime-contract.go

@@ -5,8 +5,8 @@ import (
 	"slices"
 	"strings"
 
-	gs "github.com/aperturerobotics/goscript"
 	"github.com/pkg/errors"
+	gs "github.com/s4wave/goscript"
 )
 
 // RuntimeHelperCategory names a runtime helper family owned by the contract.

package/compiler/semantic-model.go

@@ -756,6 +756,15 @@ func (o *SemanticModelOwner) collectFunctionFacts(
 				if typed.Op == token.ARROW {
 					markFunctionAsync(semFn, "channel-receive")
 				}
+			case *ast.RangeStmt:
+				if signatureForType(pkg.TypesInfo.TypeOf(typed.X)) != nil {
+					if called := calledFunction(pkg, typed.X); called != nil {
+						semFn.calls[functionOriginOrSelf(called)] = true
+					}
+					if rangeFunctionExprNeedsAwait(model, pkg, overrideFacts, typed.X) {
+						markFunctionAsync(semFn, "range-function")
+					}
+				}
 			case *ast.CallExpr:
 				if called := calledFunction(pkg, typed.Fun); called != nil {
 					semFn.calls[functionOriginOrSelf(called)] = true
@@ -785,6 +794,29 @@ func (o *SemanticModelOwner) collectFunctionFacts(
 	return diagnostics
 }
 
+func rangeFunctionExprNeedsAwait(
+	model *SemanticModel,
+	pkg *packages.Package,
+	overrideFacts *OverrideFacts,
+	expr ast.Expr,
+) bool {
+	if model == nil || pkg == nil || signatureForType(pkg.TypesInfo.TypeOf(expr)) == nil {
+		return false
+	}
+	if called := calledFunction(pkg, expr); called != nil {
+		if semFn := semanticFunctionFor(model, called); semFn != nil && semFn.async {
+			return true
+		}
+		if called.Pkg() != nil && overrideFacts.IsFunctionAsync(called.Pkg().Path(), called.Name()) {
+			return true
+		}
+	}
+	if overrideFacts.IsMethodAsync(overrideCallPackage(pkg, expr), overrideCallMethod(pkg, expr)) {
+		return true
+	}
+	return callUsesFunctionValue(pkg, expr)
+}
+
 func recordImmediateFuncLitAsyncFacts(
 	model *SemanticModel,
 	pkg *packages.Package,