goscript 0.0.23 → 0.0.25

package/compiler/composite-lit.go

@@ -13,27 +13,28 @@ import (
 //
 // It handles several types of composite literals:
 //   - Map literals (e.g., `map[K]V{k1: v1}`): Translated to `new Map([[k1_ts, v1_ts]])`.
-//     Values are processed by `writeBoxedValue`.
+//     Values are processed by `WriteVarRefedValue`.
 //   - Array/Slice literals (e.g., `[]T{e1, e2}`, `[N]T{idx: val}`):
 //   - 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`.
-//     Element values are processed by `writeBoxedValue`.
+//     Element values are processed by `WriteVarRefedValue`.
 //   - Struct literals:
 //   - Named structs (e.g., `MyStruct{F: v}` or `&MyStruct{F: v}`): Translated to
 //     `new MyStruct_ts({ F: v_ts, ... })`. The constructor typically uses an `_init` method.
 //   - Anonymous structs (e.g., `struct{F int}{F: v}`): Translated to TypeScript
 //     object literals `{ F: v_ts, ... }`.
 //     It processes keyed elements (`FieldName: Value`) and unkeyed elements (for anonymous
-//     structs or arrays). Field values are processed by `writeBoxedValue`.
+//     structs or arrays). Field values are processed by `WriteVarRefedValue`.
 //     Embedded struct fields are initialized, and explicit initializers for embedded
 //     structs (e.g. `Outer{InnerField: InnerType{...}}`) are handled.
-//     The function uses `c.analysis` to determine correct value access (e.g., `.value` for boxed fields).
+//     The function uses `c.analysis` to determine correct value access (e.g., `.value` for var-refed fields).
 func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 	// Get the type of the composite literal
 	litType := c.pkg.TypesInfo.TypeOf(exp)
+
 	if exp.Type != nil {
 		// Handle map literals: map[K]V{k1: v1, k2: v2}
 		if _, isMapType := exp.Type.(*ast.MapType); isMapType {
@@ -47,11 +48,11 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 
 				if kv, ok := elm.(*ast.KeyValueExpr); ok {
 					c.tsw.WriteLiterally("[")
-					if err := c.WriteBoxedValue(kv.Key); err != nil {
+					if err := c.WriteVarRefedValue(kv.Key); err != nil {
 						return fmt.Errorf("failed to write map literal key: %w", err)
 					}
 					c.tsw.WriteLiterally(", ")
-					if err := c.WriteBoxedValue(kv.Value); err != nil {
+					if err := c.WriteVarRefedValue(kv.Value); err != nil {
 						return fmt.Errorf("failed to write map literal value: %w", err)
 					}
 					c.tsw.WriteLiterally("]")
@@ -139,7 +140,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 						hasKeyedElements = true
 					} else {
 						c.tsw.WriteCommentInline("unhandled keyed array literal key type")
-						if err := c.WriteBoxedValue(elm); err != nil {
+						if err := c.WriteVarRefedValue(elm); err != nil {
 							return fmt.Errorf("failed to write keyed array literal element with unhandled key type: %w", err)
 						}
 					}
@@ -167,7 +168,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					c.tsw.WriteLiterally(", ")
 				}
 				if elm, ok := elements[i]; ok && elm != nil {
-					if err := c.WriteBoxedValue(elm); err != nil {
+					if err := c.WriteVarRefedValue(elm); err != nil {
 						return fmt.Errorf("failed to write array literal element: %w", err)
 					}
 				} else {
@@ -340,7 +341,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					}
 					c.tsw.WriteLiterally(keyName)
 					c.tsw.WriteLiterally(": ")
-					if err := c.WriteBoxedValue(directFields[keyName]); err != nil {
+					if err := c.WriteVarRefedValue(directFields[keyName]); err != nil {
 						return err
 					}
 					firstFieldWritten = true
@@ -368,14 +369,14 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 							if i > 0 {
 								c.tsw.WriteLiterally(", ")
 							}
-							if err := c.WriteBoxedValue(elem); err != nil {
+							if err := c.WriteVarRefedValue(elem); err != nil {
 								return err
 							}
 						}
 						c.tsw.WriteLiterally("}")
 					} else {
 						// Not a composite literal, write it normally
-						if err := c.WriteBoxedValue(explicitEmbedded[embeddedName]); err != nil {
+						if err := c.WriteVarRefedValue(explicitEmbedded[embeddedName]); err != nil {
 							return err
 						}
 					}
@@ -414,7 +415,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 						}
 						c.tsw.WriteLiterally(keyName) // Field name within the embedded struct
 						c.tsw.WriteLiterally(": ")
-						if err := c.WriteBoxedValue(fieldsMap[keyName]); err != nil {
+						if err := c.WriteVarRefedValue(fieldsMap[keyName]); err != nil {
 							return err
 						}
 					}
@@ -436,7 +437,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					if i != 0 {
 						c.tsw.WriteLiterally(", ")
 					}
-					if err := c.WriteBoxedValue(elm); err != nil {
+					if err := c.WriteVarRefedValue(elm); err != nil {
 						return fmt.Errorf("failed to write literal field: %w", err)
 					}
 				}
@@ -448,60 +449,124 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 
 	// Untyped composite literal. Let's use type information to determine what it is.
 	// First try to get the type information for the expression
-	isObject := false
 	if tv, ok := c.pkg.TypesInfo.Types[exp]; ok && tv.Type != nil {
 		underlying := tv.Type.Underlying()
 		switch underlying.(type) {
 		case *types.Map, *types.Struct:
-			isObject = true
+			// Handle struct directly with the struct literal logic
+			if structType, ok := underlying.(*types.Struct); ok {
+				return c.writeUntypedStructLiteral(exp, structType) // true = anonymous
+			}
+			// Map case would be handled here
+			return fmt.Errorf("untyped map composite literals not yet supported")
 		case *types.Array, *types.Slice:
-			isObject = false
+			// Handle array/slice
+			return c.writeUntypedArrayLiteral(exp)
+		case *types.Pointer:
+			// Handle pointer to composite literal
+			ptrType := underlying.(*types.Pointer)
+			elemType := ptrType.Elem().Underlying()
+			switch elemType.(type) {
+			case *types.Struct:
+				// This is an anonymous struct literal with inferred pointer type
+				// Just create the struct object directly - no var-refing needed
+				// Anonymous literals are not variables, so they don't get var-refed
+				structType := elemType.(*types.Struct)
+				return c.writeUntypedStructLiteral(exp, structType) // true = anonymous
+			default:
+				return fmt.Errorf("unhandled pointer composite literal element type: %T", elemType)
+			}
 		default:
 			return fmt.Errorf("unhandled composite literal type: %T", underlying)
 		}
 	} else {
 		return fmt.Errorf("could not determine composite literal type from type information")
 	}
+}
 
-	if isObject {
-		c.tsw.WriteLiterally("{ ")
-	} else {
-		c.tsw.WriteLiterally("[ ")
-	}
-
+// writeUntypedArrayLiteral handles untyped composite literals that are arrays/slices
+func (c *GoToTSCompiler) writeUntypedArrayLiteral(exp *ast.CompositeLit) error {
+	c.tsw.WriteLiterally("[ ")
 	for i, elm := range exp.Elts {
 		if i != 0 {
 			c.tsw.WriteLiterally(", ")
 		}
-		if err := c.WriteBoxedValue(elm); err != nil {
-			return fmt.Errorf("failed to write untyped composite literal element: %w", err)
+		if err := c.WriteVarRefedValue(elm); err != nil {
+			return fmt.Errorf("failed to write untyped array literal element: %w", err)
 		}
 	}
-	if isObject {
-		c.tsw.WriteLiterally(" }")
-	} else {
-		c.tsw.WriteLiterally(" ]")
+	c.tsw.WriteLiterally(" ]")
+	return nil
+}
+
+// writeUntypedStructLiteral handles untyped composite literals that are structs or pointers to structs
+func (c *GoToTSCompiler) writeUntypedStructLiteral(exp *ast.CompositeLit, structType *types.Struct) error {
+	// Create field mapping like the typed struct case
+	directFields := make(map[string]ast.Expr)
+
+	// Handle elements that are key-value pairs
+	for _, elt := range exp.Elts {
+		if kv, ok := elt.(*ast.KeyValueExpr); ok {
+			if keyIdent, ok := kv.Key.(*ast.Ident); ok {
+				directFields[keyIdent.Name] = kv.Value
+			}
+		}
 	}
+
+	// Handle elements that are positional (no key specified)
+	if len(directFields) == 0 {
+		// If no key-value pairs, try to match positional values to struct fields
+		for i, elt := range exp.Elts {
+			if _, isKV := elt.(*ast.KeyValueExpr); !isKV && i < structType.NumFields() {
+				field := structType.Field(i)
+				directFields[field.Name()] = elt
+			}
+		}
+	}
+
+	// Write the object literal (always anonymous for untyped)
+	c.tsw.WriteLiterally("{")
+
+	firstFieldWritten := false
+	// Write fields in order
+	directKeys := make([]string, 0, len(directFields))
+	for k := range directFields {
+		directKeys = append(directKeys, k)
+	}
+	slices.Sort(directKeys)
+	for _, keyName := range directKeys {
+		if firstFieldWritten {
+			c.tsw.WriteLiterally(", ")
+		}
+		c.tsw.WriteLiterally(keyName)
+		c.tsw.WriteLiterally(": ")
+		if err := c.WriteVarRefedValue(directFields[keyName]); err != nil {
+			return err
+		}
+		firstFieldWritten = true
+	}
+
+	c.tsw.WriteLiterally("}")
 	return nil
 }
 
-// WriteBoxedValue translates a Go expression (`ast.Expr`) into its TypeScript equivalent,
+// WriteVarRefedValue translates a Go expression (`ast.Expr`) into its TypeScript equivalent,
 // specifically for use as a value within a composite literal (e.g., struct fields,
 // map keys/values, or array/slice elements). Its primary goal is to ensure that the
-// actual, unboxed value of the expression is used.
+// actual un-refed value of the expression is used.
 //
 // How it works:
 //   - Identifiers (`*ast.Ident`): Delegates to `c.WriteIdent(ident, true)`, forcing
 //     the `accessValue` flag to `true`. This ensures that if `ident` refers to a
-//     GoScript boxed variable, the generated TypeScript accesses its underlying `.value`
+//     GoScript var-refed variable, the generated TypeScript accesses its underlying `.value`
 //     (e.g., `myVar.value`).
 //   - Selector Expressions (`*ast.SelectorExpr`, e.g., `obj.Field`): Delegates to
 //     `c.WriteSelectorExpr(e)`. This function handles the necessary logic for
-//     accessing fields or methods, including any required unboxing if the field
-//     itself or the object it's accessed on is boxed (e.g., `obj.value.field` or
+//     accessing fields or methods, including any required un-var-refing if the field
+//     itself or the object it's accessed on is var-refed (e.g., `obj.value.field` or
 //     `obj.field.value`).
 //   - Star Expressions (`*ast.StarExpr`, e.g., `*ptr`): Delegates to `c.WriteStarExpr(e)`.
-//     This function handles pointer dereferencing, which in GoScript's boxing model
+//     This function handles pointer dereferencing, which in GoScript's var-refing model
 //     often translates to accessing the `.value` field of the pointer (e.g., `ptr.value`).
 //   - Basic Literals (`*ast.BasicLit`, e.g., `123`, `"hello"`): Delegates to
 //     `c.WriteBasicLit(e)` for direct translation.
@@ -511,25 +576,25 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 //
 // Necessity and Distinction from `WriteValueExpr`:
 // While `WriteValueExpr` is a general-purpose function for translating Go expressions
-// and also unboxes identifiers (by calling `WriteIdent` with `accessValue: true`),
-// `WriteBoxedValue` serves a specific and crucial role when called from `WriteCompositeLit`:
+// and also un-var-refes identifiers (by calling `WriteIdent` with `accessValue: true`),
+// `WriteVarRefedValue` serves a specific and crucial role when called from `WriteCompositeLit`:
 //  1. Clarity of Intent: It explicitly signals that for the constituents of a composite
-//     literal, the *unboxed value* is mandatory.
+//     literal, the *un-var-refed value* is mandatory.
 //  2. Contract for `WriteCompositeLit`: It ensures that `WriteCompositeLit` receives
 //     the correct values for initialization, insulating it from potential changes in
-//     the default behavior of `WriteValueExpr` regarding unboxing.
+//     the default behavior of `WriteValueExpr` regarding un-var-refing.
 //  3. Prevents Recursion: `WriteValueExpr` handles `*ast.CompositeLit` nodes by
 //     calling `WriteCompositeLit`. If `WriteCompositeLit` were to directly call
 //     `WriteValueExpr` for its elements, it could lead to unintended recursion or
-//     behavior if an element itself was another composite literal. `WriteBoxedValue`
+//     behavior if an element itself was another composite literal. `WriteVarRefedValue`
 //     acts as a specific intermediary for the *elements*.
 //
-// In summary, `WriteBoxedValue` is a specialized dispatcher used by `WriteCompositeLit`
+// In summary, `WriteVarRefedValue` is a specialized dispatcher used by `WriteCompositeLit`
 // to guarantee that all parts of a Go composite literal are initialized with their
-// proper, unboxed TypeScript values.
-func (c *GoToTSCompiler) WriteBoxedValue(expr ast.Expr) error {
+// proper, unrefed TypeScript values.
+func (c *GoToTSCompiler) WriteVarRefedValue(expr ast.Expr) error {
 	if expr == nil {
-		return fmt.Errorf("nil expression passed to writeBoxedValue")
+		return fmt.Errorf("nil expression passed to write var refed value")
 	}
 
 	// Handle different expression types

package/compiler/config.go

@@ -13,13 +13,17 @@ type Config struct {
 
 	// Dir is the working directory for the compiler. If empty, uses the current working directory.
 	Dir string
-	// OutputPathRoot is the output path root.
-	OutputPathRoot string
+	// OutputPath is the output path root.
+	OutputPath string
 	// BuildFlags are the Go build flags (tags) to use during analysis.
 	BuildFlags []string
 	// AllDependencies controls whether to compile all dependencies of the requested packages.
 	// If true, all dependencies will be compiled; if false, only the requested packages are compiled.
 	AllDependencies bool
+	// DisableEmitBuiltin controls whether to emit builtin packages when they are referenced.
+	// If true, builtin packages will not be emitted; if false, they will be emitted if referenced.
+	// Default is false (emit builtin packages).
+	DisableEmitBuiltin bool
 }
 
 // Validate checks the config.
@@ -30,7 +34,7 @@ func (c *Config) Validate() error {
 	if c.fset == nil {
 		c.fset = token.NewFileSet()
 	}
-	if c.OutputPathRoot == "" {
+	if c.OutputPath == "" {
 		return errors.New("output path root must be specified")
 	}
 	return nil

package/compiler/config_test.go

@@ -1,7 +1,6 @@
 package compiler
 
 import (
-	"reflect"
 	"testing"
 )
 
@@ -15,9 +14,9 @@ func TestConfigValidate(t *testing.T) {
 		{
 			name: "valid config",
 			config: &Config{
-				Dir:            "/some/dir",
-				OutputPathRoot: "/output/path",
-				BuildFlags:     []string{"-tags", "sometag"},
+				Dir:        "/some/dir",
+				OutputPath: "/output/path",
+				BuildFlags: []string{"-tags", "sometag"},
 			},
 			wantErr: false,
 		},
@@ -33,9 +32,9 @@ func TestConfigValidate(t *testing.T) {
 		{
 			name: "nil fset gets initialized",
 			config: &Config{
-				fset:           nil,
-				Dir:            "/some/dir",
-				OutputPathRoot: "/output/path",
+				fset:       nil,
+				Dir:        "/some/dir",
+				OutputPath: "/output/path",
 			},
 			wantErr: false,
 		},
@@ -61,29 +60,3 @@ func TestConfigValidate(t *testing.T) {
 		})
 	}
 }
-
-func TestConfigFields(t *testing.T) {
-	// Verify that Config has the expected fields
-	config := Config{}
-	configType := reflect.TypeOf(config)
-
-	expectedFields := map[string]string{
-		"fset":           "*token.FileSet",
-		"Dir":            "string",
-		"OutputPathRoot": "string",
-		"BuildFlags":     "[]string",
-	}
-
-	for fieldName, expectedType := range expectedFields {
-		field, exists := configType.FieldByName(fieldName)
-		if !exists {
-			t.Errorf("Expected Config to have field %s", fieldName)
-			continue
-		}
-
-		actualType := field.Type.String()
-		if actualType != expectedType {
-			t.Errorf("Field %s has type %s, expected %s", fieldName, actualType, expectedType)
-		}
-	}
-}

package/compiler/decl.go

@@ -37,7 +37,7 @@ func (c *GoToTSCompiler) WriteDecls(decls []ast.Decl) error {
 				c.tsw.WriteLine("") // Add space after spec
 			}
 		default:
-			fmt.Printf("unknown decl: %#v\n", decl)
+			return fmt.Errorf("unknown decl: %#v", decl)
 		}
 	}
 	return nil
@@ -79,6 +79,12 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 	if obj := c.pkg.TypesInfo.Defs[decl.Name]; obj != nil {
 		isAsync = c.analysis.IsAsyncFunc(obj)
 	}
+
+	// Always make main function async (only in main package)
+	if decl.Name.Name == "main" && c.pkg.Name == "main" {
+		isAsync = true
+	}
+
 	if isAsync {
 		c.tsw.WriteLiterally("async ")
 	}

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
+}