goscript 0.1.1 → 0.1.2

package/cmd/goscript/cmd-test.go

@@ -3,6 +3,9 @@ package main
 import (
 	"context"
 	"io"
+	"os"
+	"runtime"
+	"runtime/pprof"
 	"strconv"
 	"strings"
 	"time"
@@ -18,6 +21,7 @@ func testCommands() []*cli.Command {
 
 func newTestCommand() *cli.Command {
 	var tags cli.StringSlice
+	var overrideDirs cli.StringSlice
 	var run string
 	var count int
 	var short bool
@@ -26,24 +30,45 @@ func newTestCommand() *cli.Command {
 	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) error {
+		Action: func(c *cli.Context) (err 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,
+				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
@@ -62,6 +87,12 @@ func newTestCommand() *cli.Command {
 				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",
@@ -105,10 +136,72 @@ func newTestCommand() *cli.Command {
 				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

package/cmd/goscript/cmd-test_test.go

@@ -17,7 +17,7 @@ func TestTestCommandHelp(t *testing.T) {
 		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"} {
+	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)
 		}

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/compiler/compile-request.go

@@ -36,6 +36,8 @@ 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.
@@ -77,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,
@@ -165,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

@@ -127,7 +127,6 @@ var expectedV2ComplianceGaps = map[string]bool{
 	"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,
@@ -141,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,

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/package-result.go

@@ -46,6 +46,8 @@ type PackagePhases struct {
 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.

package/compiler/gotest/request.go

@@ -2,6 +2,7 @@ package gotest
 
 import (
 	"path/filepath"
+	"runtime"
 	"slices"
 	"strings"
 	"time"
@@ -17,6 +18,8 @@ type Request struct {
 	Patterns []string
 	// BuildTags are normalized into a Go -tags build flag.
 	BuildTags []string
+	// OverrideDirs are additional GoScript override roots.
+	OverrideDirs []string
 	// Run is the optional Go test name regexp.
 	Run string
 	// Count is the number of times to run matched tests.
@@ -31,19 +34,41 @@ type Request struct {
 	WorkDir string
 	// OutputRoot stores generated TypeScript packages.
 	OutputRoot string
+	// Parallelism limits concurrent package typecheck/runtime subprocesses.
+	Parallelism int
+	// RuntimeGroups allows package runtimes to share worker Bun processes.
+	RuntimeGroups bool
+	// IncrementalTypeCheck reuses TypeScript build-info files inside WorkDir.
+	IncrementalTypeCheck bool
 }
 
 type normalizedRequest struct {
-	Dir        string
-	Patterns   []string
-	BuildFlags []string
-	Run        string
-	Count      int
-	Short      bool
-	Timeout    time.Duration
-	Verbose    bool
-	WorkDir    string
-	OutputRoot string
+	Dir                  string
+	Patterns             []string
+	BuildFlags           []string
+	OverrideDirs         []string
+	Run                  string
+	Count                int
+	Short                bool
+	Timeout              time.Duration
+	Verbose              bool
+	WorkDir              string
+	OutputRoot           string
+	Parallelism          int
+	RuntimeGroups        bool
+	IncrementalTypeCheck bool
+}
+
+// DefaultParallelism returns the default package subprocess concurrency.
+func DefaultParallelism() int {
+	parallelism := runtime.GOMAXPROCS(0)
+	if parallelism < 1 {
+		return 1
+	}
+	if parallelism > 8 {
+		return 8
+	}
+	return parallelism
 }
 
 func (r *Request) normalize() (*normalizedRequest, error) {
@@ -78,6 +103,10 @@ func (r *Request) normalize() (*normalizedRequest, error) {
 	if len(buildTags) != 0 {
 		buildFlags = append(buildFlags, "-tags="+strings.Join(buildTags, ","))
 	}
+	overrideDirs, err := normalizeOverrideDirs(r.OverrideDirs)
+	if err != nil {
+		return nil, err
+	}
 
 	workDir := strings.TrimSpace(r.WorkDir)
 	if workDir != "" {
@@ -97,20 +126,56 @@ func (r *Request) normalize() (*normalizedRequest, error) {
 		}
 	}
 
+	parallelism := r.Parallelism
+	if parallelism == 0 {
+		parallelism = DefaultParallelism()
+	}
+	if parallelism < 0 {
+		return nil, errors.New("test parallelism must be positive")
+	}
+
 	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,
+		Dir:                  absDir,
+		Patterns:             patterns,
+		BuildFlags:           buildFlags,
+		OverrideDirs:         overrideDirs,
+		Run:                  strings.TrimSpace(r.Run),
+		Count:                count,
+		Short:                r.Short,
+		Timeout:              r.Timeout,
+		Verbose:              r.Verbose,
+		WorkDir:              workDir,
+		OutputRoot:           outputRoot,
+		Parallelism:          parallelism,
+		RuntimeGroups:        r.RuntimeGroups,
+		IncrementalTypeCheck: r.IncrementalTypeCheck,
 	}, nil
 }
 
+func normalizeOverrideDirs(dirs []string) ([]string, error) {
+	if len(dirs) == 0 {
+		return nil, nil
+	}
+	var normalized []string
+	seen := make(map[string]bool)
+	for _, dir := range dirs {
+		dir = strings.TrimSpace(dir)
+		if dir == "" {
+			continue
+		}
+		abs, err := filepath.Abs(dir)
+		if err != nil {
+			return nil, errors.Wrap(err, "resolve override directory")
+		}
+		if seen[abs] {
+			continue
+		}
+		seen[abs] = true
+		normalized = append(normalized, abs)
+	}
+	return normalized, nil
+}
+
 func normalizePatterns(patterns []string) []string {
 	if len(patterns) == 0 {
 		return nil