goscript 0.0.28 → 0.0.29

package/compiler/analysis.go

@@ -57,6 +57,7 @@ type NodeInfo struct {
 	EnclosingFuncDecl *ast.FuncDecl
 	EnclosingFuncLit  *ast.FuncLit
 	IsInsideFunction  bool // true if this declaration is inside a function body
+	IsMethodValue     bool // true if this SelectorExpr is a method value that needs binding
 }
 
 // Analysis holds information gathered during the analysis phase of the Go code compilation.
@@ -236,6 +237,18 @@ func (a *Analysis) NeedsVarRefAccess(obj types.Object) bool {
 	return false
 }
 
+// IsMethodValue returns whether the given SelectorExpr node is a method value that needs binding.
+func (a *Analysis) IsMethodValue(node *ast.SelectorExpr) bool {
+	if node == nil {
+		return false
+	}
+	nodeInfo := a.NodeData[node]
+	if nodeInfo == nil {
+		return false
+	}
+	return nodeInfo.IsMethodValue
+}
+
 // analysisVisitor implements ast.Visitor and is used to traverse the AST during analysis.
 type analysisVisitor struct {
 	// analysis stores information gathered during the traversal
@@ -566,8 +579,20 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		return v
 
 	case *ast.SelectorExpr:
-		// No need to track private field access since all fields are public
-		return v
+		// Initialize NodeData for this selector expression
+		if v.analysis.NodeData[n] == nil {
+			v.analysis.NodeData[n] = &NodeInfo{}
+		}
+		v.analysis.NodeData[n].InAsyncContext = v.inAsyncFunction
+
+		// Check if this is a method value (method being used as a value, not called immediately)
+		if selection := v.pkg.TypesInfo.Selections[n]; selection != nil {
+			if selection.Kind() == types.MethodVal {
+				// This is a method value - mark it for binding during code generation
+				v.analysis.NodeData[n].IsMethodValue = true
+			}
+		}
+		return v // Continue traversal
 
 	case *ast.AssignStmt:
 		for i, currentLHSExpr := range n.Lhs {
@@ -859,6 +884,20 @@ func AnalyzeFile(file *ast.File, pkg *packages.Package, analysis *Analysis, cmap
 
 	// Walk the AST with our visitor
 	ast.Walk(visitor, file)
+
+	// Post-processing: Find all CallExpr nodes and unmark their Fun SelectorExpr as method values
+	// This distinguishes between method calls (obj.Method()) and method values (obj.Method)
+	ast.Inspect(file, func(n ast.Node) bool {
+		if callExpr, ok := n.(*ast.CallExpr); ok {
+			if selExpr, ok := callExpr.Fun.(*ast.SelectorExpr); ok {
+				// This SelectorExpr is the function being called, so it's NOT a method value
+				if nodeInfo := analysis.NodeData[selExpr]; nodeInfo != nil {
+					nodeInfo.IsMethodValue = false
+				}
+			}
+		}
+		return true
+	})
 }
 
 // getNamedReturns retrieves the named returns for a function

package/compiler/expr-call.go

@@ -513,16 +513,51 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			}
 			return errors.New("unhandled append call with incorrect number of arguments")
 		case "byte":
-			// Translate byte(val) to $.byte(val)
+			// Translate byte(arg) to $.byte(arg)
+			if len(exp.Args) != 1 {
+				return errors.Errorf("unhandled byte call with incorrect number of arguments: %d != 1", len(exp.Args))
+			}
+			c.tsw.WriteLiterally("$.byte(")
+			if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+				return fmt.Errorf("failed to write argument for byte() conversion: %w", err)
+			}
+			c.tsw.WriteLiterally(")")
+			return nil // Handled byte() conversion
+		case "int":
+			// Handle int() conversion
 			if len(exp.Args) == 1 {
-				c.tsw.WriteLiterally("$.byte(")
+				arg := exp.Args[0]
+
+				// Check if we're converting FROM a type with receiver methods TO int
+				if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
+					if namedArgType, isNamed := argType.(*types.Named); isNamed {
+						argTypeName := namedArgType.Obj().Name()
+						// Check if the argument type has receiver methods
+						if c.hasReceiverMethods(argTypeName) {
+							// Check if we're converting to int (the underlying type)
+							if types.Identical(types.Typ[types.Int], namedArgType.Underlying()) {
+								// This is a conversion from a type with methods to int
+								// Use valueOf() instead of $.int()
+								if err := c.WriteValueExpr(arg); err != nil {
+									return fmt.Errorf("failed to write argument for valueOf conversion: %w", err)
+								}
+								c.tsw.WriteLiterally(".valueOf()")
+								return nil // Handled conversion from type with methods to int
+							}
+						}
+					}
+				}
+
+				// Default case: Translate int(value) to $.int(value)
+				c.tsw.WriteLiterally("$.int(")
 				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
-					return err
+					return fmt.Errorf("failed to write argument for int() conversion: %w", err)
 				}
 				c.tsw.WriteLiterally(")")
-				return nil // Handled byte
+				return nil // Handled int() conversion
 			}
-			return errors.New("unhandled byte call with incorrect number of arguments")
+			// Return error for incorrect number of arguments
+			return fmt.Errorf("unhandled int conversion with incorrect number of arguments: %d != 1", len(exp.Args))
 		default:
 			// Check if this is a type conversion to a function type
 			if funIdent != nil {
@@ -531,6 +566,30 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					if typeName, isType := obj.(*types.TypeName); isType {
 						// Make sure we have exactly one argument
 						if len(exp.Args) == 1 {
+							arg := exp.Args[0]
+
+							// Check if we're converting FROM a type with receiver methods TO its underlying type
+							if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
+								if namedArgType, isNamed := argType.(*types.Named); isNamed {
+									argTypeName := namedArgType.Obj().Name()
+									// Check if the argument type has receiver methods
+									if c.hasReceiverMethods(argTypeName) {
+										// Check if we're converting to the underlying type
+										targetType := typeName.Type()
+										underlyingType := namedArgType.Underlying()
+										if types.Identical(targetType, underlyingType) {
+											// This is a conversion from a type with methods to its underlying type
+											// Use valueOf() instead of TypeScript cast
+											if err := c.WriteValueExpr(arg); err != nil {
+												return fmt.Errorf("failed to write argument for valueOf conversion: %w", err)
+											}
+											c.tsw.WriteLiterally(".valueOf()")
+											return nil // Handled conversion from type with methods to underlying type
+										}
+									}
+								}
+							}
+
 							// Check if this is a function type
 							if _, isFuncType := typeName.Type().Underlying().(*types.Signature); isFuncType {
 								// For function types, we need to add a __goTypeName property
@@ -545,17 +604,30 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 								c.tsw.WriteLiterallyf(", { __goTypeName: '%s' })", funIdent.String())
 								return nil // Handled function type cast
 							} else {
-								// For non-function types, use the TypeScript "as" operator
-								c.tsw.WriteLiterally("(")
-								if err := c.WriteValueExpr(exp.Args[0]); err != nil {
-									return fmt.Errorf("failed to write argument for type cast: %w", err)
-								}
+								// Check if this type has receiver methods
+								if c.hasReceiverMethods(funIdent.String()) {
+									// For types with methods, use class constructor
+									c.tsw.WriteLiterally("new ")
+									c.tsw.WriteLiterally(funIdent.String())
+									c.tsw.WriteLiterally("(")
+									if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+										return fmt.Errorf("failed to write argument for type constructor: %w", err)
+									}
+									c.tsw.WriteLiterally(")")
+									return nil // Handled type with methods conversion
+								} else {
+									// For non-function types without methods, use the TypeScript "as" operator
+									c.tsw.WriteLiterally("(")
+									if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+										return fmt.Errorf("failed to write argument for type cast: %w", err)
+									}
 
-								// 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
+									// 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
+								}
 							}
 						}
 					}

package/compiler/expr-selector.go

@@ -38,6 +38,14 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 		}
 	}
 
+	// Check if this is a method value (method being used as a value, not called immediately)
+	if c.analysis.IsMethodValue(exp) {
+		// This is a method value - we need to bind it properly
+		if selection := c.pkg.TypesInfo.Selections[exp]; selection != nil {
+			return c.writeMethodValue(exp, selection)
+		}
+	}
+
 	// --- Special case for dereferenced pointer to struct with field access: (*p).field or (**p).field etc ---
 	var baseExpr ast.Expr = exp.X
 	// Look inside parentheses if present
@@ -148,3 +156,95 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 	c.WriteIdent(exp.Sel, false)
 	return nil
 }
+
+// writeMethodValue handles method values (methods used as values, not called immediately)
+// and generates proper binding code to maintain the 'this' context.
+func (c *GoToTSCompiler) writeMethodValue(exp *ast.SelectorExpr, selection *types.Selection) error {
+	// Get the method signature to understand the receiver type
+	methodObj := selection.Obj().(*types.Func)
+	sig := methodObj.Type().(*types.Signature)
+	recv := sig.Recv()
+
+	if recv == nil {
+		// This shouldn't happen for method values, but handle gracefully
+		return fmt.Errorf("method value has no receiver: %s", methodObj.Name())
+	}
+
+	// Determine if this is a pointer receiver or value receiver
+	recvType := recv.Type()
+	isPointerReceiver := false
+	if _, ok := recvType.(*types.Pointer); ok {
+		isPointerReceiver = true
+	}
+
+	// Get the base expression type to understand what we're working with
+	baseType := c.pkg.TypesInfo.TypeOf(exp.X)
+	baseIsPointer := false
+	if _, ok := baseType.(*types.Pointer); ok {
+		baseIsPointer = true
+	}
+
+	// Write the receiver expression
+	if err := c.WriteValueExpr(exp.X); err != nil {
+		return fmt.Errorf("failed to write method value receiver: %w", err)
+	}
+
+	// Add null assertion if needed
+	if baseIsPointer {
+		c.tsw.WriteLiterally("!")
+	}
+
+	// Handle different receiver type combinations according to Go semantics
+	if isPointerReceiver && !baseIsPointer {
+		// Pointer receiver method on value type: t.Mp equivalent to (&t).Mp
+		// The receiver should be the address of the value
+		c.tsw.WriteLiterally(".")
+		c.WriteIdent(exp.Sel, false)
+		c.tsw.WriteLiterally(".bind(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write method value receiver for binding: %w", err)
+		}
+		if baseIsPointer {
+			c.tsw.WriteLiterally("!")
+		}
+		c.tsw.WriteLiterally(")")
+	} else if !isPointerReceiver && baseIsPointer {
+		// Value receiver method on pointer type: pt.Mv equivalent to (*pt).Mv
+		// The receiver should be a copy of the dereferenced value
+		c.tsw.WriteLiterally(".value.")
+		c.WriteIdent(exp.Sel, false)
+		c.tsw.WriteLiterally(".bind(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write method value receiver for binding: %w", err)
+		}
+		c.tsw.WriteLiterally("!.value.clone())")
+	} else if !isPointerReceiver && !baseIsPointer {
+		// Value receiver method on value type: t.Mv
+		// The receiver should be a copy of the value
+		c.tsw.WriteLiterally(".")
+		c.WriteIdent(exp.Sel, false)
+		c.tsw.WriteLiterally(".bind(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write method value receiver for binding: %w", err)
+		}
+		if baseIsPointer {
+			c.tsw.WriteLiterally("!")
+		}
+		c.tsw.WriteLiterally(".clone())")
+	} else {
+		// Pointer receiver method on pointer type: pt.Mp
+		// The receiver should be the pointer itself
+		c.tsw.WriteLiterally(".")
+		c.WriteIdent(exp.Sel, false)
+		c.tsw.WriteLiterally(".bind(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write method value receiver for binding: %w", err)
+		}
+		if baseIsPointer {
+			c.tsw.WriteLiterally("!")
+		}
+		c.tsw.WriteLiterally(")")
+	}
+
+	return nil
+}

package/compiler/spec-value.go

@@ -216,21 +216,92 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 						c.tsw.WriteLiterally(")")
 					}
 				} else {
-					// Regular initializer, clone if needed
-					if shouldApplyClone(c.pkg, initializerExpr) {
-						if err := c.WriteValueExpr(initializerExpr); err != nil {
-							return err
+					// Check if this is a named type with methods and the initializer is a basic value
+					if namedType, isNamed := goType.(*types.Named); isNamed {
+						typeName := namedType.Obj().Name()
+						if c.hasReceiverMethods(typeName) {
+							// Check if the initializer is a basic literal or simple value that needs wrapping
+							needsConstructor := false
+							switch initializerExpr.(type) {
+							case *ast.BasicLit:
+								needsConstructor = true
+							case *ast.Ident:
+								// Check if it's a simple identifier (not a function call or complex expression)
+								if ident := initializerExpr.(*ast.Ident); ident.Name != "nil" {
+									// Check if this identifier refers to a value of the underlying type
+									if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
+										if objType := obj.Type(); objType != nil {
+											// If the identifier's type matches the underlying type, wrap it
+											if types.Identical(objType, namedType.Underlying()) {
+												needsConstructor = true
+											}
+										}
+									}
+								}
+							}
+
+							if needsConstructor {
+								c.tsw.WriteLiterallyf("new %s(", typeName)
+								if err := c.WriteValueExpr(initializerExpr); err != nil {
+									return err
+								}
+								c.tsw.WriteLiterally(")")
+							} else {
+								// Regular initializer for named type (e.g., function call that returns the type)
+								if shouldApplyClone(c.pkg, initializerExpr) {
+									if err := c.WriteValueExpr(initializerExpr); err != nil {
+										return err
+									}
+									c.tsw.WriteLiterally(".clone()")
+								} else {
+									if err := c.WriteValueExpr(initializerExpr); err != nil {
+										return err
+									}
+								}
+							}
+						} else {
+							// Named type without methods, handle normally
+							if shouldApplyClone(c.pkg, initializerExpr) {
+								if err := c.WriteValueExpr(initializerExpr); err != nil {
+									return err
+								}
+								c.tsw.WriteLiterally(".clone()")
+							} else {
+								if err := c.WriteValueExpr(initializerExpr); err != nil {
+									return err
+								}
+							}
 						}
-						c.tsw.WriteLiterally(".clone()")
 					} else {
-						if err := c.WriteValueExpr(initializerExpr); err != nil {
-							return err
+						// Regular initializer, clone if needed
+						if shouldApplyClone(c.pkg, initializerExpr) {
+							if err := c.WriteValueExpr(initializerExpr); err != nil {
+								return err
+							}
+							c.tsw.WriteLiterally(".clone()")
+						} else {
+							if err := c.WriteValueExpr(initializerExpr); err != nil {
+								return err
+							}
 						}
 					}
 				}
 			} else {
 				// No initializer, use the zero value directly
-				c.WriteZeroValueForType(goType)
+				// Check if this is a named type with methods
+				if namedType, isNamed := goType.(*types.Named); isNamed {
+					typeName := namedType.Obj().Name()
+					if c.hasReceiverMethods(typeName) {
+						// For named types with methods, create a new instance with zero value
+						c.tsw.WriteLiterallyf("new %s(", typeName)
+						c.WriteZeroValueForType(namedType.Underlying())
+						c.tsw.WriteLiterally(")")
+					} else {
+						c.WriteZeroValueForType(goType)
+					}
+				} else {
+					c.WriteZeroValueForType(goType)
+				}
 			}
 		}
 		c.tsw.WriteLine("") // Finish the declaration line

package/compiler/spec.go

@@ -150,6 +150,237 @@ func (c *GoToTSCompiler) writeClonedFieldInitializer(fieldName string, fieldType
 	c.tsw.WriteLiterally(")")
 }
 
+// hasReceiverMethods checks if a type declaration has any receiver methods defined
+func (c *GoToTSCompiler) hasReceiverMethods(typeName string) bool {
+	for _, fileSyntax := range c.pkg.Syntax {
+		for _, decl := range fileSyntax.Decls {
+			funcDecl, isFunc := decl.(*ast.FuncDecl)
+			if !isFunc || funcDecl.Recv == nil || len(funcDecl.Recv.List) == 0 {
+				continue
+			}
+			recvField := funcDecl.Recv.List[0]
+			recvType := recvField.Type
+			if starExpr, ok := recvType.(*ast.StarExpr); ok {
+				recvType = starExpr.X
+			}
+
+			// Check for both simple identifiers (FileMode) and generic types (FileMode[T])
+			var recvTypeName string
+			if ident, ok := recvType.(*ast.Ident); ok {
+				recvTypeName = ident.Name
+			} else if indexExpr, ok := recvType.(*ast.IndexExpr); ok {
+				if ident, ok := indexExpr.X.(*ast.Ident); ok {
+					recvTypeName = ident.Name
+				}
+			}
+
+			if recvTypeName == typeName {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// WriteNamedTypeWithMethods generates a TypeScript class for a Go named type that has receiver methods
+func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
+	className := a.Name.Name
+	underlyingType := c.pkg.TypesInfo.TypeOf(a.Type)
+
+	// Add export for Go-exported types (but not if inside a function)
+	isInsideFunction := false
+	if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
+		isInsideFunction = nodeInfo.IsInsideFunction
+	}
+
+	if a.Name.IsExported() && !isInsideFunction {
+		c.tsw.WriteLiterally("export ")
+	}
+
+	c.tsw.WriteLiterallyf("class %s {", className)
+	c.tsw.WriteLine("")
+	c.tsw.Indent(1)
+
+	// Constructor that takes the underlying type value
+	c.tsw.WriteLiterally("constructor(private _value: ")
+	c.WriteGoType(underlyingType, GoTypeContextGeneral)
+	c.tsw.WriteLine(") {}")
+	c.tsw.WriteLine("")
+
+	// valueOf method to get the underlying value (for type conversions and operations)
+	c.tsw.WriteLiterally("valueOf(): ")
+	c.WriteGoType(underlyingType, GoTypeContextGeneral)
+	c.tsw.WriteLine(" {")
+	c.tsw.Indent(1)
+	c.tsw.WriteLine("return this._value")
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+	c.tsw.WriteLine("")
+
+	// toString method for string conversion
+	c.tsw.WriteLine("toString(): string {")
+	c.tsw.Indent(1)
+	c.tsw.WriteLine("return String(this._value)")
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+	c.tsw.WriteLine("")
+
+	// Static from method for type conversion
+	c.tsw.WriteLiterallyf("static from(value: ")
+	c.WriteGoType(underlyingType, GoTypeContextGeneral)
+	c.tsw.WriteLiterallyf("): %s {", className)
+	c.tsw.WriteLine("")
+	c.tsw.Indent(1)
+	c.tsw.WriteLiterallyf("return new %s(value)", className)
+	c.tsw.WriteLine("")
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+
+	// Add receiver methods for this type
+	for _, fileSyntax := range c.pkg.Syntax {
+		for _, decl := range fileSyntax.Decls {
+			funcDecl, isFunc := decl.(*ast.FuncDecl)
+			if !isFunc || funcDecl.Recv == nil || len(funcDecl.Recv.List) == 0 {
+				continue
+			}
+			recvField := funcDecl.Recv.List[0]
+			recvType := recvField.Type
+			if starExpr, ok := recvType.(*ast.StarExpr); ok {
+				recvType = starExpr.X
+			}
+
+			// Check for both simple identifiers (FileMode) and generic types (FileMode[T])
+			var recvTypeName string
+			if ident, ok := recvType.(*ast.Ident); ok {
+				recvTypeName = ident.Name
+			} else if indexExpr, ok := recvType.(*ast.IndexExpr); ok {
+				if ident, ok := indexExpr.X.(*ast.Ident); ok {
+					recvTypeName = ident.Name
+				}
+			}
+
+			if recvTypeName == className {
+				c.tsw.WriteLine("")
+				if err := c.writeNamedTypeMethod(funcDecl, className); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+
+	return nil
+}
+
+// writeNamedTypeMethod writes a method for a named type, handling receiver binding properly
+func (c *GoToTSCompiler) writeNamedTypeMethod(decl *ast.FuncDecl, className string) error {
+	if decl.Doc != nil {
+		c.WriteDoc(decl.Doc)
+	}
+
+	// Determine if method is async
+	var isAsync bool
+	if obj := c.pkg.TypesInfo.Defs[decl.Name]; obj != nil {
+		isAsync = c.analysis.IsAsyncFunc(obj)
+	}
+
+	// Methods are typically public in the TS output
+	c.tsw.WriteLiterally("public ")
+
+	// Add async modifier if needed
+	if isAsync {
+		c.tsw.WriteLiterally("async ")
+	}
+
+	// Keep original Go casing for method names
+	if err := c.WriteValueExpr(decl.Name); err != nil { // Method name is a value identifier
+		return err
+	}
+
+	// Write signature (parameters and return type)
+	funcType := decl.Type
+	c.tsw.WriteLiterally("(")
+	if funcType.Params != nil {
+		c.WriteFieldList(funcType.Params, true) // true = arguments
+	}
+	c.tsw.WriteLiterally(")")
+
+	// Handle return type
+	if funcType.Results != nil && len(funcType.Results.List) > 0 {
+		c.tsw.WriteLiterally(": ")
+		if isAsync {
+			c.tsw.WriteLiterally("Promise<")
+		}
+		if len(funcType.Results.List) == 1 {
+			// Single return value
+			resultType := funcType.Results.List[0].Type
+			c.WriteTypeExpr(resultType)
+		} else {
+			// Multiple return values -> tuple type
+			c.tsw.WriteLiterally("[")
+			for i, field := range funcType.Results.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.WriteTypeExpr(field.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+		if isAsync {
+			c.tsw.WriteLiterally(">")
+		}
+	} else {
+		// No return value -> void
+		if isAsync {
+			c.tsw.WriteLiterally(": Promise<void>")
+		} else {
+			c.tsw.WriteLiterally(": void")
+		}
+	}
+
+	c.tsw.WriteLiterally(" ")
+
+	// For named types with methods, bind receiver name to this._value
+	if recvField := decl.Recv.List[0]; len(recvField.Names) > 0 {
+		recvName := recvField.Names[0].Name
+		if recvName != "_" {
+			c.tsw.WriteLine("{")
+			c.tsw.Indent(1)
+			// Bind the receiver name to this._value for value types
+			sanitizedRecvName := c.sanitizeIdentifier(recvName)
+			c.tsw.WriteLinef("const %s = this._value", sanitizedRecvName)
+
+			// Add using statement if needed
+			if c.analysis.NeedsDefer(decl.Body) {
+				if c.analysis.IsInAsyncFunction(decl) {
+					c.tsw.WriteLine("await using __defer = new $.AsyncDisposableStack();")
+				} else {
+					c.tsw.WriteLine("using cleanup = new $.DisposableStack();")
+				}
+			}
+
+			// write method body without outer braces
+			for _, stmt := range decl.Body.List {
+				if err := c.WriteStmt(stmt); err != nil {
+					return fmt.Errorf("failed to write statement in function body: %w", err)
+				}
+			}
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+
+			return nil
+		}
+	}
+	// no named receiver, write whole body
+	if err := c.WriteStmt(decl.Body); err != nil {
+		return fmt.Errorf("failed to write function body: %w", err)
+	}
+
+	return nil
+}
+
 // WriteTypeSpec writes the type specification to the output.
 func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 	if a.Doc != nil {
@@ -165,6 +396,11 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 	case *ast.InterfaceType:
 		return c.WriteInterfaceTypeSpec(a, t)
 	default:
+		// Check if this type has receiver methods
+		if c.hasReceiverMethods(a.Name.Name) {
+			return c.WriteNamedTypeWithMethods(a)
+		}
+
 		// type alias - add export for Go-exported types (but not if inside a function)
 		isInsideFunction := false
 		if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {

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

@@ -5,6 +5,7 @@ export * from './io.js';
 export * from './map.js';
 export * from './slice.js';
 export * from './type.js';
+export declare function int(value: number): number;
 export declare function copy<T>(dst: T[] | Uint8Array, src: T[] | Uint8Array | string): number;
 export declare function multiplyDuration(duration: any, multiplier: number): any;
 /**

package/dist/gs/builtin/builtin.js

@@ -5,6 +5,17 @@ export * from './io.js';
 export * from './map.js';
 export * from './slice.js';
 export * from './type.js';
+// int converts a value to a Go int type, handling proper signed integer conversion
+// This ensures that values like 2147483648 (2^31) are properly handled according to Go semantics
+export function int(value) {
+    // In Go, int is typically 64-bit on 64-bit systems, but for compatibility with JavaScript
+    // we need to handle the conversion properly. The issue is that JavaScript's number type
+    // can represent values larger than 32-bit signed integers, but when cast in certain contexts
+    // they get interpreted as signed 32-bit integers.
+    // For Go's int type on 64-bit systems, we should preserve the full value
+    // since JavaScript numbers can safely represent integers up to Number.MAX_SAFE_INTEGER
+    return Math.trunc(value);
+}
 // 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) {