fix: mark struct value-type variables for accurate type assertions (#98)

This commit inverts the struct marking strategy from marking pointers
to marking values for better alignment with Go type assertion semantics.
Previously, we marked struct pointers with markAsStructPointer; now we
mark struct values with markAsStructValue.

- analysis.go: Added visitCompositeLit to detect &var in composites for VarRef marking.
  Updated visitTypeAssertExpr to handle pointer expr types and track struct method implementations for interfaces.
- assignment.go: Added $.markAsStructValue to struct value cloning.
  Handled pointer-to-pointer assignments with conditional .value based on varref status.
  Added special handling for pointer variable assignment to interfaces without .value for varref'd pointers.
- compiler.go: Introduced insideAddressOf flag to track when inside & operator.
- composite-lit.go: Conditionally apply $.markAsStructValue to named struct values only if not inside &.
- expr-selector.go: Added $.markAsStructValue to cloned receivers in method binding.
- expr.go: For pointer comparisons, add .value only if operands are varref'd.
  For unary &, set insideAddressOf flag during operand evaluation.
- spec-struct.go: Export struct types only if not defined inside functions.
- spec-value.go: Use WriteValueExpr for unary & initializers.
  Added $.markAsStructValue to struct clones in initializers.
  Introduced writeInitializerForInterface to handle pointer to interface assignments without .value.
- spec.go: Added $.markAsStructValue to struct field initializers and clones in constructors.
- stmt.go: Added destructuring support for type assertions in shadowed assignments.
- type.ts: Inverted marking to use STRUCT_VALUE_MARKER on values.
  Updated matchesStructType to require value marker for value assertions.
  Updated matchesPointerType to match unmarked structs (pointers) or VarRefs for pointer assertions.
  Added special handling in typeAssert to return inner .value for pointer asserts on VarRefs.

These changes ensure correct type assertion behavior distinguishing struct
values from pointers, proper VarRef handling in composites, and consistent
pointer semantics.

(Commit message written by Grok 4)

Fixes: #92

Signed-off-by: Christian Stewart <christian@aperture.us>

Author: paralin

compiler/analysis.go

@@ -589,6 +589,12 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 
 	case *ast.TypeAssertExpr:
 		return v.visitTypeAssertExpr(n)
+
+	case *ast.CompositeLit:
+		// Traverse into composite literal elements to detect &variable expressions
+		// This is important for cases like: arr := []interface{}{value1, &value2}
+		// where value2 needs to be marked as NeedsVarRef due to the &value2 usage
+		return v.visitCompositeLit(n)
 	}
 
 	// For all other nodes, continue traversal
@@ -869,10 +875,89 @@ func (v *analysisVisitor) visitIfStmt(n *ast.IfStmt) ast.Visitor {
 	return v
 }
 
-// visitTypeAssertExpr handles type assertion expression analysis
-func (v *analysisVisitor) visitTypeAssertExpr(n *ast.TypeAssertExpr) ast.Visitor {
-	// Track interface implementations when we see type assertions
-	v.trackTypeAssertion(n)
+// visitTypeAssertExpr handles type assertion analysis for interface method implementations
+func (v *analysisVisitor) visitTypeAssertExpr(typeAssert *ast.TypeAssertExpr) ast.Visitor {
+	// Get the type being asserted to
+	assertedType := v.pkg.TypesInfo.TypeOf(typeAssert.Type)
+	if assertedType == nil {
+		return v
+	}
+
+	// Check if the asserted type is an interface
+	interfaceType, isInterface := assertedType.Underlying().(*types.Interface)
+	if !isInterface {
+		return v
+	}
+
+	// Get the type of the expression being asserted
+	exprType := v.pkg.TypesInfo.TypeOf(typeAssert.X)
+	if exprType == nil {
+		return v
+	}
+
+	// Handle pointer types by getting the element type
+	if ptrType, isPtr := exprType.(*types.Pointer); isPtr {
+		exprType = ptrType.Elem()
+	}
+
+	// Check if the expression type is a named struct type
+	namedType, isNamed := exprType.(*types.Named)
+	if !isNamed {
+		return v
+	}
+
+	// For each method in the interface, check if the struct implements it
+	for i := 0; i < interfaceType.NumExplicitMethods(); i++ {
+		interfaceMethod := interfaceType.ExplicitMethod(i)
+
+		// Find the corresponding method in the struct type
+		structMethod := v.findStructMethod(namedType, interfaceMethod.Name())
+		if structMethod != nil {
+			// Determine if this struct method is async using unified system
+			isAsync := false
+			if obj := structMethod; obj != nil {
+				isAsync = v.analysis.IsAsyncFunc(obj)
+			}
+
+			// Track this interface implementation
+			v.analysis.trackInterfaceImplementation(interfaceType, namedType, structMethod, isAsync)
+		}
+	}
+	return v
+}
+
+// visitCompositeLit analyzes composite literals for address-of expressions
+// This is important for detecting cases like: arr := []interface{}{value1, &value2}
+// where value2 needs to be marked as NeedsVarRef due to the &value2 usage
+func (v *analysisVisitor) visitCompositeLit(compLit *ast.CompositeLit) ast.Visitor {
+	// Analyze each element of the composite literal
+	for _, elt := range compLit.Elts {
+		// Handle both direct elements and key-value pairs
+		var expr ast.Expr
+		if kv, ok := elt.(*ast.KeyValueExpr); ok {
+			// For key-value pairs, analyze the value expression
+			expr = kv.Value
+		} else {
+			// For direct elements, analyze the element expression
+			expr = elt
+		}
+
+		// Check if this element is an address-of expression
+		if unaryExpr, ok := expr.(*ast.UnaryExpr); ok && unaryExpr.Op == token.AND {
+			// Found &something in the composite literal
+			if ident, ok := unaryExpr.X.(*ast.Ident); ok {
+				// Found &variable - mark the variable as needing VarRef
+				if obj := v.pkg.TypesInfo.ObjectOf(ident); obj != nil {
+					// Record that this variable has its address taken
+					usageInfo := v.getOrCreateUsageInfo(obj)
+					usageInfo.Destinations = append(usageInfo.Destinations, AssignmentInfo{
+						Object: nil, // No specific destination object for composite literals
+						Type:   AddressOfAssignment,
+					})
+				}
+			}
+		}
+	}
 	return v
 }
 

compiler/assignment.go

@@ -56,10 +56,12 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 
 			// Handle the RHS expression (potentially adding .clone() for structs)
 			if shouldApplyClone(c.pkg, rhs[0]) {
+				// When cloning for value assignment, mark the result as struct value
+				c.tsw.WriteLiterally("$.markAsStructValue(")
 				if err := c.WriteValueExpr(rhs[0]); err != nil {
 					return err
 				}
-				c.tsw.WriteLiterally(".clone()")
+				c.tsw.WriteLiterally(".clone())")
 			} else {
 				if err := c.WriteValueExpr(rhs[0]); err != nil {
 					return err
@@ -338,8 +340,37 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 			}
 		}
 
+		// Check for pointer-to-pointer assignment
+		if rhsIsIdent && rhsObj != nil && len(lhs) == 1 {
+			lhsType := c.pkg.TypesInfo.TypeOf(lhs[0])
+			rhsType := rhsObj.Type()
+
+			if lhsType != nil && rhsType != nil {
+				// Check if both LHS and RHS are pointer types
+				if _, lhsIsPtr := lhsType.(*types.Pointer); lhsIsPtr {
+					if _, rhsIsPtr := rhsType.(*types.Pointer); rhsIsPtr {
+						// This is pointer-to-pointer assignment
+						// The key question: is the RHS variable itself varref'd?
+						// - If RHS is varref'd (like pp1), use .value to get the actual pointer
+						// - If RHS is not varref'd (like p1), use the variable directly
+
+						if c.analysis.NeedsVarRef(rhsObj) {
+							// RHS variable is varref'd, so we need its .value to get the actual pointer
+							c.WriteIdent(rhsIdent, true) // Add .value access
+						} else {
+							// RHS variable is not varref'd, so it directly holds the pointer
+							c.WriteIdent(rhsIdent, false) // No .value access
+						}
+						continue
+					}
+				}
+			}
+		}
+
 		// Handle different cases for struct cloning
 		if shouldApplyClone(c.pkg, r) {
+			// When cloning for value assignment, mark the result as struct value
+			c.tsw.WriteLiterally("$.markAsStructValue(")
 			// For other expressions, we need to handle variable referenced access differently
 			if _, isIdent := r.(*ast.Ident); isIdent {
 				// For identifiers, WriteValueExpr already adds .value if needed
@@ -357,8 +388,39 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 				}
 			}
 
-			c.tsw.WriteLiterally(".clone()") // Always add clone for struct values
+			c.tsw.WriteLiterally(".clone())") // Always add clone for struct values
 		} else {
+			// Check if this is a pointer variable assignment to an interface type
+			if rhsIsIdent && rhsObj != nil {
+				// Check if LHS is interface type and RHS is a pointer variable
+				if len(lhs) == 1 {
+					lhsType := c.pkg.TypesInfo.TypeOf(lhs[0])
+					rhsType := rhsObj.Type()
+
+					if lhsType != nil && rhsType != nil {
+						// Check if LHS is interface and RHS is pointer
+						if _, isInterface := lhsType.Underlying().(*types.Interface); isInterface {
+							if ptrType, isPtr := rhsType.(*types.Pointer); isPtr {
+								// This is pointer-to-interface assignment
+								// For pointer variables that point to varrefed values, write without .value
+								// We want to pass the VarRef object itself to the interface, not its .value
+								if c.analysis.NeedsVarRefAccess(rhsObj) {
+									// Write the pointer variable without .value access
+									c.WriteIdent(rhsIdent, false)
+									continue
+								}
+
+								// Check if this is a struct pointer for the element type
+								if _, isStruct := ptrType.Elem().Underlying().(*types.Struct); isStruct {
+									// Struct pointer to interface - might need special handling
+									// Continue to normal WriteValueExpr handling
+								}
+							}
+						}
+					}
+				}
+			}
+
 			// Non-struct case: write RHS normally
 			if err := c.WriteValueExpr(r); err != nil { // RHS is a non-struct value
 				return err

compiler/compiler.go

@@ -704,6 +704,9 @@ type GoToTSCompiler struct {
 	pkg *packages.Package
 
 	analysis *Analysis
+
+	// Context flags
+	insideAddressOf bool // true when processing operand of & operator
 }
 
 // It initializes the compiler with a `TSCodeWriter` for output,

compiler/composite-lit.go

@@ -212,6 +212,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 			var structType *types.Struct
 			isStructLiteral := false
 			isAnonymousStruct := false
+			needsValueMarkerClose := false // Track if we need to close $.markAsStructValue()
 
 			if namedType, ok := litType.(*types.Named); ok {
 				if underlyingStruct, ok := namedType.Underlying().(*types.Struct); ok {
@@ -224,8 +225,14 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 							return err
 						}
 					} else {
-						// Named struct, use constructor
-						c.tsw.WriteLiterally("new ")
+						// Named struct value, use constructor
+						if !c.insideAddressOf {
+							// Only mark as struct value if not inside address-of operator
+							c.tsw.WriteLiterally("$.markAsStructValue(new ")
+							needsValueMarkerClose = true
+						} else {
+							c.tsw.WriteLiterally("new ")
+						}
 						c.WriteTypeExpr(exp.Type)
 					}
 				}
@@ -241,8 +248,14 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 							return err
 						}
 					} else {
-						// Type alias for struct, use constructor
-						c.tsw.WriteLiterally("new ")
+						// Type alias for struct value, use constructor
+						if !c.insideAddressOf {
+							// Only mark as struct value if not inside address-of operator
+							c.tsw.WriteLiterally("$.markAsStructValue(new ")
+							needsValueMarkerClose = true
+						} else {
+							c.tsw.WriteLiterally("new ")
+						}
 						c.WriteTypeExpr(exp.Type)
 					}
 				}
@@ -483,6 +496,10 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					c.tsw.WriteLiterally("}")
 				} else {
 					c.tsw.WriteLiterally("})")
+					// Close markAsStructValue wrapper if we opened one
+					if needsValueMarkerClose {
+						c.tsw.WriteLiterally(")")
+					}
 				}
 
 			} else {

compiler/expr-selector.go

@@ -239,24 +239,24 @@ func (c *GoToTSCompiler) writeMethodValue(exp *ast.SelectorExpr, selection *type
 		// The receiver should be a copy of the dereferenced value
 		c.tsw.WriteLiterally(".value.")
 		c.WriteIdent(exp.Sel, false)
-		c.tsw.WriteLiterally(".bind(")
+		c.tsw.WriteLiterally(".bind($.markAsStructValue(")
 		if err := c.WriteValueExpr(exp.X); err != nil {
 			return fmt.Errorf("failed to write method value receiver for binding: %w", err)
 		}
-		c.tsw.WriteLiterally("!.value.clone())")
+		c.tsw.WriteLiterally("!.value.clone()))")
 	} else if !isPointerReceiver && !baseIsPointer {
 		// Value receiver method on value type: t.Mv
 		// The receiver should be a copy of the value
 		c.tsw.WriteLiterally(".")
 		c.WriteIdent(exp.Sel, false)
-		c.tsw.WriteLiterally(".bind(")
+		c.tsw.WriteLiterally(".bind($.markAsStructValue(")
 		if err := c.WriteValueExpr(exp.X); err != nil {
 			return fmt.Errorf("failed to write method value receiver for binding: %w", err)
 		}
 		if baseIsPointer {
 			c.tsw.WriteLiterally("!")
 		}
-		c.tsw.WriteLiterally(".clone())")
+		c.tsw.WriteLiterally(".clone()))")
 	} else {
 		// Pointer receiver method on pointer type: pt.Mp
 		// The receiver should be the pointer itself

compiler/expr.go

@@ -382,9 +382,45 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 	// Compare the varRef objects directly using === or !==
 	if c.isPointerComparison(exp) {
 		c.tsw.WriteLiterally("(") // Wrap comparison
-		if err := c.WriteValueExpr(exp.X); err != nil {
-			return fmt.Errorf("failed to write binary expression left operand: %w", err)
+
+		// For pointer comparisons, we need to handle variable varref status
+		// If a variable is varref'd, we need its .value to get the actual pointer value
+
+		// Check if operands are varref'd variables
+		var leftObj, rightObj types.Object
+		leftIsVarRef := false
+		rightIsVarRef := false
+
+		if leftIdent, ok := exp.X.(*ast.Ident); ok {
+			leftObj = c.pkg.TypesInfo.ObjectOf(leftIdent)
+			if leftObj != nil {
+				leftIsVarRef = c.analysis.NeedsVarRef(leftObj)
+			}
+		}
+
+		if rightIdent, ok := exp.Y.(*ast.Ident); ok {
+			rightObj = c.pkg.TypesInfo.ObjectOf(rightIdent)
+			if rightObj != nil {
+				rightIsVarRef = c.analysis.NeedsVarRef(rightObj)
+			}
 		}
+
+		// Write left operand
+		if leftIdent, ok := exp.X.(*ast.Ident); ok {
+			if leftIsVarRef {
+				// Variable is varref'd, access its .value to get the pointer
+				c.WriteIdent(leftIdent, true)
+			} else {
+				// Variable is not varref'd, use it directly
+				c.WriteIdent(leftIdent, false)
+			}
+		} else {
+			// For non-identifiers, use WriteValueExpr
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return fmt.Errorf("failed to write binary expression left operand: %w", err)
+			}
+		}
+
 		c.tsw.WriteLiterally(" ")
 		// Use === for == and !== for !=
 		tokStr := ""
@@ -398,9 +434,23 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		}
 		c.tsw.WriteLiterally(tokStr)
 		c.tsw.WriteLiterally(" ")
-		if err := c.WriteValueExpr(exp.Y); err != nil {
-			return fmt.Errorf("failed to write binary expression right operand: %w", err)
+
+		// Write right operand
+		if rightIdent, ok := exp.Y.(*ast.Ident); ok {
+			if rightIsVarRef {
+				// Variable is varref'd, access its .value to get the pointer
+				c.WriteIdent(rightIdent, true)
+			} else {
+				// Variable is not varref'd, use it directly
+				c.WriteIdent(rightIdent, false)
+			}
+		} else {
+			// For non-identifiers, use WriteValueExpr
+			if err := c.WriteValueExpr(exp.Y); err != nil {
+				return fmt.Errorf("failed to write binary expression right operand: %w", err)
+			}
 		}
+
 		c.tsw.WriteLiterally(")") // Close wrap
 		return nil
 	}
@@ -503,12 +553,21 @@ func (c *GoToTSCompiler) WriteUnaryExpr(exp *ast.UnaryExpr) error {
 			}
 		}
 
+		// Note: With inversion to markAsStructValue, we no longer mark &CompositeLit{}
+		// since we now mark the CompositeLit{} (struct values) instead of pointers
+
 		// Otherwise (&unvarrefedVar, &CompositeLit{}, &FuncCall(), etc.),
 		// the address-of operator in Go, when used to create a pointer,
 		// translates to simply evaluating the operand in TypeScript.
 		// The resulting value (e.g., a new object instance) acts as the "pointer".
 		// VarRefing decisions are handled at the assignment site based on the LHS variable.
-		if err := c.WriteValueExpr(exp.X); err != nil {
+
+		// Set context flag to prevent marking composite literals as struct values
+		c.insideAddressOf = true
+		err := c.WriteValueExpr(exp.X)
+		c.insideAddressOf = false
+
+		if err != nil {
 			return fmt.Errorf("failed to write &-operand: %w", err)
 		}