goscript 0.0.10 → 0.0.11

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).
@@ -113,8 +141,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 +156,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 +197,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 +205,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 +246,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 +754,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

@@ -12,7 +12,7 @@ import (
 var (
 	cliCompiler       *compiler.Compiler
 	cliCompilerConfig compiler.Config
-	cliCompilerPkg    string
+	cliCompilerPkg    cli.StringSlice
 )
 
 // CompileCommands are commands related to compiling code.
@@ -29,9 +29,10 @@ 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"},
 			Destination: &cliCompilerPkg,
 		},
 		&cli.StringFlag{
@@ -51,9 +52,10 @@ var CompileCommands = []*cli.Command{{
 
 // 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)
+	return cliCompiler.CompilePackages(context.Background(), pkgs...)
 }

package/compiler/compile.go

@@ -12,11 +12,13 @@ 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
+	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
 
 	tempVarCounter int // Counter for generating unique temporary variable names
 }
@@ -68,15 +70,30 @@ 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,
+		tempVarCounter:      0, // Initialize counter
 	}
 }
 

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
 }

package/compiler/compile_expr.go

@@ -108,6 +108,43 @@ func (c *GoToTSCompiler) WriteValueExpr(a ast.Expr) error {
 		}
 		c.tsw.WriteLiterally("]")
 		return nil
+	case *ast.SliceExpr:
+		// Translate Go slice expression to goscript.slice(x, low, high, max)
+		c.tsw.WriteLiterally("goscript.slice(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return err
+		}
+		// low argument
+		c.tsw.WriteLiterally(", ")
+		if exp.Low != nil {
+			if err := c.WriteValueExpr(exp.Low); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("undefined")
+		}
+		// high argument
+		c.tsw.WriteLiterally(", ")
+		if exp.High != nil {
+			if err := c.WriteValueExpr(exp.High); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("undefined")
+		}
+		// max argument (only for full slice expressions)
+		if exp.Slice3 {
+			c.tsw.WriteLiterally(", ")
+			if exp.Max != nil {
+				if err := c.WriteValueExpr(exp.Max); err != nil {
+					return err
+				}
+			} else {
+				c.tsw.WriteLiterally("undefined")
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		return nil
 	case *ast.ParenExpr:
 		// Translate (X) to (X)
 		c.tsw.WriteLiterally("(")
@@ -433,7 +470,20 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 				// Handle slice creation
 				if _, ok := exp.Args[0].(*ast.ArrayType); ok {
-					c.tsw.WriteLiterally("goscript.makeSlice(")
+					// Get the slice type information
+					sliceType := c.pkg.TypesInfo.TypeOf(exp.Args[0])
+					if sliceType == nil {
+						return errors.New("could not get type information for slice in make call")
+					}
+					goElemType, ok := sliceType.Underlying().(*gtypes.Slice)
+					if !ok {
+						return errors.New("expected slice type for make call")
+					}
+
+					c.tsw.WriteLiterally("goscript.makeSlice<")
+					c.WriteGoType(goElemType.Elem()) // Write the element type
+					c.tsw.WriteLiterally(">(")
+
 					if len(exp.Args) >= 2 {
 						if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 							return err
@@ -885,11 +935,18 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 	}
 
 	c.tsw.WriteLiterally(" => ")
+	
+	// Save previous async state and set current state based on isAsync
+	previousAsyncState := c.inAsyncFunction
+	c.inAsyncFunction = isAsync
 
 	// Write function body
 	if err := c.WriteStmt(exp.Body); err != nil {
+		c.inAsyncFunction = previousAsyncState // Restore state before returning error
 		return fmt.Errorf("failed to write function literal body: %w", err)
 	}
-
+	
+	// Restore previous async state
+	c.inAsyncFunction = previousAsyncState
 	return nil
 }