goscript 0.1.2 → 0.1.4

package/compiler/lowering_bench_test.go

@@ -0,0 +1,350 @@
+package compiler
+
+import (
+	"context"
+	"go/ast"
+	"go/types"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+type loweringBenchFixture struct {
+	model     *SemanticModel
+	owner     *LoweringOwner
+	semPkg    *semanticPackage
+	file      loweringBenchFile
+	genDecls  []loweringBenchGenDecl
+	stmtLists []loweringBenchStmtList
+}
+
+type loweringBenchFile struct {
+	file            *ast.File
+	sourcePath      string
+	associated      []*ast.FuncDecl
+	declFiles       map[types.Object]string
+	outputNames     map[string]string
+	lazyPackageVars map[types.Object]bool
+}
+
+type loweringBenchGenDecl struct {
+	ctx  lowerFileContext
+	decl *ast.GenDecl
+}
+
+type loweringBenchStmtList struct {
+	ctx   lowerFileContext
+	stmts []ast.Stmt
+}
+
+func BenchmarkLoweringPackage(b *testing.B) {
+	fixture := newLoweringBenchFixture(b)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, diagnostics := fixture.owner.lowerPackage(fixture.model, fixture.semPkg); diagnosticsHaveErrors(diagnostics) {
+			b.Fatal(diagnostics)
+		}
+	}
+}
+
+func BenchmarkLoweringAnalyzeLocalFileReferences(b *testing.B) {
+	fixture := newLoweringBenchFixture(b)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = fixture.owner.analyzeLocalFileReferences(
+			fixture.semPkg,
+			fixture.file.file,
+			fixture.file.sourcePath,
+			fixture.file.associated,
+			fixture.file.declFiles,
+			fixture.file.outputNames,
+		)
+	}
+}
+
+func BenchmarkLoweringFile(b *testing.B) {
+	fixture := newLoweringBenchFixture(b)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, diagnostics := fixture.owner.lowerFile(
+			fixture.model,
+			fixture.semPkg,
+			fixture.file.file,
+			fixture.file.sourcePath,
+			fixture.file.declFiles,
+			fixture.file.outputNames,
+			fixture.file.lazyPackageVars,
+		); diagnosticsHaveErrors(diagnostics) {
+			b.Fatal(diagnostics)
+		}
+	}
+}
+
+func BenchmarkLoweringGenDecls(b *testing.B) {
+	fixture := newLoweringBenchFixture(b)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, target := range fixture.genDecls {
+			if _, diagnostics := fixture.owner.lowerGenDecl(target.ctx, target.decl); diagnosticsHaveErrors(diagnostics) {
+				b.Fatal(diagnostics)
+			}
+		}
+	}
+}
+
+func BenchmarkLoweringStmtLists(b *testing.B) {
+	fixture := newLoweringBenchFixture(b)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, target := range fixture.stmtLists {
+			if _, diagnostics := fixture.owner.lowerStmtList(target.ctx, target.stmts); diagnosticsHaveErrors(diagnostics) {
+				b.Fatal(diagnostics)
+			}
+		}
+	}
+}
+
+func BenchmarkLoweringPackageDeclFiles(b *testing.B) {
+	fixture := newLoweringBenchFixture(b)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = packageDeclFiles(fixture.semPkg)
+	}
+}
+
+func BenchmarkLoweringLazyPackageVars(b *testing.B) {
+	fixture := newLoweringBenchFixture(b)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = fixture.owner.lazyPackageVars(fixture.semPkg, fixture.file.declFiles)
+	}
+}
+
+func newLoweringBenchFixture(tb testing.TB) *loweringBenchFixture {
+	tb.Helper()
+	dir := tb.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module example.test/loweringbench\n\ngo 1.25.3\n"), 0o644); err != nil {
+		tb.Fatal(err)
+	}
+	for name, source := range loweringBenchSources {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0o644); err != nil {
+			tb.Fatal(err)
+		}
+	}
+
+	service := NewCompileService()
+	req := &CompileRequest{
+		Dir:        dir,
+		OutputPath: filepath.Join(dir, "out"),
+		Patterns:   []string{"."},
+	}
+	graph, graphDiagnostics := service.PackageGraphOwner().Load(context.Background(), req)
+	if diagnosticsHaveErrors(graphDiagnostics) {
+		tb.Fatal(graphDiagnostics)
+	}
+	model, semanticDiagnostics := service.SemanticModelOwner().Build(context.Background(), graph)
+	if diagnosticsHaveErrors(semanticDiagnostics) {
+		tb.Fatal(semanticDiagnostics)
+	}
+	semPkg := model.packages["example.test/loweringbench"]
+	if semPkg == nil {
+		tb.Fatal("missing benchmark semantic package")
+	}
+	owner := service.LoweringOwner()
+	declFiles := packageDeclFiles(semPkg)
+	outputNames := packageOutputNames(semPkg)
+	lazyPackageVars := owner.lazyPackageVars(semPkg, declFiles)
+
+	var benchFile loweringBenchFile
+	var genDecls []loweringBenchGenDecl
+	var stmtLists []loweringBenchStmtList
+	for idx, file := range semPkg.source.Syntax {
+		sourcePath := sourceFilePath(semPkg, idx, file)
+		associated := owner.methodDeclsForFileTypes(semPkg, file)
+		localRefs := owner.analyzeLocalFileReferences(semPkg, file, sourcePath, associated, declFiles, outputNames)
+		ctx := lowerFileContext{
+			model:           model,
+			semPkg:          semPkg,
+			file:            file,
+			importAliases:   make(map[string]string),
+			importPaths:     make(map[string]string),
+			importNames:     make(map[string]string),
+			importObjects:   make(map[*types.PkgName]string),
+			sourcePath:      sourcePath,
+			localAliases:    localRefs.aliases,
+			lazyPackageVars: lazyPackageVars,
+			tempNames:       newTempNameOwner(),
+			topLevel:        true,
+		}
+		if filepath.Base(sourcePath) == "bench.go" {
+			benchFile = loweringBenchFile{
+				file:            file,
+				sourcePath:      sourcePath,
+				associated:      associated,
+				declFiles:       declFiles,
+				outputNames:     outputNames,
+				lazyPackageVars: lazyPackageVars,
+			}
+		}
+		for _, decl := range file.Decls {
+			switch typed := decl.(type) {
+			case *ast.GenDecl:
+				genDecls = append(genDecls, loweringBenchGenDecl{ctx: ctx, decl: typed})
+			case *ast.FuncDecl:
+				fn, _ := semPkg.source.TypesInfo.Defs[typed.Name].(*types.Func)
+				signature, _ := fn.Type().(*types.Signature)
+				bodyCtx := ctx.withSignature(signature).withAsyncFunction(owner.functionAsync(ctx, fn))
+				if typed.Body != nil {
+					stmtLists = append(stmtLists, loweringBenchStmtList{ctx: bodyCtx, stmts: typed.Body.List})
+				}
+			}
+		}
+	}
+	if benchFile.file == nil {
+		tb.Fatal("missing bench.go fixture file")
+	}
+	if len(genDecls) == 0 || len(stmtLists) == 0 {
+		tb.Fatalf("incomplete lowering benchmark fixture: genDecls=%d stmtLists=%d", len(genDecls), len(stmtLists))
+	}
+	return &loweringBenchFixture{
+		model:     model,
+		owner:     owner,
+		semPkg:    semPkg,
+		file:      benchFile,
+		genDecls:  genDecls,
+		stmtLists: stmtLists,
+	}
+}
+
+var loweringBenchSources = map[string]string{
+	"bench.go": `package loweringbench
+
+type Number interface {
+	~int | ~int64
+}
+
+type Item[T Number] struct {
+	ID     int
+	Name   string
+	Values []T
+	Meta   map[string]T
+	Next   *Item[T]
+}
+
+type Processor[T Number] interface {
+	Process(Item[T]) (T, error)
+}
+
+type Runner[T Number] struct {
+	Items []Item[T]
+	Proc  Processor[T]
+}
+
+var GlobalItems = []Item[int]{
+	{ID: 1, Name: "one", Values: []int{1, 2, 3}, Meta: map[string]int{"a": 1}},
+	{ID: 2, Name: "two", Values: []int{4, 5, 6}, Meta: map[string]int{"b": 2}},
+}
+
+var Lookup = map[string]Item[int]{
+	"one": GlobalItems[0],
+	"two": GlobalItems[1],
+}
+
+func (r *Runner[T]) Sum(seed T) (T, error) {
+	total := seed
+	for idx, item := range r.Items {
+		for _, value := range item.Values {
+			total += value
+		}
+		if r.Proc != nil {
+			next, err := r.Proc.Process(item)
+			if err != nil {
+				return total, err
+			}
+			total += next
+		}
+		if idx%2 == 0 {
+			total += T(idx)
+		}
+	}
+	return total, nil
+}
+
+func UseRunner(r *Runner[int]) int {
+	total, err := r.Sum(10)
+	if err != nil {
+		return -1
+	}
+	switch {
+	case total > 100:
+		return total / 2
+	case total > 20:
+		return total + len(r.Items)
+	default:
+		return total
+	}
+}
+`,
+	"flow.go": `package loweringbench
+
+func FoldItems(items []Item[int], fn func(Item[int]) int) int {
+	total := 0
+	for _, item := range items {
+		total += fn(item)
+	}
+	return total
+}
+
+func ComplexFlow(items []Item[int], ch chan int) int {
+	total := 0
+	for idx := 0; idx < len(items); idx++ {
+		item := items[idx]
+		select {
+		case ch <- item.ID:
+			total += item.ID
+		default:
+			total += len(item.Values)
+		}
+		for key, value := range item.Meta {
+			if key == "" {
+				continue
+			}
+			total += value
+		}
+	}
+	return total
+}
+`,
+	"types.go": `package loweringbench
+
+type NamedInt int
+
+func (n NamedInt) Process(item Item[int]) (int, error) {
+	return int(n) + item.ID + len(item.Values), nil
+}
+
+type Pair[A, B any] struct {
+	A A
+	B B
+}
+
+type Registry struct {
+	ByName map[string]Processor[int]
+	Pairs  []Pair[string, Item[int]]
+}
+
+func NewRegistry() *Registry {
+	return &Registry{
+		ByName: map[string]Processor[int]{"default": NamedInt(3)},
+		Pairs: []Pair[string, Item[int]]{{A: "one", B: GlobalItems[0]}},
+	}
+}
+`,
+}

package/compiler/override-registry_test.go

@@ -341,6 +341,49 @@ func TestCompilePackagesPropagatesOverrideAsyncInterfaceMethods(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesAwaitsOverrideAsyncInterfaceMethodCalls(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/overrideasyncinterfacemethod\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"sync\"",
+			"func Use(l sync.Locker) {",
+			"  l.Lock()",
+			"  l.Unlock()",
+			"}",
+			"func main() {}",
+			"",
+		}, "\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", "overrideasyncinterfacemethod", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export async function Use(l: sync.Locker | null): globalThis.Promise<void>",
+		"await $.pointerValue<Exclude<sync.Locker, null>>(l).Lock()",
+		"$.pointerValue<Exclude<sync.Locker, null>>(l).Unlock()",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
 func TestCompilePackagesAwaitsOverrideAsyncFunctions(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/overrideasyncfunc\n\ngo 1.25.3\n",

package/compiler/package-graph.go

@@ -2,6 +2,7 @@ package compiler
 
 import (
 	"context"
+	"go/ast"
 	"os"
 	"slices"
 	"strings"
@@ -130,6 +131,15 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 		graph.RequestedPackagePaths = append(graph.RequestedPackagePaths, path)
 	}
 	slices.Sort(graph.RequestedPackagePaths)
+	samePackageTestVariants := make(map[string]bool)
+	if req.Tests {
+		for _, pkg := range pkgs {
+			if pkg == nil || pkg.ForTest == "" || strings.HasSuffix(pkg.Name, "_test") {
+				continue
+			}
+			samePackageTestVariants[pkg.ForTest] = true
+		}
+	}
 
 	var diagnostics []Diagnostic
 	seen := make(map[string]bool)
@@ -137,7 +147,7 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 		if isTestMainPackage(pkg) {
 			continue
 		}
-		o.collect(graph, pkg, req.DependencyMode, requested, overrideFacts, seen)
+		o.collect(graph, pkg, req.DependencyMode, requested, samePackageTestVariants, overrideFacts, seen)
 		diagnostics = append(diagnostics, packageDiagnostics(pkg)...)
 	}
 	slices.SortFunc(graph.Nodes, func(a, b *PackageGraphNode) int {
@@ -161,21 +171,33 @@ func (o *PackageGraphOwner) collect(
 	pkg *packages.Package,
 	mode DependencyMode,
 	requested map[string]bool,
+	samePackageTestVariants map[string]bool,
 	overrideFacts *OverrideFacts,
 	seen map[string]bool,
 ) {
 	if pkg == nil || seen[pkg.ID] {
 		return
 	}
+	path := packagePath(pkg)
+	if pkg.ForTest != "" && path != pkg.ForTest && !strings.HasSuffix(pkg.Name, "_test") && samePackageTestVariants[path] {
+		return
+	}
+	if pkg.ForTest == "" && samePackageTestVariants[path] {
+		return
+	}
 	if pkg.ForTest != "" && !requested[pkg.ForTest] {
 		if prod := pkg.Imports[pkg.ForTest]; prod != nil {
-			o.collect(graph, prod, mode, requested, overrideFacts, seen)
+			o.collect(graph, prod, mode, requested, samePackageTestVariants, overrideFacts, seen)
 		}
 		return
 	}
+	if graph.NodesByPackagePath[path] != nil {
+		return
+	}
 	seen[pkg.ID] = true
 
-	path := packagePath(pkg)
+	normalizePackageFileOrder(pkg)
+
 	node := newPackageGraphNode(pkg, requested[path], overrideFacts)
 	graph.Nodes = append(graph.Nodes, node)
 	graph.NodesByPackagePath[path] = node
@@ -190,7 +212,7 @@ func (o *PackageGraphOwner) collect(
 	}
 	slices.Sort(imports)
 	for _, importPath := range imports {
-		o.collect(graph, pkg.Imports[importPath], mode, requested, overrideFacts, seen)
+		o.collect(graph, pkg.Imports[importPath], mode, requested, samePackageTestVariants, overrideFacts, seen)
 	}
 }
 
@@ -223,6 +245,41 @@ func newPackageGraphNode(pkg *packages.Package, requested bool, overrideFacts *O
 	}
 }
 
+func normalizePackageFileOrder(pkg *packages.Package) {
+	if pkg == nil {
+		return
+	}
+	slices.Sort(pkg.GoFiles)
+	if len(pkg.Syntax) == len(pkg.CompiledGoFiles) {
+		type sourceFile struct {
+			name string
+			file *ast.File
+		}
+		files := make([]sourceFile, len(pkg.Syntax))
+		for idx, file := range pkg.Syntax {
+			files[idx] = sourceFile{name: pkg.CompiledGoFiles[idx], file: file}
+		}
+		slices.SortFunc(files, func(a, b sourceFile) int {
+			return strings.Compare(a.name, b.name)
+		})
+		for idx, file := range files {
+			pkg.CompiledGoFiles[idx] = file.name
+			pkg.Syntax[idx] = file.file
+		}
+		return
+	}
+	slices.Sort(pkg.CompiledGoFiles)
+	slices.SortFunc(pkg.Syntax, func(a, b *ast.File) int {
+		if pkg.Fset == nil {
+			return strings.Compare(a.Name.Name, b.Name.Name)
+		}
+		return strings.Compare(
+			pkg.Fset.Position(a.Package).Filename,
+			pkg.Fset.Position(b.Package).Filename,
+		)
+	})
+}
+
 func isTestMainPackage(pkg *packages.Package) bool {
 	return pkg != nil && pkg.ForTest == "" && pkg.Name == "main" && strings.HasSuffix(packagePath(pkg), ".test")
 }

package/compiler/package-graph_test.go

@@ -176,6 +176,36 @@ func TestPackageGraphHonorsBuildFlags(t *testing.T) {
 	}
 }
 
+func TestPackageGraphNormalizesCompiledFileOrder(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/order\n\ngo 1.25.3\n",
+		"z.go":   "package order\nconst Z = 1\n",
+		"a.go":   "package order\nconst A = 1\n",
+		"m.go":   "package order\nconst M = 1\n",
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+
+	pkg := graph.packagesByPath["example.test/order"]
+	if pkg == nil {
+		t.Fatalf("missing loaded package")
+	}
+	var compiled []string
+	var syntax []string
+	for idx, file := range pkg.Syntax {
+		compiled = append(compiled, filepath.Base(pkg.CompiledGoFiles[idx]))
+		syntax = append(syntax, filepath.Base(pkg.Fset.Position(file.Package).Filename))
+	}
+	if want := []string{"a.go", "m.go", "z.go"}; !slices.Equal(compiled, want) || !slices.Equal(syntax, want) {
+		t.Fatalf("compiled files and syntax must sort together, got compiled=%v syntax=%v", compiled, syntax)
+	}
+}
+
 func TestPackageGraphAddsGoScriptBuildTag(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod":       "module example.test/goscripttag\n\ngo 1.25.3\n",

package/compiler/semantic-model-types.go

@@ -14,10 +14,13 @@ type SemanticModel struct {
 	functions                map[*types.Func]*semanticFunction
 	functionsByFullName      map[string]*semanticFunction
 	functionLookupMisses     map[*types.Func]bool
+	functionFullNames        map[*types.Func]string
 	types                    map[*types.Named]*semanticType
 	values                   map[types.Object]*semanticValue
 	generatedImports         map[string]map[string]bool
 	interfaceImplementations []semanticInterfaceImplementation
+	asyncInterfaceMethods    map[string]bool
+	asyncInterfaceMethodObjs map[*types.Func]bool
 }
 
 type semanticPackage struct {
@@ -103,6 +106,11 @@ type semanticInterfaceImplementationGraphEntry struct {
 	implMethods  map[string]*types.Func
 }
 
+type semanticAnonymousInterfaceImplementation struct {
+	ifaceMethods map[string]*types.Func
+	implMethods  map[string]*types.Func
+}
+
 type semanticImplementationMethodSet struct {
 	typ      *types.Named
 	receiver types.Type