goscript 0.1.0 → 0.1.2

package/cmd/goscript/cmd-test.go

@@ -0,0 +1,286 @@
+package main
+
+import (
+	"context"
+	"io"
+	"os"
+	"runtime"
+	"runtime/pprof"
+	"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 overrideDirs 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
+	var parallelism int
+	var runtimeGroups bool
+	var cpuProfile string
+	var memProfile string
+	var incrementalTypeCheck bool
+
+	return &cli.Command{
+		Name:     "test",
+		Category: "test",
+		Usage:    "compile and run Go package tests through GoScript",
+		Action: func(c *cli.Context) (err error) {
+			req := &gotest.Request{
+				Dir:                  dir,
+				Patterns:             c.Args().Slice(),
+				BuildTags:            tags.Value(),
+				OverrideDirs:         overrideDirs.Value(),
+				Run:                  run,
+				Count:                count,
+				Short:                short,
+				Timeout:              timeout,
+				Verbose:              verbose,
+				WorkDir:              workDir,
+				OutputRoot:           outputRoot,
+				Parallelism:          parallelism,
+				RuntimeGroups:        runtimeGroups,
+				IncrementalTypeCheck: incrementalTypeCheck,
+			}
+			stopProfile, err := startCPUProfile(cpuProfile)
+			if err != nil {
+				return err
+			}
+			if stopProfile != nil {
+				defer stopProfile()
+			}
+			defer func() {
+				if profileErr := writeMemProfile(memProfile); profileErr != nil && err == nil {
+					err = profileErr
+				}
+			}()
+			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.StringSliceFlag{
+				Name:        "gs-path",
+				Aliases:     []string{"override-dir"},
+				Usage:       "additional GoScript override root containing package-path directories",
+				Destination: &overrideDirs,
+			},
+			&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,
+			},
+			&cli.IntFlag{
+				Name:        "p",
+				Usage:       "maximum package typecheck/runtime commands to run concurrently",
+				Destination: &parallelism,
+				Value:       gotest.DefaultParallelism(),
+			},
+			&cli.BoolFlag{
+				Name:        "runtime-groups",
+				Usage:       "run package runtimes in grouped Bun worker processes",
+				Destination: &runtimeGroups,
+			},
+			&cli.BoolFlag{
+				Name:        "incremental-typecheck",
+				Usage:       "reuse TypeScript build-info files in the test workdir",
+				Destination: &incrementalTypeCheck,
+			},
+			&cli.StringFlag{
+				Name:        "cpuprofile",
+				Usage:       "write a Go CPU profile for the goscript test process",
+				Destination: &cpuProfile,
+			},
+			&cli.StringFlag{
+				Name:        "memprofile",
+				Usage:       "write a Go heap profile for the goscript test process",
+				Destination: &memProfile,
+			},
+		},
+	}
+}
+
+func startCPUProfile(path string) (func(), error) {
+	path = strings.TrimSpace(path)
+	if path == "" {
+		return nil, nil
+	}
+	file, err := os.Create(path)
+	if err != nil {
+		return nil, errors.Wrap(err, "create CPU profile")
+	}
+	if err := pprof.StartCPUProfile(file); err != nil {
+		_ = file.Close()
+		return nil, errors.Wrap(err, "start CPU profile")
+	}
+	return func() {
+		pprof.StopCPUProfile()
+		_ = file.Close()
+	}, nil
+}
+
+func writeMemProfile(path string) error {
+	path = strings.TrimSpace(path)
+	if path == "" {
+		return nil
+	}
+	file, err := os.Create(path)
+	if err != nil {
+		return errors.Wrap(err, "create memory profile")
+	}
+	defer func() { _ = file.Close() }()
+	runtime.GC()
+	if err := pprof.WriteHeapProfile(file); err != nil {
+		return errors.Wrap(err, "write memory profile")
+	}
+	return nil
+}
+
+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", "-p", "--runtime-groups", "--cpuprofile", "--memprofile"} {
+		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/cmd_compile.go

@@ -18,6 +18,7 @@ func newCompileCommand() *cli.Command {
 	var config compiler.Config
 	var packages cli.StringSlice
 	var buildFlags cli.StringSlice
+	var overrideDirs cli.StringSlice
 
 	return &cli.Command{
 		Name:     "compile",
@@ -25,6 +26,7 @@ func newCompileCommand() *cli.Command {
 		Usage:    "compile a Go package to TypeScript",
 		Action: func(c *cli.Context) error {
 			config.BuildFlags = slices.Clone(buildFlags.Value())
+			config.OverrideDirs = slices.Clone(overrideDirs.Value())
 			return compilePackage(c.Context, &config, packages.Value())
 		},
 		Flags: []cli.Flag{
@@ -56,6 +58,13 @@ func newCompileCommand() *cli.Command {
 				Destination: &buildFlags,
 				EnvVars:     []string{"GOSCRIPT_BUILD_FLAGS"},
 			},
+			&cli.StringSliceFlag{
+				Name:        "gs-path",
+				Aliases:     []string{"override-dir"},
+				Usage:       "additional GoScript override root containing package-path directories",
+				Destination: &overrideDirs,
+				EnvVars:     []string{"GOSCRIPT_GS_PATH"},
+			},
 			&cli.BoolFlag{
 				Name:        "disable-emit-builtin",
 				Usage:       "disable emitting built-in packages that have handwritten equivalents",

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

@@ -36,10 +36,14 @@ type CompileRequest struct {
 	OutputPath string
 	// BuildFlags are forwarded to the Go package loader.
 	BuildFlags []string
+	// OverrideDirs are additional GoScript override roots.
+	OverrideDirs []string
 	// DependencyMode controls whether dependencies are included in the graph.
 	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.
@@ -75,6 +79,7 @@ func (o *CompileRequestOwner) NewRequest(conf Config, patterns []string) *Compil
 		Dir:                 strings.TrimSpace(dir),
 		OutputPath:          strings.TrimSpace(conf.OutputPath),
 		BuildFlags:          append([]string(nil), conf.BuildFlags...),
+		OverrideDirs:        append([]string(nil), conf.OverrideDirs...),
 		DependencyMode:      dependencyMode,
 		RuntimeEmissionMode: runtimeEmissionMode,
 		AllDependencies:     conf.AllDependencies,
@@ -163,6 +168,34 @@ func (o *CompileRequestOwner) Validate(req *CompileRequest) []Diagnostic {
 			})
 		}
 	}
+	for _, dir := range req.OverrideDirs {
+		dir = strings.TrimSpace(dir)
+		if dir == "" {
+			diagnostics = append(diagnostics, Diagnostic{
+				Severity: DiagnosticSeverityError,
+				Code:     "goscript/request:empty-override-dir",
+				Message:  "override directories must not be empty",
+			})
+			continue
+		}
+		info, err := os.Stat(dir)
+		switch {
+		case err != nil:
+			diagnostics = append(diagnostics, Diagnostic{
+				Severity: DiagnosticSeverityError,
+				Code:     "goscript/request:override-dir",
+				Message:  "override directory is not readable",
+				Detail:   err.Error(),
+			})
+		case !info.IsDir():
+			diagnostics = append(diagnostics, Diagnostic{
+				Severity: DiagnosticSeverityError,
+				Code:     "goscript/request:override-dir",
+				Message:  "override path must be a directory",
+				Detail:   dir,
+			})
+		}
+	}
 
 	for _, pattern := range req.Patterns {
 		trimmed := strings.TrimSpace(pattern)

package/compiler/compiler.go

@@ -23,7 +23,7 @@ func NewCompiler(conf *Config, le *logrus.Entry, _ *packages.Config) (*Compiler,
 	return &Compiler{
 		le:      le,
 		config:  *conf,
-		service: NewCompileService(),
+		service: NewCompileService(conf.OverrideDirs...),
 	}, nil
 }
 

package/compiler/compliance_test.go

@@ -125,14 +125,11 @@ 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,
@@ -143,7 +140,6 @@ var expectedV2ComplianceGaps = map[string]bool{
 	"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,
@@ -164,8 +160,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 +169,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/config.go

@@ -16,6 +16,8 @@ type Config struct {
 	OutputPath string
 	// BuildFlags are the Go build flags to use during package loading.
 	BuildFlags []string
+	// OverrideDirs are additional GoScript override roots.
+	OverrideDirs []string
 	// AllDependencies controls whether dependencies are included in the graph.
 	AllDependencies bool
 	// DisableEmitBuiltin controls whether runtime packages are emitted.

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,69 @@
+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
+	// SourceDir is the package source directory used as the runtime cwd.
+	SourceDir 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
+}