goscript 0.2.0 → 0.2.2

package/cmd/goscript-wasm/main.go

@@ -3,8 +3,10 @@
 package main
 
 import (
+	"errors"
 	"syscall/js"
 
+	"github.com/aperturerobotics/goscript/compiler"
 	"github.com/aperturerobotics/goscript/compiler/wasm"
 )
 
@@ -20,8 +22,9 @@ func main() {
 func compileWrapper(this js.Value, args []js.Value) interface{} {
 	if len(args) < 1 {
 		return map[string]interface{}{
-			"error":  "missing source code argument",
-			"output": "",
+			"error":       "missing source code argument",
+			"output":      "",
+			"diagnostics": []interface{}{},
 		}
 	}
 
@@ -33,14 +36,43 @@ func compileWrapper(this js.Value, args []js.Value) interface{} {
 
 	output, err := wasm.CompileSource(source, packageName)
 	if err != nil {
+		diagnostics := []interface{}{}
+		var compileErr *compiler.CompileError
+		if errors.As(err, &compileErr) {
+			diagnostics = encodeDiagnostics(compileErr.Diagnostics)
+		}
 		return map[string]interface{}{
-			"error":  err.Error(),
-			"output": "",
+			"error":       err.Error(),
+			"output":      "",
+			"diagnostics": diagnostics,
 		}
 	}
 
 	return map[string]interface{}{
-		"error":  "",
-		"output": output,
+		"error":       "",
+		"output":      output,
+		"diagnostics": []interface{}{},
+	}
+}
+
+func encodeDiagnostics(diagnostics []compiler.Diagnostic) []interface{} {
+	encoded := make([]interface{}, 0, len(diagnostics))
+	for _, diagnostic := range diagnostics {
+		item := map[string]interface{}{
+			"severity": string(diagnostic.Severity),
+			"code":     diagnostic.Code,
+			"message":  diagnostic.Message,
+			"detail":   diagnostic.Detail,
+		}
+		if diagnostic.Position != nil {
+			item["position"] = map[string]interface{}{
+				"file":        diagnostic.Position.File,
+				"displayFile": diagnostic.Position.DisplayFile,
+				"line":        diagnostic.Position.Line,
+				"column":      diagnostic.Position.Column,
+			}
+		}
+		encoded = append(encoded, item)
 	}
+	return encoded
 }

package/compiler/diagnostic.go

@@ -1,6 +1,10 @@
 package compiler
 
-import "strings"
+import (
+	"path/filepath"
+	"strconv"
+	"strings"
+)
 
 // DiagnosticSeverity is the severity of a compiler diagnostic.
 type DiagnosticSeverity string
@@ -22,6 +26,20 @@ type Diagnostic struct {
 	Message string
 	// Detail carries optional longer guidance.
 	Detail string
+	// Position is the optional source point that caused the diagnostic.
+	Position *DiagnosticPosition
+}
+
+// DiagnosticPosition identifies the source point that caused a diagnostic.
+type DiagnosticPosition struct {
+	// File is the raw file identity from the compiler source owner.
+	File string
+	// DisplayFile is the request-relative file identity for human output.
+	DisplayFile string
+	// Line is the 1-based source line.
+	Line int
+	// Column is the 1-based source column.
+	Column int
 }
 
 // CompileError wraps structured diagnostics for ordinary Go error paths.
@@ -41,25 +59,99 @@ func (e *CompileError) Error() string {
 		return "goscript: compile failed"
 	}
 
+	return FormatDiagnostics(e.Diagnostics)
+}
+
+// FormatDiagnostics returns the canonical human-readable diagnostic summary.
+func FormatDiagnostics(diagnostics []Diagnostic) string {
 	var b strings.Builder
-	for i, diag := range e.Diagnostics {
+	for i, diag := range diagnostics {
 		if i != 0 {
 			b.WriteString("; ")
 		}
-		if diag.Code != "" {
-			b.WriteString(diag.Code)
-			b.WriteString(": ")
-		}
-		b.WriteString(diag.Message)
-		if diag.Detail != "" {
-			b.WriteString(" (")
-			b.WriteString(diag.Detail)
-			b.WriteString(")")
-		}
+		b.WriteString(FormatDiagnostic(diag))
 	}
 	return b.String()
 }
 
+// FormatDiagnostic returns the canonical human-readable form of one diagnostic.
+func FormatDiagnostic(diag Diagnostic) string {
+	var b strings.Builder
+	if pos := formatDiagnosticPosition(diag.Position); pos != "" {
+		b.WriteString(pos)
+		b.WriteString(": ")
+	}
+	if diag.Code != "" {
+		b.WriteString(diag.Code)
+		b.WriteString(": ")
+	}
+	b.WriteString(diag.Message)
+	if diag.Detail != "" {
+		b.WriteString(" (")
+		b.WriteString(diag.Detail)
+		b.WriteString(")")
+	}
+	return b.String()
+}
+
+func formatDiagnosticPosition(pos *DiagnosticPosition) string {
+	if pos == nil || pos.Line <= 0 {
+		return ""
+	}
+	file := strings.TrimSpace(pos.DisplayFile)
+	if file == "" {
+		file = strings.TrimSpace(pos.File)
+	}
+	if file == "" {
+		return ""
+	}
+	var b strings.Builder
+	b.WriteString(filepath.ToSlash(file))
+	b.WriteString(":")
+	b.WriteString(strconv.Itoa(pos.Line))
+	if pos.Column > 0 {
+		b.WriteString(":")
+		b.WriteString(strconv.Itoa(pos.Column))
+	}
+	return b.String()
+}
+
+func diagnosticPositionFromSource(pos sourcePosition, displayRoot string) *DiagnosticPosition {
+	if pos.line <= 0 {
+		return nil
+	}
+	file := strings.TrimSpace(pos.file)
+	return &DiagnosticPosition{
+		File:        file,
+		DisplayFile: diagnosticDisplayFile(file, displayRoot),
+		Line:        pos.line,
+		Column:      pos.column,
+	}
+}
+
+func diagnosticDisplayFile(file string, displayRoot string) string {
+	file = strings.TrimSpace(file)
+	if file == "" {
+		return ""
+	}
+	displayRoot = strings.TrimSpace(displayRoot)
+	if displayRoot == "" {
+		return filepath.ToSlash(file)
+	}
+	root := displayRoot
+	if absRoot, err := filepath.Abs(root); err == nil {
+		root = absRoot
+	}
+	candidate := file
+	if !filepath.IsAbs(candidate) {
+		candidate = filepath.Join(root, candidate)
+	}
+	if rel, err := filepath.Rel(root, candidate); err == nil && rel != "." && rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+		return filepath.ToSlash(rel)
+	}
+	return filepath.ToSlash(file)
+}
+
 func diagnosticsHaveErrors(diagnostics []Diagnostic) bool {
 	for _, diag := range diagnostics {
 		if diag.Severity == DiagnosticSeverityError {

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/runner.go

@@ -141,6 +141,10 @@ func (r *Runner) runPackageTools(
 	if len(indexes) == 0 {
 		return
 	}
+	if phase := materializeRuntimeModuleShims(req, outputRoots); phase.Failed() {
+		markRuntimeFailures(result, indexes, OwnerTestRunner, phase.Error)
+		return
+	}
 	if len(indexes) == 1 {
 		r.runPackageTypeCheckAndRuntime(ctx, req, workspace, result, outputRoots, indexes[0])
 		return
@@ -286,6 +290,100 @@ func (r *Runner) runPackageRuntimes(
 	r.runPackageRuntimesIndividually(ctx, req, workspace, result, outputRoots, indexes)
 }
 
+func materializeRuntimeModuleShims(req *normalizedRequest, outputRoots []string) tsworkspace.Result {
+	if req.RuntimeBackend != RuntimeBackendBun {
+		return tsworkspace.Result{Phase: tsworkspace.PhaseWorkspace}
+	}
+	seen := make(map[string]bool)
+	shimRoots := runtimeModuleShimRoots(req, outputRoots)
+	for _, outputRoot := range outputRoots {
+		if outputRoot == "" {
+			continue
+		}
+		root := filepath.Join(outputRoot, "@goscript")
+		if _, err := os.Stat(root); err != nil {
+			if os.IsNotExist(err) {
+				continue
+			}
+			return tsworkspace.Result{Phase: tsworkspace.PhaseWorkspace, Error: errors.Wrap(err, "stat GoScript runtime output root").Error()}
+		}
+		err := filepath.WalkDir(root, func(path string, entry os.DirEntry, err error) error {
+			if err != nil {
+				return err
+			}
+			if entry.IsDir() || filepath.Ext(path) != ".ts" {
+				return nil
+			}
+			rel, err := filepath.Rel(root, path)
+			if err != nil {
+				return err
+			}
+			shimRel := filepath.Join("node_modules", "@goscript", strings.TrimSuffix(rel, ".ts")+".js")
+			for _, shimRoot := range shimRoots {
+				shimPath := filepath.Join(shimRoot, shimRel)
+				seenKey := shimPath
+				if seen[seenKey] {
+					continue
+				}
+				seen[seenKey] = true
+				shimDir := filepath.Dir(shimPath)
+				importPath, err := filepath.Rel(shimDir, path)
+				if err != nil {
+					return err
+				}
+				importPath = filepath.ToSlash(importPath)
+				if !strings.HasPrefix(importPath, ".") {
+					importPath = "./" + importPath
+				}
+				if err := writeRuntimeModuleShim(shimPath, "export * from "+strconv.Quote(importPath)+"\n"); err != nil {
+					return err
+				}
+			}
+			return nil
+		})
+		if err != nil {
+			return tsworkspace.Result{Phase: tsworkspace.PhaseWorkspace, Error: errors.Wrap(err, "materialize GoScript runtime module shims").Error()}
+		}
+	}
+	return tsworkspace.Result{Phase: tsworkspace.PhaseWorkspace}
+}
+
+func runtimeModuleShimRoots(req *normalizedRequest, outputRoots []string) []string {
+	seen := make(map[string]bool)
+	var roots []string
+	for _, root := range append([]string{req.WorkDir}, outputRoots...) {
+		if root == "" {
+			continue
+		}
+		clean := filepath.Clean(root)
+		if seen[clean] {
+			continue
+		}
+		seen[clean] = true
+		roots = append(roots, clean)
+	}
+	return roots
+}
+
+func writeRuntimeModuleShim(path string, data string) error {
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return err
+	}
+	return os.WriteFile(path, []byte(data), 0o644)
+}
+
+func markRuntimeFailures(result *Result, indexes []int, owner Owner, message string) {
+	for _, idx := range indexes {
+		if idx < 0 || idx >= len(result.Packages) {
+			continue
+		}
+		result.Packages[idx].Action = ActionFail
+		result.Packages[idx].Owner = owner
+		result.Packages[idx].Phases.Runtime = PhaseStatusFail
+		result.Packages[idx].Error = message
+	}
+}
+
 func (r *Runner) runPackageRuntimesIndividually(
 	ctx context.Context,
 	req *normalizedRequest,
@@ -1531,21 +1629,5 @@ func diagnosticsHaveErrors(diagnostics []compiler.Diagnostic) bool {
 }
 
 func diagnosticsSummary(diagnostics []compiler.Diagnostic) string {
-	var b strings.Builder
-	for idx, diagnostic := range diagnostics {
-		if idx != 0 {
-			b.WriteString("; ")
-		}
-		if diagnostic.Code != "" {
-			b.WriteString(diagnostic.Code)
-			b.WriteString(": ")
-		}
-		b.WriteString(diagnostic.Message)
-		if diagnostic.Detail != "" {
-			b.WriteString(" (")
-			b.WriteString(diagnostic.Detail)
-			b.WriteString(")")
-		}
-	}
-	return b.String()
+	return compiler.FormatDiagnostics(diagnostics)
 }

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",
@@ -1609,6 +1629,51 @@ func TestRenderRuntimeTypeScriptProjectDisablesEmit(t *testing.T) {
 	}
 }
 
+func TestMaterializeRuntimeModuleShimsReexportsGeneratedTypeScript(t *testing.T) {
+	workDir := t.TempDir()
+	outputRoot := filepath.Join(workDir, "output")
+	for _, name := range []string{
+		"errors/index.ts",
+		"github.com/s4wave/spacewave/core/plugin/space/config.gs.ts",
+	} {
+		path := filepath.Join(outputRoot, "@goscript", filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+			t.Fatalf("create output parent: %v", err)
+		}
+		if err := os.WriteFile(path, []byte("export const value = 1\n"), 0o644); err != nil {
+			t.Fatalf("write output file: %v", err)
+		}
+	}
+
+	req := &normalizedRequest{
+		WorkDir:        workDir,
+		RuntimeBackend: RuntimeBackendBun,
+	}
+	phase := materializeRuntimeModuleShims(req, []string{outputRoot})
+	if phase.Failed() {
+		t.Fatalf("materialize shims: %s", phase.Error)
+	}
+	for _, root := range []string{workDir, outputRoot} {
+		for _, name := range []string{
+			"errors/index.js",
+			"github.com/s4wave/spacewave/core/plugin/space/config.gs.js",
+		} {
+			path := filepath.Join(root, "node_modules", "@goscript", filepath.FromSlash(name))
+			data, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatalf("read shim %s: %v", name, err)
+			}
+			text := string(data)
+			if !strings.Contains(text, ".ts\"") {
+				t.Fatalf("shim should re-export generated TypeScript: %s", text)
+			}
+			if strings.Contains(text, workDir) {
+				t.Fatalf("shim should use a portable relative import, got: %s", text)
+			}
+		}
+	}
+}
+
 func TestRenderTypeScriptProjectsCanUseIncrementalBuildInfo(t *testing.T) {
 	req := &normalizedRequest{
 		WorkDir:              "/work",

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

@@ -59,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 {
@@ -90,6 +91,7 @@ type loweredFunction struct {
 	indexExported    bool
 	init             bool
 	async            bool
+	sourcePath       string
 	name             string
 	typeParams       []string
 	runtimeName      string