goscript 0.0.23 → 0.0.24

package/compiler/stmt-for.go

@@ -105,6 +105,17 @@ func (c *GoToTSCompiler) WriteStmtForInit(stmt ast.Stmt) error {
 	case *ast.ExprStmt:
 		// Handle expression statement in init
 		return c.WriteValueExpr(s.X)
+	case *ast.IncDecStmt:
+		// Handle increment/decrement in init (e.g., for i++; ...)
+		if err := c.WriteValueExpr(s.X); err != nil { // The expression (e.g., i)
+			return err
+		}
+		tokStr, ok := TokenToTs(s.Tok)
+		if !ok {
+			return errors.Errorf("unknown incdec token: %v", s.Tok)
+		}
+		c.tsw.WriteLiterally(tokStr) // The token (e.g., ++)
+		return nil
 	default:
 		return errors.Errorf("unhandled for loop init statement: %T", stmt)
 	}

package/compiler/stmt-range.go

@@ -231,5 +231,115 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 		}
 	}
 
+	// Handle pointer to array/slice types
+	if ptrType, ok := underlying.(*types.Pointer); ok {
+		elem := ptrType.Elem().Underlying()
+		_, isSlice := elem.(*types.Slice)
+		_, isArray := elem.(*types.Array)
+		if isArray || isSlice {
+			// For pointer to array/slice, we need to dereference the pointer
+			// Check if the pointer variable itself is varrefed
+
+			// Determine the index variable name for the generated loop
+			indexVarName := "_i" // Default name
+			if exp.Key != nil {
+				if keyIdent, ok := exp.Key.(*ast.Ident); ok && keyIdent.Name != "_" {
+					indexVarName = keyIdent.Name
+				}
+			}
+			// If both key and value are provided, use an index loop and assign both
+			if exp.Key != nil && exp.Value != nil {
+				c.tsw.WriteLiterallyf("for (let %s = 0; %s < $.len(", indexVarName, indexVarName)
+
+				// Write the pointer expression - use WriteIdent to avoid automatic .value access
+				// since we'll add !.value for pointer dereference
+				if ident, ok := exp.X.(*ast.Ident); ok {
+					c.WriteIdent(ident, false) // Don't add .value here
+				} else {
+					if err := c.WriteValueExpr(exp.X); err != nil {
+						return fmt.Errorf("failed to write range loop pointer array/slice expression (key and value): %w", err)
+					}
+				}
+				// Add dereference for the pointer: since we're ranging over a pointer to array/slice,
+				// we need to dereference to get to the array/slice
+				c.tsw.WriteLiterally("!.value")
+				c.tsw.WriteLiterallyf("); %s++) {", indexVarName)
+				c.tsw.Indent(1)
+				c.tsw.WriteLine("")
+				// Declare value if not blank
+				if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+					c.tsw.WriteLiterally("const ")
+					c.WriteIdent(ident, false)
+					c.tsw.WriteLiterally(" = ")
+					// Write the pointer expression again for value access
+					if identX, ok := exp.X.(*ast.Ident); ok {
+						c.WriteIdent(identX, false) // Don't add .value here
+					} else {
+						if err := c.WriteValueExpr(exp.X); err != nil {
+							return fmt.Errorf("failed to write range loop pointer array/slice value expression: %w", err)
+						}
+					}
+					c.tsw.WriteLiterally("!.value![")
+					c.tsw.WriteLiterally(indexVarName)
+					c.tsw.WriteLiterally("]")
+					c.tsw.WriteLine("")
+				}
+				if err := c.WriteStmt(exp.Body); err != nil {
+					return fmt.Errorf("failed to write range loop pointer array/slice body (key and value): %w", err)
+				}
+				c.tsw.Indent(-1)
+				c.tsw.WriteLine("}")
+				return nil
+			} else if exp.Key != nil && exp.Value == nil { // Only key provided
+				c.tsw.WriteLiterallyf("for (let %s = 0; %s < $.len(", indexVarName, indexVarName)
+				// Write the pointer expression - use WriteIdent to avoid automatic .value access
+				// since we'll add !.value for pointer dereference
+				if ident, ok := exp.X.(*ast.Ident); ok {
+					c.WriteIdent(ident, false) // Don't add .value here
+				} else {
+					if err := c.WriteValueExpr(exp.X); err != nil {
+						return fmt.Errorf("failed to write expression for the pointer iterable: %w", err)
+					}
+				}
+				c.tsw.WriteLiterally("!.value")
+				c.tsw.WriteLiterallyf("); %s++) {", indexVarName)
+				c.tsw.Indent(1)
+				c.tsw.WriteLine("")
+				if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+					return fmt.Errorf("failed to write range loop pointer array/slice body (only key): %w", err)
+				}
+				c.tsw.Indent(-1)
+				c.tsw.WriteLine("}")
+				return nil
+			} else if exp.Key == nil && exp.Value != nil { // Only value provided
+				// I think this is impossible. See for_range_value_only test.
+				return errors.Errorf("unexpected value without key in for range expression: %v", exp)
+			} else {
+				// Fallback: simple index loop without declaring range variables, use _i
+				indexVarName := "_i"
+				c.tsw.WriteLiterallyf("for (let %s = 0; %s < $.len(", indexVarName, indexVarName)
+				// Write the pointer expression - use WriteIdent to avoid automatic .value access
+				// since we'll add !.value for pointer dereference
+				if ident, ok := exp.X.(*ast.Ident); ok {
+					c.WriteIdent(ident, false) // Don't add .value here
+				} else {
+					if err := c.WriteValueExpr(exp.X); err != nil {
+						return fmt.Errorf("failed to write range loop pointer array/slice length expression (fallback): %w", err)
+					}
+				}
+				c.tsw.WriteLiterally("!.value")
+				c.tsw.WriteLiterallyf("); %s++) {", indexVarName)
+				c.tsw.Indent(1)
+				c.tsw.WriteLine("")
+				if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+					return fmt.Errorf("failed to write range loop pointer array/slice body (fallback): %w", err)
+				}
+				c.tsw.Indent(-1)
+				c.tsw.WriteLine("}")
+				return nil
+			}
+		}
+	}
+
 	return errors.Errorf("unsupported range loop type: %T for expression %v", underlying, exp)
 }

package/compiler/stmt.go

@@ -28,6 +28,8 @@ import (
 //   - Go statements (`ast.GoStmt`): `WriteStmtGo`.
 //   - Select statements (`ast.SelectStmt`): `WriteStmtSelect`.
 //   - Branch statements (`ast.BranchStmt`): `WriteStmtBranch`.
+//   - Type switch statements (`ast.TypeSwitchStmt`): `WriteStmtTypeSwitch`.
+//   - Labeled statements (`ast.LabeledStmt`): `WriteStmtLabeled`.
 //
 // If an unknown statement type is encountered, it returns an error.
 func (c *GoToTSCompiler) WriteStmt(a ast.Stmt) error {
@@ -109,6 +111,10 @@ func (c *GoToTSCompiler) WriteStmt(a ast.Stmt) error {
 		if err := c.WriteStmtTypeSwitch(exp); err != nil {
 			return fmt.Errorf("failed to write type switch statement: %w", err)
 		}
+	case *ast.LabeledStmt:
+		if err := c.WriteStmtLabeled(exp); err != nil {
+			return fmt.Errorf("failed to write labeled statement: %w", err)
+		}
 	default:
 		return errors.Errorf("unknown statement: %#v\n", a)
 	}
@@ -292,6 +298,37 @@ func (c *GoToTSCompiler) WriteStmtGo(exp *ast.GoStmt) error {
 		c.tsw.WriteLiterally(")")
 		c.tsw.WriteLine("")
 
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("})") // Close the queueMicrotask callback and the statement
+	case *ast.TypeAssertExpr:
+		// Handle type assertion expressions: go x.(func())()
+		// We assume this is always synchronous (no async function returned by type assertion)
+		c.tsw.WriteLiterally("queueMicrotask(() => {")
+
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+
+		// Write the type assertion call
+		if err := c.WriteTypeAssertExpr(fun); err != nil {
+			return fmt.Errorf("failed to write type assertion expression in goroutine: %w", err)
+		}
+
+		// Add non-null assertion since mustTypeAssert throws on failure rather than returning null
+		c.tsw.WriteLiterally("!")
+
+		// Write the function arguments
+		c.tsw.WriteLiterally("(")
+		for i, arg := range callExpr.Args {
+			if i != 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			if err := c.WriteValueExpr(arg); err != nil {
+				return fmt.Errorf("failed to write argument %d in goroutine type assertion function call: %w", i, err)
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		c.tsw.WriteLine("")
+
 		c.tsw.Indent(-1)
 		c.tsw.WriteLine("})") // Close the queueMicrotask callback and the statement
 	default:
@@ -790,3 +827,18 @@ func (c *GoToTSCompiler) WriteStmtDefer(exp *ast.DeferStmt) error {
 
 	return nil
 }
+
+// WriteStmtLabeled handles labeled statements (ast.LabeledStmt), such as "label: statement".
+// In TypeScript, this translates to "label: statement" directly.
+func (c *GoToTSCompiler) WriteStmtLabeled(stmt *ast.LabeledStmt) error {
+	// Write the label name followed by a colon
+	c.tsw.WriteLiterally(stmt.Label.Name)
+	c.tsw.WriteLiterally(": ")
+
+	// Write the labeled statement
+	if err := c.WriteStmt(stmt.Stmt); err != nil {
+		return fmt.Errorf("failed to write labeled statement: %w", err)
+	}
+
+	return nil
+}

package/compiler/type.go

@@ -16,7 +16,7 @@ const (
 	GoTypeContextGeneral GoTypeContext = iota
 	// GoTypeContextFunctionReturn is used when translating types for function return values.
 	// In this context, pointer-to-struct types become `ClassName | null` instead of
-	// `$.Box<ClassName> | null` because function return values cannot be addressed.
+	// `$.VarRef<ClassName> | null` because function return values cannot be addressed.
 	GoTypeContextFunctionReturn
 )
 
@@ -27,7 +27,7 @@ const (
 // The context parameter controls how certain types (especially pointers) are handled:
 //   - GoTypeContextGeneral: Standard type translation
 //   - GoTypeContextFunctionReturn: Special handling for function return types where
-//     pointer-to-struct types become `ClassName | null` instead of `$.Box<ClassName> | null`
+//     pointer-to-struct types become `ClassName | null` instead of `$.VarRef<ClassName> | null`
 //
 // It handles nil types as 'any' with a comment, and dispatches to appropriate
 // type-specific writers for all other recognized Go types.
@@ -47,7 +47,7 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type, context GoTypeContext) {
 		if context == GoTypeContextFunctionReturn {
 			c.writePointerTypeForFunctionReturn(t)
 		} else {
-			c.WritePointerType(t)
+			c.WritePointerType(t, context)
 		}
 	case *types.Slice:
 		c.WriteSliceType(t)
@@ -78,7 +78,7 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type, context GoTypeContext) {
 // writePointerTypeForFunctionReturn translates a Go pointer type (*T) to its TypeScript
 // equivalent for function return types. Unlike WritePointerType, this function
 // handles pointer-to-struct types specially: they become `ClassName | null` instead
-// of `$.Box<ClassName> | null` because function return values cannot be addressed.
+// of `$.VarRef<ClassName> | null` because function return values cannot be addressed.
 func (c *GoToTSCompiler) writePointerTypeForFunctionReturn(t *types.Pointer) {
 	elemType := t.Elem()
 
@@ -93,8 +93,8 @@ func (c *GoToTSCompiler) writePointerTypeForFunctionReturn(t *types.Pointer) {
 		c.WriteGoType(elemType, GoTypeContextFunctionReturn)
 		c.tsw.WriteLiterally(" | null")
 	} else {
-		// For pointer-to-primitive in function returns, still use boxing
-		c.tsw.WriteLiterally("$.Box<")
+		// For pointer-to-primitive in function returns, still use varRefing
+		c.tsw.WriteLiterally("$.VarRef<")
 		c.WriteGoType(elemType, GoTypeContextFunctionReturn)
 		c.tsw.WriteLiterally("> | null")
 	}
@@ -227,11 +227,36 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 }
 
 // WritePointerType translates a Go pointer type (*T) to its TypeScript equivalent.
-// It generates $.Box<T_ts> | null, where T_ts is the translated element type.
-func (c *GoToTSCompiler) WritePointerType(t *types.Pointer) {
-	c.tsw.WriteLiterally("$.Box<")
-	c.WriteGoType(t.Elem(), GoTypeContextGeneral)
-	c.tsw.WriteLiterally("> | null") // Pointers are always nullable
+func (c *GoToTSCompiler) WritePointerType(t *types.Pointer, context GoTypeContext) {
+	elemGoType := t.Elem()
+	underlyingElemGoType := elemGoType.Underlying()
+
+	// Handle pointers to functions: *func(...) -> func(...) | null
+	if _, isSignature := underlyingElemGoType.(*types.Signature); isSignature {
+		c.WriteGoType(elemGoType, context) // Write the function signature itself, pass context
+		c.tsw.WriteLiterally(" | null")    // Function pointers are nullable
+		return
+	}
+
+	// Handle pointers to structs or interfaces: *MyStruct -> MyStruct | null
+	_, isStruct := underlyingElemGoType.(*types.Struct)
+	_, isInterface := underlyingElemGoType.(*types.Interface)
+
+	if isStruct || isInterface {
+		// For pointers to structs or interfaces, the TS type is StructName | null or InterfaceName | null.
+		// This aligns with VAR_REFS.md and JS/TS object reference semantics.
+		// TODO If the target variable is boxed, we have to wrap with VarRef as well?
+		c.WriteGoType(elemGoType, context) // Write the struct/interface type directly, pass context
+		c.tsw.WriteLiterally(" | null")
+	} else {
+		// For pointers to other types (primitives, slices, maps, other pointers like **MyStruct),
+		// they are generally represented as $.VarRef<T_ts> | null.
+		// Example: *int -> $.VarRef<number> | null
+		// Example: **MyStruct -> $.VarRef<MyStruct | null> | null (recursive call handles inner part)
+		c.tsw.WriteLiterally("$.VarRef<")
+		c.WriteGoType(elemGoType, context) // Translate element type, pass context
+		c.tsw.WriteLiterally("> | null")   // Pointers are always nullable
+	}
 }
 
 // WriteSliceType translates a Go slice type ([]T) to its TypeScript equivalent.

package/dist/gs/builtin/builtin.js

@@ -0,0 +1,37 @@
+export * from './varRef.js';
+export * from './channel.js';
+export * from './defer.js';
+export * from './io.js';
+export * from './map.js';
+export * from './slice.js';
+export * from './type.js';
+// Duration multiplication helper for time package operations
+// Handles expressions like time.Hour * 24
+export function multiplyDuration(duration, multiplier) {
+    // Check if duration has a multiply method (like our Duration class)
+    if (duration && typeof duration.multiply === 'function') {
+        return duration.multiply(multiplier);
+    }
+    // Check if duration has a valueOf method for numeric operations
+    if (duration && typeof duration.valueOf === 'function') {
+        const numValue = duration.valueOf();
+        // Return an object with the same structure but multiplied value
+        if (typeof numValue === 'number') {
+            // Try to create a new instance of the same type
+            if (duration.constructor) {
+                return new duration.constructor(numValue * multiplier);
+            }
+            // Fallback: return a simple object with valueOf
+            return {
+                valueOf: () => numValue * multiplier,
+                toString: () => (numValue * multiplier).toString() + "ns"
+            };
+        }
+    }
+    // Fallback for simple numeric values
+    if (typeof duration === 'number') {
+        return duration * multiplier;
+    }
+    throw new Error(`Cannot multiply duration of type ${typeof duration}`);
+}
+//# sourceMappingURL=builtin.js.map

package/dist/gs/builtin/builtin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin.js","sourceRoot":"","sources":["../../../gs/builtin/builtin.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AAEzB,6DAA6D;AAC7D,0CAA0C;AAC1C,MAAM,UAAU,gBAAgB,CAAC,QAAa,EAAE,UAAkB,EAAO;IACvE,oEAAoE;IACpE,IAAI,QAAQ,IAAI,OAAO,QAAQ,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;QACxD,OAAO,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IACvC,CAAC;IAED,gEAAgE;IAChE,IAAI,QAAQ,IAAI,OAAO,QAAQ,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QACvD,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,EAAE,CAAC;QACpC,gEAAgE;QAChE,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;YACjC,gDAAgD;YAChD,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;gBACzB,OAAO,IAAI,QAAQ,CAAC,WAAW,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC;YACzD,CAAC;YACD,gDAAgD;YAChD,OAAO;gBACL,OAAO,EAAE,GAAG,EAAE,CAAC,QAAQ,GAAG,UAAU;gBACpC,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,QAAQ,EAAE,GAAG,IAAI;aAC1D,CAAC;QACJ,CAAC;IACH,CAAC;IAED,qCAAqC;IACrC,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjC,OAAO,QAAQ,GAAG,UAAU,CAAC;IAC/B,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,oCAAoC,OAAO,QAAQ,EAAE,CAAC,CAAC;AAAA,CACxE"}