goscript 0.0.58 → 0.0.59

package/compiler/spec-value.go

@@ -5,8 +5,81 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
+
+	"golang.org/x/tools/go/packages"
 )
 
+// shouldApplyClone determines whether a `.clone()` method call should be appended
+// to the TypeScript translation of a Go expression `rhs` when it appears on the
+// right-hand side of an assignment. This is primarily to emulate Go's value
+// semantics for struct assignments, where assigning one struct variable to another
+// creates a copy of the struct.
+//
+// It uses `go/types` information (`pkg.TypesInfo`) to determine the type of `rhs`.
+//   - If `rhs` is identified as a struct type (either directly, as a named type
+//     whose underlying type is a struct, or an unnamed type whose underlying type
+//     is a struct), it returns `true`.
+//   - An optimization: if `rhs` is a composite literal (`*ast.CompositeLit`),
+//     it returns `false` because a composite literal already produces a new value,
+//     so cloning is unnecessary.
+//   - If type information is unavailable or `rhs` is not a struct type, it returns `false`.
+//
+// This function is crucial for ensuring that assignments of struct values in
+// TypeScript behave like copies, as they do in Go, rather than reference assignments.
+func shouldApplyClone(pkg *packages.Package, rhs ast.Expr) bool {
+	if pkg == nil || pkg.TypesInfo == nil {
+		// Cannot determine type without type info, default to no clone
+		return false
+	}
+
+	// Get the type of the RHS expression
+	var exprType types.Type
+
+	// Handle identifiers (variables) directly - the most common case
+	if ident, ok := rhs.(*ast.Ident); ok {
+		if obj := pkg.TypesInfo.Uses[ident]; obj != nil {
+			// Get the type directly from the object
+			exprType = obj.Type()
+		} else if obj := pkg.TypesInfo.Defs[ident]; obj != nil {
+			// Also check Defs map for definitions
+			exprType = obj.Type()
+		}
+	}
+
+	// If we couldn't get the type from Uses/Defs, try getting it from Types
+	if exprType == nil {
+		if tv, found := pkg.TypesInfo.Types[rhs]; found && tv.Type != nil {
+			exprType = tv.Type
+		}
+	}
+
+	// No type information available
+	if exprType == nil {
+		return false
+	}
+
+	// Optimization: If it's a composite literal for a struct, no need to clone
+	// as it's already a fresh value
+	if _, isCompositeLit := rhs.(*ast.CompositeLit); isCompositeLit {
+		return false
+	}
+
+	// Check if it's a struct type (directly, through named type, or underlying)
+	if named, ok := exprType.(*types.Named); ok {
+		if _, isStruct := named.Underlying().(*types.Struct); isStruct {
+			return true // Named struct type
+		}
+	} else if _, ok := exprType.(*types.Struct); ok {
+		return true // Direct struct type
+	} else if underlying := exprType.Underlying(); underlying != nil {
+		if _, isStruct := underlying.(*types.Struct); isStruct {
+			return true // Underlying is a struct
+		}
+	}
+
+	return false // Not a struct, do not apply clone
+}
+
 // WriteValueSpec translates a Go value specification (`ast.ValueSpec`),
 // which represents `var` or `const` declarations, into TypeScript `let`
 // declarations.
@@ -209,7 +282,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 					if unaryExprXIdent, ok := unaryExpr.X.(*ast.Ident); ok {
 						// Case: &variable
 						// Check if the variable is varrefed
-						innerObj := c.pkg.TypesInfo.Uses[unaryExprXIdent]
+						innerObj := c.objectOfIdent(unaryExprXIdent)
 						needsVarRefOperand := innerObj != nil && c.analysis.NeedsVarRef(innerObj)
 
 						// If variable is varrefed, assign the varRef itself (variable)
@@ -236,8 +309,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 					// Check if this is a named type with methods and the initializer is a basic value
 					if namedType, isNamed := goType.(*types.Named); isNamed {
 						// Check if this is a wrapper type first
-						isWrapperType := c.analysis.IsNamedBasicType(namedType)
-						if isWrapperType {
+						if c.isWrapperType(namedType) {
 							// For wrapper types, no constructor wrapping needed
 							if shouldApplyClone(c.pkg, initializerExpr) {
 								// When cloning for value assignment, mark the result as struct value
@@ -263,7 +335,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 									// Check if it's a simple identifier (not a function call or complex expression)
 									if expr.Name != "nil" {
 										// Check if this identifier refers to a value of the underlying type
-										if obj := c.pkg.TypesInfo.Uses[expr]; obj != nil {
+										if obj := c.objectOfIdent(expr); obj != nil {
 											if objType := obj.Type(); objType != nil {
 												// If the identifier's type matches the underlying type, wrap it
 												if types.Identical(objType, namedType.Underlying()) {
@@ -342,8 +414,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 				// No initializer, use the zero value directly
 				// Check if this is a wrapper type first
 				if namedType, isNamed := goType.(*types.Named); isNamed {
-					isWrapperType := c.analysis.IsNamedBasicType(namedType)
-					if isWrapperType {
+					if c.isWrapperType(namedType) {
 						// For wrapper types, just use zero value directly
 						c.WriteZeroValueForType(goType)
 					} else {
@@ -366,19 +437,21 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 		return nil
 	}
 
-	// --- Multi-variable declaration (existing logic seems okay, but less common for pointers) ---
-	c.tsw.WriteLiterally("let ")
-	c.tsw.WriteLiterally("[") // Use array destructuring for multi-assign
-	for i, name := range a.Names {
-		if i != 0 {
-			c.tsw.WriteLiterally(", ")
-		}
-		c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
-		// TODO: Add type annotations for multi-var declarations if possible/needed
-	}
-	c.tsw.WriteLiterally("]")
+	// --- Multi-variable declaration with proper individual declarations ---
+	// Instead of using array destructuring which creates undefined types,
+	// generate individual variable declarations with proper types and zero values
 	if len(a.Values) > 0 {
-		// TODO: handle other kinds of assignment += -= etc.
+		// Has initializers - use array destructuring for multiple assignments
+		c.tsw.WriteLiterally("let ")
+		c.tsw.WriteLiterally("[") // Use array destructuring for multi-assign
+		for i, name := range a.Names {
+			if i != 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
+		}
+		c.tsw.WriteLiterally("]")
+
 		c.tsw.WriteLiterally(" = ")
 		if len(a.Values) == 1 && len(a.Names) > 1 {
 			// Assign from a single multi-return value
@@ -398,13 +471,48 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 			}
 			c.tsw.WriteLiterally("]")
 		}
+		c.tsw.WriteLine("")
 	} else {
-		// No initializer, assign default values (complex for multi-assign)
-		// For simplicity, assign default array based on context (needs improvement)
-		c.tsw.WriteLiterally(" = []") // Placeholder
-		// TODO: Assign correct zero values based on types
+		// No initializers - generate individual variable declarations with zero values
+		for _, name := range a.Names {
+			// Skip underscore variables
+			if name.Name == "_" {
+				continue
+			}
+
+			obj := c.pkg.TypesInfo.Defs[name]
+			if obj == nil {
+				return fmt.Errorf("could not resolve type for variable %v", name.Name)
+			}
+
+			goType := obj.Type()
+
+			// Check if exported and not inside function
+			isInsideFunction := false
+			if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
+				isInsideFunction = nodeInfo.IsInsideFunction
+			}
+
+			if name.IsExported() && !isInsideFunction {
+				c.tsw.WriteLiterally("export ")
+			}
+
+			c.tsw.WriteLiterally("let ")
+			c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
+			c.tsw.WriteLiterally(": ")
+
+			// Write type annotation - use AST-based type if available, otherwise infer from goType
+			if a.Type != nil {
+				c.WriteTypeExpr(a.Type)
+			} else {
+				c.WriteGoType(goType, GoTypeContextGeneral)
+			}
+
+			c.tsw.WriteLiterally(" = ")
+			c.WriteZeroValueForType(goType)
+			c.tsw.WriteLine("")
+		}
 	}
-	c.tsw.WriteLine("") // Use WriteLine instead of WriteLine(";")
 	return nil
 }
 
@@ -413,7 +521,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 func (c *GoToTSCompiler) writeInitializerForInterface(initializerExpr ast.Expr, goType types.Type) error {
 	// Check if this is a pointer variable assigned to interface
 	if rhsIdent, isIdent := initializerExpr.(*ast.Ident); isIdent {
-		if rhsObj := c.pkg.TypesInfo.Uses[rhsIdent]; rhsObj != nil {
+		if rhsObj := c.objectOfIdent(rhsIdent); rhsObj != nil {
 			// Check if LHS is interface and RHS is pointer
 			if _, isInterface := goType.Underlying().(*types.Interface); isInterface {
 				if _, isPtr := rhsObj.Type().(*types.Pointer); isPtr {

package/compiler/spec.go

@@ -6,7 +6,6 @@ import (
 	"go/types"
 	"strings"
 
-	// types provides type information for Go types.
 	"github.com/pkg/errors"
 )
 
@@ -137,7 +136,7 @@ func (c *GoToTSCompiler) writeRegularFieldInitializer(fieldName string, fieldTyp
 	c.tsw.WriteLiterallyf("init?.%s ?? ", fieldName)
 
 	// Priority 1: Check if this is a wrapper type
-	if c.analysis.IsNamedBasicType(fieldType) {
+	if c.isWrapperType(fieldType) {
 		// For wrapper types, use the zero value of the underlying type with type casting
 		if named, ok := fieldType.(*types.Named); ok {
 			c.WriteZeroValueForType(named.Underlying())
@@ -156,7 +155,11 @@ func (c *GoToTSCompiler) writeRegularFieldInitializer(fieldName string, fieldTyp
 
 	// Priority 2: Handle imported types with basic underlying types (like os.FileMode)
 	if c.isImportedBasicType(fieldType) {
-		c.writeImportedBasicTypeZeroValue(fieldType)
+		if err := c.writeImportedBasicTypeZeroValue(fieldType); err != nil {
+			// Emit diagnostic and conservative zero value to avoid silent fallback
+			c.tsw.WriteCommentInlinef(" writeImportedBasicTypeZeroValue error: %v ", err)
+			c.WriteZeroValueForType(fieldType)
+		}
 		return
 	}
 
@@ -175,59 +178,14 @@ func (c *GoToTSCompiler) writeRegularFieldInitializer(fieldName string, fieldTyp
 	c.WriteZeroValueForType(fieldType)
 }
 
-func (c *GoToTSCompiler) isStructValueType(fieldType types.Type) bool {
-	if named, ok := fieldType.(*types.Named); ok {
-		if _, isStruct := named.Underlying().(*types.Struct); isStruct {
-			return true
-		}
-	}
-	return false
-}
-
-func (c *GoToTSCompiler) isImportedBasicType(fieldType types.Type) bool {
-	// Handle named types
-	if named, isNamed := fieldType.(*types.Named); isNamed {
-		obj := named.Obj()
-		if obj == nil || obj.Pkg() == nil || obj.Pkg() == c.pkg.Types {
-			return false // Not imported or is local
-		}
-
-		underlying := named.Underlying()
-		if underlying == nil {
-			return false
-		}
-
-		_, isBasic := underlying.(*types.Basic)
-		return isBasic
-	}
-
-	// Handle type aliases (like os.FileMode = fs.FileMode)
-	if alias, isAlias := fieldType.(*types.Alias); isAlias {
-		obj := alias.Obj()
-		if obj == nil || obj.Pkg() == nil || obj.Pkg() == c.pkg.Types {
-			return false // Not imported or is local
-		}
-
-		underlying := alias.Underlying()
-		if underlying == nil {
-			return false
-		}
-
-		_, isBasic := underlying.(*types.Basic)
-		return isBasic
-	}
-
-	return false
-}
-
-func (c *GoToTSCompiler) writeImportedBasicTypeZeroValue(fieldType types.Type) {
+func (c *GoToTSCompiler) writeImportedBasicTypeZeroValue(fieldType types.Type) error {
 	if named, ok := fieldType.(*types.Named); ok {
 		underlying := named.Underlying()
 		// Write zero value of underlying type with type casting
 		c.WriteZeroValueForType(underlying)
 		c.tsw.WriteLiterally(" as ")
 		c.WriteGoType(fieldType, GoTypeContextGeneral)
-		return
+		return nil
 	}
 
 	if alias, ok := fieldType.(*types.Alias); ok {
@@ -236,16 +194,17 @@ func (c *GoToTSCompiler) writeImportedBasicTypeZeroValue(fieldType types.Type) {
 		c.WriteZeroValueForType(underlying)
 		c.tsw.WriteLiterally(" as ")
 		c.WriteGoType(fieldType, GoTypeContextGeneral)
-		return
+		return nil
 	}
 
-	// Fallback (should not happen if isImportedBasicType was correct)
-	c.WriteZeroValueForType(fieldType)
+	// Reaching here indicates an internal inconsistency between isImportedBasicType and field kind
+	// Return an error to surface the issue to callers
+	return fmt.Errorf("writeImportedBasicTypeZeroValue: unexpected non-named/alias type %T", fieldType)
 }
 
 func (c *GoToTSCompiler) writeNamedTypeZeroValue(named *types.Named) {
 	// Check if this is a wrapper type first
-	if c.analysis.IsNamedBasicType(named) {
+	if c.isWrapperType(named) {
 		// For wrapper types, use the zero value of the underlying type with type casting
 		c.WriteZeroValueForType(named.Underlying())
 		c.tsw.WriteLiterally(" as ")
@@ -275,7 +234,7 @@ func (c *GoToTSCompiler) writeNamedTypeZeroValue(named *types.Named) {
 
 func (c *GoToTSCompiler) writeTypeAliasZeroValue(alias *types.Alias, astType ast.Expr) {
 	// Check if this is a wrapper type first
-	if c.analysis.IsNamedBasicType(alias) {
+	if c.isWrapperType(alias) {
 		// For wrapper types, use the zero value of the underlying type with type casting
 		c.WriteZeroValueForType(alias.Underlying())
 		c.tsw.WriteLiterally(" as ")