goscript 0.1.3 → 0.2.0

package/compiler/gotest/runner_test.go

@@ -64,6 +64,53 @@ func TestRunnerRunsOrdinaryPackageTest(t *testing.T) {
 	}
 }
 
+func TestRunnerComparesInterfacePointerValuesByIdentity(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/ifaceptr\n\ngo 1.25.3\n",
+		"value_test.go": strings.Join([]string{
+			"package ifaceptr",
+			"",
+			"import \"testing\"",
+			"",
+			"type Snapshot interface {",
+			"\tValue() int",
+			"}",
+			"",
+			"type snapshot struct {",
+			"\tvalue int",
+			"}",
+			"",
+			"func (s *snapshot) Value() int { return s.value }",
+			"",
+			"func TestInterfacePointerValuesUsePointerIdentity(t *testing.T) {",
+			"\tvar first Snapshot = &snapshot{value: 1}",
+			"\tvar second Snapshot = &snapshot{value: 1}",
+			"\tif first == second {",
+			"\t\tt.Fatalf(\"distinct pointers stored in interfaces compared equal\")",
+			"\t}",
+			"\tsecond = first",
+			"\tif first != second {",
+			"\t\tt.Fatalf(\"same pointer stored in interfaces compared unequal\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"."},
+		Timeout:  30 * time.Second,
+		Verbose:  true,
+	})
+	if err != nil {
+		t.Fatalf("run package test: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("expected package test to pass: %#v", result.Packages)
+	}
+}
+
 func TestRunnerReportsShortMode(t *testing.T) {
 	moduleDir := writeFixture(t, map[string]string{
 		"go.mod": "module example.test/short\n\ngo 1.25.3\n",
@@ -258,6 +305,86 @@ func TestRunnerRunsExternalPackageTest(t *testing.T) {
 	}
 }
 
+func TestRunnerBatchCompilesSamePackageTests(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/samebatch\n\ngo 1.25.3\n",
+		"helper/value.go": strings.Join([]string{
+			"package helper",
+			"",
+			"func Value() int { return 2 }",
+			"",
+		}, "\n"),
+		"one/value.go": strings.Join([]string{
+			"package one",
+			"",
+			"func Value() int { return 1 }",
+			"",
+		}, "\n"),
+		"one/value_test.go": strings.Join([]string{
+			"package one",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestOne(t *testing.T) {",
+			"\tif Value() != 1 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+		"two/value.go": strings.Join([]string{
+			"package two",
+			"",
+			"import \"example.test/samebatch/one\"",
+			"",
+			"func Value() int { return one.Value() + 1 }",
+			"",
+		}, "\n"),
+		"two/value_test.go": strings.Join([]string{
+			"package two",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestTwo(t *testing.T) {",
+			"\tif Value() != 2 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+		"two/external_test.go": strings.Join([]string{
+			"package two_test",
+			"",
+			"import (",
+			"\t\"testing\"",
+			"",
+			"\t\"example.test/samebatch/helper\"",
+			"\t\"example.test/samebatch/two\"",
+			")",
+			"",
+			"func TestTwoExternal(t *testing.T) {",
+			"\tif two.Value() != helper.Value() {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"./..."},
+		Timeout:  30 * time.Second,
+		Verbose:  true,
+	})
+	if err != nil {
+		t.Fatalf("run same-package batch tests: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("expected same-package batch tests to pass: %#v", result.Packages)
+	}
+}
+
 func TestRunnerAppliesOverridesToTestImports(t *testing.T) {
 	moduleDir := writeFixture(t, map[string]string{
 		"go.mod": "module example.test/testoverride\n\ngo 1.25.3\n",
@@ -909,7 +1036,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;;",
@@ -945,6 +1072,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",
@@ -1068,6 +1346,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{
 		{
@@ -1124,6 +1430,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{
@@ -1176,6 +1552,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/lowered-program.go

@@ -18,6 +18,7 @@ type loweredFile struct {
 	decls       []loweredDecl
 	exports     []string
 	typeExports []string
+	exportAll   bool
 	sideEffect  bool
 }
 
@@ -75,28 +76,34 @@ 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
+	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 {