goscript 0.0.33 → 0.0.34

package/compiler/analysis.go

@@ -864,8 +864,8 @@ func AnalyzeFile(file *ast.File, pkg *packages.Package, analysis *Analysis, cmap
 				importVars: make(map[string]struct{}),
 			}
 
-			// Use the import name or path as the key
-			key := path
+			// Use the import name or package name as the key
+			key := packageNameFromGoPath(path)
 			if name != "" {
 				key = name
 			}

package/compiler/assignment.go

@@ -197,6 +197,7 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		currentIsMapIndex := false
 		if indexExpr, ok := l.(*ast.IndexExpr); ok {
 			if tv, ok := c.pkg.TypesInfo.Types[indexExpr.X]; ok {
+				// Check if it's a concrete map type
 				if _, isMap := tv.Type.Underlying().(*types.Map); isMap {
 					currentIsMapIndex = true
 					if i == 0 {
@@ -213,6 +214,31 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 					}
 					c.tsw.WriteLiterally(", ")
 					// Value will be added after operator and RHS
+				} else if typeParam, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
+					// Check if the type parameter is 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) {
+								currentIsMapIndex = true
+								if i == 0 {
+									isMapIndexLHS = true
+								}
+								// Use mapSet helper for type parameter constrained to map
+								c.tsw.WriteLiterally("$.mapSet(")
+								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(", ")
+								// Value will be added after operator and RHS
+							}
+						}
+					}
 				}
 			}
 		}

package/compiler/builtin_test.go

@@ -1,3 +1,5 @@
+//go:build test_emit_builtin
+
 package compiler
 
 import (

package/compiler/compiler.go

@@ -892,14 +892,24 @@ func (c *GoToTSCompiler) WriteDoc(doc *ast.CommentGroup) {
 }
 
 // sanitizeIdentifier checks if an identifier is a JavaScript/TypeScript reserved word
-// and prefixes it with an underscore if it is. This prevents compilation errors
-// when Go identifiers conflict with JS/TS keywords.
+// or conflicts with built-in types, and transforms it if needed. This prevents
+// compilation errors when Go identifiers conflict with JS/TS keywords or built-ins.
 func (c *GoToTSCompiler) sanitizeIdentifier(name string) string {
 	// Don't sanitize boolean literals - they are valid in both Go and JS/TS
 	if name == "true" || name == "false" {
 		return name
 	}
 
+	// Handle TypeScript built-in types that conflict with Go type parameter names
+	builtinTypes := map[string]string{
+		"Map": "MapType",
+		// Add other built-in types as needed
+	}
+
+	if replacement, exists := builtinTypes[name]; exists {
+		return replacement
+	}
+
 	// List of JavaScript/TypeScript reserved words that could conflict
 	reservedWords := map[string]bool{
 		"abstract":    true,

package/compiler/compiler_test.go

@@ -1,7 +1,6 @@
 package compiler_test
 
 import (
-	"context"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -12,9 +11,7 @@ import (
 	"sync/atomic"
 	"testing"
 
-	"github.com/aperturerobotics/goscript/compiler"
 	"github.com/aperturerobotics/goscript/compliance"
-	"github.com/sirupsen/logrus"
 )
 
 // NOTE: this is here instead of compliance/compliance_test.go so coverage ends up in this package.
@@ -140,53 +137,3 @@ func getParentGoModulePath() (string, error) {
 	}
 	return strings.TrimSpace(string(output)), nil
 }
-
-func TestUnsafePackageCompilation(t *testing.T) {
-	// Create a temporary directory for the test output
-	tempDir, err := os.MkdirTemp("", "goscript-test-unsafe")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	// Setup logger
-	log := logrus.New()
-	log.SetLevel(logrus.DebugLevel)
-	le := logrus.NewEntry(log)
-
-	// Test with AllDependencies=true and DisableEmitBuiltin=false to ensure handwritten packages are copied
-	config := &compiler.Config{
-		OutputPath:         tempDir,
-		AllDependencies:    true,
-		DisableEmitBuiltin: false, // This ensures handwritten packages are copied to output
-	}
-
-	comp, err := compiler.NewCompiler(config, le, nil)
-	if err != nil {
-		t.Fatalf("Failed to create compiler: %v", err)
-	}
-
-	// Try to compile a package that has dependencies that import unsafe
-	// We'll use "sync/atomic" which imports unsafe but doesn't have a handwritten equivalent
-	result, err := comp.CompilePackages(context.Background(), "sync/atomic")
-	// This should now succeed since we have a handwritten unsafe package
-	if err != nil {
-		t.Fatalf("Expected compilation to succeed with handwritten unsafe package, but it failed: %v", err)
-	}
-
-	// Verify that the unsafe package was copied (not compiled) since it has a handwritten equivalent
-	if !slices.Contains(result.CopiedPackages, "unsafe") {
-		t.Errorf("Expected unsafe package to be in CopiedPackages, but it wasn't. CopiedPackages: %v", result.CopiedPackages)
-	}
-
-	// Verify that sync/atomic was compiled
-	if !slices.Contains(result.CompiledPackages, "sync/atomic") {
-		t.Errorf("Expected sync/atomic package to be in CompiledPackages, but it wasn't. CompiledPackages: %v", result.CompiledPackages)
-	}
-
-	// Check that the unsafe package directory exists in the output
-	unsafePath := filepath.Join(tempDir, "@goscript/unsafe")
-	if _, err := os.Stat(unsafePath); os.IsNotExist(err) {
-		t.Errorf("unsafe package directory was not created at %s", unsafePath)
-	}
-}

package/compiler/expr-call.go

@@ -545,6 +545,114 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					}
 				}
 			}
+			// Handle selector expressions: make(pkg.TypeName, ...)
+			// This handles cases like: make(fstest.MapFS) where fstest.MapFS is map[string]*MapFile
+			if selectorExpr, ok := exp.Args[0].(*ast.SelectorExpr); ok {
+				// Get the type information for the selector expression
+				if typ := c.pkg.TypesInfo.TypeOf(selectorExpr); typ != nil {
+					// Check the underlying type of the selector expression
+					underlying := typ.Underlying()
+
+					// Handle selector expression map types: make(pkg.MapType)
+					if mapType, isMap := underlying.(*types.Map); isMap {
+						c.tsw.WriteLiterally("$.makeMap<")
+						c.WriteGoType(mapType.Key(), GoTypeContextGeneral) // Write the key type
+						c.tsw.WriteLiterally(", ")
+						c.WriteGoType(mapType.Elem(), GoTypeContextGeneral) // Write the value type
+						c.tsw.WriteLiterally(">()")
+						return nil // Handled make for selector expression map type
+					}
+
+					// Handle selector expression slice types: make(pkg.SliceType, len, cap)
+					if sliceType, isSlice := underlying.(*types.Slice); isSlice {
+						goElemType := sliceType.Elem()
+
+						// Check if it's a selector expression 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 selector expression []byte type
+						}
+
+						// Handle other selector expression 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 selector expression slice type
+					}
+
+					// Handle selector expression channel types: make(pkg.ChannelType, bufferSize)
+					if chanType, isChan := underlying.(*types.Chan); isChan {
+						c.tsw.WriteLiterally("$.makeChannel<")
+						c.WriteGoType(chanType.Elem(), GoTypeContextGeneral)
+						c.tsw.WriteLiterally(">(")
+
+						// If buffer size is provided, add it
+						if len(exp.Args) >= 2 {
+							if err := c.WriteValueExpr(exp.Args[1]); err != nil {
+								return fmt.Errorf("failed to write buffer size in makeChannel: %w", err)
+							}
+						} else {
+							// Default to 0 (unbuffered channel)
+							c.tsw.WriteLiterally("0")
+						}
+
+						c.tsw.WriteLiterally(", ") // Add comma for zero value argument
+
+						// Write the zero value for the channel's element type
+						if chanType.Elem().String() == "struct{}" {
+							c.tsw.WriteLiterally("{}")
+						} else {
+							c.WriteZeroValueForType(chanType.Elem())
+						}
+
+						// Add direction parameter
+						c.tsw.WriteLiterally(", ")
+
+						// Determine channel direction
+						switch chanType.Dir() {
+						case types.SendRecv:
+							c.tsw.WriteLiterally("'both'")
+						case types.SendOnly:
+							c.tsw.WriteLiterally("'send'")
+						case types.RecvOnly:
+							c.tsw.WriteLiterally("'receive'")
+						default:
+							c.tsw.WriteLiterally("'both'") // Default to bidirectional
+						}
+
+						c.tsw.WriteLiterally(")")
+						return nil // Handled make for selector expression channel type
+					}
+				}
+			}
 			// Fallthrough for unhandled make calls (e.g., channels)
 			return errors.New("unhandled make call")
 		case "string":
@@ -879,12 +987,16 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			}
 			c.tsw.WriteLiterally(")")
 		} else {
-			// Not an identifier (e.g., method call on a value)
+			// Not an identifier (e.g., method call on a value, function call result)
 			if err := c.WriteValueExpr(expFun); err != nil {
 				return fmt.Errorf("failed to write method expression in call: %w", err)
 			}
 
-			if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
+			// Check if this is a function call that returns a function (e.g., simpleIterator(m)())
+			// Add non-null assertion since the returned function could be null
+			if _, isCallExpr := expFun.(*ast.CallExpr); isCallExpr {
+				c.tsw.WriteLiterally("!")
+			} else if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
 				if _, ok := funType.Underlying().(*types.Signature); ok {
 					// Check if this is a function parameter identifier that needs not-null assertion
 					if ident, isIdent := expFun.(*ast.Ident); isIdent {
@@ -899,6 +1011,13 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					} else if _, isNamed := funType.(*types.Named); isNamed {
 						c.tsw.WriteLiterally("!")
 					}
+				} else {
+					// Check if the function type is nullable (e.g., func(...) | null)
+					// This handles cases where a function call returns a nullable function
+					funTypeStr := funType.String()
+					if strings.Contains(funTypeStr, "| null") || strings.Contains(funTypeStr, "null |") {
+						c.tsw.WriteLiterally("!")
+					}
 				}
 			}
 		}

package/compiler/expr.go

@@ -52,7 +52,7 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 
 			// Generate the zero value as the default value for mapGet
 			c.WriteZeroValueForType(mapType.Elem())
-			c.tsw.WriteLiterally(")")
+			c.tsw.WriteLiterally(")[0]") // Extract the value from the tuple
 			return nil
 		}
 
@@ -77,6 +77,31 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 			if constraint != nil {
 				underlying := constraint.Underlying()
 				if iface, isInterface := underlying.(*types.Interface); isInterface {
+					// Check if this is a map constraint (like ~map[K]V)
+					if hasMapConstraint(iface) {
+						// This is a map type parameter, use map access
+						c.tsw.WriteLiterally("$.mapGet(")
+						if err := c.WriteValueExpr(exp.X); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally(", ")
+						if err := c.WriteValueExpr(exp.Index); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally(", ")
+
+						// Generate the zero value as the default value for mapGet
+						// For type parameters, we need to get the value type from the constraint
+						mapValueType := getMapValueTypeFromConstraint(iface)
+						if mapValueType != nil {
+							c.WriteZeroValueForType(mapValueType)
+						} else {
+							c.tsw.WriteLiterally("null")
+						}
+						c.tsw.WriteLiterally(")[0]") // Extract the value from the tuple
+						return nil
+					}
+
 					// Check if this is a mixed string/byte constraint (like string | []byte)
 					if hasMixedStringByteConstraint(iface) {
 						// For mixed constraints, use specialized function that returns number (byte value)
@@ -694,3 +719,43 @@ func (c *GoToTSCompiler) WriteKeyValueExpr(exp *ast.KeyValueExpr) error {
 	}
 	return nil
 }
+
+// hasMapConstraint checks if an interface constraint includes map types
+// For constraints like ~map[K]V, this returns true
+func hasMapConstraint(iface *types.Interface) bool {
+	// Check if the interface has type terms that include map 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 _, isMap := term.Type().Underlying().(*types.Map); isMap {
+					return true
+				}
+			}
+		} else if _, isMap := embedded.Underlying().(*types.Map); isMap {
+			return true
+		}
+	}
+	return false
+}
+
+// getMapValueTypeFromConstraint extracts the value type from a map constraint
+// For constraints like ~map[K]V, this returns V
+func getMapValueTypeFromConstraint(iface *types.Interface) types.Type {
+	// Check if the interface has type terms that include map 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 mapType, isMap := term.Type().Underlying().(*types.Map); isMap {
+					return mapType.Elem()
+				}
+			}
+		} else if mapType, isMap := embedded.Underlying().(*types.Map); isMap {
+			return mapType.Elem()
+		}
+	}
+	return nil
+}

package/compiler/lit.go

@@ -118,7 +118,7 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 	}
 
 	// Write function body
-	if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+	if err := c.WriteStmtBlock(exp.Body, true); err != nil {
 		return fmt.Errorf("failed to write block statement: %w", err)
 	}
 

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