goscript 0.0.42 → 0.0.43

package/compiler/analysis.go

@@ -125,6 +125,14 @@ type PackageAnalysis struct {
 	// FunctionCalls maps file names to the functions they call from other files
 	// Key: filename (without .go extension), Value: map[sourceFile][]functionNames
 	FunctionCalls map[string]map[string][]string
+
+	// TypeDefs maps file names to the types defined in that file
+	// Key: filename (without .go extension), Value: list of type names
+	TypeDefs map[string][]string
+
+	// TypeCalls maps file names to the types they reference from other files
+	// Key: filename (without .go extension), Value: map[sourceFile][]typeNames
+	TypeCalls map[string]map[string][]string
 }
 
 // NewAnalysis creates a new Analysis instance.
@@ -146,6 +154,8 @@ func NewPackageAnalysis() *PackageAnalysis {
 	return &PackageAnalysis{
 		FunctionDefs:  make(map[string][]string),
 		FunctionCalls: make(map[string]map[string][]string),
+		TypeDefs:      make(map[string][]string),
+		TypeCalls:     make(map[string]map[string][]string),
 	}
 }
 
@@ -1036,6 +1046,7 @@ func AnalyzePackage(pkg *packages.Package) *PackageAnalysis {
 		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
 
 		var functions []string
+		var types []string
 		for _, decl := range syntax.Decls {
 			if funcDecl, ok := decl.(*ast.FuncDecl); ok {
 				// Only collect top-level functions (not methods)
@@ -1043,11 +1054,22 @@ func AnalyzePackage(pkg *packages.Package) *PackageAnalysis {
 					functions = append(functions, funcDecl.Name.Name)
 				}
 			}
+			if genDecl, ok := decl.(*ast.GenDecl); ok {
+				// Collect type declarations
+				for _, spec := range genDecl.Specs {
+					if typeSpec, ok := spec.(*ast.TypeSpec); ok {
+						types = append(types, typeSpec.Name.Name)
+					}
+				}
+			}
 		}
 
 		if len(functions) > 0 {
 			analysis.FunctionDefs[baseFileName] = functions
 		}
+		if len(types) > 0 {
+			analysis.TypeDefs[baseFileName] = types
+		}
 	}
 
 	// Second pass: analyze function calls and determine which need imports
@@ -1111,6 +1133,71 @@ func AnalyzePackage(pkg *packages.Package) *PackageAnalysis {
 		}
 	}
 
+	// Third pass: analyze type references and determine which need imports
+	for i, syntax := range pkg.Syntax {
+		fileName := pkg.CompiledGoFiles[i]
+		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
+
+		// Find all type references in this file
+		typeRefsFromOtherFiles := make(map[string][]string)
+
+		ast.Inspect(syntax, func(n ast.Node) bool {
+			// Look for type references in struct fields, function parameters, etc.
+			if ident, ok := n.(*ast.Ident); ok {
+				// Check if this identifier refers to a type
+				if obj := pkg.TypesInfo.Uses[ident]; obj != nil {
+					if _, ok := obj.(*types.TypeName); ok {
+						typeName := ident.Name
+
+						// Check if this type is defined in the current file
+						currentFileTypes := analysis.TypeDefs[baseFileName]
+						isDefinedInCurrentFile := false
+						for _, t := range currentFileTypes {
+							if t == typeName {
+								isDefinedInCurrentFile = true
+								break
+							}
+						}
+
+						// If not defined in current file, find which file defines it
+						if !isDefinedInCurrentFile {
+							for sourceFile, types := range analysis.TypeDefs {
+								if sourceFile == baseFileName {
+									continue // Skip current file
+								}
+								for _, t := range types {
+									if t == typeName {
+										// Found the type in another file
+										if typeRefsFromOtherFiles[sourceFile] == nil {
+											typeRefsFromOtherFiles[sourceFile] = []string{}
+										}
+										// Check if already added to avoid duplicates
+										found := false
+										for _, existing := range typeRefsFromOtherFiles[sourceFile] {
+											if existing == typeName {
+												found = true
+												break
+											}
+										}
+										if !found {
+											typeRefsFromOtherFiles[sourceFile] = append(typeRefsFromOtherFiles[sourceFile], typeName)
+										}
+										break
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			return true
+		})
+
+		if len(typeRefsFromOtherFiles) > 0 {
+			analysis.TypeCalls[baseFileName] = typeRefsFromOtherFiles
+		}
+	}
+
 	return analysis
 }
 

package/compiler/assignment.go

@@ -124,6 +124,12 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 			}
 		}
 
+		// Add semicolon before destructuring assignment to prevent TypeScript
+		// from interpreting it as array access on the previous line
+		if tok != token.DEFINE {
+			c.tsw.WriteLiterally(";")
+		}
+
 		// Use array destructuring for multi-variable assignments
 		c.tsw.WriteLiterally("[")
 		for i, l := range lhs {

package/compiler/compiler.go

@@ -621,6 +621,61 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 		}
 	}
 
+	// Generate auto-imports for types from other files in the same package
+	if typeImports := c.PackageAnalysis.TypeCalls[currentFileName]; typeImports != nil {
+		// Sort source files for consistent import order
+		var sourceFiles []string
+		for sourceFile := range typeImports {
+			sourceFiles = append(sourceFiles, sourceFile)
+		}
+		sort.Strings(sourceFiles)
+
+		for _, sourceFile := range sourceFiles {
+			typeImports := typeImports[sourceFile]
+			if len(typeImports) > 0 {
+				// Filter out protobuf types - they should be imported from .pb.js files, not .gs.js files
+				var nonProtobufTypes []string
+				for _, typeName := range typeImports {
+					// Check if this type is a protobuf type by looking for it in the package
+					isProtobuf := false
+					if typeObj := c.pkg.Types.Scope().Lookup(typeName); typeObj != nil {
+						objType := typeObj.Type()
+						if namedType, ok := objType.(*types.Named); ok {
+							obj := namedType.Obj()
+							if obj != nil && obj.Pkg() != nil {
+								// Check if the type is defined in the current package and has a corresponding .pb.go file
+								if obj.Pkg() == c.pkg.Types {
+									// Check if there's a .pb.go file in the package that exports this type
+									// For now, we'll use a simple heuristic: if the type name ends with "Msg"
+									// and there's a .pb.go file in the package, assume it's a protobuf type
+									if strings.HasSuffix(typeName, "Msg") {
+										// Check if there are any .pb.go files in this package
+										for _, fileName := range c.pkg.CompiledGoFiles {
+											if strings.HasSuffix(fileName, ".pb.go") {
+												isProtobuf = true
+												break
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+					if !isProtobuf {
+						nonProtobufTypes = append(nonProtobufTypes, typeName)
+					}
+				}
+
+				if len(nonProtobufTypes) > 0 {
+					// Sort types for consistent output
+					sort.Strings(nonProtobufTypes)
+					c.codeWriter.WriteLinef("import { %s } from \"./%s.gs.js\";",
+						strings.Join(nonProtobufTypes, ", "), sourceFile)
+				}
+			}
+		}
+	}
+
 	c.codeWriter.WriteLine("") // Add a newline after imports
 
 	if err := goWriter.WriteDecls(f.Decls); err != nil {
@@ -690,11 +745,30 @@ func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessVarRefedValue bool) {
 	// Check if this identifier refers to a constant
 	if obj != nil {
 		if constObj, isConst := obj.(*types.Const); isConst {
-			// Only evaluate constants from the current package being compiled
-			// Don't evaluate constants from imported packages (they should use their exported names)
-			// Special case: predeclared constants like iota have a nil package, so we should evaluate them
-			if constObj.Pkg() == c.pkg.Types || constObj.Pkg() == nil {
-				// Write the constant's evaluated value instead of the identifier name
+			// Evaluate constants to literals in these cases:
+			// 1. Predeclared constants (like iota, true, false) - these have nil package
+			// 2. Constants from the current package that are computed expressions
+			//    (like iota-based constants or mathematical expressions)
+			//
+			// For simple assignments from imported constants (const x = pkg.Y),
+			// preserve the variable name for better readability.
+
+			if constObj.Pkg() == nil {
+				// Predeclared constants - always evaluate to literals
+				c.writeConstantValue(constObj)
+				return
+			}
+
+			if constObj.Pkg() == c.pkg.Types {
+				// This is a constant from the current package.
+				// Check if it's a simple assignment by looking at the constant value:
+				// If the constant has the same name as an identifier in the import,
+				// it's likely a simple assignment and we should preserve the name.
+				// Otherwise, evaluate to literal (for computed expressions like iota).
+
+				// For now, let's be conservative and evaluate current package constants
+				// to literals to maintain compatibility with existing behavior.
+				// This handles iota-based constants correctly.
 				c.writeConstantValue(constObj)
 				return
 			}
@@ -980,6 +1054,12 @@ func (c *Compiler) copyEmbeddedPackage(embeddedPath string, outputPath string) e
 				continue
 			}
 
+			// Skip .test.ts files
+			if strings.HasSuffix(fileName, ".test.ts") {
+				// c.le.Debugf("Skipping test file: %s", fileName)
+				continue
+			}
+
 			// Remove existing file if it exists (but preserve directories)
 			if stat, err := os.Stat(outputEntryPath); err == nil && !stat.IsDir() {
 				if err := os.Remove(outputEntryPath); err != nil {

package/compiler/decl.go

@@ -101,29 +101,13 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 	c.WriteFuncType(decl.Type, isAsync) // Write signature (params, return type)
 	c.tsw.WriteLiterally(" ")
 
-	hasNamedReturns := false
-	if decl.Type.Results != nil {
-		for _, field := range decl.Type.Results.List {
-			if len(field.Names) > 0 {
-				hasNamedReturns = true
-				break
-			}
-		}
-	}
-
-	if hasNamedReturns {
+	if c.hasNamedReturns(decl.Type.Results) {
 		c.tsw.WriteLine("{")
 		c.tsw.Indent(1)
 
 		// Declare named return variables and initialize them to their zero values
-		for _, field := range decl.Type.Results.List {
-			for _, name := range field.Names {
-				c.tsw.WriteLiterallyf("let %s: ", c.sanitizeIdentifier(name.Name))
-				c.WriteTypeExpr(field.Type)
-				c.tsw.WriteLiterally(" = ")
-				c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
-				c.tsw.WriteLine("")
-			}
+		if err := c.writeNamedReturnDeclarations(decl.Type.Results); err != nil {
+			return fmt.Errorf("failed to write named return declarations: %w", err)
 		}
 	}
 
@@ -131,7 +115,7 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 		return fmt.Errorf("failed to write function body: %w", err)
 	}
 
-	if hasNamedReturns {
+	if c.hasNamedReturns(decl.Type.Results) {
 		c.tsw.Indent(-1)
 		c.tsw.WriteLine("}")
 	}
@@ -244,6 +228,11 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 				}
 			}
 
+			// Declare named return variables and initialize them to their zero values
+			if err := c.writeNamedReturnDeclarations(decl.Type.Results); err != nil {
+				return fmt.Errorf("failed to write named return declarations: %w", err)
+			}
+
 			// write method body without outer braces
 			for _, stmt := range decl.Body.List {
 				if err := c.WriteStmt(stmt); err != nil {
@@ -263,3 +252,36 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 
 	return nil
 }
+
+// writeNamedReturnDeclarations generates TypeScript variable declarations for named return parameters.
+// It declares each named return variable with its appropriate type and zero value.
+func (c *GoToTSCompiler) writeNamedReturnDeclarations(results *ast.FieldList) error {
+	if results == nil {
+		return nil
+	}
+
+	for _, field := range results.List {
+		for _, name := range field.Names {
+			c.tsw.WriteLiterallyf("let %s: ", c.sanitizeIdentifier(name.Name))
+			c.WriteTypeExpr(field.Type)
+			c.tsw.WriteLiterally(" = ")
+			c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
+			c.tsw.WriteLine("")
+		}
+	}
+	return nil
+}
+
+// hasNamedReturns checks if a function type has any named return parameters.
+func (c *GoToTSCompiler) hasNamedReturns(results *ast.FieldList) bool {
+	if results == nil {
+		return false
+	}
+
+	for _, field := range results.List {
+		if len(field.Names) > 0 {
+			return true
+		}
+	}
+	return false
+}

package/compiler/expr-call.go

@@ -97,6 +97,37 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 				}
 			}
 		}
+
+		// Handle general slice type conversions like []T(namedType) where namedType has underlying type []T
+		if arrayType.Len == nil && len(exp.Args) == 1 {
+			arg := exp.Args[0]
+			if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
+				// Check if the argument is a named type with a slice underlying type
+				if namedArgType, isNamed := argType.(*types.Named); isNamed {
+					// Check if the named type has receiver methods (is a wrapper class)
+					typeName := namedArgType.Obj().Name()
+					if c.hasReceiverMethods(typeName) {
+						// Check if the underlying type matches the target slice type
+						if sliceUnderlying, isSlice := namedArgType.Underlying().(*types.Slice); isSlice {
+							// Get the target slice type
+							targetType := c.pkg.TypesInfo.TypeOf(arrayType)
+							if targetSliceType, isTargetSlice := targetType.Underlying().(*types.Slice); isTargetSlice {
+								// Check if element types are compatible
+								if types.Identical(sliceUnderlying.Elem(), targetSliceType.Elem()) {
+									// This is a conversion from NamedType to []T where NamedType has underlying []T
+									// Use valueOf() to get the underlying slice
+									if err := c.WriteValueExpr(arg); err != nil {
+										return fmt.Errorf("failed to write argument for slice type conversion: %w", err)
+									}
+									c.tsw.WriteLiterally(".valueOf()")
+									return nil // Handled named type to slice conversion
+								}
+							}
+						}
+					}
+				}
+			}
+		}
 	}
 
 	if funIdent, funIsIdent := expFun.(*ast.Ident); funIsIdent {
@@ -274,7 +305,12 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					}
 
 					c.tsw.WriteLiterally("$.makeSlice<")
-					c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
+					// Use AST-based type writing to preserve qualified names
+					if arrType, ok := exp.Args[0].(*ast.ArrayType); ok {
+						c.WriteTypeExpr(arrType.Elt)
+					} else {
+						c.WriteGoType(goElemType, GoTypeContextGeneral)
+					}
 					c.tsw.WriteLiterally(">(")
 
 					hasCapacity := len(exp.Args) == 3

package/compiler/expr-type.go

@@ -45,6 +45,26 @@ func (c *GoToTSCompiler) WriteTypeExpr(a ast.Expr) {
 		}
 	}
 
+	// Handle array/slice types to preserve qualified names in element types
+	if arrayType, ok := a.(*ast.ArrayType); ok {
+		if arrayType.Len == nil {
+			// Slice type: []T -> $.Slice<T>
+			// Check if it's a []byte slice first
+			if ident, ok := arrayType.Elt.(*ast.Ident); ok && ident.Name == "byte" {
+				c.tsw.WriteLiterally("$.Bytes")
+				return
+			}
+			c.tsw.WriteLiterally("$.Slice<")
+			c.WriteTypeExpr(arrayType.Elt) // Recursively handle element type preserving qualified names
+			c.tsw.WriteLiterally(">")
+		} else {
+			// Array type: [N]T -> T[]
+			c.WriteTypeExpr(arrayType.Elt) // Recursively handle element type preserving qualified names
+			c.tsw.WriteLiterally("[]")
+		}
+		return
+	}
+
 	// Get type information for the expression and use WriteGoType
 	typ := c.pkg.TypesInfo.TypeOf(a)
 	c.WriteGoType(typ, GoTypeContextGeneral)

package/compiler/lit.go

@@ -164,29 +164,13 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 
 	c.tsw.WriteLiterally(" => ")
 
-	hasNamedReturns := false
-	if exp.Type.Results != nil {
-		for _, field := range exp.Type.Results.List {
-			if len(field.Names) > 0 {
-				hasNamedReturns = true
-				break
-			}
-		}
-	}
-
-	if hasNamedReturns {
+	if c.hasNamedReturns(exp.Type.Results) {
 		c.tsw.WriteLine("{")
 		c.tsw.Indent(1)
 
 		// Declare named return variables and initialize them to their zero values
-		for _, field := range exp.Type.Results.List {
-			for _, name := range field.Names {
-				c.tsw.WriteLiterallyf("let %s: ", c.sanitizeIdentifier(name.Name))
-				c.WriteTypeExpr(field.Type)
-				c.tsw.WriteLiterally(" = ")
-				c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
-				c.tsw.WriteLine("")
-			}
+		if err := c.writeNamedReturnDeclarations(exp.Type.Results); err != nil {
+			return fmt.Errorf("failed to write named return declarations: %w", err)
 		}
 	}
 
@@ -195,7 +179,7 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 		return fmt.Errorf("failed to write block statement: %w", err)
 	}
 
-	if hasNamedReturns {
+	if c.hasNamedReturns(exp.Type.Results) {
 		c.tsw.Indent(-1)
 		c.tsw.WriteLiterally("}")
 	}

package/compiler/spec-struct.go

@@ -20,10 +20,9 @@ import (
 //   - Wrapper methods for promoted fields and methods from embedded structs,
 //     ensuring correct access and behavior.
 func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType) error {
-	// Add export for Go-exported structs
-	if a.Name.IsExported() {
-		c.tsw.WriteLiterally("export ")
-	}
+	// Always export types for cross-file imports within the same package
+	// This allows unexported Go types to be imported by other files in the same package
+	c.tsw.WriteLiterally("export ")
 	c.tsw.WriteLiterally("class ")
 	if err := c.WriteValueExpr(a.Name); err != nil {
 		return err

package/compiler/spec-value.go

@@ -153,7 +153,14 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 					}
 				} else {
 					// Not a pointer type, write as is.
-					c.WriteGoType(goType, GoTypeContextGeneral)
+					// Use AST-based type writing if explicit type is provided, otherwise use WriteGoType
+					if a.Type != nil {
+						// Explicit type annotation in Go code - use AST to preserve qualified names
+						c.WriteTypeExpr(a.Type)
+					} else {
+						// No explicit type - use type inference from WriteGoType
+						c.WriteGoType(goType, GoTypeContextGeneral)
+					}
 				}
 			}
 		}
@@ -249,6 +256,16 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 										}
 									}
 								}
+							case *ast.CallExpr:
+								// Check if this is a make() call that returns the underlying type
+								if funIdent, ok := expr.Fun.(*ast.Ident); ok && funIdent.Name == "make" {
+									// Check if the make call returns a type that matches the underlying type
+									if exprType := c.pkg.TypesInfo.TypeOf(expr); exprType != nil {
+										if types.Identical(exprType, namedType.Underlying()) {
+											needsConstructor = true
+										}
+									}
+								}
 							}
 
 							if needsConstructor {

package/compiler/spec.go

@@ -188,7 +188,6 @@ func (c *GoToTSCompiler) hasReceiverMethods(typeName string) bool {
 // 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
@@ -196,7 +195,7 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 		isInsideFunction = nodeInfo.IsInsideFunction
 	}
 
-	if a.Name.IsExported() && !isInsideFunction {
+	if !isInsideFunction {
 		c.tsw.WriteLiterally("export ")
 	}
 
@@ -206,13 +205,15 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 
 	// Constructor that takes the underlying type value
 	c.tsw.WriteLiterally("constructor(private _value: ")
-	c.WriteGoType(underlyingType, GoTypeContextGeneral)
+	// Use AST-based type writing to preserve qualified names like os.FileInfo
+	c.WriteTypeExpr(a.Type)
 	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)
+	// Use AST-based type writing to preserve qualified names like os.FileInfo
+	c.WriteTypeExpr(a.Type)
 	c.tsw.WriteLine(" {")
 	c.tsw.Indent(1)
 	c.tsw.WriteLine("return this._value")
@@ -230,7 +231,8 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 
 	// Static from method for type conversion
 	c.tsw.WriteLiterallyf("static from(value: ")
-	c.WriteGoType(underlyingType, GoTypeContextGeneral)
+	// Use AST-based type writing to preserve qualified names like os.FileInfo
+	c.WriteTypeExpr(a.Type)
 	c.tsw.WriteLiterallyf("): %s {", className)
 	c.tsw.WriteLine("")
 	c.tsw.Indent(1)
@@ -364,6 +366,11 @@ func (c *GoToTSCompiler) writeNamedTypeMethod(decl *ast.FuncDecl) error {
 				}
 			}
 
+			// Declare named return variables and initialize them to their zero values
+			if err := c.writeNamedReturnDeclarations(decl.Type.Results); err != nil {
+				return fmt.Errorf("failed to write named return declarations: %w", err)
+			}
+
 			// write method body without outer braces
 			for _, stmt := range decl.Body.List {
 				if err := c.WriteStmt(stmt); err != nil {
@@ -404,13 +411,13 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 			return c.WriteNamedTypeWithMethods(a)
 		}
 
-		// type alias - add export for Go-exported types (but not if inside a function)
+		// Always export types for cross-file imports within the same package (but not if inside a function)
 		isInsideFunction := false
 		if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
 			isInsideFunction = nodeInfo.IsInsideFunction
 		}
 
-		if a.Name.IsExported() && !isInsideFunction {
+		if !isInsideFunction {
 			c.tsw.WriteLiterally("export ")
 		}
 		c.tsw.WriteLiterally("type ")
@@ -438,7 +445,7 @@ func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.Interfac
 		isInsideFunction = nodeInfo.IsInsideFunction
 	}
 
-	if a.Name.IsExported() && !isInsideFunction {
+	if !isInsideFunction {
 		c.tsw.WriteLiterally("export ")
 	}
 	c.tsw.WriteLiterally("type ")

package/compiler/stmt-range.go

@@ -157,7 +157,7 @@ func (c *GoToTSCompiler) writeMapRange(exp *ast.RangeStmt) error {
 	if err := c.WriteValueExpr(exp.X); err != nil {
 		return fmt.Errorf("failed to write range loop map expression: %w", err)
 	}
-	c.tsw.WriteLiterally(".entries()) {")
+	c.tsw.WriteLiterally("?.entries() ?? []) {")
 	c.tsw.Indent(1)
 	c.tsw.WriteLine("")
 

package/compiler/type-assert.go

@@ -96,8 +96,8 @@ func (c *GoToTSCompiler) writeTypeAssert(lhs []ast.Expr, typeAssertExpr *ast.Typ
 		// For selector expressions as ok, we need to use temporary variables approach
 		if okIsSelectorExpr {
 			// Use temporary variables approach similar to SelectorExpr case
-			tempValName := "_gs_ta_val_" // Fixed name for temporary value
-			tempOkName := "_gs_ta_ok_"   // Fixed name for temporary ok status
+			tempValName := fmt.Sprintf("_gs_ta_val_%d_", typeAssertExpr.Pos()) // Unique name based on AST position
+			tempOkName := fmt.Sprintf("_gs_ta_ok_%d_", typeAssertExpr.Pos())   // Unique name based on AST position
 
 			// Declare temporary variables:
 			// let _gs_ta_val_: AssertedTypeTS;
@@ -217,8 +217,8 @@ func (c *GoToTSCompiler) writeTypeAssert(lhs []ast.Expr, typeAssertExpr *ast.Typ
 
 	case *ast.SelectorExpr:
 		// Handle s.field, ok := expr.(Type)
-		tempValName := "_gs_ta_val_" // Fixed name for temporary value
-		tempOkName := "_gs_ta_ok_"   // Fixed name for temporary ok status
+		tempValName := fmt.Sprintf("_gs_ta_val_%d_", typeAssertExpr.Pos()) // Unique name based on AST position
+		tempOkName := fmt.Sprintf("_gs_ta_ok_%d_", typeAssertExpr.Pos())   // Unique name based on AST position
 
 		// Declare temporary variables:
 		// let _gs_ta_val_: AssertedTypeTS;