goscript 0.2.0 → 0.2.1

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

@@ -1531,21 +1531,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",

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