goscript 0.1.4 → 0.2.1

package/compiler/gotest/runner_test.go

@@ -10,8 +10,28 @@ import (
 	"strings"
 	"testing"
 	"time"
+
+	"github.com/aperturerobotics/goscript/compiler"
 )
 
+func TestDiagnosticsSummaryUsesCompilerFormatter(t *testing.T) {
+	got := diagnosticsSummary([]compiler.Diagnostic{{
+		Severity: compiler.DiagnosticSeverityError,
+		Code:     "goscript/test",
+		Message:  "failed",
+		Detail:   "bad input",
+		Position: &compiler.DiagnosticPosition{
+			DisplayFile: "pkg/main.go",
+			Line:        4,
+			Column:      2,
+		},
+	}})
+	want := "pkg/main.go:4:2: goscript/test: failed (bad input)"
+	if got != want {
+		t.Fatalf("diagnosticsSummary() = %q, want %q", got, want)
+	}
+}
+
 func TestRunnerRunsOrdinaryPackageTest(t *testing.T) {
 	moduleDir := writeFixture(t, map[string]string{
 		"go.mod": "module example.test/gotest\n\ngo 1.25.3\n",
@@ -1036,7 +1056,7 @@ func TestRunnerRunsCombinedRuntimeChunks(t *testing.T) {
 		"case \"$runner\" in",
 		"runner-all-*)",
 		"\tsed -n 's/.*await __goscriptRunPackage(\"\\([^\"]*\\)\".*/\\1/p' \"$runner\" | while IFS= read -r pkg; do",
-		"\t\tprintf '" + combinedRuntimeResultPrefix + "{\"packagePath\":\"%s\",\"ok\":true,\"elapsedMs\":1,\"output\":\"\"}\\n' \"$pkg\"",
+		"\t\tprintf '" + combinedRuntimeResultPrefix + "%s\\t1\\t1\\t\\n' \"$pkg\"",
 		"\tdone",
 		"\texit 0",
 		"\t;;",
@@ -1072,6 +1092,157 @@ func TestRunnerRunsCombinedRuntimeChunks(t *testing.T) {
 	}
 }
 
+func TestRunnerRunsBrowserRuntimeBackend(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/browser\n\ngo 1.25.3\n",
+		"value_test.go": strings.Join([]string{
+			"package browser",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestBrowser(t *testing.T) {}",
+			"",
+		}, "\n"),
+	})
+	workDir := filepath.Join(moduleDir, ".tmp", "browser-runtime")
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "vitest"), strings.Join([]string{
+		"#!/bin/sh",
+		"printf '" + combinedRuntimeResultPrefix + "example.test%%2Fbrowser\\t1\\t7\\tbrowser%%20ok\\n'",
+		"exit 0",
+		"",
+	}, "\n"))
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:            moduleDir,
+		Patterns:       []string{"."},
+		Timeout:        30 * time.Second,
+		WorkDir:        workDir,
+		RuntimeBackend: RuntimeBackendBrowser,
+	})
+	if err != nil {
+		t.Fatalf("run browser runtime fixture: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("expected browser runtime fixture to pass: %#v", result.Packages)
+	}
+	if got := result.Packages[0].Output; got != "browser ok" {
+		t.Fatalf("expected browser runtime output, got %q", got)
+	}
+	config, err := os.ReadFile(filepath.Join(workDir, "vitest-browser-0.config.mts"))
+	if err != nil {
+		t.Fatalf("read browser vitest config: %v", err)
+	}
+	if !strings.Contains(string(config), "browser: \"chromium\"") {
+		t.Fatalf("expected Chromium browser config, got:\n%s", config)
+	}
+}
+
+func TestRunnerReportsBrowserRuntimeFailureRecord(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/browserfail\n\ngo 1.25.3\n",
+		"value_test.go": strings.Join([]string{
+			"package browserfail",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestBrowser(t *testing.T) {}",
+			"",
+		}, "\n"),
+	})
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "tsgo"), "#!/bin/sh\nexit 0\n")
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "vitest"), strings.Join([]string{
+		"#!/bin/sh",
+		"printf '" + combinedRuntimeResultPrefix + "example.test%%2Fbrowserfail\\t0\\t3\\tpage%%20exploded\\n'",
+		"exit 1",
+		"",
+	}, "\n"))
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:            moduleDir,
+		Patterns:       []string{"."},
+		Timeout:        30 * time.Second,
+		RuntimeBackend: RuntimeBackendBrowser,
+	})
+	if err != nil {
+		t.Fatalf("run browser failure fixture: %v", err)
+	}
+	if result.Passed() {
+		t.Fatalf("expected browser runtime failure")
+	}
+	pkg := requirePackageResult(t, result, "example.test/browserfail")
+	if pkg.Action != ActionFail || pkg.Phases.Runtime != PhaseStatusFail || pkg.Error != "page exploded" {
+		t.Fatalf("unexpected browser failure result: %#v", pkg)
+	}
+}
+
+func TestParseCombinedRuntimeRecordsLineProtocol(t *testing.T) {
+	records, ok := parseCombinedRuntimeRecords(strings.Join([]string{
+		"ordinary output",
+		combinedRuntimeResultPrefix + "example.test%2Fpkg\t1\t42\tline%201%0Aline%202%09tail",
+		"",
+	}, "\n"))
+	if !ok {
+		t.Fatal("expected combined runtime record")
+	}
+	if len(records) != 1 {
+		t.Fatalf("expected one combined runtime record, got %#v", records)
+	}
+	record := records[0]
+	if record.PackagePath != "example.test/pkg" {
+		t.Fatalf("unexpected package path: %q", record.PackagePath)
+	}
+	if !record.OK {
+		t.Fatal("expected passing runtime record")
+	}
+	if record.ElapsedMS != 42 {
+		t.Fatalf("unexpected elapsed ms: %d", record.ElapsedMS)
+	}
+	if record.Output != "line 1\nline 2\ttail" {
+		t.Fatalf("unexpected output: %q", record.Output)
+	}
+}
+
+func TestRunnerReportsBrowserRuntimeMissingResult(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/browsermissing\n\ngo 1.25.3\n",
+		"value_test.go": strings.Join([]string{
+			"package browsermissing",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestBrowser(t *testing.T) {}",
+			"",
+		}, "\n"),
+	})
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "tsgo"), "#!/bin/sh\nexit 0\n")
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "vitest"), strings.Join([]string{
+		"#!/bin/sh",
+		"printf 'page exploded before result\\n'",
+		"exit 1",
+		"",
+	}, "\n"))
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:            moduleDir,
+		Patterns:       []string{"."},
+		Timeout:        30 * time.Second,
+		RuntimeBackend: RuntimeBackendBrowser,
+	})
+	if err != nil {
+		t.Fatalf("run browser missing-result fixture: %v", err)
+	}
+	if result.Passed() {
+		t.Fatalf("expected browser runtime failure")
+	}
+	pkg := requirePackageResult(t, result, "example.test/browsermissing")
+	if pkg.Action != ActionFail || pkg.Phases.Runtime != PhaseStatusFail {
+		t.Fatalf("unexpected browser missing-result status: %#v", pkg)
+	}
+	if !strings.Contains(pkg.Error, "page exploded before result") {
+		t.Fatalf("expected browser process output in error, got %#v", pkg)
+	}
+}
+
 func TestRunnerFallsBackToPackageScopedTypeScriptProjects(t *testing.T) {
 	moduleDir := writeFixture(t, map[string]string{
 		"go.mod": "module example.test/packageprojects\n\ngo 1.25.3\n",
@@ -1195,6 +1366,34 @@ func TestNormalizeKeepsIncrementalTypeCheckExplicit(t *testing.T) {
 	}
 }
 
+func TestNormalizeRuntimeBackend(t *testing.T) {
+	norm, err := (&Request{Patterns: []string{"."}}).normalize()
+	if err != nil {
+		t.Fatalf("normalize default runtime backend: %v", err)
+	}
+	if norm.RuntimeBackend != RuntimeBackendBun {
+		t.Fatalf("runtime backend = %q, want %q", norm.RuntimeBackend, RuntimeBackendBun)
+	}
+
+	norm, err = (&Request{
+		Patterns:       []string{"."},
+		RuntimeBackend: RuntimeBackendBrowser,
+	}).normalize()
+	if err != nil {
+		t.Fatalf("normalize browser runtime backend: %v", err)
+	}
+	if norm.RuntimeBackend != RuntimeBackendBrowser {
+		t.Fatalf("runtime backend = %q, want %q", norm.RuntimeBackend, RuntimeBackendBrowser)
+	}
+
+	if _, err := (&Request{
+		Patterns:       []string{"."},
+		RuntimeBackend: RuntimeBackend("deno"),
+	}).normalize(); err == nil {
+		t.Fatal("expected unsupported runtime backend to fail")
+	}
+}
+
 func TestPackageExecutionIndexesPrioritizesLargerTestPackages(t *testing.T) {
 	result := &Result{Packages: []PackageResult{
 		{
@@ -1251,6 +1450,76 @@ func TestRenderRunnerChangesToPackageSourceDir(t *testing.T) {
 	}
 }
 
+func TestRenderBrowserRunnerAvoidsProcessAPIs(t *testing.T) {
+	req := &normalizedRequest{
+		RuntimeBackend: RuntimeBackendBrowser,
+	}
+	runner := renderPackageRunner(PackageResult{
+		PackagePath: "example.test/pkg",
+		SourceDir:   "/workspace/pkg",
+		Tests: []Test{{
+			Name:        "TestBrowser",
+			PackagePath: "example.test/pkg",
+		}},
+	}, req)
+
+	if strings.Contains(runner, "process.") {
+		t.Fatalf("browser runner should not use process APIs: %s", runner)
+	}
+	if !strings.Contains(runner, "import { test } from \"vitest\"") {
+		t.Fatalf("expected browser runner to use Vitest: %s", runner)
+	}
+	if !strings.Contains(runner, "await runTests(\"example.test/pkg\"") {
+		t.Fatalf("expected browser runner to execute package tests: %s", runner)
+	}
+}
+
+func TestRenderBrowserRunnerReportsProcessExit(t *testing.T) {
+	req := &normalizedRequest{
+		RuntimeBackend: RuntimeBackendBrowser,
+	}
+	runner := renderPackageRunner(PackageResult{
+		PackagePath: "example.test/pkg",
+		SourceDir:   "/workspace/pkg",
+		Tests: []Test{{
+			Name:        "TestBrowser",
+			PackagePath: "example.test/pkg",
+		}},
+	}, req)
+
+	if !strings.Contains(runner, "__goscriptProcessExitCode") {
+		t.Fatalf("expected browser runner to classify process exit: %s", runner)
+	}
+	if !strings.Contains(runner, "goscript process exited with code") {
+		t.Fatalf("expected browser runner to report process exit code: %s", runner)
+	}
+	if !strings.Contains(runner, "__goscriptOK = exitCode === 0") {
+		t.Fatalf("expected zero exit to pass and nonzero exit to fail: %s", runner)
+	}
+}
+
+func TestRenderBrowserRunnerHonorsPanicOnExitZero(t *testing.T) {
+	req := &normalizedRequest{
+		RuntimeBackend: RuntimeBackendBrowser,
+		PanicOnExit0:   true,
+	}
+	runner := renderPackageRunner(PackageResult{
+		PackagePath: "example.test/pkg",
+		SourceDir:   "/workspace/pkg",
+		Tests: []Test{{
+			Name:        "TestBrowser",
+			PackagePath: "example.test/pkg",
+		}},
+	}, req)
+
+	if !strings.Contains(runner, "exitCode === 0 && true") {
+		t.Fatalf("expected panic-on-exit-zero to reject os.Exit(0): %s", runner)
+	}
+	if !strings.Contains(runner, "unexpected os.Exit(0) during test") {
+		t.Fatalf("expected panic-on-exit-zero error text: %s", runner)
+	}
+}
+
 func TestRenderCombinedRunnerChangesToEachPackageSourceDir(t *testing.T) {
 	req := &normalizedRequest{}
 	runner := renderCombinedRunner(&Result{Packages: []PackageResult{
@@ -1303,6 +1572,29 @@ func TestRenderTypeScriptProjectDisablesAmbientTypePackages(t *testing.T) {
 	}
 }
 
+func TestRenderBrowserTypeScriptProjectsExcludeNodeAmbientDeclarations(t *testing.T) {
+	req := &normalizedRequest{
+		WorkDir:        "/work",
+		RuntimeBackend: RuntimeBackendBrowser,
+	}
+
+	packageTSConfig := renderTypeScriptProject(req, "/work/output/package-0", "runner-0.ts", "tsconfig-0.json", false)
+	if strings.Contains(packageTSConfig, "goscript-node.d.ts") {
+		t.Fatalf("browser package tsconfig should not include node ambient declarations: %s", packageTSConfig)
+	}
+	if !strings.Contains(packageTSConfig, "goscript-browser.d.ts") {
+		t.Fatalf("browser package tsconfig should include browser ambient declarations: %s", packageTSConfig)
+	}
+
+	aggregateTSConfig := renderRuntimeTypeScriptProject(req, []string{"/work/output"}, false)
+	if strings.Contains(aggregateTSConfig, "goscript-node.d.ts") {
+		t.Fatalf("browser aggregate tsconfig should not include node ambient declarations: %s", aggregateTSConfig)
+	}
+	if !strings.Contains(aggregateTSConfig, "goscript-browser.d.ts") {
+		t.Fatalf("browser aggregate tsconfig should include browser ambient declarations: %s", aggregateTSConfig)
+	}
+}
+
 func TestRenderTypeScriptProjectUsesNodeTypesWhenAvailable(t *testing.T) {
 	req := &normalizedRequest{
 		WorkDir: "/work",

package/compiler/gotest/testdata/browserapi/browserapi_test.go

@@ -0,0 +1,20 @@
+//go:build js && wasm
+
+package browserapi
+
+import (
+	"syscall/js"
+	"testing"
+)
+
+func TestBrowserAPI(t *testing.T) {
+	document := js.Global().Get("document")
+	if document.IsUndefined() || document.IsNull() {
+		t.Fatal("missing browser document")
+	}
+	div := document.Call("createElement", "div")
+	div.Set("id", "goscript-browser-api")
+	if got := div.Get("id").String(); got != "goscript-browser-api" {
+		t.Fatalf("div id = %q", got)
+	}
+}

package/compiler/gotest/testdata/browserapi/go.mod

@@ -0,0 +1,3 @@
+module example.test/browserapi
+
+go 1.25.3

package/compiler/index.test.ts

@@ -28,4 +28,27 @@ describe('GoScript Compiler API', () => {
     expect(generated).toContain('export async function main(): globalThis.Promise<void>')
     expect(generated).toContain('$.println("api")')
   }, 30000)
+
+  it('inherits positioned compiler diagnostics on stderr', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'goscript-api-diagnostic-'))
+    const output = join(dir, 'output')
+    await mkdir(dir, { recursive: true })
+    await writeFile(join(dir, 'go.mod'), 'module example.test/apierr\n\ngo 1.25.3\n')
+    await writeFile(join(dir, 'main.go'), [
+      'package apierr',
+      '',
+      'func Make[T ~[]int]() T {',
+      '  return make(T, 1)',
+      '}',
+      '',
+    ].join('\n'))
+
+    await expect(compile({
+      pkg: '.',
+      output,
+      dir,
+    })).rejects.toMatchObject({
+      stderr: expect.stringContaining('main.go:4:'),
+    })
+  }, 30000)
 })

package/compiler/lowered-program.go

@@ -18,6 +18,7 @@ type loweredFile struct {
 	decls       []loweredDecl
 	exports     []string
 	typeExports []string
+	exportAll   bool
 	sideEffect  bool
 }
 
@@ -58,13 +59,14 @@ type loweredDecl struct {
 }
 
 type loweredStruct struct {
-	exported      bool
-	indexExported bool
-	name          string
-	typeName      string
-	cloneMethod   string
-	fields        []loweredStructField
-	methods       []loweredFunction
+	exported             bool
+	indexExported        bool
+	protobufPreserveJSON bool
+	name                 string
+	typeName             string
+	cloneMethod          string
+	fields               []loweredStructField
+	methods              []loweredFunction
 }
 
 type loweredStructField struct {
@@ -75,28 +77,35 @@ type loweredStructField struct {
 	runtimeType string
 	doc         string
 	tag         string
+	pkgPath     string
+	index       []int
+	offset      int64
+	anonymous   bool
+	exported    bool
 	structValue bool
 	arrayValue  bool
 }
 
 type loweredFunction struct {
-	exported        bool
-	indexExported   bool
-	init            bool
-	async           bool
-	name            string
-	typeParams      []string
-	runtimeName     string
-	receiverAlias   string
-	receiverType    string
-	receiverValue   string
-	receiverMutable bool
-	params          []loweredParam
-	paramBindings   []loweredStmt
-	namedResults    []loweredNamedResult
-	result          string
-	body            []loweredStmt
-	deferState      *loweredDeferState
+	exported         bool
+	indexExported    bool
+	init             bool
+	async            bool
+	sourcePath       string
+	name             string
+	typeParams       []string
+	runtimeName      string
+	runtimeSignature string
+	receiverAlias    string
+	receiverType     string
+	receiverValue    string
+	receiverMutable  bool
+	params           []loweredParam
+	paramBindings    []loweredStmt
+	namedResults     []loweredNamedResult
+	result           string
+	body             []loweredStmt
+	deferState       *loweredDeferState
 }
 
 type loweredParam struct {