goscript 0.1.4 → 0.2.1

package/compiler/diagnostic_test.go

@@ -0,0 +1,106 @@
+package compiler
+
+import (
+	"context"
+	"errors"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestFormatDiagnosticIncludesDisplayPosition(t *testing.T) {
+	diag := Diagnostic{
+		Severity: DiagnosticSeverityError,
+		Code:     "goscript/test",
+		Message:  "failed",
+		Detail:   "bad input",
+		Position: &DiagnosticPosition{
+			File:        filepath.Join("internal", "raw.go"),
+			DisplayFile: filepath.Join("pkg", "main.go"),
+			Line:        12,
+			Column:      3,
+		},
+	}
+
+	got := FormatDiagnostic(diag)
+	want := "pkg/main.go:12:3: goscript/test: failed (bad input)"
+	if got != want {
+		t.Fatalf("FormatDiagnostic() = %q, want %q", got, want)
+	}
+}
+
+func TestFormatDiagnosticWithoutPositionPreservesLegacyShape(t *testing.T) {
+	diag := Diagnostic{
+		Severity: DiagnosticSeverityError,
+		Code:     "goscript/test",
+		Message:  "failed",
+		Detail:   "bad input",
+	}
+
+	got := FormatDiagnostic(diag)
+	want := "goscript/test: failed (bad input)"
+	if got != want {
+		t.Fatalf("FormatDiagnostic() = %q, want %q", got, want)
+	}
+}
+
+func TestDiagnosticPositionFromSourceUsesDisplayRoot(t *testing.T) {
+	root := t.TempDir()
+	file := filepath.Join(root, "pkg", "main.go")
+	pos := diagnosticPositionFromSource(sourcePosition{
+		file:   file,
+		line:   7,
+		column: 9,
+	}, root)
+
+	if pos == nil {
+		t.Fatal("expected diagnostic position")
+	}
+	if pos.File != file {
+		t.Fatalf("File = %q, want %q", pos.File, file)
+	}
+	if pos.DisplayFile != "pkg/main.go" {
+		t.Fatalf("DisplayFile = %q, want %q", pos.DisplayFile, "pkg/main.go")
+	}
+}
+
+func TestLoweringUnsupportedDiagnosticIncludesSourcePosition(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":  "module example.test/loweringdiag\n\ngo 1.25.3\n",
+		"main.go": "package loweringdiag\n\nfunc Make[T ~[]int]() T {\n\treturn make(T, 1)\n}\n",
+	})
+	service := NewCompileService()
+	_, err := service.Compile(context.Background(), &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "output"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeReference,
+	})
+	if err == nil {
+		t.Fatal("expected lowering diagnostic")
+	}
+	var compileErr *CompileError
+	if !errors.As(err, &compileErr) {
+		t.Fatalf("expected CompileError, got %T: %v", err, err)
+	}
+	if len(compileErr.Diagnostics) != 1 {
+		t.Fatalf("Diagnostics = %#v, want exactly one", compileErr.Diagnostics)
+	}
+	diag := compileErr.Diagnostics[0]
+	if diag.Code != "goscript/lowering:unsupported" {
+		t.Fatalf("Code = %q, want goscript/lowering:unsupported", diag.Code)
+	}
+	if diag.Position == nil {
+		t.Fatalf("missing position in %#v", diag)
+	}
+	if diag.Position.DisplayFile != "main.go" {
+		t.Fatalf("DisplayFile = %q, want main.go", diag.Position.DisplayFile)
+	}
+	if diag.Position.Line != 4 {
+		t.Fatalf("Line = %d, want 4", diag.Position.Line)
+	}
+	if got := FormatDiagnostics(compileErr.Diagnostics); !strings.HasPrefix(got, "main.go:4:") {
+		t.Fatalf("formatted diagnostic = %q, want main.go:4 prefix", got)
+	}
+}

package/compiler/gotest/request.go

@@ -30,12 +30,16 @@ type Request struct {
 	Timeout time.Duration
 	// Verbose emits test-level output.
 	Verbose bool
+	// PanicOnExit0 makes os.Exit(0) fail like go test's -test.paniconexit0.
+	PanicOnExit0 bool
 	// WorkDir stores generated runner files and logs.
 	WorkDir string
 	// OutputRoot stores generated TypeScript packages.
 	OutputRoot string
 	// Parallelism limits concurrent package typecheck/runtime subprocesses.
 	Parallelism int
+	// RuntimeBackend selects the JavaScript host used for package runtime tests.
+	RuntimeBackend RuntimeBackend
 	// RuntimeGroups allows package runtimes to share worker Bun processes.
 	RuntimeGroups bool
 	// IncrementalTypeCheck reuses TypeScript build-info files inside WorkDir.
@@ -52,13 +56,25 @@ type normalizedRequest struct {
 	Short                bool
 	Timeout              time.Duration
 	Verbose              bool
+	PanicOnExit0         bool
 	WorkDir              string
 	OutputRoot           string
 	Parallelism          int
+	RuntimeBackend       RuntimeBackend
 	RuntimeGroups        bool
 	IncrementalTypeCheck bool
 }
 
+// RuntimeBackend selects the JavaScript host used for package runtime tests.
+type RuntimeBackend string
+
+const (
+	// RuntimeBackendBun runs generated package-test modules directly in Bun.
+	RuntimeBackendBun RuntimeBackend = "bun"
+	// RuntimeBackendBrowser runs generated package-test modules in Chromium.
+	RuntimeBackendBrowser RuntimeBackend = "browser"
+)
+
 // DefaultParallelism returns the default package subprocess concurrency.
 func DefaultParallelism() int {
 	parallelism := runtime.GOMAXPROCS(0)
@@ -134,6 +150,16 @@ func (r *Request) normalize() (*normalizedRequest, error) {
 		return nil, errors.New("test parallelism must be positive")
 	}
 
+	runtimeBackend := r.RuntimeBackend
+	if runtimeBackend == "" {
+		runtimeBackend = RuntimeBackendBun
+	}
+	switch runtimeBackend {
+	case RuntimeBackendBun, RuntimeBackendBrowser:
+	default:
+		return nil, errors.Errorf("unsupported runtime backend %q", runtimeBackend)
+	}
+
 	return &normalizedRequest{
 		Dir:                  absDir,
 		Patterns:             patterns,
@@ -144,9 +170,11 @@ func (r *Request) normalize() (*normalizedRequest, error) {
 		Short:                r.Short,
 		Timeout:              r.Timeout,
 		Verbose:              r.Verbose,
+		PanicOnExit0:         r.PanicOnExit0,
 		WorkDir:              workDir,
 		OutputRoot:           outputRoot,
 		Parallelism:          parallelism,
+		RuntimeBackend:       runtimeBackend,
 		RuntimeGroups:        r.RuntimeGroups,
 		IncrementalTypeCheck: r.IncrementalTypeCheck,
 	}, nil