goscript 0.1.0 → 0.1.2

package/compiler/package-test-graph-variant.go

@@ -0,0 +1,129 @@
+package compiler
+
+import (
+	"go/ast"
+	"slices"
+	"strconv"
+	"strings"
+	"unicode"
+
+	"golang.org/x/tools/go/packages"
+)
+
+// PackageTestGraphVariant describes one Go test package variant.
+type PackageTestGraphVariant struct {
+	// ID is the go/packages package identity.
+	ID string
+	// PkgPath is the stable Go package path for this variant.
+	PkgPath string
+	// Name is the Go package name for this variant.
+	Name string
+	// ForTest is the package path this variant tests.
+	ForTest string
+	// GoFiles are the package source files.
+	GoFiles []string
+	// CompiledGoFiles are files selected by build constraints.
+	CompiledGoFiles []string
+	// Imports are packages imported directly by this test variant.
+	Imports []string
+	// Diagnostics are load diagnostics attached to this variant.
+	Diagnostics []Diagnostic
+	// Tests are ordinary TestXxx functions discovered in this variant.
+	Tests []PackageTestFunction
+}
+
+func newPackageTestGraphVariant(pkg *packages.Package, diagnostics []Diagnostic) *PackageTestGraphVariant {
+	imports := make([]string, 0, len(pkg.Imports))
+	for importPath := range pkg.Imports {
+		imports = append(imports, importPath)
+	}
+	slices.Sort(imports)
+	return &PackageTestGraphVariant{
+		ID:              pkg.ID,
+		PkgPath:         packagePath(pkg),
+		Name:            pkg.Name,
+		ForTest:         pkg.ForTest,
+		GoFiles:         append([]string(nil), pkg.GoFiles...),
+		CompiledGoFiles: append([]string(nil), pkg.CompiledGoFiles...),
+		Imports:         imports,
+		Diagnostics:     append([]Diagnostic(nil), diagnostics...),
+		Tests:           discoverPackageTestFunctions(pkg),
+	}
+}
+
+func discoverPackageTestFunctions(pkg *packages.Package) []PackageTestFunction {
+	if pkg == nil {
+		return nil
+	}
+	var tests []PackageTestFunction
+	for _, file := range pkg.Syntax {
+		testingAliases := fileTestingAliases(file)
+		for _, decl := range file.Decls {
+			fn, _ := decl.(*ast.FuncDecl)
+			if !isOrdinaryTestFuncDecl(fn, testingAliases) {
+				continue
+			}
+			tests = append(tests, PackageTestFunction{
+				Name:        fn.Name.Name,
+				PackagePath: packagePath(pkg),
+			})
+		}
+	}
+	return tests
+}
+
+func isOrdinaryTestFuncDecl(fn *ast.FuncDecl, testingAliases map[string]bool) bool {
+	if fn == nil || fn.Recv != nil || !isTestName(fn.Name.Name) || fn.Type == nil {
+		return false
+	}
+	if fn.Type.Results != nil && len(fn.Type.Results.List) != 0 {
+		return false
+	}
+	if fn.Type.Params == nil || len(fn.Type.Params.List) != 1 {
+		return false
+	}
+	param := fn.Type.Params.List[0]
+	if len(param.Names) > 1 {
+		return false
+	}
+	ptr, ok := param.Type.(*ast.StarExpr)
+	return ok && isTestingT(ptr.X, testingAliases)
+}
+
+func fileTestingAliases(file *ast.File) map[string]bool {
+	aliases := make(map[string]bool)
+	for _, imp := range file.Imports {
+		path, err := strconv.Unquote(imp.Path.Value)
+		if err != nil || path != "testing" {
+			continue
+		}
+		name := "testing"
+		if imp.Name != nil {
+			name = imp.Name.Name
+		}
+		aliases[name] = true
+	}
+	return aliases
+}
+
+func isTestingT(expr ast.Expr, aliases map[string]bool) bool {
+	switch typed := expr.(type) {
+	case *ast.SelectorExpr:
+		base, _ := typed.X.(*ast.Ident)
+		return base != nil && aliases[base.Name] && typed.Sel.Name == "T"
+	case *ast.Ident:
+		return aliases["."] && typed.Name == "T"
+	default:
+		return false
+	}
+}
+
+func isTestName(name string) bool {
+	if !strings.HasPrefix(name, "Test") || name == "Test" {
+		return false
+	}
+	for _, r := range strings.TrimPrefix(name, "Test") {
+		return !unicode.IsLower(r)
+	}
+	return false
+}

package/compiler/package-test-graph.go

@@ -0,0 +1,112 @@
+package compiler
+
+import (
+	"context"
+	"os"
+	"slices"
+	"strings"
+
+	"golang.org/x/tools/go/packages"
+)
+
+// PackageTestGraph is the package-scoped graph used by GoScript test runners.
+type PackageTestGraph struct {
+	// RequestedPatterns are the package patterns from the compile request.
+	RequestedPatterns []string
+	// Packages are deterministic package-test facts keyed by package under test.
+	Packages []*PackageTestGraphPackage
+
+	packagesByPath map[string]*PackageTestGraphPackage
+}
+
+// PackageByPath returns the package facts for a package under test.
+func (g *PackageTestGraph) PackageByPath(path string) *PackageTestGraphPackage {
+	if g == nil {
+		return nil
+	}
+	return g.packagesByPath[path]
+}
+
+// LoadTestGraph builds package-scoped test graph facts for a validated request.
+func (o *PackageGraphOwner) LoadTestGraph(ctx context.Context, req *CompileRequest) (*PackageTestGraph, []Diagnostic) {
+	if err := ctx.Err(); err != nil {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/context:canceled",
+			Message:  err.Error(),
+		}}
+	}
+
+	cfg := &packages.Config{
+		Context:    ctx,
+		Dir:        req.Dir,
+		Env:        append(os.Environ(), "GOOS=js", "GOARCH=wasm"),
+		BuildFlags: goScriptBuildFlags(req.BuildFlags),
+		Tests:      true,
+		Mode: packages.NeedName |
+			packages.NeedFiles |
+			packages.NeedCompiledGoFiles |
+			packages.NeedImports |
+			packages.NeedSyntax |
+			packages.NeedForTest |
+			packages.NeedModule,
+	}
+	pkgs, err := packages.Load(cfg, req.Patterns...)
+	if err != nil {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/package-graph:load",
+			Message:  "failed to load Go test packages",
+			Detail:   err.Error(),
+		}}
+	}
+
+	graph := &PackageTestGraph{
+		RequestedPatterns: append([]string(nil), req.Patterns...),
+		packagesByPath:    make(map[string]*PackageTestGraphPackage),
+	}
+	var diagnostics []Diagnostic
+	for _, pkg := range pkgs {
+		if pkg == nil || isTestMainPackage(pkg) {
+			continue
+		}
+		pkgDiagnostics := packageDiagnostics(pkg)
+		diagnostics = append(diagnostics, pkgDiagnostics...)
+		if pkg.ForTest == "" {
+			facts := graph.packageFacts(packagePath(pkg))
+			facts.setPackage(pkg)
+			facts.appendDiagnostics(pkgDiagnostics)
+			continue
+		}
+		facts := graph.packageFacts(pkg.ForTest)
+		variant := newPackageTestGraphVariant(pkg, pkgDiagnostics)
+		if strings.HasSuffix(pkg.Name, "_test") {
+			facts.ExternalPackageTests = variant
+		} else {
+			facts.SamePackageTests = variant
+		}
+		facts.appendDiagnostics(pkgDiagnostics)
+	}
+	if len(graph.Packages) == 0 {
+		diagnostics = append(diagnostics, Diagnostic{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/package-graph:no-test-packages",
+			Message:  "package patterns did not match any test packages",
+		})
+	}
+	slices.SortFunc(graph.Packages, func(a, b *PackageTestGraphPackage) int {
+		return strings.Compare(a.PackagePath, b.PackagePath)
+	})
+	return graph, diagnostics
+}
+
+func (g *PackageTestGraph) packageFacts(path string) *PackageTestGraphPackage {
+	facts := g.packagesByPath[path]
+	if facts != nil {
+		return facts
+	}
+	facts = &PackageTestGraphPackage{PackagePath: path}
+	g.packagesByPath[path] = facts
+	g.Packages = append(g.Packages, facts)
+	return facts
+}

package/compiler/package-test-graph_test.go

@@ -0,0 +1,202 @@
+package compiler
+
+import (
+	"context"
+	"path/filepath"
+	"slices"
+	"strings"
+	"testing"
+)
+
+func TestPackageGraphOwnerLoadTestGraphFacts(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/testgraph\n\ngo 1.25.3\n",
+		"same/value.go": strings.Join([]string{
+			"package same",
+			"",
+			"func Add(a int, b int) int {",
+			"\treturn a + b",
+			"}",
+			"",
+		}, "\n"),
+		"same/value_test.go": strings.Join([]string{
+			"package same",
+			"",
+			"import testpkg \"testing\"",
+			"",
+			"func TestAdd(t *testpkg.T) {}",
+			"func TestIgnoredBadSignature(t *badT) {}",
+			"type badT struct{}",
+			"",
+		}, "\n"),
+		"external/value.go": strings.Join([]string{
+			"package external",
+			"",
+			"func Name() string {",
+			"\treturn \"external\"",
+			"}",
+			"",
+		}, "\n"),
+		"external/value_test.go": strings.Join([]string{
+			"package external_test",
+			"",
+			"import (",
+			"\t\"testing\"",
+			"",
+			"\texternal \"example.test/testgraph/external\"",
+			")",
+			"",
+			"func TestName(t *testing.T) {",
+			"\t_ = external.Name()",
+			"}",
+			"",
+		}, "\n"),
+		"notests/value.go": "package notests\nconst Value = 1\n",
+	})
+
+	graph, diagnostics := loadPackageTestGraph(t, &CompileRequest{
+		Patterns:            []string{"./..."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("test graph load failed: %#v", diagnostics)
+	}
+
+	if len(graph.Packages) != 3 {
+		t.Fatalf("expected three requested packages, got %#v", graph.Packages)
+	}
+	same := graph.PackageByPath("example.test/testgraph/same")
+	if same == nil || same.SamePackageTests == nil || same.ExternalPackageTests != nil || !same.HasTests() {
+		t.Fatalf("unexpected same-package facts: %#v", same)
+	}
+	if len(same.SamePackageTests.Tests) != 1 || same.SamePackageTests.Tests[0].Name != "TestAdd" {
+		t.Fatalf("same-package test discovery should keep only ordinary tests: %#v", same.SamePackageTests.Tests)
+	}
+	external := graph.PackageByPath("example.test/testgraph/external")
+	if external == nil || external.ExternalPackageTests == nil || external.SamePackageTests != nil || !external.HasTests() {
+		t.Fatalf("unexpected external-package facts: %#v", external)
+	}
+	notests := graph.PackageByPath("example.test/testgraph/notests")
+	if notests == nil || notests.HasTests() {
+		t.Fatalf("unexpected no-test package facts: %#v", notests)
+	}
+}
+
+func TestPackageGraphOwnerLoadTestGraphScopesDiagnostics(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/testgraphdiag\n\ngo 1.25.3\n",
+		"clean/value.go": strings.Join([]string{
+			"package clean",
+			"",
+			"func Value() int {",
+			"\treturn 1",
+			"}",
+			"",
+		}, "\n"),
+		"clean/value_test.go": strings.Join([]string{
+			"package clean",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestValue(t *testing.T) {}",
+			"",
+		}, "\n"),
+		"broken/value.go": "package broken\nconst Value = 1\n",
+		"broken/value_test.go": strings.Join([]string{
+			"package broken",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestBroken(t *testing.T) {",
+			"\tif {",
+			"}",
+			"",
+		}, "\n"),
+	})
+
+	graph, diagnostics := loadPackageTestGraph(t, &CompileRequest{
+		Patterns:            []string{"./..."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	requireDiagnosticCode(t, diagnostics, "goscript/package-graph:load-error")
+
+	clean := graph.PackageByPath("example.test/testgraphdiag/clean")
+	if clean == nil || len(clean.Diagnostics) != 0 {
+		t.Fatalf("clean package should not inherit broken diagnostics: %#v", clean)
+	}
+	broken := graph.PackageByPath("example.test/testgraphdiag/broken")
+	if broken == nil || len(broken.Diagnostics) == 0 {
+		t.Fatalf("broken package should carry load diagnostics: %#v", broken)
+	}
+	if broken.SamePackageTests == nil || len(broken.SamePackageTests.Diagnostics) == 0 {
+		t.Fatalf("broken same-package test variant should carry diagnostics: %#v", broken)
+	}
+}
+
+func TestPackageGraphOwnerLoadTestGraphDoesNotLoadDependencies(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/testgraphdeps\n\ngo 1.25.3\n",
+		"clean/value.go": strings.Join([]string{
+			"package clean",
+			"",
+			"func Value() int {",
+			"\treturn 1",
+			"}",
+			"",
+		}, "\n"),
+		"clean/value_test.go": strings.Join([]string{
+			"package clean",
+			"",
+			"import (",
+			"\t\"testing\"",
+			"",
+			"\t\"example.test/testgraphdeps/brokendep\"",
+			")",
+			"",
+			"func TestValue(t *testing.T) {",
+			"\t_ = brokendep.Value",
+			"}",
+			"",
+		}, "\n"),
+		"brokendep/value.go": strings.Join([]string{
+			"package brokendep",
+			"",
+			"const Value =",
+			"",
+		}, "\n"),
+	})
+
+	graph, diagnostics := loadPackageTestGraph(t, &CompileRequest{
+		Patterns:            []string{"./clean"},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("test graph discovery should not load dependency bodies: %#v", diagnostics)
+	}
+	clean := graph.PackageByPath("example.test/testgraphdeps/clean")
+	if clean == nil || clean.SamePackageTests == nil || len(clean.SamePackageTests.Tests) != 1 {
+		t.Fatalf("clean package test discovery failed: %#v", clean)
+	}
+	if !slices.Contains(clean.SamePackageTests.Imports, "example.test/testgraphdeps/brokendep") {
+		t.Fatalf("test graph should retain direct test imports: %#v", clean.SamePackageTests.Imports)
+	}
+}
+
+func loadPackageTestGraph(t *testing.T, req *CompileRequest) (*PackageTestGraph, []Diagnostic) {
+	t.Helper()
+
+	diagnostics := NewCompileRequestOwner().Validate(req)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("request validation failed: %#v", diagnostics)
+	}
+	return NewPackageGraphOwner().LoadTestGraph(context.Background(), req)
+}