goscript 0.0.22 → 0.0.23

package/compiler/composite-lit.go

@@ -15,7 +15,8 @@ import (
 //   - Map literals (e.g., `map[K]V{k1: v1}`): Translated to `new Map([[k1_ts, v1_ts]])`.
 //     Values are processed by `writeBoxedValue`.
 //   - Array/Slice literals (e.g., `[]T{e1, e2}`, `[N]T{idx: val}`):
-//     Translated using the `$.arrayToSlice<T_ts>([...])` runtime helper.
+//   - For `[]byte{...}`, translated to `new Uint8Array([...])`.
+//   - For other `[]T` or `[N]T`, translated using the `$.arrayToSlice<T_ts>([...])` runtime helper.
 //     It handles both keyed and unkeyed elements, infers length if necessary,
 //     and uses zero values for uninitialized array elements.
 //     Multi-dimensional arrays/slices pass a depth parameter to `$.arrayToSlice`.
@@ -73,14 +74,29 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 				// We'll handle this with depth parameter to arrayToSlice
 			}
 
-			c.tsw.WriteLiterally("$.arrayToSlice")
+			// Check if it's a []byte literal
+			isByteSliceLiteral := false
+			if typInfo := c.pkg.TypesInfo.TypeOf(exp.Type); typInfo != nil {
+				if sliceT, ok := typInfo.Underlying().(*types.Slice); ok {
+					if basicElem, ok := sliceT.Elem().(*types.Basic); ok && basicElem.Kind() == types.Uint8 {
+						isByteSliceLiteral = true
+					}
+				}
+			}
 
-			// write the type annotation
-			c.tsw.WriteLiterally("<")
-			// Write the element type using the existing function
-			c.WriteTypeExpr(arrType.Elt)
-			c.tsw.WriteLiterally(">")
+			if isByteSliceLiteral {
+				c.tsw.WriteLiterally("new Uint8Array")
+			} else {
+				c.tsw.WriteLiterally("$.arrayToSlice")
+
+				// write the type annotation
+				c.tsw.WriteLiterally("<")
+				// Write the element type using the existing function
+				c.WriteTypeExpr(arrType.Elt)
+				c.tsw.WriteLiterally(">")
+			}
 
+			// opening
 			c.tsw.WriteLiterally("([")
 
 			// Use type info to get array length and element type
@@ -166,7 +182,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 			c.tsw.WriteLiterally("]")
 
 			// If it's a multi-dimensional array/slice, use depth=2 to convert nested arrays
-			if isMultiDimensional {
+			if isMultiDimensional && !isByteSliceLiteral { // Depth parameter not applicable to Uint8Array constructor
 				c.tsw.WriteLiterally(", 2") // Depth of 2 for one level of nesting
 			}
 
@@ -271,9 +287,8 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 				}
 
 				// Handle the case where an anonymous struct has values without keys
-				// Handle the case where an anonymous struct has values without keys.
 				// This block processes non-key-value elements and associates them with struct fields.
-				if isAnonymousStruct && len(exp.Elts) > 0 && len(directFields) == 0 && structType != nil {
+				if isAnonymousStruct && len(exp.Elts) > 0 && len(directFields) == 0 {
 					// Check if any elements in the composite literal are not key-value pairs.
 					hasNonKeyValueElts := false
 					for _, elt := range exp.Elts {

package/compiler/decl.go

@@ -88,14 +88,50 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 		return fmt.Errorf("failed to write function name: %w", err)
 	}
 
+	// Write type parameters if present
+	if decl.Type.TypeParams != nil {
+		c.WriteTypeParameters(decl.Type.TypeParams)
+	}
+
 	// WriteFuncType needs to be aware if the function is async
 	c.WriteFuncType(decl.Type, isAsync) // Write signature (params, return type)
 	c.tsw.WriteLiterally(" ")
 
+	hasNamedReturns := false
+	if decl.Type.Results != nil {
+		for _, field := range decl.Type.Results.List {
+			if len(field.Names) > 0 {
+				hasNamedReturns = true
+				break
+			}
+		}
+	}
+
+	if hasNamedReturns {
+		c.tsw.WriteLine("{")
+		c.tsw.Indent(1)
+
+		// Declare named return variables and initialize them to their zero values
+		for _, field := range decl.Type.Results.List {
+			for _, name := range field.Names {
+				c.tsw.WriteLiterallyf("let %s: ", name.Name)
+				c.WriteTypeExpr(field.Type)
+				c.tsw.WriteLiterally(" = ")
+				c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
+				c.tsw.WriteLine("")
+			}
+		}
+	}
+
 	if err := c.WriteStmt(decl.Body); err != nil {
 		return fmt.Errorf("failed to write function body: %w", err)
 	}
 
+	if hasNamedReturns {
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("}")
+	}
+
 	return nil
 }
 

package/compiler/expr-call.go

@@ -13,15 +13,19 @@ import (
 // into its TypeScript equivalent.
 // It handles several Go built-in functions specially:
 // - `println(...)` becomes `console.log(...)`.
+// - `panic(...)` becomes `$.panic(...)`.
 // - `len(arg)` becomes `$.len(arg)`.
 // - `cap(arg)` becomes `$.cap(arg)`.
 // - `delete(m, k)` becomes `$.deleteMapEntry(m, k)`.
 // - `make(chan T, size)` becomes `$.makeChannel<T_ts>(size, zeroValueForT)`.
 // - `make(map[K]V)` becomes `$.makeMap<K_ts, V_ts>()`.
 // - `make([]T, len, cap)` becomes `$.makeSlice<T_ts>(len, cap)`.
+// - `make([]byte, len, cap)` becomes `new Uint8Array(len)`.
 // - `string(runeVal)` becomes `String.fromCharCode(runeVal)`.
-// - `string([]runeVal)` or `string([]byteVal)` becomes `$.runesToString(sliceVal)`.
-// - `[]rune(stringVal)` becomes `$.stringToRunes(stringVal)`.
+// - `string([]runeVal)` becomes `$.runesToString(sliceVal)`.
+// - `string([]byteVal)` becomes `$.bytesToString(sliceVal)`.
+// - `[]rune(stringVal)` becomes `$.stringToRunes(stringVal)“.
+// - `[]byte(stringVal)` becomes `$.stringToBytes(stringVal)`.
 // - `close(ch)` becomes `ch.close()`.
 // - `append(slice, elems...)` becomes `$.append(slice, elems...)`.
 // - `byte(val)` becomes `$.byte(val)`.
@@ -70,66 +74,56 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 				}
 			}
 		}
+		// Check if it's a []byte type and the argument is a string
+		if eltIdent, ok := arrayType.Elt.(*ast.Ident); ok && eltIdent.Name == "byte" && arrayType.Len == nil {
+			if len(exp.Args) == 1 {
+				arg := exp.Args[0]
+				// Ensure TypesInfo is available and the argument type can be determined
+				if tv, typeOk := c.pkg.TypesInfo.Types[arg]; typeOk && tv.Type != nil {
+					if basicArgType, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && (basicArgType.Info()&types.IsString) != 0 {
+						c.tsw.WriteLiterally("$.stringToBytes(")
+						if err := c.WriteValueExpr(arg); err != nil {
+							return fmt.Errorf("failed to write argument for []byte(string) conversion: %w", err)
+						}
+						c.tsw.WriteLiterally(")")
+						return nil // Handled []byte(string)
+					}
+				}
+			}
+		}
 	}
 
 	if funIdent, funIsIdent := expFun.(*ast.Ident); funIsIdent {
 		switch funIdent.String() {
+		case "panic":
+			c.tsw.WriteLiterally("$.panic")
 		case "println":
-			c.tsw.WriteLiterally("console.log(")
-			for i, arg := range exp.Args {
-				if i != 0 {
-					c.tsw.WriteLiterally(", ")
-				}
-				if err := c.WriteValueExpr(arg); err != nil {
-					return err
-				}
-			}
-			c.tsw.WriteLiterally(")")
-			return nil
+			c.tsw.WriteLiterally("console.log")
 		case "len":
 			// Translate len(arg) to $.len(arg)
-			if len(exp.Args) == 1 {
-				c.tsw.WriteLiterally("$.len(")
-				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
-					return err
-				}
-				c.tsw.WriteLiterally(")")
-				return nil // Handled len
+			if len(exp.Args) != 1 {
+				return errors.Errorf("unhandled len call with incorrect number of arguments: %d != 1", len(exp.Args))
 			}
-			return errors.New("unhandled len call with incorrect number of arguments")
+			c.tsw.WriteLiterally("$.len")
 		case "cap":
 			// Translate cap(arg) to $.cap(arg)
-			if len(exp.Args) == 1 {
-				c.tsw.WriteLiterally("$.cap(")
-				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
-					return err
-				}
-				c.tsw.WriteLiterally(")")
-				return nil // Handled cap
+			if len(exp.Args) != 1 {
+				return errors.Errorf("unhandled cap call with incorrect number of arguments: %d != 1", len(exp.Args))
 			}
-			return errors.New("unhandled cap call with incorrect number of arguments")
+			c.tsw.WriteLiterally("$.cap")
 		case "delete":
 			// Translate delete(map, key) to $.deleteMapEntry(map, key)
-			if len(exp.Args) == 2 {
-				c.tsw.WriteLiterally("$.deleteMapEntry(")
-				if err := c.WriteValueExpr(exp.Args[0]); err != nil { // Map
-					return err
-				}
-				c.tsw.WriteLiterally(", ")
-				if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Key
-					return err
-				}
-				c.tsw.WriteLiterally(")")
-				return nil // Handled delete
+			if len(exp.Args) != 2 {
+				return errors.Errorf("unhandled delete call with incorrect number of arguments: %d != 2", len(exp.Args))
 			}
-			return errors.New("unhandled delete call with incorrect number of arguments")
+			c.tsw.WriteLiterally("$.deleteMapEntry")
 		case "make":
 			// First check if we have a channel type
 			if typ := c.pkg.TypesInfo.TypeOf(exp.Args[0]); typ != nil {
 				if chanType, ok := typ.Underlying().(*types.Chan); ok {
 					// Handle channel creation: make(chan T, bufferSize) or make(chan T)
 					c.tsw.WriteLiterally("$.makeChannel<")
-					c.WriteGoType(chanType.Elem())
+					c.WriteGoType(chanType.Elem(), GoTypeContextGeneral)
 					c.tsw.WriteLiterally(">(")
 
 					// If buffer size is provided, add it
@@ -189,13 +183,30 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					if sliceType == nil {
 						return errors.New("could not get type information for slice in make call")
 					}
-					goElemType, ok := sliceType.Underlying().(*types.Slice)
+					goUnderlyingType, ok := sliceType.Underlying().(*types.Slice)
 					if !ok {
 						return errors.New("expected slice type for make call")
 					}
+					goElemType := goUnderlyingType.Elem()
+
+					// Check if it's make([]byte, ...)
+					if basicElem, isBasic := goElemType.(*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 []byte
+					}
 
 					c.tsw.WriteLiterally("$.makeSlice<")
-					c.WriteGoType(goElemType.Elem()) // Write the element type
+					c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
 					c.tsw.WriteLiterally(">(")
 
 					if len(exp.Args) >= 2 {
@@ -253,7 +264,16 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 				// Handle direct string(int32) conversion
 				// This assumes 'rune' is int32
 				if tv, ok := c.pkg.TypesInfo.Types[arg]; ok {
-					if basic, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && basic.Kind() == types.Int32 {
+					// Case 3a: Argument is already a string - no-op
+					if basic, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && basic.Kind() == types.String {
+						// Translate string(stringValue) to stringValue (no-op)
+						if err := c.WriteValueExpr(arg); err != nil {
+							return fmt.Errorf("failed to write argument for string(string) no-op conversion: %w", err)
+						}
+						return nil // Handled string(string) no-op
+					}
+
+					if basic, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && (basic.Kind() == types.Int32 || basic.Kind() == types.UntypedRune) {
 						// Translate string(rune_val) to String.fromCharCode(rune_val)
 						c.tsw.WriteLiterally("String.fromCharCode(")
 						if err := c.WriteValueExpr(arg); err != nil {
@@ -266,18 +286,43 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					// Case 3: Argument is a slice of runes or bytes string([]rune{...}) or string([]byte{...})
 					if sliceType, isSlice := tv.Type.Underlying().(*types.Slice); isSlice {
 						if basic, isBasic := sliceType.Elem().Underlying().(*types.Basic); isBasic {
-							// Handle both runes (int32) and bytes (uint8)
-							if basic.Kind() == types.Int32 || basic.Kind() == types.Uint8 {
-								// Translate string([]rune) or string([]byte) to $.runesToString(...)
+							// Handle string([]byte)
+							if basic.Kind() == types.Uint8 {
+								c.tsw.WriteLiterally("$.bytesToString(")
+								if err := c.WriteValueExpr(arg); err != nil {
+									return fmt.Errorf("failed to write argument for string([]byte) conversion: %w", err)
+								}
+								c.tsw.WriteLiterally(")")
+								return nil // Handled string([]byte)
+							}
+							// Handle both runes (int32)
+							if basic.Kind() == types.Int32 {
+								// Translate string([]rune) to $.runesToString(...)
 								c.tsw.WriteLiterally("$.runesToString(")
 								if err := c.WriteValueExpr(arg); err != nil {
-									return fmt.Errorf("failed to write argument for string([]rune/[]byte) conversion: %w", err)
+									return fmt.Errorf("failed to write argument for string([]rune) conversion: %w", err)
 								}
 								c.tsw.WriteLiterally(")")
-								return nil // Handled string([]rune) or string([]byte)
+								return nil // Handled string([]rune)
 							}
 						}
 					}
+
+					// Case 4: Argument is a generic type parameter (e.g., string | []byte)
+					if typeParam, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
+						// Check if this is a []byte | string union constraint
+						constraint := typeParam.Constraint()
+						if constraint != nil {
+							// For now, assume any type parameter that could be string or []byte needs the helper
+							// This is a heuristic - in the future we could parse the constraint more precisely
+							c.tsw.WriteLiterally("$.genericBytesOrStringToString(")
+							if err := c.WriteValueExpr(arg); err != nil {
+								return fmt.Errorf("failed to write argument for string(generic) conversion: %w", err)
+							}
+							c.tsw.WriteLiterally(")")
+							return nil // Handled string(generic type parameter)
+						}
+					}
 				}
 			}
 			// Return error for other unhandled string conversions
@@ -352,8 +397,10 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 									return fmt.Errorf("failed to write argument for type cast: %w", err)
 								}
 
-								// Then use the TypeScript "as" operator with the type name
-								c.tsw.WriteLiterallyf(" as %s)", funIdent.String())
+								// Then use the TypeScript "as" operator with the mapped type name
+								c.tsw.WriteLiterally(" as ")
+								c.WriteGoType(typeName.Type(), GoTypeContextGeneral)
+								c.tsw.WriteLiterally(")")
 								return nil // Handled non-function type cast
 							}
 						}
@@ -396,15 +443,24 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			return nil // Handled regular function call
 		}
 	} else {
-		// Not an identifier (e.g., method call on a value)
-		if err := c.WriteValueExpr(expFun); err != nil {
-			return fmt.Errorf("failed to write method expression in call: %w", err)
-		}
+		// If expFun is a function literal, it needs to be wrapped in parentheses for IIFE syntax
+		if _, isFuncLit := expFun.(*ast.FuncLit); isFuncLit {
+			c.tsw.WriteLiterally("(")
+			if err := c.WriteValueExpr(expFun); err != nil {
+				return fmt.Errorf("failed to write function literal in call: %w", err)
+			}
+			c.tsw.WriteLiterally(")")
+		} else {
+			// Not an identifier (e.g., method call on a value)
+			if err := c.WriteValueExpr(expFun); err != nil {
+				return fmt.Errorf("failed to write method expression in call: %w", err)
+			}
 
-		if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
-			if _, ok := funType.Underlying().(*types.Signature); ok {
-				if _, isNamed := funType.(*types.Named); isNamed {
-					c.tsw.WriteLiterally("!")
+			if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
+				if _, ok := funType.Underlying().(*types.Signature); ok {
+					if _, isNamed := funType.(*types.Named); isNamed {
+						c.tsw.WriteLiterally("!")
+					}
 				}
 			}
 		}

package/compiler/expr-selector.go

@@ -91,8 +91,28 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 		return fmt.Errorf("failed to write selector base expression: %w", err)
 	}
 
-	// Add .
-	c.tsw.WriteLiterally(".")
+	// Add null assertion for selector expressions when accessing fields/methods on nullable types
+	// In Go, accessing fields or calling methods on nil pointers/interfaces panics, so we should throw in TypeScript
+	baseType := c.pkg.TypesInfo.TypeOf(exp.X)
+	if baseType != nil {
+		// Check if the base is a pointer type
+		if _, isPtr := baseType.(*types.Pointer); isPtr {
+			c.tsw.WriteLiterally("!.")
+		} else if _, isInterface := baseType.Underlying().(*types.Interface); isInterface {
+			// For interface types, add null assertion since interfaces can be nil
+			c.tsw.WriteLiterally("!.")
+		} else if callExpr, isCall := exp.X.(*ast.CallExpr); isCall {
+			// For function calls that return nullable types, add null assertion
+			_ = callExpr // Use the variable to avoid unused error
+			c.tsw.WriteLiterally("!.")
+		} else {
+			// Add .
+			c.tsw.WriteLiterally(".")
+		}
+	} else {
+		// Add .
+		c.tsw.WriteLiterally(".")
+	}
 
 	// Write the field/method name.
 	// Pass 'true' to WriteIdent to potentially add '.value' if the field itself

package/compiler/expr-type.go

@@ -22,13 +22,59 @@ import (
 func (c *GoToTSCompiler) WriteTypeExpr(a ast.Expr) {
 	// Get type information for the expression and use WriteGoType
 	typ := c.pkg.TypesInfo.TypeOf(a)
-	c.WriteGoType(typ)
+	c.WriteGoType(typ, GoTypeContextGeneral)
 }
 
 // writeTypeDescription writes the TypeInfo for a type expr.
 func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 	switch t := typeExpr.(type) {
 	case *ast.Ident:
+		// Resolve the identifier to its type
+		goType := c.pkg.TypesInfo.TypeOf(t)
+		if goType != nil {
+			if namedType, isNamed := goType.(*types.Named); isNamed {
+				if sig, isFuncSig := namedType.Underlying().(*types.Signature); isFuncSig {
+					// It's a named function type (e.g. type MyFunc func())
+					c.tsw.WriteLiterally("{")
+					c.tsw.WriteLiterally("kind: $.TypeKind.Function, ")
+					c.tsw.WriteLiterallyf("name: '%s'", namedType.Obj().Name()) // Use the original defined name
+
+					// Add params if present
+					if sig.Params() != nil && sig.Params().Len() > 0 {
+						c.tsw.WriteLiterally(", params: [")
+						for i := 0; i < sig.Params().Len(); i++ {
+							if i > 0 {
+								c.tsw.WriteLiterally(", ")
+							}
+							paramVar := sig.Params().At(i)
+							c.writeTypeInfoObject(paramVar.Type())
+						}
+						c.tsw.WriteLiterally("]")
+					} else {
+						c.tsw.WriteLiterally(", params: []")
+					}
+
+					// Add results if present
+					if sig.Results() != nil && sig.Results().Len() > 0 {
+						c.tsw.WriteLiterally(", results: [")
+						for i := 0; i < sig.Results().Len(); i++ {
+							if i > 0 {
+								c.tsw.WriteLiterally(", ")
+							}
+							resultVar := sig.Results().At(i)
+							c.writeTypeInfoObject(resultVar.Type())
+						}
+						c.tsw.WriteLiterally("]")
+					} else {
+						c.tsw.WriteLiterally(", results: []")
+					}
+
+					c.tsw.WriteLiterally("}")
+					return
+				}
+			}
+		}
+
 		if isPrimitiveType(t.Name) {
 			if tsType, ok := GoBuiltinToTypescript(t.Name); ok {
 				c.tsw.WriteLiterally("{")
@@ -112,9 +158,16 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 		c.tsw.WriteLiterally("kind: $.TypeKind.Function")
 
 		// Add name if this is a named function type
-		if namedType := c.pkg.TypesInfo.TypeOf(typeExpr); namedType != nil {
-			if named, ok := namedType.(*types.Named); ok {
-				c.tsw.WriteLiterallyf(", name: '%s'", named.Obj().Name())
+		// For an anonymous ast.FuncType, typeExpr is the ast.FuncType itself.
+		// We need to check if the type information associated with this AST node
+		// points to a *types.Named type.
+		resolvedGoType := c.pkg.TypesInfo.TypeOf(typeExpr)
+		if resolvedGoType != nil {
+			if named, ok := resolvedGoType.(*types.Named); ok {
+				// Ensure it's actually a function type that's named
+				if _, isFuncSig := named.Underlying().(*types.Signature); isFuncSig {
+					c.tsw.WriteLiterallyf(", name: '%s'", named.Obj().Name())
+				}
 			}
 		}
 
@@ -174,6 +227,80 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 			c.tsw.WriteLiterally("'both'")
 		}
 
+		c.tsw.WriteLiterally("}")
+	case *ast.InterfaceType:
+		// Handle inline interface types like interface{ Method() string }
+		c.tsw.WriteLiterally("{")
+		c.tsw.WriteLiterally("kind: $.TypeKind.Interface, ")
+		c.tsw.WriteLiterally("methods: [")
+
+		// Add method signatures for each method in the interface
+		if t.Methods != nil && t.Methods.List != nil {
+			hasMethod := false
+			for _, field := range t.Methods.List {
+				// Only process method declarations (not embedded interfaces)
+				if len(field.Names) > 0 {
+					for _, methodName := range field.Names {
+						if hasMethod {
+							c.tsw.WriteLiterally(", ")
+						}
+						hasMethod = true
+
+						// Write method signature in the same format as writeMethodSignatures
+						c.tsw.WriteLiterallyf("{ name: '%s', args: [", methodName.Name)
+
+						// Get the function type for this method
+						if funcType, ok := field.Type.(*ast.FuncType); ok {
+							// Add parameters
+							if funcType.Params != nil && funcType.Params.List != nil {
+								paramIndex := 0
+								for _, param := range funcType.Params.List {
+									// Each parameter field can declare multiple variables of the same type
+									if len(param.Names) > 0 {
+										for _, paramName := range param.Names {
+											if paramIndex > 0 {
+												c.tsw.WriteLiterally(", ")
+											}
+											c.tsw.WriteLiterallyf("{ name: '%s', type: ", paramName.Name)
+											c.writeTypeDescription(param.Type)
+											c.tsw.WriteLiterally(" }")
+											paramIndex++
+										}
+									} else {
+										// No names, create a generic parameter name
+										if paramIndex > 0 {
+											c.tsw.WriteLiterally(", ")
+										}
+										c.tsw.WriteLiterallyf("{ name: '_p%d', type: ", paramIndex)
+										c.writeTypeDescription(param.Type)
+										c.tsw.WriteLiterally(" }")
+										paramIndex++
+									}
+								}
+							}
+
+							c.tsw.WriteLiterally("], returns: [")
+
+							// Add return types
+							if funcType.Results != nil && funcType.Results.List != nil {
+								for i, result := range funcType.Results.List {
+									if i > 0 {
+										c.tsw.WriteLiterally(", ")
+									}
+									c.tsw.WriteLiterally("{ type: ")
+									c.writeTypeDescription(result.Type)
+									c.tsw.WriteLiterally(" }")
+								}
+							}
+
+							c.tsw.WriteLiterally("] }")
+						}
+					}
+				}
+			}
+		}
+
+		c.tsw.WriteLiterally("]")
 		c.tsw.WriteLiterally("}")
 	default:
 		// For other types, use the string representation

package/compiler/expr-value.go

@@ -1,6 +1,8 @@
 package compiler
 
-import "go/ast"
+import (
+	"go/ast"
+)
 
 // WriteValueExpr translates a Go abstract syntax tree (AST) expression (`ast.Expr`)
 // that represents a value into its TypeScript value equivalent.
@@ -50,43 +52,11 @@ func (c *GoToTSCompiler) WriteValueExpr(a ast.Expr) error {
 		return c.WriteTypeAssertExpr(exp)
 	case *ast.IndexExpr:
 		return c.WriteIndexExpr(exp)
+	case *ast.IndexListExpr:
+		// Handle generic function instantiation: f[T1, T2](args) -> f<T1, T2>(args)
+		return c.WriteIndexListExpr(exp)
 	case *ast.SliceExpr:
-		// Translate Go slice expression to $.goSlice(x, low, high, max)
-		c.tsw.WriteLiterally("$.goSlice(")
-		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
+		return c.WriteSliceExpr(exp)
 	case *ast.ParenExpr:
 		// Check if this is a nil pointer to struct type cast: (*struct{})(nil)
 		if starExpr, isStarExpr := exp.X.(*ast.StarExpr); isStarExpr {