goscript 0.0.56 → 0.0.58

package/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
 }
 

package/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

package/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,

package/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 {

package/compiler/decl.go

@@ -3,7 +3,9 @@ package compiler
 import (
 	"fmt"
 	"go/ast"
+	"go/token"
 	"go/types"
+	"sort"
 )
 
 // WriteDecls iterates through a slice of Go top-level declarations (`ast.Decl`)
@@ -17,33 +19,384 @@ import (
 //     variables, or type definitions: It iterates through `d.Specs` and calls
 //     `WriteSpec` for each specification.
 //
+// Type declarations are sorted by dependencies to ensure referenced types are
+// defined before types that reference them, avoiding initialization order issues.
 // A newline is added after each processed declaration or spec group for readability.
 // Unknown declaration types result in a printed diagnostic message.
 func (c *GoToTSCompiler) WriteDecls(decls []ast.Decl) error {
+	// Separate type declarations from other declarations for dependency sorting
+	var typeSpecs []*ast.TypeSpec
+	var varSpecs []*ast.ValueSpec
+	var otherDecls []ast.Decl
+	var otherSpecs []ast.Spec
+
 	for _, decl := range decls {
 		switch d := decl.(type) {
 		case *ast.FuncDecl:
 			// Only handle top-level functions here. Methods are handled within WriteTypeSpec.
 			if d.Recv == nil {
-				if err := c.WriteFuncDeclAsFunction(d); err != nil {
-					return err
-				}
-				c.tsw.WriteLine("") // Add space after function
+				otherDecls = append(otherDecls, d)
 			}
 		case *ast.GenDecl:
 			for _, spec := range d.Specs {
-				if err := c.WriteSpec(spec); err != nil {
-					return err
+				if typeSpec, ok := spec.(*ast.TypeSpec); ok {
+					typeSpecs = append(typeSpecs, typeSpec)
+				} else if varSpec, ok := spec.(*ast.ValueSpec); ok && d.Tok == token.VAR {
+					varSpecs = append(varSpecs, varSpec)
+				} else {
+					otherSpecs = append(otherSpecs, spec)
 				}
-				c.tsw.WriteLine("") // Add space after spec
 			}
+		default:
+			otherDecls = append(otherDecls, d)
+		}
+	}
+
+	// Sort type declarations by dependencies
+	sortedTypeSpecs, err := c.sortTypeSpecsByDependencies(typeSpecs)
+	if err != nil {
+		return fmt.Errorf("failed to sort type declarations: %w", err)
+	}
+
+	// Sort variable declarations by type dependencies
+	sortedVarSpecs, err := c.sortVarSpecsByTypeDependencies(varSpecs, typeSpecs)
+	if err != nil {
+		return fmt.Errorf("failed to sort variable declarations: %w", err)
+	}
+
+	// Write non-type, non-var declarations first (imports, constants)
+	for _, spec := range otherSpecs {
+		if err := c.WriteSpec(spec); err != nil {
+			return err
+		}
+		c.tsw.WriteLine("") // Add space after spec
+	}
+
+	// Write sorted type declarations
+	for _, typeSpec := range sortedTypeSpecs {
+		if err := c.WriteSpec(typeSpec); err != nil {
+			return err
+		}
+		c.tsw.WriteLine("") // Add space after spec
+	}
+
+	// Write sorted variable declarations
+	for _, varSpec := range sortedVarSpecs {
+		if err := c.WriteSpec(varSpec); err != nil {
+			return err
+		}
+		c.tsw.WriteLine("") // Add space after spec
+	}
+
+	// Write function declarations last
+	for _, decl := range otherDecls {
+		switch d := decl.(type) {
+		case *ast.FuncDecl:
+			if err := c.WriteFuncDeclAsFunction(d); err != nil {
+				return err
+			}
+			c.tsw.WriteLine("") // Add space after function
 		default:
 			return fmt.Errorf("unknown decl: %#v", decl)
 		}
 	}
+
 	return nil
 }
 
+// sortTypeSpecsByDependencies performs a topological sort of type specifications
+// based on their dependencies to ensure referenced types are defined before
+// types that reference them.
+func (c *GoToTSCompiler) sortTypeSpecsByDependencies(typeSpecs []*ast.TypeSpec) ([]*ast.TypeSpec, error) {
+	if len(typeSpecs) <= 1 {
+		return typeSpecs, nil
+	}
+
+	// Build dependency graph
+	dependencies := make(map[string][]string) // typeName -> list of types it depends on
+	typeSpecMap := make(map[string]*ast.TypeSpec)
+
+	// First pass: collect all type names
+	for _, typeSpec := range typeSpecs {
+		typeName := typeSpec.Name.Name
+		typeSpecMap[typeName] = typeSpec
+		dependencies[typeName] = []string{}
+	}
+
+	// Second pass: analyze dependencies
+	for _, typeSpec := range typeSpecs {
+		typeName := typeSpec.Name.Name
+		deps := c.extractTypeDependencies(typeSpec.Type, typeSpecMap)
+		dependencies[typeName] = deps
+	}
+
+	// Perform topological sort
+	sorted, err := c.topologicalSort(dependencies)
+	if err != nil {
+		return nil, err
+	}
+
+	// Build result in sorted order
+	var result []*ast.TypeSpec
+	for _, typeName := range sorted {
+		if typeSpec, exists := typeSpecMap[typeName]; exists {
+			result = append(result, typeSpec)
+		}
+	}
+
+	return result, nil
+}
+
+// extractTypeDependencies extracts structural type dependencies from a type expression.
+// Only dependencies that affect class initialization order are considered:
+// - Struct field types (cause initialization order issues)
+// - Embedded types (directly affect struct layout)
+// - Type aliases (direct type references)
+// Method parameters and return types are ignored as they're just annotations.
+func (c *GoToTSCompiler) extractTypeDependencies(typeExpr ast.Expr, typeSpecMap map[string]*ast.TypeSpec) []string {
+	var deps []string
+
+	switch t := typeExpr.(type) {
+	case *ast.Ident:
+		// Direct type reference (e.g., type MyType OtherType)
+		if _, isLocalType := typeSpecMap[t.Name]; isLocalType {
+			deps = append(deps, t.Name)
+		}
+
+	case *ast.StructType:
+		// Struct type - check field types only
+		if t.Fields != nil {
+			for _, field := range t.Fields.List {
+				fieldDeps := c.extractTypeDependencies(field.Type, typeSpecMap)
+				deps = append(deps, fieldDeps...)
+			}
+		}
+
+	case *ast.ArrayType:
+		// Array type - check element type
+		elemDeps := c.extractTypeDependencies(t.Elt, typeSpecMap)
+		deps = append(deps, elemDeps...)
+
+	case *ast.StarExpr:
+		// Pointer type - check pointed-to type
+		ptrDeps := c.extractTypeDependencies(t.X, typeSpecMap)
+		deps = append(deps, ptrDeps...)
+
+	case *ast.MapType:
+		// Map type - check key and value types
+		keyDeps := c.extractTypeDependencies(t.Key, typeSpecMap)
+		valueDeps := c.extractTypeDependencies(t.Value, typeSpecMap)
+		deps = append(deps, keyDeps...)
+		deps = append(deps, valueDeps...)
+
+	case *ast.InterfaceType:
+		// Interface type - methods don't create initialization dependencies
+		// Only embedded interfaces matter, but those are rare and complex to handle
+		// For now, interfaces are considered to have no dependencies
+
+	case *ast.FuncType:
+		// Function types don't create initialization dependencies
+
+	case *ast.SelectorExpr:
+		// External package types don't create local dependencies
+
+		// Add other type expressions as needed
+	}
+
+	// Sort dependencies for deterministic output
+	sort.Strings(deps)
+	return deps
+}
+
+// sortVarSpecsByTypeDependencies sorts variable declarations based on their type dependencies
+func (c *GoToTSCompiler) sortVarSpecsByTypeDependencies(varSpecs []*ast.ValueSpec, typeSpecs []*ast.TypeSpec) ([]*ast.ValueSpec, error) {
+	if len(varSpecs) <= 1 {
+		return varSpecs, nil
+	}
+
+	// Build type name map
+	typeSpecMap := make(map[string]*ast.TypeSpec)
+	for _, typeSpec := range typeSpecs {
+		typeSpecMap[typeSpec.Name.Name] = typeSpec
+	}
+
+	// Group variables by dependency status with names for sorting
+	type namedVarSpec struct {
+		spec *ast.ValueSpec
+		name string
+	}
+
+	var independentVars []namedVarSpec
+	var dependentVars []namedVarSpec
+
+	for _, varSpec := range varSpecs {
+		// Get variable name for sorting
+		varName := ""
+		if len(varSpec.Names) > 0 {
+			varName = varSpec.Names[0].Name
+		}
+
+		hasDependency := false
+
+		// Check type annotation
+		if varSpec.Type != nil {
+			deps := c.extractTypeDependencies(varSpec.Type, typeSpecMap)
+			if len(deps) > 0 {
+				hasDependency = true
+			}
+		}
+
+		// Check initializer expressions for type usage
+		if !hasDependency {
+			for _, value := range varSpec.Values {
+				if c.hasTypeReferences(value, typeSpecMap) {
+					hasDependency = true
+					break
+				}
+			}
+		}
+
+		namedVar := namedVarSpec{spec: varSpec, name: varName}
+		if hasDependency {
+			dependentVars = append(dependentVars, namedVar)
+		} else {
+			independentVars = append(independentVars, namedVar)
+		}
+	}
+
+	// Sort both groups by name for deterministic output
+	sort.Slice(independentVars, func(i, j int) bool {
+		return independentVars[i].name < independentVars[j].name
+	})
+	sort.Slice(dependentVars, func(i, j int) bool {
+		return dependentVars[i].name < dependentVars[j].name
+	})
+
+	// Return independent variables first, then dependent ones
+	result := make([]*ast.ValueSpec, 0, len(varSpecs))
+	for _, namedVar := range independentVars {
+		result = append(result, namedVar.spec)
+	}
+	for _, namedVar := range dependentVars {
+		result = append(result, namedVar.spec)
+	}
+
+	return result, nil
+}
+
+// hasTypeReferences checks if an expression contains references to local types
+func (c *GoToTSCompiler) hasTypeReferences(expr ast.Expr, typeSpecMap map[string]*ast.TypeSpec) bool {
+	hasRef := false
+
+	ast.Inspect(expr, func(n ast.Node) bool {
+		switch t := n.(type) {
+		case *ast.CallExpr:
+			// Check function calls like new Message(), makeChannel<Message>()
+			if ident, ok := t.Fun.(*ast.Ident); ok {
+				if _, isLocalType := typeSpecMap[ident.Name]; isLocalType {
+					hasRef = true
+					return false
+				}
+			}
+			// Check type arguments in generic calls
+			if funcType, ok := t.Fun.(*ast.IndexExpr); ok {
+				if c.hasTypeReferences(funcType.Index, typeSpecMap) {
+					hasRef = true
+					return false
+				}
+			}
+		case *ast.CompositeLit:
+			// Check composite literals like Message{...}
+			if ident, ok := t.Type.(*ast.Ident); ok {
+				if _, isLocalType := typeSpecMap[ident.Name]; isLocalType {
+					hasRef = true
+					return false
+				}
+			}
+		case *ast.Ident:
+			// Check direct type references
+			if _, isLocalType := typeSpecMap[t.Name]; isLocalType {
+				hasRef = true
+				return false
+			}
+		}
+		return !hasRef // Stop walking if we found a reference
+	})
+
+	return hasRef
+}
+
+// topologicalSort performs a topological sort of the dependency graph
+func (c *GoToTSCompiler) topologicalSort(dependencies map[string][]string) ([]string, error) {
+	// Kahn's algorithm for topological sorting with deterministic ordering
+	inDegree := make(map[string]int)
+	graph := make(map[string][]string)
+
+	// Initialize in-degree counts and reverse graph
+	for node := range dependencies {
+		inDegree[node] = 0
+		graph[node] = []string{}
+	}
+
+	// Build reverse graph and count in-degrees
+	for node, deps := range dependencies {
+		// Sort dependencies for consistent output
+		sortedDeps := make([]string, len(deps))
+		copy(sortedDeps, deps)
+		sort.Strings(sortedDeps)
+
+		for _, dep := range sortedDeps {
+			if _, exists := inDegree[dep]; exists {
+				graph[dep] = append(graph[dep], node)
+				inDegree[node]++
+			}
+		}
+	}
+
+	// Sort neighbors in graph for consistency
+	for node := range graph {
+		sort.Strings(graph[node])
+	}
+
+	// Find nodes with no incoming edges and sort them
+	var queue []string
+	for node, degree := range inDegree {
+		if degree == 0 {
+			queue = append(queue, node)
+		}
+	}
+	sort.Strings(queue) // Sort initial queue for deterministic output
+
+	var result []string
+
+	for len(queue) > 0 {
+		// Remove node from queue (already sorted)
+		current := queue[0]
+		queue = queue[1:]
+		result = append(result, current)
+
+		// Collect new zero-degree nodes
+		var newZeroNodes []string
+		for _, neighbor := range graph[current] {
+			inDegree[neighbor]--
+			if inDegree[neighbor] == 0 {
+				newZeroNodes = append(newZeroNodes, neighbor)
+			}
+		}
+
+		// Sort new zero-degree nodes and add to queue
+		sort.Strings(newZeroNodes)
+		queue = append(queue, newZeroNodes...)
+	}
+
+	// Check for cycles
+	if len(result) != len(dependencies) {
+		return nil, fmt.Errorf("circular dependency detected in type declarations")
+	}
+
+	return result, nil
+}
+
 // WriteFuncDeclAsFunction translates a Go function declaration (`ast.FuncDecl`)
 // that does not have a receiver (i.e., it's a regular function, not a method)
 // into a TypeScript function.

package/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