goscript 0.0.26 → 0.0.29

package/compiler/expr-call.go

@@ -5,6 +5,7 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
+	"strings"
 
 	"github.com/pkg/errors"
 )
@@ -38,6 +39,11 @@ import (
 func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 	expFun := exp.Fun
 
+	// Handle protobuf method calls
+	if handled, err := c.writeProtobufMethodCall(exp); handled {
+		return err
+	}
+
 	// Handle any type conversion with nil argument
 	if len(exp.Args) == 1 {
 		if nilIdent, isIdent := exp.Args[0].(*ast.Ident); isIdent && nilIdent.Name == "nil" {
@@ -325,6 +331,53 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 										}
 									}
 								}
+							} else {
+								// Handle named types with slice underlying types: make(NamedSliceType, len, cap)
+								// This handles cases like: type appendSliceWriter []byte; make(appendSliceWriter, 0, len(s))
+								namedType := typeName.Type()
+								if sliceType, isSlice := namedType.Underlying().(*types.Slice); isSlice {
+									goElemType := sliceType.Elem()
+
+									// Check if it's a named type with []byte underlying type
+									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 named []byte type
+									}
+
+									// Handle other named slice types
+									c.tsw.WriteLiterally("$.makeSlice<")
+									c.WriteGoType(goElemType, 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 named slice type
+								}
 							}
 						}
 					}
@@ -460,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 {
@@ -478,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
@@ -492,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
+								}
 							}
 						}
 					}
@@ -554,6 +679,36 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			return nil // Handled regular function call
 		}
 	} else {
+		// Check if this is an async method call (e.g., mu.Lock())
+		if selExpr, ok := expFun.(*ast.SelectorExpr); ok {
+			// Check if this is a method call on a variable (e.g., mu.Lock())
+			if ident, ok := selExpr.X.(*ast.Ident); ok {
+				// Get the type of the receiver
+				if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
+					if varObj, ok := obj.(*types.Var); ok {
+						// Get the type name and package
+						if namedType, ok := varObj.Type().(*types.Named); ok {
+							typeName := namedType.Obj().Name()
+							methodName := selExpr.Sel.Name
+
+							// Check if the type is from an imported package
+							if typePkg := namedType.Obj().Pkg(); typePkg != nil && typePkg != c.pkg.Types {
+								pkgPath := typePkg.Path()
+								// Extract package name from path (e.g., "sync" from "github.com/.../gs/sync")
+								parts := strings.Split(pkgPath, "/")
+								pkgName := parts[len(parts)-1]
+
+								// Check if this method is async based on metadata
+								if c.analysis.IsMethodAsync(pkgName, typeName, methodName) {
+									c.tsw.WriteLiterally("await ")
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
 		// 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("(")

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/expr.go

@@ -388,7 +388,7 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		isBitwise = true
 	}
 
-	// Special handling for large bit shift expressions that would overflow in JavaScript
+	// Handle large bit shift expressions that would overflow in JavaScript
 	if exp.Op == token.SHL {
 		// Check if this is 1 << 63 pattern
 		if leftLit, leftIsLit := exp.X.(*ast.BasicLit); leftIsLit && leftLit.Value == "1" {