goscript 0.1.1 → 0.1.2

package/compiler/tsworkspace/owner-process-unix_test.go

@@ -0,0 +1,72 @@
+//go:build unix
+
+package tsworkspace
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+	"testing"
+	"time"
+)
+
+func TestOwnerRunToolCancelsProcessGroup(t *testing.T) {
+	dir := t.TempDir()
+	pidFile := filepath.Join(dir, "child.pid")
+	tool := filepath.Join(dir, "spawn-child.sh")
+	script := "#!/bin/sh\n" +
+		"sleep 30 &\n" +
+		"echo $! > " + strconv.Quote(pidFile) + "\n" +
+		"wait\n"
+	if err := os.WriteFile(tool, []byte(script), 0o755); err != nil {
+		t.Fatal(err.Error())
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+	result := NewOwner(dir, dir).RunTool(ctx, PhaseRuntime, dir, tool)
+	if !result.Failed() {
+		t.Fatalf("expected canceled tool to fail")
+	}
+
+	pid := readChildPID(t, pidFile)
+	deadline := time.Now().Add(2 * time.Second)
+	for processExists(pid) && time.Now().Before(deadline) {
+		time.Sleep(25 * time.Millisecond)
+	}
+	if processExists(pid) {
+		_ = syscall.Kill(pid, syscall.SIGKILL)
+		t.Fatalf("child process %d survived canceled tool", pid)
+	}
+}
+
+func readChildPID(t *testing.T, path string) int {
+	t.Helper()
+	deadline := time.Now().Add(2 * time.Second)
+	var data []byte
+	var err error
+	for time.Now().Before(deadline) {
+		data, err = os.ReadFile(path)
+		if err == nil {
+			break
+		}
+		time.Sleep(25 * time.Millisecond)
+	}
+	if err != nil {
+		t.Fatalf("read child pid: %v", err)
+	}
+	pid, err := strconv.Atoi(strings.TrimSpace(string(data)))
+	if err != nil {
+		t.Fatalf("parse child pid %q: %v", data, err)
+	}
+	return pid
+}
+
+func processExists(pid int) bool {
+	err := syscall.Kill(pid, 0)
+	return err == nil || errors.Is(err, syscall.EPERM)
+}

package/compiler/tsworkspace/owner.go

@@ -106,6 +106,12 @@ func (o *Owner) RunTool(ctx context.Context, phase Phase, dir string, name strin
 	}
 	start := time.Now()
 	cmd := exec.CommandContext(ctx, tool, args...)
+	configureToolCommand(cmd)
+	cmd.Cancel = func() error {
+		killToolCommand(cmd)
+		return nil
+	}
+	cmd.WaitDelay = 5 * time.Second
 	cmd.Dir = dir
 	var output bytes.Buffer
 	cmd.Stdout = &output
@@ -232,6 +238,8 @@ func sourceDirectory() string {
 
 const nodeAmbientTypes = `declare const process: {
   env?: Record<string, string | undefined>
+  chdir?: (directory: string) => void
+  cwd?: () => string
   exit?: (code?: number) => never
 }
 

package/compiler/tsworkspace/tool-process-other.go

@@ -0,0 +1,14 @@
+//go:build !unix
+
+package tsworkspace
+
+import "os/exec"
+
+func configureToolCommand(cmd *exec.Cmd) {}
+
+func killToolCommand(cmd *exec.Cmd) {
+	if cmd == nil || cmd.Process == nil {
+		return
+	}
+	_ = cmd.Process.Kill()
+}

package/compiler/tsworkspace/tool-process-unix.go

@@ -0,0 +1,19 @@
+//go:build unix
+
+package tsworkspace
+
+import (
+	"os/exec"
+	"syscall"
+)
+
+func configureToolCommand(cmd *exec.Cmd) {
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+}
+
+func killToolCommand(cmd *exec.Cmd) {
+	if cmd == nil || cmd.Process == nil {
+		return
+	}
+	_ = syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
+}

package/compiler/typescript-emitter.go

@@ -132,6 +132,16 @@ func (o *TypeScriptEmitOwner) renderLoweredFile(pkg *loweredPackage, file *lower
 		b.WriteString(imp.source)
 		b.WriteString("\"\n")
 	}
+	sideEffectImports := make(map[string]bool)
+	for _, imp := range file.imports {
+		if !imp.sideEffect || sideEffectImports[imp.source] {
+			continue
+		}
+		sideEffectImports[imp.source] = true
+		b.WriteString("import \"")
+		b.WriteString(imp.source)
+		b.WriteString("\"\n")
+	}
 	if len(file.imports) != 0 {
 		b.WriteString("\n")
 	}
@@ -251,6 +261,8 @@ func structZeroValueDeps(structType *loweredStruct, names map[string]bool) []str
 func renderStruct(b *strings.Builder, structType *loweredStruct, runtimeOwner *RuntimeContractOwner) {
 	varRef := runtimeOwner.QualifiedHelper(RuntimeHelperVarRef)
 	markStructValue := runtimeOwner.QualifiedHelper(RuntimeHelperMarkAsStructValue)
+	cloneStructValue := runtimeOwner.QualifiedHelper(RuntimeHelperCloneStructValue)
+	cloneArrayValue := runtimeOwner.QualifiedHelper(RuntimeHelperCloneArrayValue)
 	registerStructType := runtimeOwner.QualifiedHelper(RuntimeHelperRegisterStructType)
 	if structType.exported {
 		b.WriteString("export ")
@@ -305,9 +317,20 @@ func renderStruct(b *strings.Builder, structType *loweredStruct, runtimeOwner *R
 			b.WriteString(field.name)
 			b.WriteString(" ? ")
 			b.WriteString(markStructValue)
+			b.WriteString("(")
+			b.WriteString(cloneStructValue)
+			b.WriteString("(init.")
+			b.WriteString(field.name)
+			b.WriteString(")) : ")
+			b.WriteString(field.zero)
+		} else if field.arrayValue {
+			b.WriteString("init?.")
+			b.WriteString(field.name)
+			b.WriteString(" !== undefined ? ")
+			b.WriteString(cloneArrayValue)
 			b.WriteString("(init.")
 			b.WriteString(field.name)
-			b.WriteString(".clone()) : ")
+			b.WriteString(") : ")
 			b.WriteString(field.zero)
 		} else {
 			b.WriteString("init?.")
@@ -337,9 +360,16 @@ func renderStruct(b *strings.Builder, structType *loweredStruct, runtimeOwner *R
 		b.WriteString("(")
 		if field.structValue {
 			b.WriteString(markStructValue)
+			b.WriteString("(")
+			b.WriteString(cloneStructValue)
 			b.WriteString("(this._fields.")
 			b.WriteString(field.name)
-			b.WriteString(".value.clone())")
+			b.WriteString(".value))")
+		} else if field.arrayValue {
+			b.WriteString(cloneArrayValue)
+			b.WriteString("(this._fields.")
+			b.WriteString(field.name)
+			b.WriteString(".value)")
 		} else {
 			b.WriteString("this._fields.")
 			b.WriteString(field.name)
@@ -421,6 +451,7 @@ func renderFunction(b *strings.Builder, fn *loweredFunction) {
 	}
 	b.WriteString("function ")
 	b.WriteString(fn.name)
+	renderFunctionTypeParams(b, fn)
 	b.WriteString("(")
 	for idx, param := range fn.params {
 		if idx != 0 {
@@ -463,6 +494,7 @@ func renderMethod(b *strings.Builder, fn *loweredFunction) {
 		b.WriteString("async ")
 	}
 	b.WriteString(fn.name)
+	renderFunctionTypeParams(b, fn)
 	b.WriteString("(")
 	for idx, param := range fn.params {
 		if idx != 0 {
@@ -499,6 +531,20 @@ func renderMethod(b *strings.Builder, fn *loweredFunction) {
 	b.WriteString("}\n")
 }
 
+func renderFunctionTypeParams(b *strings.Builder, fn *loweredFunction) {
+	if len(fn.typeParams) == 0 {
+		return
+	}
+	b.WriteString("<")
+	for idx, typeParam := range fn.typeParams {
+		if idx != 0 {
+			b.WriteString(", ")
+		}
+		b.WriteString(typeParam)
+	}
+	b.WriteString(">")
+}
+
 func receiverValue(fn *loweredFunction) string {
 	if fn.receiverValue != "" {
 		return fn.receiverValue
@@ -774,7 +820,7 @@ func renderSelect(b *strings.Builder, stmt *loweredSelect, indent int) {
 	}
 	b.WriteString(">([\n")
 	for idx, switchCase := range stmt.cases {
-		renderSelectCase(b, switchCase, stmt.external, indent+1)
+		renderSelectCase(b, switchCase, stmt.external, stmt.result, indent+1)
 		if idx != len(stmt.cases)-1 {
 			b.WriteString(",")
 		}
@@ -821,7 +867,9 @@ func renderSelectExternalBodies(b *strings.Builder, stmt *loweredSelect, indent
 		writeIndent(b, indent+2)
 		b.WriteString("{\n")
 		writeIndent(b, indent+3)
-		b.WriteString("const result = ")
+		b.WriteString("const ")
+		b.WriteString(stmt.result)
+		b.WriteString(" = ")
 		b.WriteString(stmt.value)
 		b.WriteString("\n")
 		renderStmts(b, switchCase.prelude, indent+3)
@@ -839,7 +887,7 @@ func renderSelectExternalBodies(b *strings.Builder, stmt *loweredSelect, indent
 	}
 }
 
-func renderSelectCase(b *strings.Builder, switchCase loweredSelectCase, external bool, indent int) {
+func renderSelectCase(b *strings.Builder, switchCase loweredSelectCase, external bool, resultName string, indent int) {
 	writeIndent(b, indent)
 	b.WriteString("{\n")
 	writeIndent(b, indent+1)
@@ -865,10 +913,14 @@ func renderSelectCase(b *strings.Builder, switchCase loweredSelectCase, external
 		b.WriteString(",\n")
 	}
 	writeIndent(b, indent+1)
-	b.WriteString("onSelected: async (result) => {\n")
+	b.WriteString("onSelected: async (")
+	b.WriteString(resultName)
+	b.WriteString(") => {\n")
 	if external {
 		writeIndent(b, indent+2)
-		b.WriteString("return result\n")
+		b.WriteString("return ")
+		b.WriteString(resultName)
+		b.WriteString("\n")
 		writeIndent(b, indent+1)
 		b.WriteString("}\n")
 		writeIndent(b, indent)
@@ -876,13 +928,67 @@ func renderSelectCase(b *strings.Builder, switchCase loweredSelectCase, external
 		return
 	}
 	renderStmts(b, switchCase.prelude, indent+2)
-	renderStmts(b, switchCase.body, indent+2)
+	renderSelectCaseStmts(b, switchCase.body, indent+2)
 	writeIndent(b, indent+1)
 	b.WriteString("}\n")
 	writeIndent(b, indent)
 	b.WriteString("}")
 }
 
+func renderSelectCaseStmts(b *strings.Builder, stmts []loweredStmt, indent int) {
+	for idx, stmt := range stmts {
+		renderLeadingLines(b, stmt.leading, indent)
+		if stmt.rangeFunc != nil {
+			renderRangeFunc(b, stmt.rangeFunc, indent)
+			continue
+		}
+		if stmt.switchStmt != nil {
+			renderSwitch(b, stmt.switchStmt, indent)
+			continue
+		}
+		if stmt.selectStmt != nil {
+			renderSelect(b, stmt.selectStmt, indent)
+			continue
+		}
+		if stmt.typeSwitch != nil {
+			renderTypeSwitch(b, stmt.typeSwitch, indent)
+			continue
+		}
+		writeIndent(b, indent)
+		if stmt.text == "" && (stmt.hasBlock || len(stmt.children) != 0) {
+			b.WriteString("{\n")
+			renderSelectCaseStmts(b, stmt.children, indent+1)
+			writeIndent(b, indent)
+			b.WriteString("}\n")
+			continue
+		}
+		if strings.TrimSpace(stmt.text) == "return" {
+			b.WriteString("return $.selectVoidReturn()\n")
+			continue
+		}
+		writeIndentedText(b, stmt.text, indent)
+		if !stmt.hasBlock && len(stmt.children) == 0 {
+			if idx+1 < len(stmts) && needsASIBarrier(stmt, stmts[idx+1]) {
+				b.WriteString(";")
+			}
+			b.WriteString("\n")
+			continue
+		}
+		b.WriteString(" {\n")
+		renderSelectCaseStmts(b, stmt.children, indent+1)
+		writeIndent(b, indent)
+		b.WriteString("}")
+		if len(stmt.elseBody) == 0 {
+			b.WriteString("\n")
+			continue
+		}
+		b.WriteString(" else {\n")
+		renderSelectCaseStmts(b, stmt.elseBody, indent+1)
+		writeIndent(b, indent)
+		b.WriteString("}\n")
+	}
+}
+
 func renderTypeSwitch(b *strings.Builder, stmt *loweredTypeSwitch, indent int) {
 	writeIndent(b, indent)
 	b.WriteString("{\n")
@@ -965,7 +1071,11 @@ func renderTypeSwitchInlineBody(
 	indent int,
 ) {
 	if varName == "" {
-		renderStmts(b, body, indent)
+		writeIndent(b, indent)
+		b.WriteString("{\n")
+		renderStmts(b, body, indent+1)
+		writeIndent(b, indent)
+		b.WriteString("}\n")
 		return
 	}
 	writeIndent(b, indent)
@@ -1002,6 +1112,9 @@ func renderTypeSwitchInlineBody(
 func renderIndex(pkg *loweredPackage) string {
 	var lines []string
 	for _, file := range pkg.files {
+		if file.sideEffect {
+			lines = append(lines, "import \"./"+file.outputName+"\"")
+		}
 		exports := slices.Clone(file.exports)
 		slices.Sort(exports)
 		if len(exports) != 0 {

package/dist/gs/builtin/builtin.d.ts

@@ -10,11 +10,16 @@ export declare function print(...args: any[]): void;
  * @param args Arguments to print
  */
 export declare function println(...args: any[]): void;
+export declare class GoPanic extends Error {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
 /**
  * Implementation of Go's built-in panic function
  * @param args Arguments passed to panic
  */
-export declare function panic(...args: any[]): never;
+export declare function panic(...args: unknown[]): never;
+export declare function panicValue(value: unknown): unknown;
 /**
  * Implementation of Go's built-in clear function.
  * For slices, it sets all elements to their zero value.
@@ -35,7 +40,9 @@ export declare function assignStruct<T>(target: T, source: T): void;
  * variable's address.
  */
 export declare function pointerValue<T>(value: T | VarRef<T> | null | undefined): T;
+export declare function pointerValueOrNil<T>(value: T | VarRef<T> | null | undefined): T | null;
 export declare function arrayEqual(a: unknown, b: unknown): boolean;
+export declare function comparableEqual(a: unknown, b: unknown): boolean;
 export interface Complex {
     real: number;
     imag: number;
@@ -48,13 +55,25 @@ export declare function int(value: number | bigint, bits?: number): number;
 export declare function uint(value: number | bigint, bits?: number): number;
 export declare function uint64Shl(value: number | bigint, shift: number | bigint): number;
 export declare function uint64Shr(value: number | bigint, shift: number | bigint): number;
+export declare function int64Shl(value: number | bigint, shift: number | bigint): number;
+export declare function int64Shr(value: number | bigint, shift: number | bigint): number;
 export declare function uintShr(value: number | bigint, shift: number | bigint, bits?: number): number;
 export declare function uint64Mul(left: number | bigint, right: number | bigint): number;
+export declare function int64Mul(left: number | bigint, right: number | bigint): number;
+export declare function uint64Div(left: number | bigint, right: number | bigint): number;
+export declare function int64Div(left: number | bigint, right: number | bigint): number;
+export declare function uint64Mod(left: number | bigint, right: number | bigint): number;
+export declare function int64Mod(left: number | bigint, right: number | bigint): number;
 export declare function uint64Add(left: number | bigint, right: number | bigint): number;
+export declare function int64Add(left: number | bigint, right: number | bigint): number;
 export declare function uint64Sub(left: number | bigint, right: number | bigint): number;
+export declare function int64Sub(left: number | bigint, right: number | bigint): number;
 export declare function uint64And(left: number | bigint, right: number | bigint): number;
+export declare function int64And(left: number | bigint, right: number | bigint): number;
 export declare function uint64Or(left: number | bigint, right: number | bigint): number;
+export declare function int64Or(left: number | bigint, right: number | bigint): number;
 export declare function uint64Xor(left: number | bigint, right: number | bigint): number;
+export declare function int64Xor(left: number | bigint, right: number | bigint): number;
 /**
  * Normalizes various byte representations into a `Uint8Array` for protobuf compatibility.
  *