goscript 0.0.84 → 0.1.1

package/compiler/compliance_test.go

@@ -0,0 +1,188 @@
+package compiler_test
+
+import (
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"testing"
+
+	"github.com/aperturerobotics/goscript/tests"
+)
+
+// TestCompliance runs the inherited GoScript compliance fixtures through the
+// v2 compiler pipeline.
+func TestCompliance(t *testing.T) {
+	workspaceDir, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("failed to get working directory: %v", err)
+	}
+	workspaceDir = filepath.Clean(filepath.Join(workspaceDir, ".."))
+
+	testsDir := filepath.Join(workspaceDir, "tests", "tests")
+	entries, err := os.ReadDir(testsDir)
+	if err != nil {
+		t.Fatalf("failed to read tests dir: %v", err)
+	}
+
+	categories := make(map[string][]string)
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+		testPath := filepath.Join(testsDir, entry.Name())
+		goFiles, err := filepath.Glob(filepath.Join(testPath, "*.go"))
+		if err != nil || len(goFiles) == 0 {
+			continue
+		}
+		category := complianceCategory(entry.Name())
+		categories[category] = append(categories[category], testPath)
+	}
+
+	categoryNames := make([]string, 0, len(categories))
+	for category := range categories {
+		categoryNames = append(categoryNames, category)
+		slices.Sort(categories[category])
+	}
+	slices.Sort(categoryNames)
+
+	ranTests := 0
+	for _, category := range categoryNames {
+		paths := categories[category]
+		t.Run(category, func(t *testing.T) {
+			for _, testPath := range paths {
+				t.Run(filepath.Base(testPath), func(t *testing.T) {
+					name := filepath.Base(testPath)
+					if hasComplianceMarker(t, testPath, "expect-fail") {
+						t.Skip("expected compliance failure marker")
+					}
+					if expectedV2ComplianceGaps[name] {
+						t.Skip("expected v2 compliance gap")
+					}
+
+					ranTests++
+					tests.RunGoScriptTestDir(t, workspaceDir, testPath)
+					if !t.Failed() {
+						if err := os.RemoveAll(filepath.Join(testPath, "run")); err != nil {
+							t.Logf("failed to remove run directory for %s: %v", name, err)
+						}
+					}
+				})
+			}
+		})
+	}
+
+	if ranTests == 0 {
+		t.Fatal("compliance harness did not run any fixture directories")
+	}
+}
+
+func hasComplianceMarker(t *testing.T, testPath, marker string) bool {
+	t.Helper()
+	_, err := os.Stat(filepath.Join(testPath, marker))
+	if err == nil {
+		return true
+	}
+	if !os.IsNotExist(err) {
+		t.Fatalf("failed to check marker %s for %s: %v", marker, testPath, err)
+	}
+	return false
+}
+
+func complianceCategory(name string) string {
+	switch {
+	case strings.HasPrefix(name, "package_import"):
+		return "package-import"
+	case strings.Contains(name, "async") ||
+		strings.Contains(name, "channel") ||
+		strings.Contains(name, "goroutine") ||
+		strings.Contains(name, "select") ||
+		strings.Contains(name, "defer"):
+		return "async"
+	case strings.Contains(name, "generic"):
+		return "generics"
+	case strings.Contains(name, "interface") ||
+		strings.Contains(name, "method") ||
+		strings.Contains(name, "type_assert") ||
+		strings.Contains(name, "type_switch"):
+		return "interfaces"
+	case strings.Contains(name, "array") ||
+		strings.Contains(name, "map") ||
+		strings.Contains(name, "slice") ||
+		strings.Contains(name, "string"):
+		return "collections"
+	case strings.Contains(name, "pointer") ||
+		strings.Contains(name, "struct") ||
+		strings.Contains(name, "varref"):
+		return "values"
+	default:
+		return "core"
+	}
+}
+
+var expectedV2ComplianceGaps = map[string]bool{
+	"bitwise_and_not_assignment":        true,
+	"buffer_value_field_error":          true,
+	"bytes":                             true,
+	"chan_type_assertion":               true,
+	"debug_marshal":                     true,
+	"debug_simple":                      true,
+	"embedded_interface_null_assertion": true,
+	"filepath_walkfunc_call":            true,
+	"flag_bitwise_op":                   true,
+	"for_init_multi_assign":             true,
+	"for_range":                         true,
+	"function_call_variable_shadowing":  true,
+	"function_signature_type":           true,
+	"generics":                          true,
+	"generics_interface":                true,
+	"generics_leading_int":              true,
+	"hex_escape_sequence":               true,
+	"if_type_assert":                    true,
+	"import_interface":                  true,
+	"index_expr_type_assertion":         true,
+	"interface_async_method_call":       true,
+	"interface_embedding":               true,
+	"interface_type_reference":          true,
+	"json_debug":                        true,
+	"json_encoder_debug":                true,
+	"json_numfield":                     true,
+	"json_typefields":                   true,
+	"json_typefields_flow":              true,
+	"linkname_alias":                    true,
+	"map_const_key":                     true,
+	"map_value_field_access_cross_file": true,
+	"method_async_dependency":           true,
+	"method_binding":                    true,
+	"method_receiver_async_paren":       true,
+	"method_receiver_await_paren":       true,
+	"method_receiver_call_return":       true,
+	"method_receiver_paren_line":        true,
+	"method_receiver_shadowing":         true,
+	"method_receiver_with_call_expr":    true,
+	"missing_valueof_error":             true,
+	"multi_return_same_type":            true,
+	"named_slice_wrapper":               true,
+	"named_struct_async_method":         true,
+	"named_types_valueof":               true,
+	"nil_pkg_pointer_dereference":       true,
+	"os_filemode_struct":                true,
+	"path_error_constructor":            true,
+	"pointer_circular_ref":              true,
+	"pointer_composite_literal_untyped": true,
+	"pointer_range_loop":                true,
+	"promise_return_type":               true,
+	"protobuf_lite_ts":                  true,
+	"receiver_variable":                 true,
+	"reflect_implements":                true,
+	"reflect_numfield":                  true,
+	"reserved_words":                    true,
+	"star_expr_destructuring":           true,
+	"struct_embedding":                  true,
+	"struct_embedding_bytes_buffer":     true,
+	"type_conversion_interface_ptr_nil": true,
+	"type_declaration_receiver":         true,
+	"util_promise":                      true,
+	"varref_deref_struct":               true,
+	"wrapper_type_args":                 true,
+}

package/compiler/config.go

@@ -6,27 +6,23 @@ import (
 	"github.com/pkg/errors"
 )
 
-// Config is the configuration for the compiler
-// Dir is the working directory for the compiler. If empty, uses the current working directory.
+// Config is the public compiler configuration.
 type Config struct {
 	fset *token.FileSet
 
-	// Dir is the working directory for the compiler. If empty, uses the current working directory.
+	// Dir is the working directory for the compiler.
 	Dir string
 	// OutputPath is the output path root.
 	OutputPath string
-	// BuildFlags are the Go build flags (tags) to use during analysis.
+	// BuildFlags are the Go build flags to use during package loading.
 	BuildFlags []string
-	// AllDependencies controls whether to compile all dependencies of the requested packages.
-	// If true, all dependencies will be compiled; if false, only the requested packages are compiled.
+	// AllDependencies controls whether dependencies are included in the graph.
 	AllDependencies bool
-	// DisableEmitBuiltin controls whether to emit builtin packages when they are referenced.
-	// If true, builtin packages will not be emitted; if false, they will be emitted if referenced.
-	// Default is false (emit builtin packages).
+	// DisableEmitBuiltin controls whether runtime packages are emitted.
 	DisableEmitBuiltin bool
 }
 
-// Validate checks the config.
+// Validate checks the config and initializes owned defaults.
 func (c *Config) Validate() error {
 	if c == nil {
 		return errors.New("config cannot be nil")
@@ -34,8 +30,5 @@ func (c *Config) Validate() error {
 	if c.fset == nil {
 		c.fset = token.NewFileSet()
 	}
-	if c.OutputPath == "" {
-		return errors.New("output path root must be specified")
-	}
 	return nil
 }

package/compiler/diagnostic.go

@@ -0,0 +1,70 @@
+package compiler
+
+import "strings"
+
+// DiagnosticSeverity is the severity of a compiler diagnostic.
+type DiagnosticSeverity string
+
+const (
+	// DiagnosticSeverityError marks a diagnostic that stops compilation.
+	DiagnosticSeverityError DiagnosticSeverity = "error"
+	// DiagnosticSeverityWarning marks a diagnostic that does not stop compilation.
+	DiagnosticSeverityWarning DiagnosticSeverity = "warning"
+)
+
+// Diagnostic is a structured compiler message surfaced by every adapter.
+type Diagnostic struct {
+	// Severity is the diagnostic severity.
+	Severity DiagnosticSeverity
+	// Code is a stable machine-readable diagnostic code.
+	Code string
+	// Message is the short human-readable diagnostic.
+	Message string
+	// Detail carries optional longer guidance.
+	Detail string
+}
+
+// CompileError wraps structured diagnostics for ordinary Go error paths.
+type CompileError struct {
+	// Diagnostics are the structured compiler diagnostics.
+	Diagnostics []Diagnostic
+}
+
+// NewCompileError creates a compile error from diagnostics.
+func NewCompileError(diagnostics []Diagnostic) *CompileError {
+	return &CompileError{Diagnostics: append([]Diagnostic(nil), diagnostics...)}
+}
+
+// Error returns the human-readable diagnostic summary.
+func (e *CompileError) Error() string {
+	if e == nil || len(e.Diagnostics) == 0 {
+		return "goscript: compile failed"
+	}
+
+	var b strings.Builder
+	for i, diag := range e.Diagnostics {
+		if i != 0 {
+			b.WriteString("; ")
+		}
+		if diag.Code != "" {
+			b.WriteString(diag.Code)
+			b.WriteString(": ")
+		}
+		b.WriteString(diag.Message)
+		if diag.Detail != "" {
+			b.WriteString(" (")
+			b.WriteString(diag.Detail)
+			b.WriteString(")")
+		}
+	}
+	return b.String()
+}
+
+func diagnosticsHaveErrors(diagnostics []Diagnostic) bool {
+	for _, diag := range diagnostics {
+		if diag.Severity == DiagnosticSeverityError {
+			return true
+		}
+	}
+	return false
+}

package/compiler/gotest/owner.go

@@ -0,0 +1,24 @@
+// Package gotest owns GoScript package-test execution.
+package gotest
+
+// Owner classifies the package owner that should receive a test-runner failure.
+type Owner string
+
+const (
+	// OwnerPackageGraph classifies package pattern, build tag, or dependency graph failures.
+	OwnerPackageGraph Owner = "PackageGraphOwner"
+	// OwnerSemanticModel classifies Go type or semantic fact failures.
+	OwnerSemanticModel Owner = "SemanticModelOwner"
+	// OwnerLowering classifies unsupported Go-to-GoScript lowering failures.
+	OwnerLowering Owner = "LoweringOwner"
+	// OwnerTypeScriptEmitter classifies invalid emitted TypeScript failures.
+	OwnerTypeScriptEmitter Owner = "TypeScriptEmitterOwner"
+	// OwnerRuntimePackage classifies GoScript runtime primitive failures.
+	OwnerRuntimePackage Owner = "RuntimePackageOwner"
+	// OwnerOverridePackage classifies handwritten package override failures.
+	OwnerOverridePackage Owner = "OverridePackageOwner"
+	// OwnerTestRunner classifies generated testmain, execution, and aggregation failures.
+	OwnerTestRunner Owner = "TestRunnerOwner"
+	// OwnerSpacewaveHarness classifies target-ring or harness selection failures.
+	OwnerSpacewaveHarness Owner = "SpacewaveHarnessOwner"
+)

package/compiler/gotest/package-result.go

@@ -0,0 +1,67 @@
+package gotest
+
+import "time"
+
+// Action names the package-level result action.
+type Action string
+
+const (
+	// ActionPass means the package tests passed.
+	ActionPass Action = "pass"
+	// ActionFail means the package tests failed.
+	ActionFail Action = "fail"
+	// ActionSkip means the package has no runnable tests.
+	ActionSkip Action = "skip"
+)
+
+// PhaseStatus names a package-test phase state.
+type PhaseStatus string
+
+const (
+	// PhaseStatusPending means the phase has not run yet.
+	PhaseStatusPending PhaseStatus = "pending"
+	// PhaseStatusPass means the phase passed.
+	PhaseStatusPass PhaseStatus = "pass"
+	// PhaseStatusFail means the phase failed.
+	PhaseStatusFail PhaseStatus = "fail"
+	// PhaseStatusSkip means the phase was skipped.
+	PhaseStatusSkip PhaseStatus = "skip"
+)
+
+// PackagePhases records structured package-test phase status.
+type PackagePhases struct {
+	// Workspace covers workspace files and tool discovery.
+	Workspace PhaseStatus
+	// Compile covers GoScript compile/lowering work.
+	Compile PhaseStatus
+	// Emit covers TypeScript emit/copy output work.
+	Emit PhaseStatus
+	// TypeCheck covers tsgo execution.
+	TypeCheck PhaseStatus
+	// Runtime covers Bun test execution.
+	Runtime PhaseStatus
+}
+
+// PackageResult describes one package-test result.
+type PackageResult struct {
+	// PackagePath is the package under test.
+	PackagePath string
+	// TestPackagePath is the package variant that contains test functions.
+	TestPackagePath string
+	// TestImports are direct imports from selected test variants.
+	TestImports []string
+	// Tests are the selected tests for this package.
+	Tests []Test
+	// Action is the package result.
+	Action Action
+	// Phases records structured status for each runner phase.
+	Phases PackagePhases
+	// Owner is the primary owner classification for failures.
+	Owner Owner
+	// Error is the concise package failure message.
+	Error string
+	// Output is raw process output for the package.
+	Output string
+	// Elapsed is the package runtime.
+	Elapsed time.Duration
+}

package/compiler/gotest/request.go

@@ -0,0 +1,145 @@
+package gotest
+
+import (
+	"path/filepath"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+// Request describes one GoScript package-test run.
+type Request struct {
+	// Dir is the working directory for package loading.
+	Dir string
+	// Patterns are Go package patterns to test.
+	Patterns []string
+	// BuildTags are normalized into a Go -tags build flag.
+	BuildTags []string
+	// Run is the optional Go test name regexp.
+	Run string
+	// Count is the number of times to run matched tests.
+	Count int
+	// Short reports true from testing.Short in generated tests.
+	Short bool
+	// Timeout bounds compile, typecheck, and execution.
+	Timeout time.Duration
+	// Verbose emits test-level output.
+	Verbose bool
+	// WorkDir stores generated runner files and logs.
+	WorkDir string
+	// OutputRoot stores generated TypeScript packages.
+	OutputRoot string
+}
+
+type normalizedRequest struct {
+	Dir        string
+	Patterns   []string
+	BuildFlags []string
+	Run        string
+	Count      int
+	Short      bool
+	Timeout    time.Duration
+	Verbose    bool
+	WorkDir    string
+	OutputRoot string
+}
+
+func (r *Request) normalize() (*normalizedRequest, error) {
+	if r == nil {
+		return nil, errors.New("goscript test request cannot be nil")
+	}
+
+	dir := strings.TrimSpace(r.Dir)
+	if dir == "" {
+		dir = "."
+	}
+	absDir, err := filepath.Abs(dir)
+	if err != nil {
+		return nil, errors.Wrap(err, "resolve test working directory")
+	}
+
+	patterns := normalizePatterns(r.Patterns)
+	if len(patterns) == 0 {
+		return nil, errors.New("at least one Go package pattern is required")
+	}
+
+	count := r.Count
+	if count == 0 {
+		count = 1
+	}
+	if count < 0 {
+		return nil, errors.New("test count must be positive")
+	}
+
+	buildTags := normalizeBuildTags(r.BuildTags)
+	var buildFlags []string
+	if len(buildTags) != 0 {
+		buildFlags = append(buildFlags, "-tags="+strings.Join(buildTags, ","))
+	}
+
+	workDir := strings.TrimSpace(r.WorkDir)
+	if workDir != "" {
+		var err error
+		workDir, err = filepath.Abs(workDir)
+		if err != nil {
+			return nil, errors.Wrap(err, "resolve test work directory")
+		}
+	}
+
+	outputRoot := strings.TrimSpace(r.OutputRoot)
+	if outputRoot != "" {
+		var err error
+		outputRoot, err = filepath.Abs(outputRoot)
+		if err != nil {
+			return nil, errors.Wrap(err, "resolve test output root")
+		}
+	}
+
+	return &normalizedRequest{
+		Dir:        absDir,
+		Patterns:   patterns,
+		BuildFlags: buildFlags,
+		Run:        strings.TrimSpace(r.Run),
+		Count:      count,
+		Short:      r.Short,
+		Timeout:    r.Timeout,
+		Verbose:    r.Verbose,
+		WorkDir:    workDir,
+		OutputRoot: outputRoot,
+	}, nil
+}
+
+func normalizePatterns(patterns []string) []string {
+	if len(patterns) == 0 {
+		return nil
+	}
+	normalized := make([]string, 0, len(patterns))
+	for _, pattern := range patterns {
+		pattern = strings.TrimSpace(pattern)
+		if pattern != "" {
+			normalized = append(normalized, pattern)
+		}
+	}
+	return normalized
+}
+
+func normalizeBuildTags(tags []string) []string {
+	seen := make(map[string]bool)
+	var normalized []string
+	for _, value := range tags {
+		for _, tag := range strings.FieldsFunc(value, func(r rune) bool {
+			return r == ',' || r == ' ' || r == '\t' || r == '\n'
+		}) {
+			tag = strings.TrimSpace(tag)
+			if tag == "" || seen[tag] {
+				continue
+			}
+			seen[tag] = true
+			normalized = append(normalized, tag)
+		}
+	}
+	slices.Sort(normalized)
+	return normalized
+}

package/compiler/gotest/result.go

@@ -0,0 +1,28 @@
+package gotest
+
+import "github.com/aperturerobotics/goscript/compiler"
+
+// Result describes one GoScript package-test run.
+type Result struct {
+	// WorkDir is the generated test workspace.
+	WorkDir string
+	// OutputRoot is the generated TypeScript package root.
+	OutputRoot string
+	// Packages are deterministic package-level test results.
+	Packages []PackageResult
+	// Diagnostics are compiler diagnostics surfaced during the run.
+	Diagnostics []compiler.Diagnostic
+}
+
+// Passed returns true when every package result passed or had no tests.
+func (r *Result) Passed() bool {
+	if r == nil {
+		return false
+	}
+	for _, pkg := range r.Packages {
+		if pkg.Action == ActionFail {
+			return false
+		}
+	}
+	return true
+}