goscript 0.0.33 → 0.0.34

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.