goscript 0.0.41 → 0.0.42

package/compiler/analysis.go

@@ -43,6 +43,14 @@ type VariableUsageInfo struct {
 	Destinations []AssignmentInfo
 }
 
+// ShadowingInfo tracks variable shadowing in if statement initializations
+type ShadowingInfo struct {
+	// ShadowedVariables maps shadowed variable names to their outer scope objects
+	ShadowedVariables map[string]types.Object
+	// TempVariables maps shadowed variable names to temporary variable names
+	TempVariables map[string]string
+}
+
 // FunctionTypeInfo represents Go function type information for reflection
 type FunctionTypeInfo struct {
 	Params   []types.Type // Parameter types
@@ -69,8 +77,9 @@ type NodeInfo struct {
 	IsBareReturn      bool
 	EnclosingFuncDecl *ast.FuncDecl
 	EnclosingFuncLit  *ast.FuncLit
-	IsInsideFunction  bool // true if this declaration is inside a function body
-	IsMethodValue     bool // true if this SelectorExpr is a method value that needs binding
+	IsInsideFunction  bool           // true if this declaration is inside a function body
+	IsMethodValue     bool           // true if this SelectorExpr is a method value that needs binding
+	ShadowingInfo     *ShadowingInfo // variable shadowing information for if statements
 }
 
 // Analysis holds information gathered during the analysis phase of the Go code compilation.
@@ -270,6 +279,30 @@ func (a *Analysis) IsMethodValue(node *ast.SelectorExpr) bool {
 	return nodeInfo.IsMethodValue
 }
 
+// HasVariableShadowing returns whether the given node has variable shadowing issues
+func (a *Analysis) HasVariableShadowing(node ast.Node) bool {
+	if node == nil {
+		return false
+	}
+	nodeInfo := a.NodeData[node]
+	if nodeInfo == nil {
+		return false
+	}
+	return nodeInfo.ShadowingInfo != nil
+}
+
+// GetShadowingInfo returns the variable shadowing information for the given node
+func (a *Analysis) GetShadowingInfo(node ast.Node) *ShadowingInfo {
+	if node == nil {
+		return nil
+	}
+	nodeInfo := a.NodeData[node]
+	if nodeInfo == nil {
+		return nil
+	}
+	return nodeInfo.ShadowingInfo
+}
+
 // analysisVisitor implements ast.Visitor and is used to traverse the AST during analysis.
 type analysisVisitor struct {
 	// analysis stores information gathered during the traversal
@@ -631,6 +664,19 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		return v // Continue traversal
 
 	case *ast.AssignStmt:
+		// Detect variable shadowing in any := assignment
+		if n.Tok == token.DEFINE {
+			shadowingInfo := v.detectVariableShadowing(n)
+			if shadowingInfo != nil {
+				// Store shadowing info on the assignment statement itself
+				if v.analysis.NodeData[n] == nil {
+					v.analysis.NodeData[n] = &NodeInfo{}
+				}
+				v.analysis.NodeData[n].ShadowingInfo = shadowingInfo
+			}
+		}
+
+		// Continue with the existing assignment analysis logic
 		for i, currentLHSExpr := range n.Lhs {
 			if i >= len(n.Rhs) {
 				break // Should not happen in valid Go
@@ -779,6 +825,22 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			}
 		}
 		return v // Continue traversal
+
+	case *ast.IfStmt:
+		// Detect variable shadowing in if statement initializations
+		if n.Init != nil {
+			if assignStmt, ok := n.Init.(*ast.AssignStmt); ok && assignStmt.Tok == token.DEFINE {
+				shadowingInfo := v.detectVariableShadowing(assignStmt)
+				if shadowingInfo != nil {
+					// Initialize NodeData for this if statement
+					if v.analysis.NodeData[n] == nil {
+						v.analysis.NodeData[n] = &NodeInfo{}
+					}
+					v.analysis.NodeData[n].ShadowingInfo = shadowingInfo
+				}
+			}
+		}
+		return v // Continue traversal
 	}
 
 	// For all other nodes, continue traversal
@@ -1225,3 +1287,112 @@ func (v *analysisVisitor) markFunctionVariable(ident *ast.Ident, funcType *types
 		v.analysis.MarkFunctionForReflection(funcNode, funcType)
 	}
 }
+
+// detectVariableShadowing detects variable shadowing in any := assignment
+func (v *analysisVisitor) detectVariableShadowing(assignStmt *ast.AssignStmt) *ShadowingInfo {
+	shadowingInfo := &ShadowingInfo{
+		ShadowedVariables: make(map[string]types.Object),
+		TempVariables:     make(map[string]string),
+	}
+
+	hasShadowing := false
+
+	// First, collect all LHS variable names that are being declared
+	lhsVarNames := make(map[string]*ast.Ident)
+	for _, lhsExpr := range assignStmt.Lhs {
+		if lhsIdent, ok := lhsExpr.(*ast.Ident); ok && lhsIdent.Name != "_" {
+			lhsVarNames[lhsIdent.Name] = lhsIdent
+		}
+	}
+
+	// Next, check all RHS expressions for usage of variables that are also being declared on LHS
+	for _, rhsExpr := range assignStmt.Rhs {
+		v.findVariableUsageInExpr(rhsExpr, lhsVarNames, shadowingInfo, &hasShadowing)
+	}
+
+	if hasShadowing {
+		return shadowingInfo
+	}
+	return nil
+}
+
+// findVariableUsageInExpr recursively searches for variable usage in an expression
+func (v *analysisVisitor) findVariableUsageInExpr(expr ast.Expr, lhsVarNames map[string]*ast.Ident, shadowingInfo *ShadowingInfo, hasShadowing *bool) {
+	if expr == nil {
+		return
+	}
+
+	switch e := expr.(type) {
+	case *ast.Ident:
+		// Check if this identifier is being shadowed
+		if lhsIdent, exists := lhsVarNames[e.Name]; exists {
+			// This variable is being used on RHS but also declared on LHS - this is shadowing!
+
+			// Get the outer scope object for this variable
+			if outerObj := v.pkg.TypesInfo.Uses[e]; outerObj != nil {
+				// Make sure this isn't the same object as the LHS (which would mean no shadowing)
+				if lhsObj := v.pkg.TypesInfo.Defs[lhsIdent]; lhsObj != outerObj {
+					shadowingInfo.ShadowedVariables[e.Name] = outerObj
+					shadowingInfo.TempVariables[e.Name] = "_temp_" + e.Name
+					*hasShadowing = true
+				}
+			}
+		}
+
+	case *ast.CallExpr:
+		// Check function arguments
+		for _, arg := range e.Args {
+			v.findVariableUsageInExpr(arg, lhsVarNames, shadowingInfo, hasShadowing)
+		}
+		// Check function expression itself
+		v.findVariableUsageInExpr(e.Fun, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.SelectorExpr:
+		// Check the base expression (e.g., x in x.Method())
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.IndexExpr:
+		// Check both the expression and index (e.g., arr[i])
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+		v.findVariableUsageInExpr(e.Index, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.SliceExpr:
+		// Check the expression and slice bounds
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+		if e.Low != nil {
+			v.findVariableUsageInExpr(e.Low, lhsVarNames, shadowingInfo, hasShadowing)
+		}
+		if e.High != nil {
+			v.findVariableUsageInExpr(e.High, lhsVarNames, shadowingInfo, hasShadowing)
+		}
+		if e.Max != nil {
+			v.findVariableUsageInExpr(e.Max, lhsVarNames, shadowingInfo, hasShadowing)
+		}
+
+	case *ast.UnaryExpr:
+		// Check the operand (e.g., &x, -x, !x)
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.BinaryExpr:
+		// Check both operands (e.g., x + y)
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+		v.findVariableUsageInExpr(e.Y, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.ParenExpr:
+		// Check the parenthesized expression
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.TypeAssertExpr:
+		// Check the expression being type-asserted
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.StarExpr:
+		// Check the expression being dereferenced
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	// Add more expression types as needed
+	default:
+		// For other expression types, we might need to add specific handling
+		// For now, we'll ignore them as they're less common in shadowing scenarios
+	}
+}

package/compiler/compiler.go

@@ -639,6 +639,9 @@ type GoToTSCompiler struct {
 	pkg *packages.Package
 
 	analysis *Analysis
+
+	// shadowingContext tracks temporary variable mappings when we're in a shadowing context
+	shadowingContext map[string]string
 }
 
 // It initializes the compiler with a `TSCodeWriter` for output,
@@ -646,9 +649,10 @@ type GoToTSCompiler struct {
 // analysis results (`Analysis`) to guide the translation process.
 func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, analysis *Analysis) *GoToTSCompiler {
 	return &GoToTSCompiler{
-		tsw:      tsw,
-		pkg:      pkg,
-		analysis: analysis,
+		tsw:              tsw,
+		pkg:              pkg,
+		analysis:         analysis,
+		shadowingContext: make(map[string]string),
 	}
 }
 
@@ -670,6 +674,12 @@ func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessVarRefedValue bool) {
 		return
 	}
 
+	// Check if we're in a shadowing context and should use a temporary variable
+	if tempVarName, exists := c.shadowingContext[exp.Name]; exists {
+		c.tsw.WriteLiterally(c.sanitizeIdentifier(tempVarName))
+		return
+	}
+
 	// Use TypesInfo to find the object associated with the identifier
 	var obj types.Object
 	obj = c.pkg.TypesInfo.Uses[exp]

package/compiler/stmt.go

@@ -444,53 +444,90 @@ func (c *GoToTSCompiler) WriteStmtSend(exp *ast.SendStmt) error {
 //     recursively calling `WriteStmtIf`.
 //
 // The function aims to produce idiomatic TypeScript `if/else if/else` structures.
-func (s *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
+func (c *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
 	if exp.Init != nil {
-		s.tsw.WriteLiterally("{") // Write opening brace
-		s.tsw.WriteLine("")       // Add newline immediately after opening brace
-		s.tsw.Indent(1)           // Indent for the initializer
+		// Check if we need to handle variable shadowing BEFORE creating the block
+		var shadowingInfo *ShadowingInfo
+		if assignStmt, ok := exp.Init.(*ast.AssignStmt); ok {
+			shadowingInfo = c.analysis.GetShadowingInfo(assignStmt)
+		}
+
+		// Generate temporary variables OUTSIDE the block to avoid temporal dead zone
+		if shadowingInfo != nil {
+			for varName, tempVarName := range shadowingInfo.TempVariables {
+				c.tsw.WriteLiterally("let ")
+				c.tsw.WriteLiterally(tempVarName)
+				c.tsw.WriteLiterally(" = ")
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(varName))
+				c.tsw.WriteLine("")
+			}
+		}
 
-		if err := s.WriteStmt(exp.Init); err != nil { // Write the initializer
-			return err
+		c.tsw.WriteLiterally("{") // Write opening brace
+		c.tsw.WriteLine("")       // Add newline immediately after opening brace
+		c.tsw.Indent(1)           // Indent for the initializer
+
+		// Check if we need to handle variable shadowing
+		if assignStmt, ok := exp.Init.(*ast.AssignStmt); ok {
+			if shadowingInfo != nil {
+				// Write the assignment statement with special handling for shadowing
+				if err := c.writeShadowedAssignment(assignStmt, shadowingInfo); err != nil {
+					return err
+				}
+			} else {
+				// No shadowing, write normally
+				if err := c.WriteStmt(exp.Init); err != nil {
+					return err
+				}
+			}
+		} else {
+			// Not an assignment statement, write normally
+			if err := c.WriteStmt(exp.Init); err != nil {
+				return err
+			}
 		}
 
 		// This defer handles closing the synthetic block for the initializer
 		defer func() {
-			s.tsw.Indent(-1)
-			s.tsw.WriteLiterally("}") // Write the closing brace at the now-correct indent level
-			s.tsw.WriteLine("")       // Ensure a newline *after* this '}', critical for preventing '}}'
+			c.tsw.Indent(-1)
+			c.tsw.WriteLiterally("}") // Write the closing brace at the now-correct indent level
+			c.tsw.WriteLine("")       // Ensure a newline *after* this '}', critical for preventing '}}'
 		}()
 	}
 
-	s.tsw.WriteLiterally("if (")
-	if err := s.WriteValueExpr(exp.Cond); err != nil { // Condition is a value
+	// Ensure shadowing context is clear before writing condition
+	// (condition should refer to new local variables, not temp variables)
+	c.shadowingContext = make(map[string]string)
+
+	c.tsw.WriteLiterally("if (")
+	if err := c.WriteValueExpr(exp.Cond); err != nil { // Condition is a value
 		return err
 	}
-	s.tsw.WriteLiterally(") ")
+	c.tsw.WriteLiterally(") ")
 
 	if exp.Body != nil {
-		if err := s.WriteStmtBlock(exp.Body, exp.Else != nil); err != nil {
+		if err := c.WriteStmtBlock(exp.Body, exp.Else != nil); err != nil {
 			return fmt.Errorf("failed to write if body block statement: %w", err)
 		}
 	} else {
 		// Handle nil body case using WriteStmtBlock with an empty block
-		if err := s.WriteStmtBlock(&ast.BlockStmt{}, exp.Else != nil); err != nil {
+		if err := c.WriteStmtBlock(&ast.BlockStmt{}, exp.Else != nil); err != nil {
 			return fmt.Errorf("failed to write empty block statement in if statement: %w", err)
 		}
 	}
 
 	// handle else branch
 	if exp.Else != nil {
-		s.tsw.WriteLiterally(" else ")
+		c.tsw.WriteLiterally(" else ")
 		switch elseStmt := exp.Else.(type) {
 		case *ast.BlockStmt:
 			// Always pass false for suppressNewline here
-			if err := s.WriteStmtBlock(elseStmt, false); err != nil {
+			if err := c.WriteStmtBlock(elseStmt, false); err != nil {
 				return fmt.Errorf("failed to write else block statement in if statement: %w", err)
 			}
 		case *ast.IfStmt:
 			// Recursive call handles its own block formatting
-			if err := s.WriteStmtIf(elseStmt); err != nil {
+			if err := c.WriteStmtIf(elseStmt); err != nil {
 				return fmt.Errorf("failed to write else if statement in if statement: %w", err)
 			}
 		}
@@ -897,3 +934,67 @@ func (c *GoToTSCompiler) WriteStmtLabeled(stmt *ast.LabeledStmt) error {
 
 	return nil
 }
+
+// writeShadowedAssignment writes an assignment statement that has variable shadowing,
+// applying the shadowing context only to RHS expressions.
+func (c *GoToTSCompiler) writeShadowedAssignment(stmt *ast.AssignStmt, shadowingInfo *ShadowingInfo) error {
+	// Write the LHS variables (these are new declarations, don't use temp variables)
+	for i, lhsExpr := range stmt.Lhs {
+		if i > 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+
+		if ident, ok := lhsExpr.(*ast.Ident); ok {
+			if ident.Name == "_" {
+				c.tsw.WriteLiterally("_")
+			} else {
+				c.tsw.WriteLiterally("let ")
+				c.WriteIdent(ident, false) // Don't use temp variable for LHS
+			}
+		} else {
+			// For non-identifier LHS (shouldn't happen in := assignments), write normally
+			if err := c.WriteValueExpr(lhsExpr); err != nil {
+				return err
+			}
+		}
+	}
+
+	c.tsw.WriteLiterally(" = ")
+
+	// Set up shadowing context for RHS expressions only
+	originalContext := make(map[string]string)
+	for varName, tempVarName := range shadowingInfo.TempVariables {
+		originalContext[varName] = c.shadowingContext[varName] // backup original
+		c.shadowingContext[varName] = tempVarName
+	}
+
+	// Write RHS expressions with shadowing context
+	for i, rhsExpr := range stmt.Rhs {
+		if i > 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+		if err := c.WriteValueExpr(rhsExpr); err != nil {
+			// Restore context on error
+			for varName := range shadowingInfo.TempVariables {
+				if original, existed := originalContext[varName]; existed {
+					c.shadowingContext[varName] = original
+				} else {
+					delete(c.shadowingContext, varName)
+				}
+			}
+			return err
+		}
+	}
+
+	// Restore original context after writing RHS
+	for varName := range shadowingInfo.TempVariables {
+		if original, existed := originalContext[varName]; existed {
+			c.shadowingContext[varName] = original
+		} else {
+			delete(c.shadowingContext, varName)
+		}
+	}
+
+	c.tsw.WriteLine("")
+	return nil
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",