goscript 0.0.21 → 0.0.23

package/compiler/{write-type-spec.go → spec-struct.go}

@@ -4,159 +4,32 @@ import (
 	"fmt"
 	"go/ast"
 	"go/types"
+	"sort"
 	"strings"
-
-	// types provides type information for Go types.
-	"github.com/pkg/errors"
 )
 
-func (c *GoToTSCompiler) getEmbeddedFieldKeyName(fieldType types.Type) string {
-	trueType := fieldType
-	if ptr, isPtr := trueType.(*types.Pointer); isPtr {
-		trueType = ptr.Elem()
-	}
-
-	if named, isNamed := trueType.(*types.Named); isNamed {
-		return named.Obj().Name()
-	} else {
-		// Fallback for unnamed embedded types, though less common for structs
-		fieldKeyName := strings.Title(trueType.String()) // Simple heuristic
-		if dotIndex := strings.LastIndex(fieldKeyName, "."); dotIndex != -1 {
-			fieldKeyName = fieldKeyName[dotIndex+1:]
-		}
-		return fieldKeyName
-	}
-}
-
-func (c *GoToTSCompiler) writeGetterSetter(fieldName string, fieldType types.Type, doc, comment *ast.CommentGroup) {
-	fieldTypeStr := c.getTypeString(fieldType)
-
-	// Generate getter
-	if doc != nil {
-		c.WriteDoc(doc)
-	}
-	if comment != nil {
-		c.WriteDoc(comment)
-	}
-	c.tsw.WriteLinef("public get %s(): %s {", fieldName, fieldTypeStr)
-	c.tsw.Indent(1)
-	c.tsw.WriteLinef("return this._fields.%s.value", fieldName)
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-
-	// Generate setter (no comments)
-	c.tsw.WriteLinef("public set %s(value: %s) {", fieldName, fieldTypeStr)
-	c.tsw.Indent(1)
-	c.tsw.WriteLinef("this._fields.%s.value = value", fieldName)
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-	c.tsw.WriteLine("")
-}
-
-func (c *GoToTSCompiler) writeBoxedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
-	c.tsw.WriteLiterally(fieldName)
-	c.tsw.WriteLiterally(": $.box(")
-
-	if isEmbedded {
-		if _, isPtr := fieldType.(*types.Pointer); isPtr {
-			c.tsw.WriteLiterallyf("init?.%s ?? null", fieldName)
-		} else {
-			typeForNew := fieldName
-			c.tsw.WriteLiterallyf("new %s(init?.%s)", typeForNew, fieldName)
-		}
-	} else {
-		isStructValueType := false
-		var structTypeNameForClone string
-		if named, ok := fieldType.(*types.Named); ok {
-			if _, isStruct := named.Underlying().(*types.Struct); isStruct {
-				isStructValueType = true
-				structTypeNameForClone = named.Obj().Name()
-			}
-		}
-
-		if isStructValueType {
-			c.tsw.WriteLiterallyf("init?.%s?.clone() ?? new %s()", fieldName, structTypeNameForClone)
-		} else {
-			c.tsw.WriteLiterallyf("init?.%s ?? ", fieldName)
-			c.WriteZeroValueForType(fieldType)
-		}
-	}
-
-	c.tsw.WriteLiterally(")")
-}
-
-func (c *GoToTSCompiler) writeClonedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
-	c.tsw.WriteLiterally(fieldName)
-	c.tsw.WriteLiterally(": $.box(")
-
-	if isEmbedded {
-		isPointerToStruct := false
-		trueType := fieldType
-		if ptr, isPtr := trueType.(*types.Pointer); isPtr {
-			trueType = ptr.Elem()
-			isPointerToStruct = true
-		}
-
-		if named, isNamed := trueType.(*types.Named); isNamed {
-			_, isUnderlyingStruct := named.Underlying().(*types.Struct)
-			if isUnderlyingStruct && !isPointerToStruct { // Is a value struct
-				c.tsw.WriteLiterallyf("this._fields.%s.value.clone()", fieldName)
-			} else { // Is a pointer to a struct, or not a struct
-				c.tsw.WriteLiterallyf("this._fields.%s.value", fieldName)
-			}
-		} else {
-			c.tsw.WriteLiterallyf("this._fields.%s.value", fieldName)
-		}
-	} else {
-		isValueTypeStruct := false
-		if named, ok := fieldType.(*types.Named); ok {
-			if _, isStruct := named.Underlying().(*types.Struct); isStruct {
-				isValueTypeStruct = true
-			}
-		}
-
-		if isValueTypeStruct {
-			c.tsw.WriteLiterallyf("this._fields.%s.value?.clone() ?? null", fieldName)
-		} else {
-			c.tsw.WriteLiterallyf("this._fields.%s.value", fieldName)
-		}
-	}
-
-	c.tsw.WriteLiterally(")")
-}
-
-// WriteTypeSpec writes the type specification to the output.
-func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
-	if a.Doc != nil {
-		c.WriteDoc(a.Doc)
-	}
-	if a.Comment != nil {
-		c.WriteDoc(a.Comment)
-	}
-
-	switch t := a.Type.(type) {
-	case *ast.StructType:
-		return c.WriteStructTypeSpec(a, t)
-	case *ast.InterfaceType:
-		return c.WriteInterfaceTypeSpec(a, t)
-	default:
-		// type alias
-		c.tsw.WriteLiterally("type ")
-		if err := c.WriteValueExpr(a.Name); err != nil {
-			return err
-		}
-		c.tsw.WriteLiterally(" = ")
-		c.WriteTypeExpr(a.Type) // The aliased type
-		c.tsw.WriteLine(";")
-	}
-	return nil
-}
-
+// 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 `$.Box` 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 {
 	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)
@@ -188,7 +61,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	}
 
 	// Generate getters and setters for EMBEDDED struct fields themselves
-	for i := 0; i < underlyingStruct.NumFields(); i++ {
+	for i := range underlyingStruct.NumFields() {
 		field := underlyingStruct.Field(i)
 		if field.Anonymous() {
 			fieldKeyName := c.getEmbeddedFieldKeyName(field.Type())
@@ -221,43 +94,63 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	c.tsw.WriteLine("")
 	c.tsw.WriteLinef("constructor(init?: Partial<%s>) {", flattenedInitType)
 	c.tsw.Indent(1)
-	c.tsw.WriteLine("this._fields = {")
-	c.tsw.Indent(1)
+	c.tsw.WriteLiterally("this._fields = {")
 
 	numFields := underlyingStruct.NumFields()
-	for i := 0; i < numFields; i++ {
-		field := underlyingStruct.Field(i)
-		fieldType := field.Type()
-		var fieldKeyName string
-		if field.Anonymous() {
-			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
-		} else {
-			fieldKeyName = field.Name()
-		}
+	if numFields != 0 {
+		c.tsw.WriteLine("")
+		c.tsw.Indent(1)
+
+		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()
+			}
 
-		c.writeBoxedFieldInitializer(fieldKeyName, fieldType, field.Anonymous())
+			c.writeBoxedFieldInitializer(fieldKeyName, fieldType, field.Anonymous())
 
-		if i < numFields-1 {
-			c.tsw.WriteLine(",")
-		} else {
-			c.tsw.WriteLine("")
+			if i < numFields-1 {
+				c.tsw.WriteLine(",")
+			} else {
+				c.tsw.WriteLine("")
+			}
 		}
+		c.tsw.Indent(-1)
 	}
-
-	c.tsw.Indent(-1)
 	c.tsw.WriteLine("}")
+
 	c.tsw.Indent(-1)
 	c.tsw.WriteLine("}")
 	c.tsw.WriteLine("")
 
 	// Generate the clone method
-	c.tsw.WriteLinef("public clone(): %s {", className)
+	cloneReturnType := className
+	if a.TypeParams != nil && len(a.TypeParams.List) > 0 {
+		cloneReturnType += "<"
+		first := true
+		for _, field := range a.TypeParams.List {
+			for _, name := range field.Names {
+				if !first {
+					cloneReturnType += ", "
+				}
+				first = false
+				cloneReturnType += name.Name
+			}
+		}
+		cloneReturnType += ">"
+	}
+
+	c.tsw.WriteLinef("public clone(): %s {", cloneReturnType)
 	c.tsw.Indent(1)
-	c.tsw.WriteLinef("const cloned = new %s()", className)
+	c.tsw.WriteLinef("const cloned = new %s()", cloneReturnType)
 	c.tsw.WriteLine("cloned._fields = {")
 	c.tsw.Indent(1)
 
-	for i := 0; i < numFields; i++ {
+	for i := range numFields {
 		field := underlyingStruct.Field(i)
 		fieldType := field.Type()
 		var fieldKeyName string
@@ -294,7 +187,18 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 			if starExpr, ok := recvType.(*ast.StarExpr); ok {
 				recvType = starExpr.X
 			}
-			if ident, ok := recvType.(*ast.Ident); ok && ident.Name == className {
+
+			// Check for both simple identifiers (Pair) and generic types (Pair[T])
+			var recvTypeName string
+			if ident, ok := recvType.(*ast.Ident); ok {
+				recvTypeName = ident.Name
+			} else if indexExpr, ok := recvType.(*ast.IndexExpr); ok {
+				if ident, ok := indexExpr.X.(*ast.Ident); ok {
+					recvTypeName = ident.Name
+				}
+			}
+
+			if recvTypeName == className {
 				c.tsw.WriteLine("")
 				if err := c.WriteFuncDeclAsMethod(funcDecl); err != nil {
 					return err
@@ -307,7 +211,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	seenPromotedFields := make(map[string]bool)
 	directMethods := make(map[string]bool)
 	// Populate directMethods (methods defined directly on this struct type)
-	for i := 0; i < goStructType.NumMethods(); i++ {
+	for i := range goStructType.NumMethods() {
 		method := goStructType.Method(i)
 		sig := method.Type().(*types.Signature)
 		if sig.Recv() != nil {
@@ -322,7 +226,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 		}
 	}
 
-	for i := 0; i < underlyingStruct.NumFields(); i++ {
+	for i := range underlyingStruct.NumFields() {
 		field := underlyingStruct.Field(i)
 		if !field.Anonymous() {
 			continue
@@ -383,7 +287,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 
 		// Promoted methods
 		embeddedMethodSet := types.NewMethodSet(embeddedFieldType) // Use original field type for method set
-		for k := 0; k < embeddedMethodSet.Len(); k++ {
+		for k := range embeddedMethodSet.Len() {
 			methodSelection := embeddedMethodSet.At(k)
 			method := methodSelection.Obj().(*types.Func)
 			methodName := method.Name()
@@ -422,21 +326,21 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 					}
 					c.tsw.WriteLiterally(paramName)
 					c.tsw.WriteLiterally(": ")
-					c.WriteGoType(param.Type())
+					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())
+						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())
+							c.WriteGoType(results.At(j).Type(), GoTypeContextFunctionReturn)
 						}
 						c.tsw.WriteLiterally("]")
 					}
@@ -456,14 +360,54 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 		}
 	}
 
-	// Add code to register the type with the runtime system
+	// 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")
 	c.tsw.WriteLinef("static __typeInfo = $.registerStructType(")
 	c.tsw.WriteLinef("  '%s',", className)
 	c.tsw.WriteLinef("  new %s(),", className)
-	c.tsw.WriteLinef("  new Set([%s]),", c.collectMethodNames(className)) // collectMethodNames should ideally consider promoted methods too
-	c.tsw.WriteLinef("  %s", className)
+	c.tsw.WriteLiterally("  [")
+	// Collect methods for the struct type
+	var structMethods []*types.Func
+	for i := range goStructType.NumMethods() {
+		method := goStructType.Method(i)
+		// 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()
+		}
+		// fieldTsType := c.getTypeString(field.Type())
+		if !firstField {
+			c.tsw.WriteLiterally(", ")
+		}
+		firstField = false
+		c.tsw.WriteLiterallyf("%q: ", fieldKeyName)
+		c.writeTypeInfoObject(field.Type()) // Use writeTypeInfoObject for field types
+	}
+	c.tsw.WriteLiterally("}")
+	c.tsw.WriteLine("")
 	c.tsw.WriteLinef(");")
 
 	c.tsw.Indent(-1)
@@ -471,36 +415,99 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	return nil
 }
 
-// WriteInterfaceTypeSpec writes the TypeScript type for a Go interface type.
-func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.InterfaceType) error {
-	c.tsw.WriteLiterally("type ")
-	if err := c.WriteValueExpr(a.Name); err != nil {
-		return err
-	}
-	c.tsw.WriteLiterally(" = ")
-	// Get the types.Interface from the ast.InterfaceType.
-	// For an interface definition like `type MyInterface interface { M() }`,
-	// 't' is the *ast.InterfaceType representing `interface { M() }`.
-	// TypesInfo.TypeOf(t) will give the *types.Interface.
-	goType := c.pkg.TypesInfo.TypeOf(t)
-	if goType == nil {
-		return errors.Errorf("could not get type for interface AST node for %s", a.Name.Name)
+// 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) string {
+	if structType == nil {
+		return "{}"
 	}
-	ifaceType, ok := goType.(*types.Interface)
+
+	// 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 errors.Errorf("expected *types.Interface, got %T for %s when processing interface literal", goType, a.Name.Name)
+		return "{}"
 	}
-	c.WriteInterfaceType(ifaceType, t) // Pass the *ast.InterfaceType for comment fetching
-	c.tsw.WriteLine("")
 
-	// Add code to register the interface with the runtime system
-	interfaceName := a.Name.Name
-	c.tsw.WriteLine("")
-	c.tsw.WriteLinef("$.registerInterfaceType(")
-	c.tsw.WriteLinef("  '%s',", interfaceName)
-	c.tsw.WriteLinef("  null, // Zero value for interface is null")
-	c.tsw.WriteLinef("  new Set([%s]),", c.collectInterfaceMethods(t))
-	c.tsw.WriteLinef(");")
+	// First add the direct fields and track embedded types
+	for i := 0; i < underlying.NumFields(); i++ {
+		field := underlying.Field(i)
+		fieldName := field.Name()
 
-	return nil
+		if !field.Exported() && field.Pkg() != c.pkg.Types {
+			continue
+		}
+
+		if field.Anonymous() {
+			fieldType := field.Type()
+			isPtr := false
+			if ptr, ok := fieldType.(*types.Pointer); ok {
+				fieldType = ptr.Elem()
+				isPtr = true
+			}
+
+			if named, ok := fieldType.(*types.Named); ok {
+				embeddedName := named.Obj().Name()
+				// For embedded structs, the init type should allow providing fields of the embedded struct,
+				// or the embedded struct itself.
+				// We generate Partial<EmbeddedStructFields> | EmbeddedStructType
+				// This is complex. For now, let's use ConstructorParameters as before for simplicity,
+				// or allow the embedded struct type itself.
+				// The example `Person?: ConstructorParameters<typeof Person>[0]` is for the fields.
+				// Let's try to generate a type that allows either the embedded struct instance or its fields.
+				// This might be: `Partial<FlattenedInitType<EmbeddedName>> | EmbeddedName`
+				// For now, stick to the simpler `ConstructorParameters<typeof %s>[0]` which implies field-based init.
+				// Or, more simply, the type of the embedded struct itself if it's a pointer.
+				if isPtr {
+					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = c.getTypeString(field.Type()) // MyEmbeddedType | null
+				} else {
+					// For value-type embedded structs, allow initializing with its fields.
+					// This requires getting the flattened init type for the embedded struct.
+					// This could lead to recursion if not handled carefully.
+					// A simpler approach for now: use the embedded struct's own type.
+					// embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = c.getTypeString(field.Type())
+					// Or, using ConstructorParameters to allow field-based initialization:
+					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = fmt.Sprintf("Partial<ConstructorParameters<typeof %s>[0]>", embeddedName)
+				}
+			}
+			continue
+		}
+		fieldMap[fieldName] = c.getTypeString(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)
+	for embeddedName, embeddedTSType := range embeddedTypeMap {
+		fieldMap[embeddedName] = embeddedTSType
+	}
+
+	var fieldNames []string
+	for name := range fieldMap {
+		fieldNames = append(fieldNames, name)
+	}
+	sort.Strings(fieldNames)
+
+	var fieldDefs []string
+	for _, fieldName := range fieldNames {
+		fieldDefs = append(fieldDefs, fmt.Sprintf("%s?: %s", fieldName, fieldMap[fieldName]))
+	}
+
+	return "{" + strings.Join(fieldDefs, ", ") + "}"
 }