goscript 0.0.10 → 0.0.13

package/README.md

@@ -306,7 +306,7 @@ func main() {
 Generated with `goscript compile .`:
 
 ```typescript
-import * as goscript from "@go/builtin"
+import * as goscript from "@goscript/builtin"
 
 class MyStruct {
   // MyInt is a public integer field, initialized to zero.
@@ -460,10 +460,10 @@ export async function main(): Promise<void> {
 
 Code is compiled with `GOARCH=js` and uses a 32-bit environment similar to wasm.
 
-All Go import paths are prefixed with `@go/` and can be imported in TypeScript:
+All Go import paths are prefixed with `@goscript/` and can be imported in TypeScript:
 
 ```typescript
-import { MyAsyncFunction, MyStruct } from '@go/github.com/myorg/mypackage';
+import { MyAsyncFunction, MyStruct } from '@goscript/github.com/myorg/mypackage';
 
 // Example of importing and using a compiled Go async function
 async function runGoCode() {

package/builtin/builtin.go

@@ -0,0 +1,11 @@
+package builtin
+
+import (
+	_ "embed"
+)
+
+// BuiltinTs contains the contents of the builtin.ts file which provides
+// runtime support for GoScript compiled code.
+//
+//go:embed builtin.ts
+var BuiltinTs string

package/builtin/builtin.ts

@@ -13,6 +13,34 @@ export const makeSlice = <T>(
   return slice
 }
 
+/**
+ * Creates a new slice header that shares the backing array.
+ * Arguments mirror Go semantics; omitted indices are undefined.
+ *
+ * @param arr  The original slice/array produced by makeSlice or another slice
+ * @param low  Starting index (defaults to 0)
+ * @param high Ending index (defaults to arr.length)
+ * @param max  Capacity limit (defaults to original capacity)
+ */
+export const slice = <T>(
+  arr: Array<T> & { __capacity?: number },
+  low?: number,
+  high?: number,
+  max?: number,
+): Array<T> & { __capacity?: number } => {
+  const start = low ?? 0
+  const origLen = arr.length
+  const origCap = arr.__capacity !== undefined ? arr.__capacity : origLen
+  const end = high !== undefined ? high : origLen
+  const newCap = max !== undefined ? max - start : origCap - start
+
+  const newArr = arr.slice(start, end) as Array<T> & {
+    __capacity?: number
+  }
+  newArr.__capacity = newCap
+  return newArr
+}
+
 /**
  * Creates a new map (TypeScript Map).
  * @returns A new TypeScript Map.
@@ -50,8 +78,8 @@ export const cap = <T>(slice: Array<T> & { __capacity?: number }): number => {
  * Represents the Go error type (interface).
  */
 export type Error = {
-  Error(): string;
-} | null;
+  Error(): string
+} | null
 
 /**
  * Converts a string to an array of Unicode code points (runes).
@@ -62,6 +90,15 @@ export const stringToRunes = (str: string): number[] => {
   return Array.from(str).map((c) => c.codePointAt(0) || 0)
 }
 
+/**
+ * Converts an array of Unicode code points (runes) to a string.
+ * @param runes The input array of numbers representing Unicode code points.
+ * @returns The resulting string.
+ */
+export const runesToString = (runes: number[]): string => {
+  return String.fromCharCode(...runes);
+};
+
 /**
  * Gets a value from a map, with a default value if the key doesn't exist.
  * @param map The map to get from.
@@ -113,8 +150,14 @@ export const mapHas = <K, V>(map: Map<K, V>, key: K): boolean => {
  * @param elements The elements to append.
  * @returns The modified slice (TypeScript array).
  */
-export const append = <T>(slice: Array<T>, ...elements: T[]): Array<T> => {
+export const append = <T>(
+  slice: Array<T> & { __capacity?: number },
+  ...elements: T[]
+): Array<T> & { __capacity?: number } => {
   slice.push(...elements)
+  if (slice.__capacity !== undefined && slice.length > slice.__capacity) {
+    slice.__capacity = slice.length
+  }
   return slice
 }
 
@@ -122,35 +165,35 @@ export const append = <T>(slice: Array<T>, ...elements: T[]): Array<T> => {
  * Represents the kinds of Go types that can be registered at runtime.
  */
 export enum TypeKind {
-  Struct = "struct",
-  Interface = "interface",
-  Basic = "basic",
-  Pointer = "pointer",
-  Slice = "slice",
-  Map = "map",
-  Channel = "channel",
-  Function = "function",
+  Struct = 'struct',
+  Interface = 'interface',
+  Basic = 'basic',
+  Pointer = 'pointer',
+  Slice = 'slice',
+  Map = 'map',
+  Channel = 'channel',
+  Function = 'function',
 }
 
 /**
  * Represents type information for a Go type in the runtime.
  */
 export interface TypeInfo {
-  name: string;
-  kind: TypeKind;
-  zeroValue: any;
+  name: string
+  kind: TypeKind
+  zeroValue: any
   // For interfaces, the set of methods
-  methods?: Set<string>;
+  methods?: Set<string>
   // For structs, the constructor
-  constructor?: new (...args: any[]) => any;
+  constructor?: new (...args: any[]) => any
 }
 
 // Registry to store runtime type information
-const typeRegistry = new Map<string, TypeInfo>();
+const typeRegistry = new Map<string, TypeInfo>()
 
 /**
  * Registers a type with the runtime type system.
- * 
+ *
  * @param name The name of the type.
  * @param kind The kind of the type.
  * @param zeroValue The zero value for the type.
@@ -163,7 +206,7 @@ export const registerType = (
   kind: TypeKind,
   zeroValue: any,
   methods?: Set<string>,
-  constructor?: new (...args: any[]) => any
+  constructor?: new (...args: any[]) => any,
 ): TypeInfo => {
   const typeInfo: TypeInfo = {
     name,
@@ -171,37 +214,40 @@ export const registerType = (
     zeroValue,
     methods,
     constructor,
-  };
-  typeRegistry.set(name, typeInfo);
-  return typeInfo;
-};
+  }
+  typeRegistry.set(name, typeInfo)
+  return typeInfo
+}
 
 /**
  * Represents the result of a type assertion.
  */
 export interface TypeAssertResult<T> {
-  value: T;
-  ok: boolean;
+  value: T
+  ok: boolean
 }
 
 /**
  * Performs a type assertion at runtime.
- * 
+ *
  * @param value The value to assert.
  * @param typeName The name of the target type.
  * @returns An object with the asserted value and whether the assertion succeeded.
  */
-export function typeAssert<T>(value: any, typeName: string): TypeAssertResult<T> {
+export function typeAssert<T>(
+  value: any,
+  typeName: string,
+): TypeAssertResult<T> {
   // Get the type information from the registry
-  const typeInfo = typeRegistry.get(typeName);
+  const typeInfo = typeRegistry.get(typeName)
   if (!typeInfo) {
-    console.warn(`Type information for '${typeName}' not found in registry.`);
-    return { value: null as unknown as T, ok: false };
+    console.warn(`Type information for '${typeName}' not found in registry.`)
+    return { value: null as unknown as T, ok: false }
   }
 
   // If value is null or undefined, assertion fails
   if (value === null || value === undefined) {
-    return { value: typeInfo.zeroValue as T, ok: false };
+    return { value: typeInfo.zeroValue as T, ok: false }
   }
 
   // Check based on the kind of the target type
@@ -209,86 +255,88 @@ export function typeAssert<T>(value: any, typeName: string): TypeAssertResult<T>
     case TypeKind.Struct:
       // For structs, use instanceof with the constructor
       if (typeInfo.constructor && value instanceof typeInfo.constructor) {
-        return { value: value as T, ok: true };
+        return { value: value as T, ok: true }
       }
-      break;
-      
+      break
+
     case TypeKind.Interface:
       // For interfaces, check if the value has all the required methods
       if (typeInfo.methods && typeof value === 'object') {
         const allMethodsPresent = Array.from(typeInfo.methods).every(
-          (method) => typeof (value as any)[method] === 'function'
-        );
+          (method) => typeof (value as any)[method] === 'function',
+        )
         if (allMethodsPresent) {
-          return { value: value as T, ok: true };
+          return { value: value as T, ok: true }
         }
       }
-      break;
-      
+      break
+
     case TypeKind.Basic:
       // For basic types, check if the value matches the expected JavaScript type
       // This is a simple check for common basic types
-      const basicType = typeof value;
+      const basicType = typeof value
       if (
-        basicType === 'string' || 
-        basicType === 'number' || 
+        basicType === 'string' ||
+        basicType === 'number' ||
         basicType === 'boolean'
       ) {
-        return { value: value as T, ok: true };
+        return { value: value as T, ok: true }
       }
-      break;
-      
+      break
+
     case TypeKind.Pointer:
       // For pointers, check if value is not null or undefined
       // In Go, pointers can be nil which we represent as null/undefined in TS
       if (value !== null && value !== undefined) {
-        return { value: value as T, ok: true };
+        return { value: value as T, ok: true }
       }
-      break;
-      
+      break
+
     case TypeKind.Slice:
       // For slices, check if the value is an array
       if (Array.isArray(value)) {
-        return { value: value as T, ok: true };
+        return { value: value as T, ok: true }
       }
-      break;
-      
+      break
+
     case TypeKind.Map:
       // For maps, check if the value is a Map
       if (value instanceof Map) {
-        return { value: value as T, ok: true };
+        return { value: value as T, ok: true }
       }
-      break;
-      
+      break
+
     case TypeKind.Channel:
       // For channels, check if the value has the required Channel interface methods
       if (
-        typeof value === 'object' && 
+        typeof value === 'object' &&
         value !== null &&
-        'send' in value && 
-        'receive' in value && 
+        'send' in value &&
+        'receive' in value &&
         'close' in value &&
         typeof value.send === 'function' &&
         typeof value.receive === 'function' &&
         typeof value.close === 'function'
       ) {
-        return { value: value as T, ok: true };
+        return { value: value as T, ok: true }
       }
-      break;
-      
+      break
+
     case TypeKind.Function:
       // For functions, check if the value is a function
       if (typeof value === 'function') {
-        return { value: value as T, ok: true };
+        return { value: value as T, ok: true }
       }
-      break;
-      
+      break
+
     default:
-      console.warn(`Type assertion for kind '${typeInfo.kind}' not implemented.`);
+      console.warn(
+        `Type assertion for kind '${typeInfo.kind}' not implemented.`,
+      )
   }
 
   // Assertion failed
-  return { value: typeInfo.zeroValue as T, ok: false };
+  return { value: typeInfo.zeroValue as T, ok: false }
 }
 
 /**
@@ -715,3 +763,60 @@ export const makeChannel = <T>(
 ): Channel<T> => {
   return new BufferedChannel<T>(bufferSize, zeroValue)
 }
+
+/**
+ * DisposableStack manages synchronous disposable resources, mimicking Go's defer behavior.
+ * Functions added via `defer` are executed in LIFO order when the stack is disposed.
+ * Implements the `Disposable` interface for use with `using` declarations.
+ */
+export class DisposableStack implements Disposable {
+  #stack: (() => void)[] = [];
+
+  /**
+   * Adds a function to be executed when the stack is disposed.
+   * @param fn The function to defer.
+   */
+  defer(fn: () => void): void { this.#stack.push(fn); }
+
+  /**
+   * Disposes of the resources in the stack by executing the deferred functions
+   * in Last-In, First-Out (LIFO) order.
+   * If a deferred function throws an error, disposal stops, and the error is rethrown,
+   * similar to Go's panic behavior during defer execution.
+   */
+  [Symbol.dispose](): void {
+    // Emulate Go: if a deferred throws, stop and rethrow
+    while (this.#stack.length) {
+      const fn = this.#stack.pop()!;
+      fn();
+    }
+  }
+}
+
+/**
+ * AsyncDisposableStack manages asynchronous disposable resources, mimicking Go's defer behavior.
+ * Functions added via `defer` are executed sequentially in LIFO order when the stack is disposed.
+ * Implements the `AsyncDisposable` interface for use with `await using` declarations.
+ */
+export class AsyncDisposableStack implements AsyncDisposable {
+  #stack: (() => Promise<void> | void)[] = [];
+
+  /**
+   * Adds a synchronous or asynchronous function to be executed when the stack is disposed.
+   * @param fn The function to defer. Can return void or a Promise<void>.
+   */
+  defer(fn: () => Promise<void> | void): void {
+    this.#stack.push(fn);
+  }
+
+  /**
+   * Asynchronously disposes of the resources in the stack by executing the deferred functions
+   * sequentially in Last-In, First-Out (LIFO) order. It awaits each function if it returns a promise.
+   */
+  async [Symbol.asyncDispose](): Promise<void> {
+    // Execute in LIFO order, awaiting each potentially async function
+    for (let i = this.#stack.length - 1; i >= 0; --i) {
+      await this.#stack[i]();
+    }
+  }
+}

package/cmd/goscript/cmd_compile.go

@@ -2,17 +2,22 @@ package main
 
 import (
 	"context"
+	"slices"
 
 	"github.com/aperturerobotics/cli"
 	"github.com/paralin/goscript/compiler"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
+
+	// _ ensure we include the builtin package
+	_ "github.com/paralin/goscript/builtin"
 )
 
 var (
-	cliCompiler       *compiler.Compiler
-	cliCompilerConfig compiler.Config
-	cliCompilerPkg    string
+	cliCompiler           *compiler.Compiler
+	cliCompilerConfig     compiler.Config
+	cliCompilerPkg        cli.StringSlice
+	cliCompilerBuildFlags cli.StringSlice
 )
 
 // CompileCommands are commands related to compiling code.
@@ -29,9 +34,11 @@ var CompileCommands = []*cli.Command{{
 		return
 	},
 	Flags: []cli.Flag{
-		&cli.StringFlag{
+		&cli.StringSliceFlag{
 			Name:        "package",
-			Usage:       "the package to compile",
+			Usage:       "the package(s) to compile",
+			Aliases:     []string{"p", "packages"},
+			EnvVars:     []string{"GOSCRIPT_PACKAGES"},
 			Destination: &cliCompilerPkg,
 		},
 		&cli.StringFlag{
@@ -39,21 +46,34 @@ var CompileCommands = []*cli.Command{{
 			Usage:       "the output typescript path to use",
 			Destination: &cliCompilerConfig.OutputPathRoot,
 			Value:       "./output",
+			EnvVars:     []string{"GOSCRIPT_OUTPUT"},
 		},
 		&cli.StringFlag{
 			Name:        "dir",
 			Usage:       "the working directory to use for the compiler (default: current directory)",
 			Destination: &cliCompilerConfig.Dir,
 			Value:       "",
+			EnvVars:     []string{"GOSCRIPT_DIR"},
+		},
+		&cli.StringSliceFlag{
+			Name:        "build-flags",
+			Aliases:     []string{"b", "buildflags", "build-flag", "buildflag"},
+			Usage:       "Go build flags (tags) to use during analysis",
+			Destination: &cliCompilerBuildFlags,
+			EnvVars:     []string{"GOSCRIPT_BUILD_FLAGS"},
 		},
 	},
 }}
 
 // compilePackage tries to compile the package.
 func compilePackage(c *cli.Context) error {
-	if cliCompilerPkg == "" {
-		return errors.New("package must be specified")
+	pkgs := cliCompilerPkg.Value()
+	if len(pkgs) == 0 {
+		return errors.New("package(s) must be specified")
 	}
 
-	return cliCompiler.CompilePackages(context.Background(), cliCompilerPkg)
+	// build flags
+	cliCompilerConfig.BuildFlags = slices.Clone(cliCompilerBuildFlags.Value())
+
+	return cliCompiler.CompilePackages(context.Background(), pkgs...)
 }

package/compiler/compile.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/token"
-	"go/types"
+	gtypes "go/types"
 
 	gstypes "github.com/paralin/goscript/compiler/types"
 	"golang.org/x/tools/go/packages"
@@ -12,19 +12,19 @@ import (
 
 // GoToTSCompiler compiles Go code to TypeScript code.
 type GoToTSCompiler struct {
-	tsw        *TSCodeWriter
-	imports    map[string]*fileImport
-	pkg        *packages.Package
-	cmap       ast.CommentMap
-	asyncFuncs map[string]bool // Track which functions are async
-
-	tempVarCounter int // Counter for generating unique temporary variable names
+	tsw                 *TSCodeWriter
+	imports             map[string]*fileImport
+	pkg                 *packages.Package
+	cmap                ast.CommentMap
+	asyncFuncs          map[string]bool // Track which functions are async
+	nextBlockNeedsDefer bool            // Track if the next block should have a "using" statement
+	inAsyncFunction     bool            // Track if we're inside an async function
 }
 
 // WriteGoType writes a Go type as a TypeScript type.
-func (c *GoToTSCompiler) WriteGoType(typ types.Type) {
+func (c *GoToTSCompiler) WriteGoType(typ gtypes.Type) {
 	switch t := typ.(type) {
-	case *types.Basic:
+	case *gtypes.Basic:
 		// Handle basic types (int, string, etc.)
 		name := t.Name()
 		if tsType, ok := gstypes.GoBuiltinToTypescript(name); ok {
@@ -32,31 +32,31 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type) {
 		} else {
 			c.tsw.WriteLiterally(name)
 		}
-	case *types.Named:
+	case *gtypes.Named:
 		// Handle named types (custom types)
 		c.tsw.WriteLiterally(t.Obj().Name())
-	case *types.Pointer:
+	case *gtypes.Pointer:
 		// Handle pointer types (*T becomes T | null)
 		c.WriteGoType(t.Elem())
 		c.tsw.WriteLiterally(" | null")
-	case *types.Slice, *types.Array:
+	case *gtypes.Slice, *gtypes.Array:
 		// Handle array/slice types ([]T or [N]T becomes T[])
-		var elemType types.Type
-		if slice, ok := t.(*types.Slice); ok {
+		var elemType gtypes.Type
+		if slice, ok := t.(*gtypes.Slice); ok {
 			elemType = slice.Elem()
-		} else if array, ok := t.(*types.Array); ok {
+		} else if array, ok := t.(*gtypes.Array); ok {
 			elemType = array.Elem()
 		}
 		c.WriteGoType(elemType)
 		c.tsw.WriteLiterally("[]")
-	case *types.Map:
+	case *gtypes.Map:
 		// Handle map types (map[K]V becomes Map<K, V>)
 		c.tsw.WriteLiterally("Map<")
 		c.WriteGoType(t.Key())
 		c.tsw.WriteLiterally(", ")
 		c.WriteGoType(t.Elem())
 		c.tsw.WriteLiterally(">")
-	case *types.Chan:
+	case *gtypes.Chan:
 		// Handle channel types (chan T becomes goscript.Channel<T>)
 		c.tsw.WriteLiterally("goscript.Channel<")
 		c.WriteGoType(t.Elem())
@@ -68,24 +68,32 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type) {
 	}
 }
 
+// scanForDefer checks if a block contains any defer statements (recursively).
+func (c *GoToTSCompiler) scanForDefer(block *ast.BlockStmt) bool {
+	hasDefer := false
+	ast.Inspect(block, func(n ast.Node) bool {
+		if _, ok := n.(*ast.DeferStmt); ok {
+			hasDefer = true
+			return false // Stop traversal
+		}
+		return true // Continue traversal
+	})
+	return hasDefer
+}
+
 // NewGoToTSCompiler builds a new GoToTSCompiler
 func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, cmap ast.CommentMap) *GoToTSCompiler {
 	return &GoToTSCompiler{
-		tsw:            tsw,
-		imports:        make(map[string]*fileImport),
-		pkg:            pkg,
-		cmap:           cmap,
-		asyncFuncs:     make(map[string]bool),
-		tempVarCounter: 0, // Initialize counter
+		tsw:                 tsw,
+		imports:             make(map[string]*fileImport),
+		pkg:                 pkg,
+		cmap:                cmap,
+		asyncFuncs:          make(map[string]bool),
+		nextBlockNeedsDefer: false,
+		inAsyncFunction:     false,
 	}
 }
 
-// newTempVar generates a unique temporary variable name.
-func (c *GoToTSCompiler) newTempVar() string {
-	c.tempVarCounter++
-	return fmt.Sprintf("_tempVar%d", c.tempVarCounter)
-}
-
 // isAsyncFunc determines if a function is asynchronous
 // A function is async if it contains channel operations or calls other async functions
 func (c *GoToTSCompiler) isAsyncFunc(name string) bool {
@@ -128,7 +136,7 @@ func (c *GoToTSCompiler) containsAsyncOperations(node ast.Node) bool {
 // Handles array types recursively.
 func (c *GoToTSCompiler) WriteZeroValueForType(typ any) {
 	switch t := typ.(type) {
-	case *types.Array:
+	case *gtypes.Array:
 		c.tsw.WriteLiterally("[")
 		for i := 0; i < int(t.Len()); i++ {
 			if i > 0 {
@@ -153,11 +161,11 @@ func (c *GoToTSCompiler) WriteZeroValueForType(typ any) {
 			c.WriteZeroValueForType(t.Elt)
 		}
 		c.tsw.WriteLiterally("]")
-	case *types.Basic:
+	case *gtypes.Basic:
 		switch t.Kind() {
-		case types.Bool:
+		case gtypes.Bool:
 			c.tsw.WriteLiterally("false")
-		case types.String:
+		case gtypes.String:
 			c.tsw.WriteLiterally(`""`)
 		default:
 			c.tsw.WriteLiterally("0")

package/compiler/compile_decls.go

@@ -65,8 +65,20 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 	// WriteFuncType needs to be aware if the function is async
 	c.WriteFuncType(decl.Type, isAsync) // Write signature (params, return type)
 	c.tsw.WriteLiterally(" ")
+
+	// Check if function body has defer statements
+	c.nextBlockNeedsDefer = c.scanForDefer(decl.Body)
+	
+	// Save previous async state and set current state based on isAsync
+	previousAsyncState := c.inAsyncFunction
+	c.inAsyncFunction = isAsync
+
 	if err := c.WriteStmt(decl.Body); err != nil {
+		c.inAsyncFunction = previousAsyncState // Restore state before returning error
 		return fmt.Errorf("failed to write function body: %w", err)
 	}
+	
+	// Restore previous async state
+	c.inAsyncFunction = previousAsyncState
 	return nil
 }