goscript 0.0.84 → 0.1.1

package/compiler/spec-struct.go

@@ -1,995 +0,0 @@
-package compiler
-
-import (
-	"fmt"
-	"go/ast"
-	"go/types"
-	"maps"
-	"slices"
-	"strings"
-)
-
-// WriteStructTypeSpec generates the TypeScript class definition for a Go struct type.
-// It handles the generation of:
-//   - The class declaration.
-//   - Getters and setters for all fields (both direct and embedded).
-//   - The internal `_fields` property, which stores field values in `$.VarRef` containers
-//     to maintain Go's value semantics.
-//   - A constructor that initializes the `_fields` and allows partial initialization.
-//   - A `clone` method for creating a deep copy of the struct instance.
-//   - Methods defined directly on the struct.
-//   - 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 {
-	isInsideFunction := false
-	if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
-		isInsideFunction = nodeInfo.IsInsideFunction
-	}
-	if !isInsideFunction {
-		c.tsw.WriteLiterally("export ")
-	}
-	c.tsw.WriteLiterally("class ")
-	if err := c.WriteValueExpr(a.Name); err != nil {
-		return err
-	}
-
-	// Write type parameters if present (for generics)
-	if a.TypeParams != nil {
-		c.WriteTypeParameters(a.TypeParams)
-	}
-
-	c.tsw.WriteLiterally(" ")
-	c.tsw.WriteLine("{")
-	c.tsw.Indent(1)
-
-	className := sanitizeIdentifier(a.Name.Name)
-
-	goStructType, ok := c.pkg.TypesInfo.Defs[a.Name].Type().(*types.Named)
-	if !ok {
-		return fmt.Errorf("could not get named type for %s", a.Name.Name)
-	}
-	underlyingStruct, ok := goStructType.Underlying().(*types.Struct)
-	if !ok {
-		return fmt.Errorf("underlying type of %s is not a struct", a.Name.Name)
-	}
-
-	// Generate getters and setters for each non-embedded field first
-	for _, field := range t.Fields.List {
-		if len(field.Names) == 0 { // Skip anonymous/embedded fields here; they are handled below or via promotion
-			continue
-		}
-		for _, name := range field.Names {
-			fieldName := name.Name
-			// Skip underscore fields
-			if fieldName == "_" {
-				continue
-			}
-			fieldType := c.pkg.TypesInfo.TypeOf(field.Type)
-			if fieldType == nil {
-				fieldType = types.Typ[types.Invalid]
-			}
-			c.writeGetterSetter(fieldName, fieldType, field.Doc, field.Comment, field.Type)
-		}
-	}
-
-	// Generate getters and setters for EMBEDDED struct fields themselves
-	for field := range underlyingStruct.Fields() {
-		if field.Anonymous() {
-			fieldKeyName := c.getEmbeddedFieldKeyName(field.Type())
-			c.writeGetterSetter(fieldKeyName, field.Type(), nil, nil, nil)
-		}
-	}
-
-	// Create a mapping from field names to AST types for preserving qualified names
-	fieldASTTypes := make(map[string]ast.Expr)
-	for _, field := range t.Fields.List {
-		if len(field.Names) > 0 {
-			for _, name := range field.Names {
-				fieldASTTypes[name.Name] = field.Type
-			}
-		}
-	}
-
-	// Define the _fields property type
-	c.tsw.WriteLiterally("public _fields: {")
-	c.tsw.Indent(1)
-	c.tsw.WriteLine("")
-
-	for field := range underlyingStruct.Fields() {
-		var fieldKeyName string
-		if field.Anonymous() {
-			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
-		} else {
-			fieldKeyName = field.Name()
-		}
-		// Skip underscore fields
-		if fieldKeyName == "_" {
-			continue
-		}
-
-		// Use AST-based type string when available, fall back to types-based
-		// Note: getASTTypeString already includes "null |" for interface types
-		astType := fieldASTTypes[fieldKeyName]
-		fieldTsType := c.getASTTypeString(astType, field.Type())
-
-		c.tsw.WriteLinef("%s: $.VarRef<%s>;", fieldKeyName, fieldTsType)
-	}
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-
-	// Generate the flattened type string for the constructor init parameter
-	flattenedInitType := c.generateFlattenedInitTypeString(goStructType, fieldASTTypes)
-
-	c.tsw.WriteLine("")
-	c.tsw.WriteLinef("constructor(init?: Partial<%s>) {", flattenedInitType)
-	c.tsw.Indent(1)
-	c.tsw.WriteLiterally("this._fields = {")
-
-	numFields := underlyingStruct.NumFields()
-	if numFields != 0 {
-		c.tsw.WriteLine("")
-		c.tsw.Indent(1)
-
-		firstFieldWritten := false
-		for i := range numFields {
-			field := underlyingStruct.Field(i)
-			fieldType := field.Type()
-			var fieldKeyName string
-			if field.Anonymous() {
-				fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
-			} else {
-				fieldKeyName = field.Name()
-			}
-
-			// Skip underscore fields
-			if fieldKeyName == "_" {
-				continue
-			}
-
-			if firstFieldWritten {
-				c.tsw.WriteLine(",")
-			}
-
-			c.writeVarRefedFieldInitializer(fieldKeyName, fieldType, field.Anonymous(), fieldASTTypes[fieldKeyName])
-			firstFieldWritten = true
-		}
-		if firstFieldWritten {
-			c.tsw.WriteLine("")
-		}
-		c.tsw.Indent(-1)
-	}
-	c.tsw.WriteLine("}")
-
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-	c.tsw.WriteLine("")
-
-	// Generate the clone method
-	var cloneReturnType strings.Builder
-	cloneReturnType.WriteString(className)
-	if a.TypeParams != nil && len(a.TypeParams.List) > 0 {
-		cloneReturnType.WriteString("<")
-		first := true
-		for _, field := range a.TypeParams.List {
-			for _, name := range field.Names {
-				if !first {
-					cloneReturnType.WriteString(", ")
-				}
-				first = false
-				cloneReturnType.WriteString(name.Name)
-			}
-		}
-		cloneReturnType.WriteString(">")
-	}
-
-	c.tsw.WriteLinef("public clone(): %s {", cloneReturnType.String())
-	c.tsw.Indent(1)
-	c.tsw.WriteLinef("const cloned = new %s()", cloneReturnType.String())
-	c.tsw.WriteLine("cloned._fields = {")
-	c.tsw.Indent(1)
-
-	firstFieldWritten := false
-	for i := range numFields {
-		field := underlyingStruct.Field(i)
-		fieldType := field.Type()
-		var fieldKeyName string
-		if field.Anonymous() {
-			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
-		} else {
-			fieldKeyName = field.Name()
-		}
-
-		// Skip underscore fields
-		if fieldKeyName == "_" {
-			continue
-		}
-
-		if firstFieldWritten {
-			c.tsw.WriteLine(",")
-		}
-
-		c.writeClonedFieldInitializer(fieldKeyName, fieldType, field.Anonymous())
-		firstFieldWritten = true
-	}
-	if firstFieldWritten {
-		c.tsw.WriteLine("")
-	}
-
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-	c.tsw.WriteLine("return cloned")
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-
-	// Methods for this struct (direct methods)
-	for _, fileSyntax := range c.pkg.Syntax {
-		for _, decl := range fileSyntax.Decls {
-			funcDecl, isFunc := decl.(*ast.FuncDecl)
-			if !isFunc || funcDecl.Recv == nil || len(funcDecl.Recv.List) == 0 {
-				continue
-			}
-			recvField := funcDecl.Recv.List[0]
-			recvType := recvField.Type
-			if starExpr, ok := recvType.(*ast.StarExpr); ok {
-				recvType = starExpr.X
-			}
-
-			// Check for both simple identifiers (Pair) and generic types (Pair[T])
-			var recvTypeName string
-			if ident, ok := recvType.(*ast.Ident); ok {
-				recvTypeName = sanitizeIdentifier(ident.Name)
-			} else if indexExpr, ok := recvType.(*ast.IndexExpr); ok {
-				if ident, ok := indexExpr.X.(*ast.Ident); ok {
-					recvTypeName = sanitizeIdentifier(ident.Name)
-				}
-			}
-
-			if recvTypeName == className {
-				c.tsw.WriteLine("")
-				if err := c.WriteFuncDeclAsMethod(funcDecl); err != nil {
-					return err
-				}
-			}
-		}
-	}
-
-	// Generate getters/setters and wrapper methods for PROMOTED fields/methods from embedded structs
-	seenPromotedFields := make(map[string]bool)
-	directMethods := make(map[string]bool)
-	// Populate directMethods (methods defined directly on this struct type)
-	for method := range goStructType.Methods() {
-		sig := method.Type().(*types.Signature)
-		if sig.Recv() != nil {
-			recvType := sig.Recv().Type()
-			if namedRecv, ok := recvType.(*types.Named); ok && namedRecv.Obj() == goStructType.Obj() {
-				directMethods[method.Name()] = true
-			} else if ptrRecv, ok := recvType.(*types.Pointer); ok {
-				if namedElem, ok := ptrRecv.Elem().(*types.Named); ok && namedElem.Obj() == goStructType.Obj() {
-					directMethods[method.Name()] = true
-				}
-			}
-		}
-	}
-
-	for field := range underlyingStruct.Fields() {
-		if !field.Anonymous() {
-			continue
-		}
-
-		embeddedFieldType := field.Type()
-		embeddedFieldKeyName := c.getEmbeddedFieldKeyName(field.Type())
-
-		// Skip if not a named type (required for proper embedding promotion)
-		trueEmbeddedType := embeddedFieldType
-		if ptr, isPtr := trueEmbeddedType.(*types.Pointer); isPtr {
-			trueEmbeddedType = ptr.Elem()
-		}
-		if _, isNamed := trueEmbeddedType.(*types.Named); !isNamed {
-			continue
-		}
-
-		// Promoted fields
-		if namedEmbedded, ok := trueEmbeddedType.(*types.Named); ok {
-			if underlyingEmbeddedStruct, ok := namedEmbedded.Underlying().(*types.Struct); ok {
-				for promotedField := range underlyingEmbeddedStruct.Fields() {
-					if !promotedField.Exported() && promotedField.Pkg() != c.pkg.Types {
-						continue
-					}
-					promotedFieldName := promotedField.Name()
-					if seenPromotedFields[promotedFieldName] {
-						continue
-					}
-					// Check for conflicts with outer struct's own fields or other promoted fields
-					conflict := false
-					for field := range underlyingStruct.Fields() {
-						if !field.Anonymous() && field.Name() == promotedFieldName {
-							conflict = true
-							break
-						}
-					}
-					if conflict {
-						continue
-					}
-
-					seenPromotedFields[promotedFieldName] = true
-					tsPromotedFieldType := c.getTypeString(promotedField.Type())
-					c.tsw.WriteLine("")
-					c.tsw.WriteLinef("public get %s(): %s {", promotedFieldName, tsPromotedFieldType)
-					c.tsw.Indent(1)
-					// Check if the embedded type is an interface and add null assertion
-					embeddedFieldTypeUnderlying := embeddedFieldType
-					if ptr, isPtr := embeddedFieldTypeUnderlying.(*types.Pointer); isPtr {
-						embeddedFieldTypeUnderlying = ptr.Elem()
-					}
-					if named, isNamed := embeddedFieldTypeUnderlying.(*types.Named); isNamed {
-						embeddedFieldTypeUnderlying = named.Underlying()
-					}
-					if _, isInterface := embeddedFieldTypeUnderlying.(*types.Interface); isInterface {
-						c.tsw.WriteLinef("return this.%s!.%s", embeddedFieldKeyName, promotedFieldName)
-					} else {
-						c.tsw.WriteLinef("return this.%s.%s", embeddedFieldKeyName, promotedFieldName)
-					}
-					c.tsw.Indent(-1)
-					c.tsw.WriteLine("}")
-					c.tsw.WriteLinef("public set %s(value: %s) {", promotedFieldName, tsPromotedFieldType)
-					c.tsw.Indent(1)
-					if _, isInterface := embeddedFieldTypeUnderlying.(*types.Interface); isInterface {
-						c.tsw.WriteLinef("this.%s!.%s = value", embeddedFieldKeyName, promotedFieldName)
-					} else {
-						c.tsw.WriteLinef("this.%s.%s = value", embeddedFieldKeyName, promotedFieldName)
-					}
-					c.tsw.Indent(-1)
-					c.tsw.WriteLine("}")
-				}
-			}
-		}
-
-		// Promoted methods
-		// Use pointer to embedded type to get both value and pointer receiver methods
-		// This matches Go's behavior where embedding T promotes both T and *T methods
-		// Exception: For interfaces, use the interface directly as pointer-to-interface has no methods
-		methodSetType := embeddedFieldType
-		if _, isPtr := embeddedFieldType.(*types.Pointer); !isPtr {
-			if _, isInterface := embeddedFieldType.Underlying().(*types.Interface); !isInterface {
-				methodSetType = types.NewPointer(embeddedFieldType)
-			}
-		}
-		embeddedMethodSet := types.NewMethodSet(methodSetType)
-		for methodSelection := range embeddedMethodSet.Methods() {
-			method := methodSelection.Obj().(*types.Func)
-			methodName := method.Name()
-
-			// Skip if it's not a promoted method (indirect) or if it's shadowed by a direct method or an already processed promoted method
-			if len(methodSelection.Index()) == 1 && !directMethods[methodName] && !seenPromotedFields[methodName] {
-				// Check for conflict with outer struct's own fields
-				conflictWithField := false
-				for field := range underlyingStruct.Fields() {
-					if !field.Anonymous() && field.Name() == methodName {
-						conflictWithField = true
-						break
-					}
-				}
-				if conflictWithField {
-					continue
-				}
-
-				seenPromotedFields[methodName] = true // Mark as handled to avoid duplicates from other embeddings
-				sig := method.Type().(*types.Signature)
-				c.tsw.WriteLine("")
-				c.tsw.WriteLiterally("public ")
-				c.tsw.WriteLiterally(methodName)
-				c.tsw.WriteLiterally("(")
-				params := sig.Params()
-				paramNames := make([]string, params.Len())
-				for j := 0; j < params.Len(); j++ {
-					param := params.At(j)
-					paramName := param.Name()
-					if paramName == "" || paramName == "_" {
-						paramName = fmt.Sprintf("_p%d", j)
-					}
-					paramNames[j] = paramName
-					if j > 0 {
-						c.tsw.WriteLiterally(", ")
-					}
-					c.tsw.WriteLiterally(paramName)
-					c.tsw.WriteLiterally(": ")
-					c.WriteGoType(param.Type(), GoTypeContextGeneral)
-				}
-				c.tsw.WriteLiterally(")")
-				results := sig.Results()
-				if results.Len() > 0 {
-					c.tsw.WriteLiterally(": ")
-					if results.Len() == 1 {
-						c.WriteGoType(results.At(0).Type(), GoTypeContextFunctionReturn)
-					} else {
-						c.tsw.WriteLiterally("[")
-						for j := 0; j < results.Len(); j++ {
-							if j > 0 {
-								c.tsw.WriteLiterally(", ")
-							}
-							c.WriteGoType(results.At(j).Type(), GoTypeContextFunctionReturn)
-						}
-						c.tsw.WriteLiterally("]")
-					}
-				} else {
-					c.tsw.WriteLiterally(": void")
-				}
-				c.tsw.WriteLine(" {")
-				c.tsw.Indent(1)
-				if results.Len() > 0 {
-					c.tsw.WriteLiterally("return ")
-				}
-
-				assertionPrefix := "this.%s"
-				if _, isInterface := embeddedFieldType.Underlying().(*types.Interface); isInterface {
-					assertionPrefix = "this.%s!"
-				}
-				c.tsw.WriteLiterallyf(assertionPrefix+".%s(%s)", embeddedFieldKeyName, methodName, strings.Join(paramNames, ", "))
-
-				c.tsw.WriteLine("")
-				c.tsw.Indent(-1)
-				c.tsw.WriteLine("}")
-			}
-		}
-	}
-
-	// Add code to register the type with the runtime type system
-	c.tsw.WriteLine("")
-	c.tsw.WriteLinef("// Register this type with the runtime type system")
-
-	// Build full package path name for registration
-	structName := className
-	pkgPath := c.pkg.Types.Path()
-	pkgName := c.pkg.Types.Name()
-	if pkgPath != "" && pkgName != "main" {
-		structName = pkgPath + "." + className
-	} else if pkgName == "main" {
-		structName = "main." + className
-	}
-
-	c.tsw.WriteLinef("static __typeInfo = $.registerStructType(")
-	c.tsw.WriteLinef("  '%s',", structName)
-	c.tsw.WriteLinef("  new %s(),", className)
-	c.tsw.WriteLiterally("  [")
-	// Collect methods for the struct type
-	var structMethods []*types.Func
-	for method := range goStructType.Methods() {
-		// Ensure it's a method directly on this type (not promoted here, promotion handled separately)
-		// Check if receiver is *T or T where T is goStructType
-		sig := method.Type().(*types.Signature)
-		recv := sig.Recv().Type()
-		if ptr, ok := recv.(*types.Pointer); ok {
-			recv = ptr.Elem()
-		}
-		if namedRecv, ok := recv.(*types.Named); ok && namedRecv.Obj() == goStructType.Obj() {
-			structMethods = append(structMethods, method)
-		}
-	}
-	c.writeMethodSignatures(structMethods)
-	c.tsw.WriteLiterally("],")
-	c.tsw.WriteLine("")
-
-	c.tsw.WriteLinef("  %s,", className)
-	// Add field type information for type assertions
-	c.tsw.WriteLiterally("  {")
-	firstField := true
-	for i := 0; i < underlyingStruct.NumFields(); i++ {
-		field := underlyingStruct.Field(i)
-		var fieldKeyName string
-		if field.Anonymous() {
-			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
-		} else {
-			fieldKeyName = field.Name()
-		}
-		// Skip underscore fields
-		if fieldKeyName == "_" {
-			continue
-		}
-		if !firstField {
-			c.tsw.WriteLiterally(", ")
-		}
-		firstField = false
-		c.tsw.WriteLiterallyf("%q: ", fieldKeyName)
-
-		// Get the struct tag for this field
-		tag := underlyingStruct.Tag(i)
-		if tag != "" {
-			// Write field info with tag as StructFieldInfo object
-			c.tsw.WriteLiterally("{ type: ")
-			c.writeTypeInfoObject(field.Type())
-			c.tsw.WriteLiterallyf(", tag: %q }", tag)
-		} else {
-			// No tag, write type info directly for backwards compatibility
-			c.writeTypeInfoObject(field.Type())
-		}
-	}
-	c.tsw.WriteLiterally("}")
-	c.tsw.WriteLine("")
-	c.tsw.WriteLinef(");")
-
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-	return nil
-}
-
-// WriteNamedStructTypeSpec generates a TypeScript class for a named type whose
-// underlying type is another named struct. The emitted class copies the field
-// layout without inheriting the underlying named type's prototype methods.
-func (c *GoToTSCompiler) WriteNamedStructTypeSpec(a *ast.TypeSpec, named *types.Named) error {
-	isInsideFunction := false
-	if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
-		isInsideFunction = nodeInfo.IsInsideFunction
-	}
-	if !isInsideFunction {
-		c.tsw.WriteLiterally("export ")
-	}
-	c.tsw.WriteLiterally("class ")
-	if err := c.WriteValueExpr(a.Name); err != nil {
-		return err
-	}
-
-	if a.TypeParams != nil {
-		c.WriteTypeParameters(a.TypeParams)
-	}
-
-	c.tsw.WriteLiterally(" ")
-	c.tsw.WriteLine("{")
-	c.tsw.Indent(1)
-
-	className := sanitizeIdentifier(a.Name.Name)
-	underlyingStruct, ok := named.Underlying().(*types.Struct)
-	if !ok {
-		return fmt.Errorf("underlying type of %s is not a struct", a.Name.Name)
-	}
-
-	underlyingType := c.pkg.TypesInfo.TypeOf(a.Type)
-	underlyingInitType := "{}"
-	if underlyingNamed, ok := underlyingType.(*types.Named); ok {
-		underlyingInitType = c.generateFlattenedInitTypeString(underlyingNamed, nil)
-	}
-	underlyingTypeName := c.getASTTypeString(a.Type, underlyingType)
-
-	for i := 0; i < underlyingStruct.NumFields(); i++ {
-		field := underlyingStruct.Field(i)
-		if field.Anonymous() {
-			continue
-		}
-		if !field.Exported() && field.Pkg() != c.pkg.Types {
-			continue
-		}
-		c.writeGetterSetter(field.Name(), field.Type(), nil, nil, nil)
-	}
-
-	for field := range underlyingStruct.Fields() {
-		if field.Anonymous() {
-			fieldKeyName := c.getEmbeddedFieldKeyName(field.Type())
-			c.writeGetterSetter(fieldKeyName, field.Type(), nil, nil, nil)
-		}
-	}
-
-	c.tsw.WriteLiterally("public _fields: {")
-	c.tsw.Indent(1)
-	c.tsw.WriteLine("")
-	for i := 0; i < underlyingStruct.NumFields(); i++ {
-		field := underlyingStruct.Field(i)
-		fieldKeyName := field.Name()
-		if field.Anonymous() {
-			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
-		}
-		if fieldKeyName == "_" {
-			continue
-		}
-		c.tsw.WriteLinef("%s: $.VarRef<%s>;", fieldKeyName, c.getTypeString(field.Type()))
-	}
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-	c.tsw.WriteLine("")
-
-	c.tsw.WriteLinef("constructor(init?: Partial<%s>) {", underlyingInitType)
-	c.tsw.Indent(1)
-	c.tsw.WriteLinef("const base = new %s(init)", underlyingTypeName)
-	c.tsw.WriteLine("this._fields = base._fields")
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-	c.tsw.WriteLine("")
-
-	var cloneReturnType strings.Builder
-	cloneReturnType.WriteString(className)
-	if a.TypeParams != nil && len(a.TypeParams.List) > 0 {
-		cloneReturnType.WriteString("<")
-		first := true
-		for _, field := range a.TypeParams.List {
-			for _, name := range field.Names {
-				if !first {
-					cloneReturnType.WriteString(", ")
-				}
-				first = false
-				cloneReturnType.WriteString(name.Name)
-			}
-		}
-		cloneReturnType.WriteString(">")
-	}
-
-	c.tsw.WriteLinef("public clone(): %s {", cloneReturnType.String())
-	c.tsw.Indent(1)
-	c.tsw.WriteLinef("const cloned = new %s()", cloneReturnType.String())
-	c.tsw.WriteLine("cloned._fields = {")
-	c.tsw.Indent(1)
-
-	firstFieldWritten := false
-	for i := 0; i < underlyingStruct.NumFields(); i++ {
-		field := underlyingStruct.Field(i)
-		fieldType := field.Type()
-		fieldKeyName := field.Name()
-		if field.Anonymous() {
-			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
-		}
-		if fieldKeyName == "_" {
-			continue
-		}
-
-		if firstFieldWritten {
-			c.tsw.WriteLine(",")
-		}
-		c.writeClonedFieldInitializer(fieldKeyName, fieldType, field.Anonymous())
-		firstFieldWritten = true
-	}
-	if firstFieldWritten {
-		c.tsw.WriteLine("")
-	}
-
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-	c.tsw.WriteLine("return cloned")
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-
-	for _, fileSyntax := range c.pkg.Syntax {
-		for _, decl := range fileSyntax.Decls {
-			funcDecl, isFunc := decl.(*ast.FuncDecl)
-			if !isFunc || funcDecl.Recv == nil || len(funcDecl.Recv.List) == 0 {
-				continue
-			}
-			recvType := funcDecl.Recv.List[0].Type
-			if starExpr, ok := recvType.(*ast.StarExpr); ok {
-				recvType = starExpr.X
-			}
-
-			var recvTypeName string
-			if ident, ok := recvType.(*ast.Ident); ok {
-				recvTypeName = sanitizeIdentifier(ident.Name)
-			} else if indexExpr, ok := recvType.(*ast.IndexExpr); ok {
-				if ident, ok := indexExpr.X.(*ast.Ident); ok {
-					recvTypeName = sanitizeIdentifier(ident.Name)
-				}
-			}
-
-			if recvTypeName == className {
-				c.tsw.WriteLine("")
-				if err := c.WriteFuncDeclAsMethod(funcDecl); err != nil {
-					return err
-				}
-			}
-		}
-	}
-
-	seenPromotedFields := make(map[string]bool)
-	directMethods := make(map[string]bool)
-	for method := range named.Methods() {
-		sig := method.Type().(*types.Signature)
-		if sig.Recv() != nil {
-			recvType := sig.Recv().Type()
-			if namedRecv, ok := recvType.(*types.Named); ok && namedRecv.Obj() == named.Obj() {
-				directMethods[method.Name()] = true
-			} else if ptrRecv, ok := recvType.(*types.Pointer); ok {
-				if namedElem, ok := ptrRecv.Elem().(*types.Named); ok && namedElem.Obj() == named.Obj() {
-					directMethods[method.Name()] = true
-				}
-			}
-		}
-	}
-
-	for field := range underlyingStruct.Fields() {
-		if !field.Anonymous() {
-			continue
-		}
-
-		embeddedFieldType := field.Type()
-		embeddedFieldKeyName := c.getEmbeddedFieldKeyName(field.Type())
-
-		trueEmbeddedType := embeddedFieldType
-		if ptr, isPtr := trueEmbeddedType.(*types.Pointer); isPtr {
-			trueEmbeddedType = ptr.Elem()
-		}
-		if _, isNamed := trueEmbeddedType.(*types.Named); !isNamed {
-			continue
-		}
-
-		if namedEmbedded, ok := trueEmbeddedType.(*types.Named); ok {
-			if underlyingEmbeddedStruct, ok := namedEmbedded.Underlying().(*types.Struct); ok {
-				for promotedField := range underlyingEmbeddedStruct.Fields() {
-					if !promotedField.Exported() && promotedField.Pkg() != c.pkg.Types {
-						continue
-					}
-					promotedFieldName := promotedField.Name()
-					if seenPromotedFields[promotedFieldName] {
-						continue
-					}
-					conflict := false
-					for field := range underlyingStruct.Fields() {
-						if !field.Anonymous() && field.Name() == promotedFieldName {
-							conflict = true
-							break
-						}
-					}
-					if conflict {
-						continue
-					}
-
-					seenPromotedFields[promotedFieldName] = true
-					tsPromotedFieldType := c.getTypeString(promotedField.Type())
-					c.tsw.WriteLine("")
-					c.tsw.WriteLinef("public get %s(): %s {", promotedFieldName, tsPromotedFieldType)
-					c.tsw.Indent(1)
-					embeddedFieldTypeUnderlying := embeddedFieldType
-					if ptr, isPtr := embeddedFieldTypeUnderlying.(*types.Pointer); isPtr {
-						embeddedFieldTypeUnderlying = ptr.Elem()
-					}
-					if named, isNamed := embeddedFieldTypeUnderlying.(*types.Named); isNamed {
-						embeddedFieldTypeUnderlying = named.Underlying()
-					}
-					if _, isInterface := embeddedFieldTypeUnderlying.(*types.Interface); isInterface {
-						c.tsw.WriteLinef("return this.%s!.%s", embeddedFieldKeyName, promotedFieldName)
-					} else {
-						c.tsw.WriteLinef("return this.%s.%s", embeddedFieldKeyName, promotedFieldName)
-					}
-					c.tsw.Indent(-1)
-					c.tsw.WriteLine("}")
-					c.tsw.WriteLinef("public set %s(value: %s) {", promotedFieldName, tsPromotedFieldType)
-					c.tsw.Indent(1)
-					if _, isInterface := embeddedFieldTypeUnderlying.(*types.Interface); isInterface {
-						c.tsw.WriteLinef("this.%s!.%s = value", embeddedFieldKeyName, promotedFieldName)
-					} else {
-						c.tsw.WriteLinef("this.%s.%s = value", embeddedFieldKeyName, promotedFieldName)
-					}
-					c.tsw.Indent(-1)
-					c.tsw.WriteLine("}")
-				}
-			}
-		}
-
-		methodSetType := embeddedFieldType
-		if _, isPtr := embeddedFieldType.(*types.Pointer); !isPtr {
-			if _, isInterface := embeddedFieldType.Underlying().(*types.Interface); !isInterface {
-				methodSetType = types.NewPointer(embeddedFieldType)
-			}
-		}
-		embeddedMethodSet := types.NewMethodSet(methodSetType)
-		for methodSelection := range embeddedMethodSet.Methods() {
-			method := methodSelection.Obj().(*types.Func)
-			methodName := method.Name()
-
-			if len(methodSelection.Index()) == 1 && !directMethods[methodName] && !seenPromotedFields[methodName] {
-				conflictWithField := false
-				for field := range underlyingStruct.Fields() {
-					if !field.Anonymous() && field.Name() == methodName {
-						conflictWithField = true
-						break
-					}
-				}
-				if conflictWithField {
-					continue
-				}
-
-				seenPromotedFields[methodName] = true
-				sig := method.Type().(*types.Signature)
-				c.tsw.WriteLine("")
-				c.tsw.WriteLiterally("public ")
-				c.tsw.WriteLiterally(methodName)
-				c.tsw.WriteLiterally("(")
-				params := sig.Params()
-				paramNames := make([]string, params.Len())
-				for j := 0; j < params.Len(); j++ {
-					param := params.At(j)
-					paramName := param.Name()
-					if paramName == "" || paramName == "_" {
-						paramName = fmt.Sprintf("_p%d", j)
-					}
-					paramNames[j] = paramName
-					if j > 0 {
-						c.tsw.WriteLiterally(", ")
-					}
-					c.tsw.WriteLiterally(paramName)
-					c.tsw.WriteLiterally(": ")
-					c.WriteGoType(param.Type(), GoTypeContextGeneral)
-				}
-				c.tsw.WriteLiterally(")")
-				results := sig.Results()
-				if results.Len() > 0 {
-					c.tsw.WriteLiterally(": ")
-					if results.Len() == 1 {
-						c.WriteGoType(results.At(0).Type(), GoTypeContextFunctionReturn)
-					} else {
-						c.tsw.WriteLiterally("[")
-						for j := 0; j < results.Len(); j++ {
-							if j > 0 {
-								c.tsw.WriteLiterally(", ")
-							}
-							c.WriteGoType(results.At(j).Type(), GoTypeContextFunctionReturn)
-						}
-						c.tsw.WriteLiterally("]")
-					}
-				} else {
-					c.tsw.WriteLiterally(": void")
-				}
-				c.tsw.WriteLine(" {")
-				c.tsw.Indent(1)
-				if results.Len() > 0 {
-					c.tsw.WriteLiterally("return ")
-				}
-
-				assertionPrefix := "this.%s"
-				if _, isInterface := embeddedFieldType.Underlying().(*types.Interface); isInterface {
-					assertionPrefix = "this.%s!"
-				}
-				c.tsw.WriteLiterallyf(assertionPrefix+".%s(%s)", embeddedFieldKeyName, methodName, strings.Join(paramNames, ", "))
-
-				c.tsw.WriteLine("")
-				c.tsw.Indent(-1)
-				c.tsw.WriteLine("}")
-			}
-		}
-	}
-
-	c.tsw.WriteLine("")
-	c.tsw.WriteLine("// Register this type with the runtime type system")
-
-	structName := className
-	pkgPath := c.pkg.Types.Path()
-	pkgName := c.pkg.Types.Name()
-	if pkgPath != "" && pkgName != "main" {
-		structName = pkgPath + "." + className
-	} else if pkgName == "main" {
-		structName = "main." + className
-	}
-
-	c.tsw.WriteLine("static __typeInfo = $.registerStructType(")
-	c.tsw.WriteLinef("  %q,", structName)
-	c.tsw.WriteLinef("  new %s(),", className)
-	c.tsw.WriteLiterally("  [")
-
-	var structMethods []*types.Func
-	for method := range named.Methods() {
-		sig := method.Type().(*types.Signature)
-		recv := sig.Recv().Type()
-		if ptr, ok := recv.(*types.Pointer); ok {
-			recv = ptr.Elem()
-		}
-		if namedRecv, ok := recv.(*types.Named); ok && namedRecv.Obj() == named.Obj() {
-			structMethods = append(structMethods, method)
-		}
-	}
-	c.writeMethodSignatures(structMethods)
-	c.tsw.WriteLiterally("],")
-	c.tsw.WriteLine("")
-
-	c.tsw.WriteLinef("  %s,", className)
-	c.tsw.WriteLiterally("  {")
-	firstField := true
-	for i := 0; i < underlyingStruct.NumFields(); i++ {
-		field := underlyingStruct.Field(i)
-		fieldKeyName := field.Name()
-		if field.Anonymous() {
-			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
-		}
-		if fieldKeyName == "_" {
-			continue
-		}
-		if !firstField {
-			c.tsw.WriteLiterally(", ")
-		}
-		firstField = false
-		c.tsw.WriteLiterallyf("%q: ", fieldKeyName)
-
-		tag := underlyingStruct.Tag(i)
-		if tag != "" {
-			c.tsw.WriteLiterally("{ type: ")
-			c.writeTypeInfoObject(field.Type())
-			c.tsw.WriteLiterallyf(", tag: %q }", tag)
-		} else {
-			c.writeTypeInfoObject(field.Type())
-		}
-	}
-	c.tsw.WriteLiterally("}")
-	c.tsw.WriteLine("")
-	c.tsw.WriteLine(");")
-
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-	return nil
-}
-
-// generateFlattenedInitTypeString generates a TypeScript type string for the
-// initialization object passed to a Go struct's constructor (`_init` method in TypeScript).
-// The generated type is a `Partial`-like structure, `"{ Field1?: Type1, Field2?: Type2, ... }"`,
-// including all direct and promoted fields of the `structType`.
-//   - It iterates through the direct fields of the `structType`. Exported fields
-//     are included with their TypeScript types (obtained via `WriteGoType`).
-//   - For anonymous (embedded) fields, it generates a type like `EmbeddedName?: ConstructorParameters<typeof EmbeddedName>[0]`,
-//     allowing initialization of the embedded struct's fields directly within the outer struct's initializer.
-//   - It then uses `types.NewMethodSet` and checks for `types.Var` objects that are fields
-//     to find promoted fields from embedded structs, adding them to the type string if not already present.
-//
-// The resulting string is sorted by field name for deterministic output and represents
-// the shape of the object expected by the struct's TypeScript constructor.
-func (c *GoToTSCompiler) generateFlattenedInitTypeString(structType *types.Named, fieldASTTypes map[string]ast.Expr) string {
-	if structType == nil {
-		return "{}"
-	}
-
-	// Use a map to collect unique field names and their types
-	fieldMap := make(map[string]string)
-	embeddedTypeMap := make(map[string]string) // Stores TS type string for embedded struct initializers
-
-	underlying, ok := structType.Underlying().(*types.Struct)
-	if !ok {
-		return "{}"
-	}
-
-	// First add the direct fields and track embedded types
-	for field := range underlying.Fields() {
-		fieldName := field.Name()
-
-		// Skip underscore fields
-		if fieldName == "_" {
-			continue
-		}
-
-		if !field.Exported() && field.Pkg() != c.pkg.Types {
-			continue
-		}
-
-		if field.Anonymous() {
-			fieldType := field.Type()
-			if ptr, ok := fieldType.(*types.Pointer); ok {
-				fieldType = ptr.Elem()
-			}
-
-			if _, ok := fieldType.(*types.Named); ok {
-				// Check if the embedded type is an interface
-				if _, isInterface := fieldType.Underlying().(*types.Interface); isInterface {
-					// For embedded interfaces, use the full qualified interface type
-					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = c.getTypeString(field.Type())
-				} else {
-					// For embedded structs, use ConstructorParameters for field-based initialization
-					// Use getTypeString to get the qualified type name (e.g., bytes.Buffer not just Buffer)
-					qualifiedTypeName := c.getTypeString(fieldType)
-					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = fmt.Sprintf("Partial<ConstructorParameters<typeof %s>[0]>", qualifiedTypeName)
-				}
-			}
-			continue
-		}
-		fieldMap[fieldName] = c.getASTTypeString(fieldASTTypes[fieldName], field.Type())
-	}
-
-	// Promoted fields (handled by Go's embedding, init should use direct/embedded names)
-	// The current logic for `generateFlattenedInitTypeString` seems to focus on top-level
-	// settable properties in the constructor. Promoted fields are accessed via `this.promotedField`,
-	// not typically set directly in `init?` unless the embedded struct itself is named in `init?`.
-
-	// Add embedded types to the field map (these are the names of the embedded structs themselves)
-	maps.Copy(fieldMap, embeddedTypeMap)
-
-	var fieldNames []string
-	for name := range fieldMap {
-		fieldNames = append(fieldNames, name)
-	}
-	slices.Sort(fieldNames)
-
-	var fieldDefs []string
-	for _, fieldName := range fieldNames {
-		fieldDefs = append(fieldDefs, fmt.Sprintf("%s?: %s", fieldName, fieldMap[fieldName]))
-	}
-
-	return "{" + strings.Join(fieldDefs, ", ") + "}"
-}