goscript 0.0.24 → 0.0.25

package/compiler/expr-call.go

@@ -111,6 +111,15 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 				return errors.Errorf("unhandled cap call with incorrect number of arguments: %d != 1", len(exp.Args))
 			}
 			c.tsw.WriteLiterally("$.cap")
+		case "new":
+			// Translate new(T) to new T_ts()
+			if len(exp.Args) != 1 {
+				return errors.Errorf("unhandled new call with incorrect number of arguments: %d != 1", len(exp.Args))
+			}
+			c.tsw.WriteLiterally("new ")
+			c.WriteTypeExpr(exp.Args[0]) // This should write the TypeScript type T_ts
+			c.tsw.WriteLiterally("()")
+			return nil // Prevent falling through to generic argument handling
 		case "delete":
 			// Translate delete(map, key) to $.deleteMapEntry(map, key)
 			if len(exp.Args) != 2 {
@@ -205,6 +214,33 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 						return nil // Handled make for []byte
 					}
 
+					// Check if the element type is a generic type parameter
+					if _, isTypeParam := goElemType.(*types.TypeParam); isTypeParam {
+						// This is make([]E, n) where E is a type parameter
+						c.tsw.WriteLiterally("$.makeSlice<")
+						c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type parameter
+						c.tsw.WriteLiterally(">(")
+
+						if len(exp.Args) >= 2 {
+							if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+								return err
+							}
+							if len(exp.Args) == 3 {
+								c.tsw.WriteLiterally(", ")
+								if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+									return err
+								}
+							} else if len(exp.Args) > 3 {
+								return errors.New("makeSlice expects 2 or 3 arguments")
+							}
+						} else {
+							// If no length is provided, default to 0
+							c.tsw.WriteLiterally("0")
+						}
+						c.tsw.WriteLiterally(")")
+						return nil // Handled make for []E where E is type parameter
+					}
+
 					c.tsw.WriteLiterally("$.makeSlice<")
 					c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
 					c.tsw.WriteLiterally(">(")
@@ -228,6 +264,71 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					c.tsw.WriteLiterally(")")
 					return nil // Handled make for slice
 				}
+
+				// Handle generic type parameter make calls: make(S, len, cap) where S ~[]E
+				if ident, ok := exp.Args[0].(*ast.Ident); ok {
+					// Check if this identifier refers to a type parameter
+					if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
+						if typeName, isTypeName := obj.(*types.TypeName); isTypeName {
+							if typeParam, isTypeParam := typeName.Type().(*types.TypeParam); isTypeParam {
+								// Check if the type parameter is constrained to slice types
+								constraint := typeParam.Constraint()
+								if constraint != nil {
+									underlying := constraint.Underlying()
+									if iface, isInterface := underlying.(*types.Interface); isInterface {
+										// Check if the constraint includes slice types
+										// For constraints like ~[]E, we need to look at the type terms
+										if hasSliceConstraint(iface) {
+											// This is a generic slice type parameter
+											// We need to determine the element type from the constraint
+											elemType := getSliceElementTypeFromConstraint(iface)
+											if elemType != nil {
+												// Check if it's make(S, ...) where S constrains to []byte
+												if basicElem, isBasic := elemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
+													c.tsw.WriteLiterally("new Uint8Array(")
+													if len(exp.Args) >= 2 {
+														if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+															return err
+														}
+														// Capacity argument for make([]byte, len, cap) is ignored for new Uint8Array(len)
+													} else {
+														// If no length is provided, default to 0
+														c.tsw.WriteLiterally("0")
+													}
+													c.tsw.WriteLiterally(")")
+													return nil // Handled make for generic []byte
+												}
+
+												c.tsw.WriteLiterally("$.makeSlice<")
+												c.WriteGoType(elemType, GoTypeContextGeneral) // Write the element type
+												c.tsw.WriteLiterally(">(")
+
+												if len(exp.Args) >= 2 {
+													if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+														return err
+													}
+													if len(exp.Args) == 3 {
+														c.tsw.WriteLiterally(", ")
+														if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+															return err
+														}
+													} else if len(exp.Args) > 3 {
+														return errors.New("makeSlice expects 2 or 3 arguments")
+													}
+												} else {
+													// If no length is provided, default to 0
+													c.tsw.WriteLiterally("0")
+												}
+												c.tsw.WriteLiterally(")")
+												return nil // Handled make for generic slice
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
 			}
 			// Fallthrough for unhandled make calls (e.g., channels)
 			return errors.New("unhandled make call")
@@ -424,7 +525,17 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 			if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
 				if _, ok := funType.Underlying().(*types.Signature); ok {
-					if _, isNamed := funType.(*types.Named); isNamed {
+					// Check if this is a function parameter identifier that needs not-null assertion
+					if ident, isIdent := expFun.(*ast.Ident); isIdent {
+						// Check if this identifier is a function parameter
+						if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
+							if _, isVar := obj.(*types.Var); isVar {
+								// This is a variable (including function parameters)
+								// Function parameters that are function types need ! assertion
+								c.tsw.WriteLiterally("!")
+							}
+						}
+					} else if _, isNamed := funType.(*types.Named); isNamed {
 						c.tsw.WriteLiterally("!")
 					}
 				}
@@ -458,7 +569,17 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 			if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
 				if _, ok := funType.Underlying().(*types.Signature); ok {
-					if _, isNamed := funType.(*types.Named); isNamed {
+					// Check if this is a function parameter identifier that needs not-null assertion
+					if ident, isIdent := expFun.(*ast.Ident); isIdent {
+						// Check if this identifier is a function parameter
+						if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
+							if _, isVar := obj.(*types.Var); isVar {
+								// This is a variable (including function parameters)
+								// Function parameters that are function types need ! assertion
+								c.tsw.WriteLiterally("!")
+							}
+						}
+					} else if _, isNamed := funType.(*types.Named); isNamed {
 						c.tsw.WriteLiterally("!")
 					}
 				}
@@ -477,3 +598,92 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 	c.tsw.WriteLiterally(")")
 	return nil
 }
+
+// hasSliceConstraint checks if an interface constraint includes slice types
+// For constraints like ~[]E, this returns true
+func hasSliceConstraint(iface *types.Interface) bool {
+	// Check if the interface has type terms that include slice types
+	for i := 0; i < iface.NumEmbeddeds(); i++ {
+		embedded := iface.EmbeddedType(i)
+		if union, ok := embedded.(*types.Union); ok {
+			for j := 0; j < union.Len(); j++ {
+				term := union.Term(j)
+				if _, isSlice := term.Type().Underlying().(*types.Slice); isSlice {
+					return true
+				}
+			}
+		} else if _, isSlice := embedded.Underlying().(*types.Slice); isSlice {
+			return true
+		}
+	}
+	return false
+}
+
+// getSliceElementTypeFromConstraint extracts the element type from a slice constraint
+// For constraints like ~[]E, this returns E
+func getSliceElementTypeFromConstraint(iface *types.Interface) types.Type {
+	// Check if the interface has type terms that include slice types
+	for i := 0; i < iface.NumEmbeddeds(); i++ {
+		embedded := iface.EmbeddedType(i)
+		if union, ok := embedded.(*types.Union); ok {
+			for j := 0; j < union.Len(); j++ {
+				term := union.Term(j)
+				if sliceType, isSlice := term.Type().Underlying().(*types.Slice); isSlice {
+					return sliceType.Elem()
+				}
+			}
+		} else if sliceType, isSlice := embedded.Underlying().(*types.Slice); isSlice {
+			return sliceType.Elem()
+		}
+	}
+	return nil
+}
+
+// hasMixedStringByteConstraint checks if an interface constraint includes both string and []byte types
+// For constraints like string | []byte, this returns true
+// For pure slice constraints like ~[]E, this returns false
+func hasMixedStringByteConstraint(iface *types.Interface) bool {
+	hasString := false
+	hasByteSlice := false
+
+	// Check if the interface has type terms that include both string and []byte
+	for i := 0; i < iface.NumEmbeddeds(); i++ {
+		embedded := iface.EmbeddedType(i)
+		if union, ok := embedded.(*types.Union); ok {
+			for j := 0; j < union.Len(); j++ {
+				term := union.Term(j)
+				termType := term.Type().Underlying()
+
+				// Check for string type
+				if basicType, isBasic := termType.(*types.Basic); isBasic && (basicType.Info()&types.IsString) != 0 {
+					hasString = true
+				}
+
+				// Check for []byte type
+				if sliceType, isSlice := termType.(*types.Slice); isSlice {
+					if elemType, isBasic := sliceType.Elem().(*types.Basic); isBasic && elemType.Kind() == types.Uint8 {
+						hasByteSlice = true
+					}
+				}
+			}
+		} else {
+			// Handle non-union embedded types
+			termType := embedded.Underlying()
+
+			// Check for string type
+			if basicType, isBasic := termType.(*types.Basic); isBasic && (basicType.Info()&types.IsString) != 0 {
+				hasString = true
+			}
+
+			// Check for []byte type
+			if sliceType, isSlice := termType.(*types.Slice); isSlice {
+				if elemType, isBasic := sliceType.Elem().(*types.Basic); isBasic && elemType.Kind() == types.Uint8 {
+					hasByteSlice = true
+				}
+			}
+		}
+	}
+
+	// Return true only if we have both string and []byte in the constraint
+	return hasString && hasByteSlice
+}

package/compiler/expr.go

@@ -71,8 +71,44 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 		}
 
 		// Check if it's a type parameter with a union constraint (e.g., string | []byte)
-		if _, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
-			// For type parameters with string | []byte constraint, use specialized function
+		if typeParam, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
+			// Check if the type parameter is constrained to slice types
+			constraint := typeParam.Constraint()
+			if constraint != nil {
+				underlying := constraint.Underlying()
+				if iface, isInterface := underlying.(*types.Interface); isInterface {
+					// Check if this is a mixed string/byte constraint (like string | []byte)
+					if hasMixedStringByteConstraint(iface) {
+						// For mixed constraints, use specialized function that returns number (byte value)
+						c.tsw.WriteLiterally("$.indexStringOrBytes(")
+						if err := c.WriteValueExpr(exp.X); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally(", ")
+						if err := c.WriteValueExpr(exp.Index); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally(")")
+						return nil
+					}
+
+					// Check if the constraint includes only slice types (pure slice constraint)
+					if hasSliceConstraint(iface) {
+						// This is a pure slice type parameter, use regular slice indexing
+						if err := c.WriteValueExpr(exp.X); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally("![") // non-null assertion
+						if err := c.WriteValueExpr(exp.Index); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally("]")
+						return nil
+					}
+				}
+			}
+
+			// For other type parameters, use specialized function as fallback
 			// that returns number (byte value) for better TypeScript typing
 			c.tsw.WriteLiterally("$.indexStringOrBytes(")
 			if err := c.WriteValueExpr(exp.X); err != nil {
@@ -377,6 +413,7 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 	if !ok {
 		return errors.Errorf("unhandled binary op: %s", exp.Op.String())
 	}
+
 	c.tsw.WriteLiterally(tokStr)
 	c.tsw.WriteLiterally(" ")
 	if err := c.WriteValueExpr(exp.Y); err != nil {
@@ -452,6 +489,13 @@ func (c *GoToTSCompiler) WriteUnaryExpr(exp *ast.UnaryExpr) error {
 	if !ok {
 		return errors.Errorf("unhandled unary op: %s", exp.Op.String())
 	}
+
+	// Special case: In Go, ^ is bitwise NOT when used as unary operator
+	// In TypeScript, bitwise NOT is ~, not ^
+	if exp.Op == token.XOR {
+		tokStr = "~"
+	}
+
 	c.tsw.WriteLiterally(tokStr)
 
 	// Add space if operator is not postfix (e.g., !)

package/compiler/field.go

@@ -47,7 +47,7 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 				if j > 0 {
 					c.tsw.WriteLiterally(", ")
 				}
-				c.tsw.WriteLiterally(name.Name)
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
 				c.tsw.WriteLiterally(": ")
 				typ := c.pkg.TypesInfo.TypeOf(field.Type)
 				c.WriteGoType(typ, GoTypeContextGeneral)
@@ -65,7 +65,7 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 				c.tsw.WriteLiterally(", ")
 			}
 			c.tsw.WriteLiterally("...")
-			c.tsw.WriteLiterally(name.Name)
+			c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
 		}
 
 		c.tsw.WriteLiterally(": ")
@@ -86,7 +86,7 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 					if j > 0 {
 						c.tsw.WriteLiterally(", ")
 					}
-					c.tsw.WriteLiterally(name.Name)
+					c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
 					c.tsw.WriteLiterally(": ")
 					typ := c.pkg.TypesInfo.TypeOf(field.Type)
 					c.WriteGoType(typ, GoTypeContextGeneral) // Use WriteGoType for parameter type
@@ -143,7 +143,7 @@ func (c *GoToTSCompiler) WriteField(field *ast.Field, isArguments bool) {
 
 		// argument names: keep original casing, no access modifier
 		if isArguments {
-			c.tsw.WriteLiterally(name.Name)
+			c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
 			// Argument type is handled in WriteFieldList, so continue
 			continue
 		} else {

package/compiler/stmt-range.go

@@ -146,13 +146,15 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 			if err := c.WriteValueExpr(exp.X); err != nil { // This is N
 				return fmt.Errorf("failed to write range loop integer expression: %w", err)
 			}
-			c.tsw.WriteLiterallyf("; %s++) ", indexVarName)
+			c.tsw.WriteLiterallyf("; %s++) {", indexVarName)
 
 			// write body
 			if err := c.WriteStmtBlock(exp.Body, false); err != nil {
 				return fmt.Errorf("failed to write range loop integer body: %w", err)
 			}
 
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
 			return nil
 		}
 	}
@@ -341,5 +343,206 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 		}
 	}
 
+	// Handle iterator function signatures
+	if sig, ok := underlying.(*types.Signature); ok {
+		// Check if this is an iterator function signature
+		// Iterator functions have the form: func(yield func(...) bool)
+		params := sig.Params()
+		if params.Len() == 1 {
+			yieldParam := params.At(0).Type()
+			if yieldSig, ok := yieldParam.Underlying().(*types.Signature); ok {
+				yieldParams := yieldSig.Params()
+				yieldResults := yieldSig.Results()
+
+				// Verify the yield function returns bool
+				if yieldResults.Len() == 1 {
+					if basic, ok := yieldResults.At(0).Type().Underlying().(*types.Basic); ok && basic.Kind() == types.Bool {
+						// This is an iterator function
+						// Generate TypeScript code that calls the iterator with a yield function
+
+						if yieldParams.Len() == 0 {
+							// func(func() bool) - iterator with no values
+							c.tsw.WriteLiterally(";(() => {")
+							c.tsw.Indent(1)
+							c.tsw.WriteLine("")
+							c.tsw.WriteLiterally("let shouldContinue = true")
+							c.tsw.WriteLine("")
+							if err := c.WriteValueExpr(exp.X); err != nil {
+								return fmt.Errorf("failed to write iterator expression: %w", err)
+							}
+							c.tsw.WriteLiterally("(() => {")
+							c.tsw.Indent(1)
+							c.tsw.WriteLine("")
+							if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+								return fmt.Errorf("failed to write iterator body: %w", err)
+							}
+							c.tsw.WriteLiterally("return shouldContinue")
+							c.tsw.WriteLine("")
+							c.tsw.Indent(-1)
+							c.tsw.WriteLiterally("})")
+							c.tsw.WriteLine("")
+							c.tsw.Indent(-1)
+							c.tsw.WriteLine("})()")
+							return nil
+						} else if yieldParams.Len() == 1 {
+							// func(func(V) bool) - iterator with one value
+							c.tsw.WriteLiterally(";(() => {")
+							c.tsw.Indent(1)
+							c.tsw.WriteLine("")
+							c.tsw.WriteLiterally("let shouldContinue = true")
+							c.tsw.WriteLine("")
+							if err := c.WriteValueExpr(exp.X); err != nil {
+								return fmt.Errorf("failed to write iterator expression: %w", err)
+							}
+							c.tsw.WriteLiterally("((")
+							if exp.Value != nil {
+								if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+									c.WriteIdent(ident, false)
+								} else {
+									c.tsw.WriteLiterally("v")
+								}
+							} else {
+								c.tsw.WriteLiterally("v")
+							}
+							c.tsw.WriteLiterally(") => {")
+							c.tsw.Indent(1)
+							c.tsw.WriteLine("")
+							if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+								return fmt.Errorf("failed to write iterator body: %w", err)
+							}
+							c.tsw.WriteLiterally("return shouldContinue")
+							c.tsw.WriteLine("")
+							c.tsw.Indent(-1)
+							c.tsw.WriteLiterally("})")
+							c.tsw.WriteLine("")
+							c.tsw.Indent(-1)
+							c.tsw.WriteLine("})()")
+							return nil
+						} else if yieldParams.Len() == 2 {
+							// func(func(K, V) bool) - iterator with key-value pairs
+							c.tsw.WriteLiterally(";(() => {")
+							c.tsw.Indent(1)
+							c.tsw.WriteLine("")
+							c.tsw.WriteLiterally("let shouldContinue = true")
+							c.tsw.WriteLine("")
+							if err := c.WriteValueExpr(exp.X); err != nil {
+								return fmt.Errorf("failed to write iterator expression: %w", err)
+							}
+							c.tsw.WriteLiterally("((")
+							if exp.Key != nil {
+								if ident, ok := exp.Key.(*ast.Ident); ok && ident.Name != "_" {
+									c.WriteIdent(ident, false)
+								} else {
+									c.tsw.WriteLiterally("k")
+								}
+							} else {
+								c.tsw.WriteLiterally("k")
+							}
+							c.tsw.WriteLiterally(", ")
+							if exp.Value != nil {
+								if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+									c.WriteIdent(ident, false)
+								} else {
+									c.tsw.WriteLiterally("v")
+								}
+							} else {
+								c.tsw.WriteLiterally("v")
+							}
+							c.tsw.WriteLiterally(") => {")
+							c.tsw.Indent(1)
+							c.tsw.WriteLine("")
+							if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+								return fmt.Errorf("failed to write iterator body: %w", err)
+							}
+							c.tsw.WriteLiterally("return shouldContinue")
+							c.tsw.WriteLine("")
+							c.tsw.Indent(-1)
+							c.tsw.WriteLiterally("})")
+							c.tsw.WriteLine("")
+							c.tsw.Indent(-1)
+							c.tsw.WriteLine("})()")
+							return nil
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Handle interface types that may represent iterators
+	if _, ok := underlying.(*types.Interface); ok {
+		// For interface types, we need to treat them as potential iterators
+		// In Go 1.23+, interfaces can represent iterator functions
+		// We'll attempt to call them as iterator functions with a yield callback
+
+		// Try to determine the iterator pattern based on context or assume key-value pairs
+		// Since we can't easily determine the exact signature from just the interface,
+		// we'll generate a generic iterator call pattern
+
+		c.tsw.WriteLiterally(";(() => {")
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+		c.tsw.WriteLiterally("let shouldContinue = true")
+		c.tsw.WriteLine("")
+
+		// Call the interface as an iterator function
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write interface iterator expression: %w", err)
+		}
+
+		// Generate the appropriate yield function based on the range variables
+		if exp.Key != nil && exp.Value != nil {
+			// Key-value iterator
+			c.tsw.WriteLiterally("((")
+			if ident, ok := exp.Key.(*ast.Ident); ok && ident.Name != "_" {
+				c.WriteIdent(ident, false)
+			} else {
+				c.tsw.WriteLiterally("k")
+			}
+			c.tsw.WriteLiterally(", ")
+			if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+				c.WriteIdent(ident, false)
+			} else {
+				c.tsw.WriteLiterally("v")
+			}
+			c.tsw.WriteLiterally(") => {")
+		} else if exp.Value != nil {
+			// Value-only iterator
+			c.tsw.WriteLiterally("((")
+			if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+				c.WriteIdent(ident, false)
+			} else {
+				c.tsw.WriteLiterally("v")
+			}
+			c.tsw.WriteLiterally(") => {")
+		} else if exp.Key != nil {
+			// Key-only iterator (treating it as value for single-param iterator)
+			c.tsw.WriteLiterally("((")
+			if ident, ok := exp.Key.(*ast.Ident); ok && ident.Name != "_" {
+				c.WriteIdent(ident, false)
+			} else {
+				c.tsw.WriteLiterally("k")
+			}
+			c.tsw.WriteLiterally(") => {")
+		} else {
+			// No variables iterator
+			c.tsw.WriteLiterally("(() => {")
+		}
+
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+		if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+			return fmt.Errorf("failed to write interface iterator body: %w", err)
+		}
+		c.tsw.WriteLiterally("return shouldContinue")
+		c.tsw.WriteLine("")
+		c.tsw.Indent(-1)
+		c.tsw.WriteLiterally("})")
+		c.tsw.WriteLine("")
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("})()")
+		return nil
+	}
+
 	return errors.Errorf("unsupported range loop type: %T for expression %v", underlying, exp)
 }

package/compiler/type.go

@@ -68,6 +68,15 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type, context GoTypeContext) {
 	case *types.TypeParam:
 		// For type parameters, write the type parameter name (e.g., "T", "K", etc.)
 		c.tsw.WriteLiterally(t.Obj().Name())
+	case *types.Union:
+		// Handle union types (e.g., string | []byte)
+		for i := 0; i < t.Len(); i++ {
+			if i > 0 {
+				c.tsw.WriteLiterally(" | ")
+			}
+			term := t.Term(i)
+			c.WriteGoType(term.Type(), context)
+		}
 	default:
 		// For other types, just write "any" and add a comment
 		c.tsw.WriteLiterally("any")
@@ -202,7 +211,8 @@ func (c *GoToTSCompiler) WriteBasicType(t *types.Basic) {
 
 // WriteNamedType translates a Go named type to its TypeScript equivalent.
 // It specially handles the error interface as $.GoError, and uses the original
-// type name for other named types. For generic types, it includes type arguments.
+// type name for other named types. For imported types, it writes the qualified
+// name using the import alias found from the analysis imports. For generic types, it includes type arguments.
 func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 	// Check if the named type is the error interface
 	if iface, ok := t.Underlying().(*types.Interface); ok && iface.String() == "interface{Error() string}" {
@@ -210,7 +220,40 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 		return
 	}
 
-	// Use Obj().Name() for the original defined name
+	// Check if this type is from an imported package
+	typePkg := t.Obj().Pkg()
+	if typePkg != nil && typePkg != c.pkg.Types {
+		// This type is from an imported package, find the import alias
+		typePkgPath := typePkg.Path()
+
+		// Try to find the import alias by matching the package path
+		for importAlias, _ := range c.analysis.Imports {
+			// The importAlias could be either the explicit alias or the default package name
+			// If it's the default package name, it should match the last segment of the path
+			defaultPkgName := packageNameFromGoPath(typePkgPath)
+			if importAlias == defaultPkgName || importAlias == typePkgPath {
+				// Write the qualified name: importAlias.TypeName
+				c.tsw.WriteLiterally(importAlias)
+				c.tsw.WriteLiterally(".")
+				c.tsw.WriteLiterally(t.Obj().Name())
+
+				// For generic types, include type arguments
+				if t.TypeArgs() != nil && t.TypeArgs().Len() > 0 {
+					c.tsw.WriteLiterally("<")
+					for i := 0; i < t.TypeArgs().Len(); i++ {
+						if i > 0 {
+							c.tsw.WriteLiterally(", ")
+						}
+						c.WriteGoType(t.TypeArgs().At(i), GoTypeContextGeneral)
+					}
+					c.tsw.WriteLiterally(">")
+				}
+				return
+			}
+		}
+	}
+
+	// Use Obj().Name() for the original defined name (local types or unmatched imports)
 	c.tsw.WriteLiterally(t.Obj().Name())
 
 	// For generic types, include type arguments
@@ -388,7 +431,7 @@ func (c *GoToTSCompiler) WriteSignatureType(t *types.Signature) {
 
 		// Use parameter name if available, otherwise use p0, p1, etc.
 		if param.Name() != "" {
-			c.tsw.WriteLiterally(param.Name())
+			c.tsw.WriteLiterally(c.sanitizeIdentifier(param.Name()))
 		} else {
 			c.tsw.WriteLiterallyf("p%d", i)
 		}
@@ -483,7 +526,7 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 				if paramName == "" || paramName == "_" {
 					paramName = fmt.Sprintf("_p%d", j)
 				}
-				c.tsw.WriteLiterally(paramName)
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(paramName))
 				c.tsw.WriteLiterally(": ")
 				c.WriteGoType(paramVar.Type(), GoTypeContextGeneral) // Recursive call for param type
 			}

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

@@ -0,0 +1,9 @@
+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';
+export declare function copy<T>(dst: T[], src: T[]): number;
+export declare function multiplyDuration(duration: any, multiplier: number): any;

package/dist/gs/builtin/builtin.js

@@ -5,6 +5,15 @@ export * from './io.js';
 export * from './map.js';
 export * from './slice.js';
 export * from './type.js';
+// Copy is the Go builtin function that copies the contents of one slice to another.
+// It returns the number of elements copied.
+export function copy(dst, src) {
+    const n = Math.min(dst.length, src.length);
+    for (let i = 0; i < n; i++) {
+        dst[i] = src[i];
+    }
+    return n;
+}
 // Duration multiplication helper for time package operations
 // Handles expressions like time.Hour * 24
 export function multiplyDuration(duration, multiplier) {