goscript 0.0.8 → 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.
@@ -46,6 +74,13 @@ export const cap = <T>(slice: Array<T> & { __capacity?: number }): number => {
   return slice.__capacity !== undefined ? slice.__capacity : slice.length
 }
 
+/**
+ * Represents the Go error type (interface).
+ */
+export type Error = {
+  Error(): string
+} | null
+
 /**
  * Converts a string to an array of Unicode code points (runes).
  * @param str The input string.
@@ -106,11 +141,195 @@ 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
 }
 
+/**
+ * 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',
+}
+
+/**
+ * Represents type information for a Go type in the runtime.
+ */
+export interface TypeInfo {
+  name: string
+  kind: TypeKind
+  zeroValue: any
+  // For interfaces, the set of methods
+  methods?: Set<string>
+  // For structs, the constructor
+  constructor?: new (...args: any[]) => any
+}
+
+// Registry to store runtime type information
+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.
+ * @param methods Optional set of method names for interfaces.
+ * @param constructor Optional constructor for structs.
+ * @returns The type information object for chaining.
+ */
+export const registerType = (
+  name: string,
+  kind: TypeKind,
+  zeroValue: any,
+  methods?: Set<string>,
+  constructor?: new (...args: any[]) => any,
+): TypeInfo => {
+  const typeInfo: TypeInfo = {
+    name,
+    kind,
+    zeroValue,
+    methods,
+    constructor,
+  }
+  typeRegistry.set(name, typeInfo)
+  return typeInfo
+}
+
+/**
+ * Represents the result of a type assertion.
+ */
+export interface TypeAssertResult<T> {
+  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> {
+  // Get the type information from the registry
+  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 }
+  }
+
+  // If value is null or undefined, assertion fails
+  if (value === null || value === undefined) {
+    return { value: typeInfo.zeroValue as T, ok: false }
+  }
+
+  // Check based on the kind of the target type
+  switch (typeInfo.kind) {
+    case TypeKind.Struct:
+      // For structs, use instanceof with the constructor
+      if (typeInfo.constructor && value instanceof typeInfo.constructor) {
+        return { value: value as T, ok: true }
+      }
+      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',
+        )
+        if (allMethodsPresent) {
+          return { value: value as T, ok: true }
+        }
+      }
+      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
+      if (
+        basicType === 'string' ||
+        basicType === 'number' ||
+        basicType === 'boolean'
+      ) {
+        return { value: value as T, ok: true }
+      }
+      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 }
+      }
+      break
+
+    case TypeKind.Slice:
+      // For slices, check if the value is an array
+      if (Array.isArray(value)) {
+        return { value: value as T, ok: true }
+      }
+      break
+
+    case TypeKind.Map:
+      // For maps, check if the value is a Map
+      if (value instanceof Map) {
+        return { value: value as T, ok: true }
+      }
+      break
+
+    case TypeKind.Channel:
+      // For channels, check if the value has the required Channel interface methods
+      if (
+        typeof value === 'object' &&
+        value !== null &&
+        '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 }
+      }
+      break
+
+    case TypeKind.Function:
+      // For functions, check if the value is a function
+      if (typeof value === 'function') {
+        return { value: value as T, ok: true }
+      }
+      break
+
+    default:
+      console.warn(
+        `Type assertion for kind '${typeInfo.kind}' not implemented.`,
+      )
+  }
+
+  // Assertion failed
+  return { value: typeInfo.zeroValue as T, ok: false }
+}
+
 /**
  * Represents the result of a channel receive operation with 'ok' value
  */
@@ -535,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

@@ -7,6 +7,7 @@ import (
 	"go/token"
 	gtypes "go/types"
 	"strconv"
+	"strings"
 
 	gstypes "github.com/paralin/goscript/compiler/types"
 )
@@ -72,6 +73,9 @@ func (c *GoToTSCompiler) WriteValueExpr(a ast.Expr) error {
 		return c.WriteCompositeLitValue(exp)
 	case *ast.KeyValueExpr:
 		return c.WriteKeyValueExprValue(exp)
+	case *ast.TypeAssertExpr:
+		// Handle type assertion in an expression context
+		return c.WriteTypeAssertExpr(exp)
 	case *ast.IndexExpr:
 		// Handle map access: use Map.get() instead of brackets for reading values
 		if tv, ok := c.pkg.TypesInfo.Types[exp.X]; ok {
@@ -104,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("(")
@@ -121,11 +162,51 @@ func (c *GoToTSCompiler) WriteValueExpr(a ast.Expr) error {
 	}
 }
 
+// WriteTypeAssertExpr writes a type assertion expression.
+func (c *GoToTSCompiler) WriteTypeAssertExpr(exp *ast.TypeAssertExpr) error {
+	// Get the type name string for the asserted type
+	typeName := c.getTypeNameString(exp.Type)
+
+	// Generate a call to goscript.typeAssert
+	c.tsw.WriteLiterally("goscript.typeAssert<")
+	c.WriteTypeExpr(exp.Type) // Write the asserted type for the generic
+	c.tsw.WriteLiterally(">(")
+	if err := c.WriteValueExpr(exp.X); err != nil { // The interface expression
+		return fmt.Errorf("failed to write interface expression in type assertion expression: %w", err)
+	}
+	c.tsw.WriteLiterally(", ")
+	c.tsw.WriteLiterally(fmt.Sprintf("'%s'", typeName))
+	c.tsw.WriteLiterally(").value") // Access the value field directly in expression context
+	return nil
+}
+
+// getTypeNameString returns the string representation of a type name
+func (c *GoToTSCompiler) getTypeNameString(typeExpr ast.Expr) string {
+	switch t := typeExpr.(type) {
+	case *ast.Ident:
+		return t.Name
+	case *ast.SelectorExpr:
+		// For imported types like pkg.Type
+		if ident, ok := t.X.(*ast.Ident); ok {
+			return fmt.Sprintf("%s.%s", ident.Name, t.Sel.Name)
+		}
+	}
+	// Default case, use a placeholder for complex types
+	return "unknown"
+}
+
 // --- Exported Node-Specific Writers ---
 
 // WriteIdentType writes an identifier used as a type.
 func (c *GoToTSCompiler) WriteIdentType(exp *ast.Ident) {
 	name := exp.Name
+
+	// Special case for the built-in error interface
+	if name == "error" {
+		c.tsw.WriteLiterally("goscript.Error")
+		return
+	}
+
 	if tsname, ok := gstypes.GoBuiltinToTypescript(name); ok {
 		name = tsname
 	} else {
@@ -150,9 +231,13 @@ func (c *GoToTSCompiler) WriteIdentType(exp *ast.Ident) {
 	c.tsw.WriteLiterally(name)
 }
 
-// WriteIdentValue writes an identifier used as a value (variable, function name).
+// WriteIdentValue writes an identifier used as a value (variable, function name, nil).
 func (c *GoToTSCompiler) WriteIdentValue(exp *ast.Ident) {
-	c.tsw.WriteLiterally(exp.Name)
+	if exp.Name == "nil" {
+		c.tsw.WriteLiterally("null")
+	} else {
+		c.tsw.WriteLiterally(exp.Name)
+	}
 }
 
 // WriteSelectorExprType writes a selector expression used as a type (e.g., pkg.Type).
@@ -205,32 +290,47 @@ func (c *GoToTSCompiler) WriteStructType(exp *ast.StructType) {
 
 // WriteInterfaceType writes an interface type definition.
 func (c *GoToTSCompiler) WriteInterfaceType(exp *ast.InterfaceType) {
-	if exp.Methods == nil || exp.Methods.NumFields() == 0 {
-		c.tsw.WriteLiterally("{}")
-		return
-	}
-	c.tsw.WriteLine("{")
-	c.tsw.Indent(1)
-	for _, method := range exp.Methods.List {
-		if len(method.Names) > 0 {
-			// Keep original Go casing for method names
-			methodName := method.Names[0]
-			c.WriteIdentValue(methodName)
-
-			// Method signature is a FuncType
-			if funcType, ok := method.Type.(*ast.FuncType); ok {
-				c.WriteFuncType(funcType, false) // Interface method signatures are not async
+	var embeddedInterfaces []string
+	var methods []*ast.Field
+
+	if exp.Methods != nil {
+		for _, method := range exp.Methods.List {
+			if len(method.Names) > 0 {
+				// Named method
+				methods = append(methods, method)
 			} else {
-				// Should not happen for valid interfaces, but handle defensively
-				c.tsw.WriteCommentInline("unexpected method type")
+				// Embedded interface - collect the type name using type info
+				if tv, ok := c.pkg.TypesInfo.Types[method.Type]; ok && tv.Type != nil {
+					if namedType, ok := tv.Type.(*gtypes.Named); ok {
+						embeddedInterfaces = append(embeddedInterfaces, namedType.Obj().Name())
+					} else {
+						c.tsw.WriteCommentLine(fmt.Sprintf("// Unhandled embedded interface type: %T", tv.Type))
+					}
+				} else {
+					c.tsw.WriteCommentLine("// Could not resolve embedded interface type")
+				}
 			}
-			c.tsw.WriteLine(";")
-		} else {
-			// Embedded interface - write the type name
-			c.WriteTypeExpr(method.Type)
-			c.tsw.WriteLine("; // Embedded interface - requires manual merging or mixin in TS")
 		}
 	}
+
+	// If there are embedded interfaces, write the extends clause
+	if len(embeddedInterfaces) > 0 {
+		c.tsw.WriteLiterally(" extends ")
+		c.tsw.WriteLiterally(strings.Join(embeddedInterfaces, ", "))
+	}
+
+	// Write the interface body on the same line
+	c.tsw.WriteLiterally("{") // Removed leading space
+	c.tsw.WriteLine("")       // Newline after opening brace
+	c.tsw.Indent(1)
+
+	// Write named methods
+	for _, method := range methods {
+		if err := c.WriteInterfaceMethodSignature(method); err != nil {
+			c.tsw.WriteCommentInline(fmt.Sprintf("error writing interface method signature: %v", err))
+		}
+	}
+
 	c.tsw.Indent(-1)
 	c.tsw.WriteLine("}")
 }
@@ -370,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
@@ -790,12 +903,50 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 	// Write arrow function: (params) => { body }
 	c.tsw.WriteLiterally("(")
 	c.WriteFieldList(exp.Type.Params, true) // true = arguments
-	c.tsw.WriteLiterally(") => ")
+	c.tsw.WriteLiterally(")")
+
+	// Handle return type for function literals
+	if exp.Type.Results != nil && len(exp.Type.Results.List) > 0 {
+		c.tsw.WriteLiterally(": ")
+		if isAsync {
+			c.tsw.WriteLiterally("Promise<")
+		}
+		if len(exp.Type.Results.List) == 1 && len(exp.Type.Results.List[0].Names) == 0 {
+			c.WriteTypeExpr(exp.Type.Results.List[0].Type)
+		} else {
+			c.tsw.WriteLiterally("[")
+			for i, field := range exp.Type.Results.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.WriteTypeExpr(field.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+		if isAsync {
+			c.tsw.WriteLiterally(">")
+		}
+	} else {
+		if isAsync {
+			c.tsw.WriteLiterally(": Promise<void>")
+		} else {
+			c.tsw.WriteLiterally(": void")
+		}
+	}
+
+	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
 }