goscript 0.1.0 → 0.1.1

package/cmd/goscript/cmd-test.go

@@ -0,0 +1,193 @@
+package main
+
+import (
+	"context"
+	"io"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/aperturerobotics/cli"
+	"github.com/aperturerobotics/goscript/compiler/gotest"
+	"github.com/pkg/errors"
+)
+
+func testCommands() []*cli.Command {
+	return []*cli.Command{newTestCommand()}
+}
+
+func newTestCommand() *cli.Command {
+	var tags cli.StringSlice
+	var run string
+	var count int
+	var short bool
+	var timeout time.Duration
+	var verbose bool
+	var outputRoot string
+	var workDir string
+	var dir string
+
+	return &cli.Command{
+		Name:     "test",
+		Category: "test",
+		Usage:    "compile and run Go package tests through GoScript",
+		Action: func(c *cli.Context) error {
+			req := &gotest.Request{
+				Dir:        dir,
+				Patterns:   c.Args().Slice(),
+				BuildTags:  tags.Value(),
+				Run:        run,
+				Count:      count,
+				Short:      short,
+				Timeout:    timeout,
+				Verbose:    verbose,
+				WorkDir:    workDir,
+				OutputRoot: outputRoot,
+			}
+			result, err := gotest.NewRunner().Run(c.Context, req)
+			if err != nil {
+				return err
+			}
+			if err := printTestResult(c.Context, c.App.Writer, result); err != nil {
+				return err
+			}
+			if !result.Passed() {
+				return errors.New("goscript test failed")
+			}
+			return nil
+		},
+		Flags: []cli.Flag{
+			&cli.StringSliceFlag{
+				Name:        "tags",
+				Usage:       "comma-separated Go build tags",
+				Destination: &tags,
+			},
+			&cli.StringFlag{
+				Name:        "run",
+				Usage:       "run only tests matching the regexp",
+				Destination: &run,
+			},
+			&cli.IntFlag{
+				Name:        "count",
+				Usage:       "run each selected test this many times",
+				Destination: &count,
+				Value:       1,
+			},
+			&cli.BoolFlag{
+				Name:        "short",
+				Usage:       "report true from testing.Short",
+				Destination: &short,
+			},
+			&cli.DurationFlag{
+				Name:        "timeout",
+				Usage:       "maximum time for the package-test run",
+				Destination: &timeout,
+				Value:       30 * time.Second,
+			},
+			&cli.BoolFlag{
+				Name:        "v",
+				Aliases:     []string{"verbose"},
+				Usage:       "emit verbose test output",
+				Destination: &verbose,
+			},
+			&cli.StringFlag{
+				Name:        "output",
+				Usage:       "generated TypeScript output root",
+				Destination: &outputRoot,
+			},
+			&cli.StringFlag{
+				Name:        "workdir",
+				Usage:       "generated test workspace directory",
+				Destination: &workDir,
+			},
+			&cli.StringFlag{
+				Name:        "dir",
+				Usage:       "Go module working directory",
+				Destination: &dir,
+			},
+		},
+	}
+}
+
+func printTestResult(ctx context.Context, w io.Writer, result *gotest.Result) error {
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	if result == nil {
+		return errors.New("goscript test result is nil")
+	}
+	for _, pkg := range result.Packages {
+		if strings.TrimSpace(pkg.Output) != "" {
+			if _, err := io.WriteString(w, strings.TrimSpace(pkg.Output)+"\n"); err != nil {
+				return err
+			}
+		}
+		switch pkg.Action {
+		case gotest.ActionPass:
+			if _, err := io.WriteString(w, "ok  \t"+pkg.PackagePath+"\t"+formatElapsed(pkg.Elapsed)+"\n"); err != nil {
+				return err
+			}
+		case gotest.ActionSkip:
+			if _, err := io.WriteString(w, "?   \t"+pkg.PackagePath+"\t[no test files]\n"); err != nil {
+				return err
+			}
+		case gotest.ActionFail:
+			line := "FAIL\t" + pkg.PackagePath
+			if pkg.Owner != "" {
+				line += "\towner=" + string(pkg.Owner)
+			}
+			if phase := failedPhase(pkg.Phases); phase != "" {
+				line += "\tphase=" + phase
+			}
+			if _, err := io.WriteString(w, line+"\n"); err != nil {
+				return err
+			}
+			if strings.TrimSpace(pkg.Error) != "" {
+				if _, err := io.WriteString(w, strings.TrimSpace(pkg.Error)+"\n"); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	if result.WorkDir != "" {
+		if _, err := io.WriteString(w, "goscript test workdir: "+result.WorkDir+"\n"); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func failedPhase(phases gotest.PackagePhases) string {
+	switch {
+	case phases.Workspace == gotest.PhaseStatusFail:
+		return "workspace"
+	case phases.Compile == gotest.PhaseStatusFail:
+		return "compile"
+	case phases.Emit == gotest.PhaseStatusFail:
+		return "emit"
+	case phases.TypeCheck == gotest.PhaseStatusFail:
+		return "typecheck"
+	case phases.Runtime == gotest.PhaseStatusFail:
+		return "runtime"
+	default:
+		return ""
+	}
+}
+
+func formatElapsed(elapsed time.Duration) string {
+	if elapsed <= 0 {
+		return "0.000s"
+	}
+	millis := elapsed.Milliseconds()
+	seconds := millis / 1000
+	remainder := millis % 1000
+	return strconv.FormatInt(seconds, 10) + "." + leftPadMillis(remainder) + "s"
+}
+
+func leftPadMillis(value int64) string {
+	raw := strconv.FormatInt(value, 10)
+	for len(raw) < 3 {
+		raw = "0" + raw
+	}
+	return raw
+}

package/cmd/goscript/cmd-test_test.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"bytes"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestTestCommandHelp(t *testing.T) {
+	var out bytes.Buffer
+	app := newApp()
+	app.Writer = &out
+
+	err := app.Run([]string{"goscript", "test", "--help"})
+	if err != nil {
+		t.Fatalf("test help failed: %v", err)
+	}
+	help := out.String()
+	for _, expected := range []string{"compile and run Go package tests through GoScript", "--tags", "--run", "--count", "--short", "--timeout"} {
+		if !strings.Contains(help, expected) {
+			t.Fatalf("help output missing %q:\n%s", expected, help)
+		}
+	}
+}
+
+func TestTestCommandRunsPackageTest(t *testing.T) {
+	dir := t.TempDir()
+	writeFile(t, filepath.Join(dir, "go.mod"), "module example.test/cmdtest\n\ngo 1.25.3\n")
+	writeFile(t, filepath.Join(dir, "value.go"), strings.Join([]string{
+		"package cmdtest",
+		"func Value() int { return 7 }",
+		"",
+	}, "\n"))
+	writeFile(t, filepath.Join(dir, "value_test.go"), strings.Join([]string{
+		"package cmdtest",
+		"import \"testing\"",
+		"func TestValue(t *testing.T) {",
+		"\tif Value() != 7 {",
+		"\t\tt.Fatal(\"bad value\")",
+		"\t}",
+		"}",
+		"",
+	}, "\n"))
+
+	var out bytes.Buffer
+	app := newApp()
+	app.Writer = &out
+	err := app.Run([]string{
+		"goscript",
+		"test",
+		"--dir",
+		dir,
+		"--workdir",
+		filepath.Join(dir, ".tmp", "cmd-test"),
+		"-v",
+		".",
+	})
+	if err != nil {
+		t.Fatalf("test command failed: %v\n%s", err, out.String())
+	}
+	if !strings.Contains(out.String(), "ok  \texample.test/cmdtest") {
+		t.Fatalf("expected ok package output, got:\n%s", out.String())
+	}
+}
+
+func TestTestCommandRejectsUnsupportedFlags(t *testing.T) {
+	app := newApp()
+	err := app.Run([]string{"goscript", "test", "--cover", "."})
+	if err == nil {
+		t.Fatalf("expected unsupported flag to fail")
+	}
+	if !strings.Contains(err.Error(), "flag provided but not defined") {
+		t.Fatalf("unexpected unsupported flag error: %v", err)
+	}
+}

package/cmd/goscript/main.go

@@ -27,6 +27,7 @@ func newApp() *cli.App {
 
 	app.Usage = "GoScript compiles Go to Typescript."
 	app.Commands = append(app.Commands, compileCommands()...)
+	app.Commands = append(app.Commands, testCommands()...)
 
 	return app
 }

package/compiler/build-flags.go

@@ -0,0 +1,38 @@
+package compiler
+
+import "slices"
+
+import "strings"
+
+const goScriptBuildTag = "goscript"
+
+func goScriptBuildFlags(flags []string) []string {
+	normalized := append([]string(nil), flags...)
+	for i, flag := range normalized {
+		switch {
+		case flag == "-tags" && i+1 < len(normalized):
+			normalized[i+1] = appendBuildTag(normalized[i+1], goScriptBuildTag)
+			return normalized
+		case strings.HasPrefix(flag, "-tags="):
+			normalized[i] = "-tags=" + appendBuildTag(strings.TrimPrefix(flag, "-tags="), goScriptBuildTag)
+			return normalized
+		}
+	}
+	return append(normalized, "-tags="+goScriptBuildTag)
+}
+
+func appendBuildTag(value string, tag string) string {
+	tags := strings.FieldsFunc(value, func(r rune) bool {
+		return r == ',' || r == ' ' || r == '\t' || r == '\n'
+	})
+	if slices.Contains(tags, tag) {
+		return value
+	}
+	if strings.TrimSpace(value) == "" {
+		return tag
+	}
+	if strings.ContainsAny(value, " \t\n") {
+		return value + " " + tag
+	}
+	return value + "," + tag
+}

package/compiler/compile-request.go

@@ -40,6 +40,8 @@ type CompileRequest struct {
 	DependencyMode DependencyMode
 	// RuntimeEmissionMode controls runtime package emission policy.
 	RuntimeEmissionMode RuntimeEmissionMode
+	// Tests controls whether package loading includes Go package-test variants.
+	Tests bool
 	// AllDependencies controls whether the package graph should include deps.
 	AllDependencies bool
 	// DisableEmitBuiltin controls whether runtime packages are emitted.

package/compiler/compliance_test.go

@@ -125,14 +125,12 @@ var expectedV2ComplianceGaps = map[string]bool{
 	"buffer_value_field_error":          true,
 	"bytes":                             true,
 	"chan_type_assertion":               true,
-	"constants_iota":                    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_post_multi_assign":             true,
 	"for_range":                         true,
 	"function_call_variable_shadowing":  true,
 	"function_signature_type":           true,
@@ -164,8 +162,6 @@ var expectedV2ComplianceGaps = map[string]bool{
 	"method_receiver_with_call_expr":    true,
 	"missing_valueof_error":             true,
 	"multi_return_same_type":            true,
-	"named_return_method":               true,
-	"named_return_multiple":             true,
 	"named_slice_wrapper":               true,
 	"named_struct_async_method":         true,
 	"named_types_valueof":               true,
@@ -175,22 +171,18 @@ var expectedV2ComplianceGaps = map[string]bool{
 	"pointer_circular_ref":              true,
 	"pointer_composite_literal_untyped": true,
 	"pointer_range_loop":                true,
-	"primitive_error_type":              true,
 	"promise_return_type":               true,
 	"protobuf_lite_ts":                  true,
-	"range_const_reassign":              true,
 	"receiver_variable":                 true,
 	"reflect_implements":                true,
 	"reflect_numfield":                  true,
 	"reserved_words":                    true,
-	"star_compound_assign":              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,
-	"variable_shadowing_scope":          true,
 	"varref_deref_struct":               true,
 	"wrapper_type_args":                 true,
 }

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
+}