goscript 0.1.0 → 0.1.2

package/compiler/semantic-model_test.go

@@ -2,6 +2,7 @@ package compiler
 
 import (
 	"context"
+	"go/token"
 	"go/types"
 	"path/filepath"
 	"strings"
@@ -281,6 +282,109 @@ func TestSemanticModelColorsAsyncFunctionsAndOverrides(t *testing.T) {
 	}
 }
 
+func TestSemanticModelPropagatesCascadedAsyncInterfaceMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/asynciface\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package asynciface",
+			"type Config interface { Equals(Config) bool }",
+			"type Directive interface { IsEquivalent(Directive) bool }",
+			"type channelConfig struct { ch chan struct{} }",
+			"func (c *channelConfig) Equals(other Config) bool { <-c.ch; return true }",
+			"type execDirective struct { c Config }",
+			"func (d *execDirective) IsEquivalent(other Directive) bool { return d.c.Equals(nil) }",
+			"func Use(d Directive, other Directive) bool { return d.IsEquivalent(other) }",
+			"",
+		}, "\n"),
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	model := buildSemanticModel(t, graph)
+
+	for _, name := range []string{"Equals", "IsEquivalent", "Use"} {
+		fn := requireDefinedFunc(t, graph, "example.test/asynciface", name)
+		if !model.functions[fn].async {
+			t.Fatalf("expected %s to be async, got %#v", name, model.functions[fn])
+		}
+	}
+}
+
+func TestSemanticModelIndexesFunctionsByFullName(t *testing.T) {
+	model := newSemanticModel()
+	semPkg := &semanticPackage{}
+	pkg := types.NewPackage("example.test/indexed", "indexed")
+	signature := types.NewSignatureType(nil, nil, nil, types.NewTuple(), types.NewTuple(), false)
+	fn := types.NewFunc(token.NoPos, pkg, "Call", signature)
+	semFn := NewSemanticModelOwner().addFunction(model, semPkg, fn, sourcePosition{})
+
+	duplicatePkg := types.NewPackage("example.test/indexed", "indexed")
+	duplicate := types.NewFunc(token.NoPos, duplicatePkg, "Call", signature)
+	if got := semanticFunctionFor(model, duplicate); got != semFn {
+		t.Fatalf("semanticFunctionFor duplicate before add = %#v, want %#v", got, semFn)
+	}
+	stalePkg := types.NewPackage("example.test/indexed", "indexed")
+	stale := types.NewFunc(token.NoPos, stalePkg, "Call", signature)
+	staleModel := newSemanticModel()
+	if got := semanticFunctionFor(staleModel, stale); got != nil {
+		t.Fatalf("semanticFunctionFor stale before add = %#v, want nil", got)
+	}
+	NewSemanticModelOwner().addFunction(staleModel, &semanticPackage{}, fn, sourcePosition{})
+	if got := semanticFunctionFor(staleModel, stale); got == nil {
+		t.Fatalf("semanticFunctionFor stale miss did not retry full-name lookup")
+	}
+	duplicatePkgEntry := &semanticPackage{}
+	if got := NewSemanticModelOwner().addFunction(model, duplicatePkgEntry, duplicate, sourcePosition{}); got != semFn {
+		t.Fatalf("addFunction duplicate = %#v, want %#v", got, semFn)
+	}
+	if got := semanticFunctionFor(model, duplicate); got != semFn {
+		t.Fatalf("semanticFunctionFor duplicate = %#v, want %#v", got, semFn)
+	}
+}
+
+func TestSemanticModelAsyncPropagationObservesContext(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	diagnostics := NewSemanticModelOwner().propagateFunctionAsync(ctx, newSemanticModel())
+	if !diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("expected canceled context diagnostic")
+	}
+	if diagnostics[0].Code != "goscript/context:canceled" {
+		t.Fatalf("unexpected diagnostic: %#v", diagnostics[0])
+	}
+}
+
+func TestSemanticModelMarksFunctionIdentifierCallAsync(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/callback\n\ngo 1.25.3\n",
+		"callback.go": strings.Join([]string{
+			"package callback",
+			"func Run(fn func() error) error {",
+			"  return fn()",
+			"}",
+			"",
+		}, "\n"),
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	model := buildSemanticModel(t, graph)
+	run := requireDefinedFunc(t, graph, "example.test/callback", "Run")
+	semFn := model.functions[run]
+	if semFn == nil || !semFn.async {
+		t.Fatalf("expected Run to be async after calling function parameter, got %#v", semFn)
+	}
+}
+
 func buildSemanticModel(t *testing.T, graph *PackageGraph) *SemanticModel {
 	t.Helper()
 

package/compiler/service.go

@@ -1,6 +1,9 @@
 package compiler
 
-import "context"
+import (
+	"context"
+	"slices"
+)
 
 // CompileService owns the v2 compiler pipeline.
 type CompileService struct {
@@ -14,12 +17,12 @@ type CompileService struct {
 }
 
 // NewCompileService creates a compile service with every pipeline owner.
-func NewCompileService() *CompileService {
-	overrideOwner := NewOverrideRegistryOwner()
+func NewCompileService(overrideDirs ...string) *CompileService {
+	overrideOwner := NewOverrideRegistryOwner(overrideDirs...)
 	runtimeOwner := NewRuntimeContractOwner()
 	return &CompileService{
 		requestOwner:  NewCompileRequestOwner(),
-		graphOwner:    NewPackageGraphOwner(),
+		graphOwner:    NewPackageGraphOwner(overrideOwner),
 		semanticOwner: NewSemanticModelOwner(overrideOwner),
 		loweringOwner: NewLoweringOwner(runtimeOwner, overrideOwner),
 		emitterOwner:  NewTypeScriptEmitOwner(runtimeOwner),
@@ -79,6 +82,9 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 		result.Diagnostics = diagnostics
 		return result, NewCompileError(diagnostics)
 	}
+	if !slices.Equal(s.overrideOwner.overrideDirs, req.OverrideDirs) {
+		return NewCompileService(req.OverrideDirs...).Compile(ctx, req)
+	}
 
 	graph, graphDiagnostics := s.graphOwner.Load(ctx, req)
 	diagnostics = append(diagnostics, graphDiagnostics...)