goscript 0.0.32 → 0.0.34

package/compiler/stmt-assign.go

@@ -276,122 +276,106 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 	}
 
 	// writeMapLookupWithExists handles the map comma-ok idiom: value, exists := myMap[key]
-	// Note: We don't use WriteIndexExpr here because we need to handle .has() and .get() separately
+	// Uses array destructuring with the tuple-returning $.mapGet function
 	writeMapLookupWithExists := func(lhs []ast.Expr, indexExpr *ast.IndexExpr, tok token.Token) error {
 		// First check that we have exactly two LHS expressions (value and exists)
 		if len(lhs) != 2 {
 			return fmt.Errorf("map comma-ok idiom requires exactly 2 variables on LHS, got %d", len(lhs))
 		}
 
-		// Check for blank identifiers and get variable names
+		// Check for blank identifiers
 		valueIsBlank := false
 		existsIsBlank := false
-		var valueName string
-		var existsName string
 
-		if valIdent, ok := lhs[0].(*ast.Ident); ok {
-			if valIdent.Name == "_" {
-				valueIsBlank = true
-			} else {
-				valueName = valIdent.Name
-			}
-		} else {
-			return fmt.Errorf("unhandled LHS expression type for value in map comma-ok: %T", lhs[0])
+		if valIdent, ok := lhs[0].(*ast.Ident); ok && valIdent.Name == "_" {
+			valueIsBlank = true
+		}
+		if existsIdent, ok := lhs[1].(*ast.Ident); ok && existsIdent.Name == "_" {
+			existsIsBlank = true
 		}
 
-		if existsIdent, ok := lhs[1].(*ast.Ident); ok {
-			if existsIdent.Name == "_" {
-				existsIsBlank = true
-			} else {
-				existsName = existsIdent.Name
-			}
+		// Use array destructuring with mapGet tuple return
+		if tok == token.DEFINE {
+			c.tsw.WriteLiterally("let ")
 		} else {
-			return fmt.Errorf("unhandled LHS expression type for exists in map comma-ok: %T", lhs[1])
+			// Add semicolon before destructuring assignment to prevent TypeScript
+			// from interpreting it as array access on the previous line
+			c.tsw.WriteLiterally(";")
 		}
 
-		// Declare variables if using := and not blank
-		if tok == token.DEFINE {
-			if !valueIsBlank {
-				c.tsw.WriteLiterally("let ")
-				c.tsw.WriteLiterally(valueName)
-				// TODO: Add type annotation based on map value type
-				c.tsw.WriteLine("")
-			}
-			if !existsIsBlank {
-				c.tsw.WriteLiterally("let ")
-				c.tsw.WriteLiterally(existsName)
-				c.tsw.WriteLiterally(": boolean") // exists is always boolean
-				c.tsw.WriteLine("")
+		c.tsw.WriteLiterally("[")
+
+		// Write LHS variables, handling blanks
+		if !valueIsBlank {
+			if err := c.WriteValueExpr(lhs[0]); err != nil {
+				return err
 			}
 		}
+		// Note: for blank identifiers, we just omit the variable name entirely
+
+		c.tsw.WriteLiterally(", ")
 
-		// Assign 'exists'
 		if !existsIsBlank {
-			c.tsw.WriteLiterally(existsName)
-			c.tsw.WriteLiterally(" = ")
-			c.tsw.WriteLiterally("$.mapHas(")
-			if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
-				return err
-			}
-			c.tsw.WriteLiterally(", ")
-			if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
+			if err := c.WriteValueExpr(lhs[1]); err != nil {
 				return err
 			}
-			c.tsw.WriteLiterally(")")
-			c.tsw.WriteLine("")
 		}
+		// Note: for blank identifiers, we just omit the variable name entirely
 
-		// Assign 'value'
-		if !valueIsBlank {
-			c.tsw.WriteLiterally(valueName)
-			c.tsw.WriteLiterally(" = ")
-			c.tsw.WriteLiterally("$.mapGet(")
-			if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
-				return err
-			}
-			c.tsw.WriteLiterally(", ")
-			if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
-				return err
-			}
-			c.tsw.WriteLiterally(", ")
-			// Write the zero value for the map's value type
-			if tv, ok := c.pkg.TypesInfo.Types[indexExpr.X]; ok {
-				if mapType, isMap := tv.Type.Underlying().(*types.Map); isMap {
-					c.WriteZeroValueForType(mapType.Elem())
+		c.tsw.WriteLiterally("] = $.mapGet(")
+
+		// Write map expression
+		if err := c.WriteValueExpr(indexExpr.X); err != nil {
+			return err
+		}
+
+		c.tsw.WriteLiterally(", ")
+
+		// Write key expression
+		if err := c.WriteValueExpr(indexExpr.Index); err != nil {
+			return err
+		}
+
+		c.tsw.WriteLiterally(", ")
+
+		// Write the zero value for the map's value type
+		if tv, ok := c.pkg.TypesInfo.Types[indexExpr.X]; ok {
+			if mapType, isMap := tv.Type.Underlying().(*types.Map); isMap {
+				c.WriteZeroValueForType(mapType.Elem())
+			} else if typeParam, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
+				// Handle type parameter constrained to be a map type
+				constraint := typeParam.Constraint()
+				if constraint != nil {
+					underlying := constraint.Underlying()
+					if iface, isInterface := underlying.(*types.Interface); isInterface {
+						if hasMapConstraint(iface) {
+							// Get the value type from the constraint
+							mapValueType := getMapValueTypeFromConstraint(iface)
+							if mapValueType != nil {
+								c.WriteZeroValueForType(mapValueType)
+							} else {
+								c.tsw.WriteLiterally("null")
+							}
+						} else {
+							c.tsw.WriteLiterally("null")
+						}
+					} else {
+						c.tsw.WriteLiterally("null")
+					}
 				} else {
-					// Fallback zero value if type info is missing or not a map
 					c.tsw.WriteLiterally("null")
 				}
 			} else {
+				// Fallback zero value if type info is missing or not a map
 				c.tsw.WriteLiterally("null")
 			}
-			c.tsw.WriteLiterally(")")
-			c.tsw.WriteLine("")
-		} else if existsIsBlank {
-			// If both are blank, still evaluate for side effects (though .has/.get are usually pure)
-			// We add a ; otherwise TypeScript thinks we are invoking a function.
-			c.tsw.WriteLiterally(";(") // Wrap in parens to make it an expression statement
-			c.tsw.WriteLiterally("$.mapHas(")
-			if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
-				return err
-			}
-			c.tsw.WriteLiterally(", ")
-			if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
-				return err
-			}
-			c.tsw.WriteLiterally("), ") // Evaluate .has
-			c.tsw.WriteLiterally("$.mapGet(")
-			if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
-				return err
-			}
-			c.tsw.WriteLiterally(", ")
-			if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
-				return err
-			}
-			c.tsw.WriteLiterally(", null))") // Evaluate .get with null as default
-			c.tsw.WriteLine("")
+		} else {
+			c.tsw.WriteLiterally("null")
 		}
 
+		c.tsw.WriteLiterally(")")
+		c.tsw.WriteLine("")
+
 		return nil
 	}
 
@@ -417,6 +401,8 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 				}
 				return nil
 			}
+			// Handle general function calls that return multiple values
+			return writeMultiVarAssignFromCall(exp.Lhs, callExpr, exp.Tok)
 		}
 
 		if typeAssertExpr, ok := rhsExpr.(*ast.TypeAssertExpr); ok {
@@ -428,10 +414,22 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 				if c.pkg != nil && c.pkg.TypesInfo != nil {
 					tv, ok := c.pkg.TypesInfo.Types[indexExpr.X]
 					if ok {
-						// Check if it's a map type
+						// Check if it's a concrete map type
 						if _, isMap := tv.Type.Underlying().(*types.Map); isMap {
 							return writeMapLookupWithExists(exp.Lhs, indexExpr, exp.Tok)
 						}
+						// Check if it's a type parameter constrained to be a map type
+						if typeParam, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
+							constraint := typeParam.Constraint()
+							if constraint != nil {
+								underlying := constraint.Underlying()
+								if iface, isInterface := underlying.(*types.Interface); isInterface {
+									if hasMapConstraint(iface) {
+										return writeMapLookupWithExists(exp.Lhs, indexExpr, exp.Tok)
+									}
+								}
+							}
+						}
 					}
 				}
 			}
@@ -441,8 +439,6 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 				return c.writeChannelReceiveWithOk(exp.Lhs, unaryExpr, exp.Tok)
 			}
 			// If LHS count is not 2, fall through to error or other handling
-		} else if callExpr, ok := rhsExpr.(*ast.CallExpr); ok {
-			return writeMultiVarAssignFromCall(exp.Lhs, callExpr, exp.Tok)
 		}
 		// If none of the specific multi-assign patterns match, fall through to the error check below
 	}
@@ -463,7 +459,27 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 
 	// Ensure LHS and RHS have the same length for valid Go code in these cases
 	if len(exp.Lhs) != len(exp.Rhs) {
-		return fmt.Errorf("invalid assignment statement: LHS count (%d) != RHS count (%d)", len(exp.Lhs), len(exp.Rhs))
+		// Special case: allow multiple LHS with single RHS if RHS can produce multiple values
+		// This handles cases like: x, y := getValue() where getValue() returns multiple values
+		// or other expressions that can produce multiple values
+		if len(exp.Rhs) == 1 {
+			// Allow single RHS expressions that can produce multiple values:
+			// - Function calls that return multiple values
+			// - Type assertions with comma-ok
+			// - Map lookups with comma-ok
+			// - Channel receives with comma-ok
+			// The Go type checker should have already verified this is valid
+			rhsExpr := exp.Rhs[0]
+			switch rhsExpr.(type) {
+			case *ast.CallExpr, *ast.TypeAssertExpr, *ast.IndexExpr, *ast.UnaryExpr:
+				// These expression types can potentially produce multiple values
+				// Let the general assignment logic handle them
+			default:
+				return fmt.Errorf("invalid assignment statement: LHS count (%d) != RHS count (%d)", len(exp.Lhs), len(exp.Rhs))
+			}
+		} else {
+			return fmt.Errorf("invalid assignment statement: LHS count (%d) != RHS count (%d)", len(exp.Lhs), len(exp.Rhs))
+		}
 	}
 
 	// Handle multi-variable assignment (e.g., swaps) using writeAssignmentCore

package/compiler/stmt-for.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/token"
+	"go/types"
 
 	"github.com/pkg/errors"
 )
@@ -64,7 +65,25 @@ func (c *GoToTSCompiler) WriteStmtForInit(stmt ast.Stmt) error {
 	case *ast.AssignStmt:
 		// Handle assignment in init (e.g., i := 0 or i = 0)
 		// For TypeScript for-loop init, we need to handle multi-variable declarations differently
-		if s.Tok == token.DEFINE && len(s.Lhs) > 1 && len(s.Rhs) > 0 {
+		if s.Tok == token.DEFINE && len(s.Lhs) > 1 && len(s.Rhs) == 1 {
+			// Handle the case where we have multiple LHS variables but only one RHS expression
+			// Use array destructuring for all cases including map comma-ok idiom
+			rhsExpr := s.Rhs[0]
+			c.tsw.WriteLiterally("let [")
+			for i, lhs := range s.Lhs {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				if err := c.WriteValueExpr(lhs); err != nil {
+					return err
+				}
+			}
+			c.tsw.WriteLiterally("] = ")
+			if err := c.writeDestructuringValue(rhsExpr); err != nil {
+				return err
+			}
+			return nil
+		} else if s.Tok == token.DEFINE && len(s.Lhs) > 1 && len(s.Rhs) > 0 {
 			// For loop initialization with multiple variables (e.g., let i = 0, j = 10)
 			c.tsw.WriteLiterally("let ")
 
@@ -121,6 +140,64 @@ func (c *GoToTSCompiler) WriteStmtForInit(stmt ast.Stmt) error {
 	}
 }
 
+// writeDestructuringValue writes a value expression in a destructuring context.
+// For map index expressions, it generates the full tuple without [0] indexing.
+func (c *GoToTSCompiler) writeDestructuringValue(expr ast.Expr) error {
+	// Check if this is a map index expression that should return a tuple
+	if indexExpr, ok := expr.(*ast.IndexExpr); ok {
+		if tv, ok := c.pkg.TypesInfo.Types[indexExpr.X]; ok {
+			underlyingType := tv.Type.Underlying()
+			// Check if it's a map type
+			if mapType, isMap := underlyingType.(*types.Map); isMap {
+				c.tsw.WriteLiterally("$.mapGet(")
+				if err := c.WriteValueExpr(indexExpr.X); err != nil {
+					return err
+				}
+				c.tsw.WriteLiterally(", ")
+				if err := c.WriteValueExpr(indexExpr.Index); err != nil {
+					return err
+				}
+				c.tsw.WriteLiterally(", ")
+				// Write the zero value as the default value for mapGet
+				c.WriteZeroValueForType(mapType.Elem())
+				c.tsw.WriteLiterally(")") // Don't add [0] for destructuring
+				return nil
+			}
+			// Check if it's a type parameter constrained to be a map type
+			if typeParam, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
+				constraint := typeParam.Constraint()
+				if constraint != nil {
+					underlying := constraint.Underlying()
+					if iface, isInterface := underlying.(*types.Interface); isInterface {
+						if hasMapConstraint(iface) {
+							c.tsw.WriteLiterally("$.mapGet(")
+							if err := c.WriteValueExpr(indexExpr.X); err != nil {
+								return err
+							}
+							c.tsw.WriteLiterally(", ")
+							if err := c.WriteValueExpr(indexExpr.Index); err != nil {
+								return err
+							}
+							c.tsw.WriteLiterally(", ")
+							// Generate the zero value as the default value for mapGet
+							mapValueType := getMapValueTypeFromConstraint(iface)
+							if mapValueType != nil {
+								c.WriteZeroValueForType(mapValueType)
+							} else {
+								c.tsw.WriteLiterally("null")
+							}
+							c.tsw.WriteLiterally(")") // Don't add [0] for destructuring
+							return nil
+						}
+					}
+				}
+			}
+		}
+	}
+	// For non-map expressions, use the regular WriteValueExpr
+	return c.WriteValueExpr(expr)
+}
+
 // WriteStmtForPost translates the post-iteration part of a Go `for` loop header
 // (e.g., `i++` or `i, j = i+1, j-1` in `for ...; i++`) into its TypeScript
 // equivalent.