goscript 0.1.3 → 0.2.0

package/compiler/semantic-model_test.go

@@ -242,6 +242,87 @@ func TestSemanticModelRecordsInterfaceAssertionAndNilFacts(t *testing.T) {
 	}
 }
 
+func TestSemanticModelRejectsInterfaceMethodSignatureMismatch(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/signaturemismatch\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package signaturemismatch",
+			"type Reader interface { Read() int }",
+			"type Impl struct{}",
+			"func (Impl) Read() string { return \"bad\" }",
+			"",
+		}, "\n"),
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	model := buildSemanticModel(t, graph)
+
+	if hasInterfaceImplementation(model, "Impl", "Reader", false) {
+		t.Fatalf("unexpected Impl -> Reader implementation: %#v", model.interfaceImplementations)
+	}
+}
+
+func TestSemanticModelAcceptsPromotedInterfaceMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/promoted\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package promoted",
+			"type Reader interface { Read() int }",
+			"type Base struct{}",
+			"func (Base) Read() int { return 1 }",
+			"type Impl struct { Base }",
+			"",
+		}, "\n"),
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	model := buildSemanticModel(t, graph)
+
+	if !hasInterfaceImplementation(model, "Impl", "Reader", false) {
+		t.Fatalf("missing promoted Impl -> Reader implementation: %#v", model.interfaceImplementations)
+	}
+}
+
+func TestSemanticModelKeepsUnexportedInterfaceMethodsPackageScoped(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/unexportediface\n\ngo 1.25.3\n",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"type private interface { read() int }",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package unexportediface",
+			"import _ \"example.test/unexportediface/dep\"",
+			"type Impl struct{}",
+			"func (Impl) read() int { return 1 }",
+			"",
+		}, "\n"),
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	model := buildSemanticModel(t, graph)
+
+	if hasInterfaceImplementation(model, "Impl", "private", false) {
+		t.Fatalf("unexpected cross-package unexported implementation: %#v", model.interfaceImplementations)
+	}
+}
+
 func TestSemanticModelColorsAsyncFunctionsAndOverrides(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/async\n\ngo 1.25.3\n",
@@ -314,6 +395,144 @@ func TestSemanticModelPropagatesCascadedAsyncInterfaceMethods(t *testing.T) {
 	}
 }
 
+func TestSemanticModelPropagatesAsyncToOverrideInterfaceMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/overrideiface\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package overrideiface",
+			"import (",
+			"  \"io\"",
+			"  \"sync\"",
+			")",
+			"type asyncWriter struct { mu sync.Mutex }",
+			"func (w *asyncWriter) Write(p []byte) (int, error) {",
+			"  w.mu.Lock()",
+			"  defer w.mu.Unlock()",
+			"  return len(p), nil",
+			"}",
+			"func Use(w io.Writer) {",
+			"  _, _ = w.Write(nil)",
+			"}",
+			"func main() { Use(&asyncWriter{}) }",
+			"",
+		}, "\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{"Write", "Use", "main"} {
+		fn := requireDefinedFunc(t, graph, "example.test/overrideiface", name)
+		if !model.functions[fn].async {
+			t.Fatalf("expected %s to be async, got %#v", name, model.functions[fn])
+		}
+	}
+	found := false
+	for _, implementation := range model.interfaceImplementations {
+		if implementation.typ != nil && implementation.typ.Obj().Name() == "asyncWriter" &&
+			implementation.iface != nil && implementation.iface.Obj().Pkg().Path() == "io" &&
+			implementation.iface.Obj().Name() == "Writer" &&
+			implementation.pointer {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Fatalf("missing async *asyncWriter -> io.Writer implementation: %#v", model.interfaceImplementations)
+	}
+}
+
+func TestSemanticModelPropagatesAsyncToAnonymousInterfaceMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/anonymousiface\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package anonymousiface",
+			"import \"context\"",
+			"type Snapshot int",
+			"type Watcher struct { ch chan Snapshot }",
+			"func (w *Watcher) WaitValueChange(ctx context.Context, old Snapshot, errCh <-chan error) (Snapshot, error) {",
+			"  select {",
+			"  case v := <-w.ch:",
+			"    return v, nil",
+			"  case err := <-errCh:",
+			"    return old, err",
+			"  case <-ctx.Done():",
+			"    return old, ctx.Err()",
+			"  }",
+			"}",
+			"func Use(ctx context.Context, w interface {",
+			"  WaitValueChange(context.Context, Snapshot, <-chan error) (Snapshot, error)",
+			"}, old Snapshot) (Snapshot, error) {",
+			"  return w.WaitValueChange(ctx, old, nil)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	model := buildSemanticModel(t, graph)
+
+	fn := requireDefinedFunc(t, graph, "example.test/anonymousiface", "Use")
+	if !model.functions[fn].async {
+		t.Fatalf("expected Use to be async, got %#v", model.functions[fn])
+	}
+}
+
+func TestSemanticModelPropagatesAsyncThroughInstantiatedNamedInterface(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/instantiatediface\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package instantiatediface",
+			"import \"context\"",
+			"type Snapshot int",
+			"type Watchable[T any] interface {",
+			"  WaitValueChange(context.Context, T, <-chan error) (T, error)",
+			"}",
+			"type Container[T any] struct { ch chan T }",
+			"func (c *Container[T]) WaitValueChange(ctx context.Context, old T, errCh <-chan error) (T, error) {",
+			"  select {",
+			"  case v := <-c.ch:",
+			"    return v, nil",
+			"  case err := <-errCh:",
+			"    return old, err",
+			"  case <-ctx.Done():",
+			"    return old, ctx.Err()",
+			"  }",
+			"}",
+			"func Bind(w Watchable[Snapshot]) {}",
+			"func Use(ctx context.Context, w interface {",
+			"  WaitValueChange(context.Context, Snapshot, <-chan error) (Snapshot, error)",
+			"}, old Snapshot) (Snapshot, error) {",
+			"  return w.WaitValueChange(ctx, old, nil)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	model := buildSemanticModel(t, graph)
+
+	fn := requireDefinedFunc(t, graph, "example.test/instantiatediface", "Use")
+	if !model.functions[fn].async {
+		t.Fatalf("expected Use to be async, got %#v", model.functions[fn])
+	}
+}
+
 func TestSemanticModelIndexesFunctionsByFullName(t *testing.T) {
 	model := newSemanticModel()
 	semPkg := &semanticPackage{}

package/compiler/service.go

@@ -14,6 +14,7 @@ type CompileService struct {
 	emitterOwner  *TypeScriptEmitOwner
 	runtimeOwner  *RuntimeContractOwner
 	overrideOwner *OverrideRegistryOwner
+	parityOwner   *OverrideParityVerifier
 }
 
 // NewCompileService creates a compile service with every pipeline owner.
@@ -28,6 +29,7 @@ func NewCompileService(overrideDirs ...string) *CompileService {
 		emitterOwner:  NewTypeScriptEmitOwner(runtimeOwner),
 		runtimeOwner:  runtimeOwner,
 		overrideOwner: overrideOwner,
+		parityOwner:   NewOverrideParityVerifier(),
 	}
 }
 
@@ -96,6 +98,19 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 		return result, NewCompileError(diagnostics)
 	}
 
+	overrideFacts, factsDiagnostics := s.overrideOwner.Facts(ctx)
+	diagnostics = append(diagnostics, factsDiagnostics...)
+	if diagnosticsHaveErrors(diagnostics) {
+		result.Diagnostics = diagnostics
+		return result, NewCompileError(diagnostics)
+	}
+	parityDiagnostics := s.parityOwner.Verify(ctx, graph, overrideFacts)
+	diagnostics = append(diagnostics, parityDiagnostics...)
+	if diagnosticsHaveErrors(diagnostics) {
+		result.Diagnostics = diagnostics
+		return result, NewCompileError(diagnostics)
+	}
+
 	semanticModel, semanticDiagnostics := s.semanticOwner.Build(ctx, graph)
 	diagnostics = append(diagnostics, semanticDiagnostics...)
 	if diagnosticsHaveErrors(diagnostics) {
@@ -110,7 +125,11 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 		return result, NewCompileError(diagnostics)
 	}
 
-	loweredProgram, loweringDiagnostics := s.loweringOwner.Build(ctx, semanticModel)
+	loweredProgram, loweringDiagnostics := s.loweringOwner.Build(ctx, semanticModel, LoweringOptions{
+		SourceRoot:                protobufTypeScriptBindingRoot(req.Dir),
+		OutputPath:                req.OutputPath,
+		ProtobufTypeScriptBinding: req.ProtobufTypeScriptBinding,
+	})
 	diagnostics = append(diagnostics, loweringDiagnostics...)
 	if diagnosticsHaveErrors(diagnostics) {
 		result.Diagnostics = diagnostics