goscript 0.0.47 → 0.0.49

package/compiler/spec.go

@@ -92,123 +92,196 @@ func (c *GoToTSCompiler) writeVarRefedFieldInitializer(fieldName string, fieldTy
 	c.tsw.WriteLiterally(": $.varRef(")
 
 	if isEmbedded {
-		_, isPtr := fieldType.(*types.Pointer)
-		_, isInterface := fieldType.Underlying().(*types.Interface)
-		if isPtr || isInterface {
-			c.tsw.WriteLiterallyf("init?.%s ?? null", fieldName)
-		} else {
-			// Check if the embedded type is an interface
-			embeddedTypeUnderlying := fieldType
-			if named, isNamed := embeddedTypeUnderlying.(*types.Named); isNamed {
-				embeddedTypeUnderlying = named.Underlying()
-			}
-			if _, isInterface := embeddedTypeUnderlying.(*types.Interface); isInterface {
-				// For interfaces, use the provided value or null instead of trying to instantiate
-				c.tsw.WriteLiterallyf("init?.%s ?? null", fieldName)
-			} else {
-				// For structs, instantiate with provided fields
-				typeForNew := fieldName
-				c.tsw.WriteLiterallyf("new %s(init?.%s)", typeForNew, fieldName)
-			}
-		}
+		c.writeEmbeddedFieldInitializer(fieldName, fieldType)
 	} else {
-		isStructValueType := false
-		var structTypeNameForClone string
-		if named, ok := fieldType.(*types.Named); ok {
-			if _, isStruct := named.Underlying().(*types.Struct); isStruct {
-				isStructValueType = true
-				structTypeNameForClone = c.getTypeString(fieldType)
-			}
-		}
-
-		if isStructValueType {
-			c.tsw.WriteLiterallyf("init?.%s?.clone() ?? new %s()", fieldName, structTypeNameForClone)
-		} else {
-			c.tsw.WriteLiterallyf("init?.%s ?? ", fieldName)
-			// Check if this is a named type or type alias and use constructor instead of null
-			if named, isNamed := fieldType.(*types.Named); isNamed {
-				// This is a named type
-				// Check if underlying type is an interface
-				if _, isInterface := named.Underlying().(*types.Interface); isInterface {
-					// For interfaces, use null as the zero value
-					c.tsw.WriteLiterally("null")
-				} else if _, isStruct := named.Underlying().(*types.Struct); !isStruct {
-					// For non-struct, non-interface named types, use constructor
-					c.tsw.WriteLiterally("new ")
-					c.WriteNamedType(named)
-					c.tsw.WriteLiterally("(")
-					c.WriteZeroValueForType(named.Underlying())
-					c.tsw.WriteLiterally(")")
-				} else {
-					c.WriteZeroValueForType(fieldType)
-				}
-			} else if alias, isAlias := fieldType.(*types.Alias); isAlias {
-				// This is a type alias (like os.FileMode)
-				// Check if underlying type is an interface
-				if _, isInterface := alias.Underlying().(*types.Interface); isInterface {
-					// For interface type aliases, use null as the zero value
-					c.tsw.WriteLiterally("null")
-				} else if _, isStruct := alias.Underlying().(*types.Struct); !isStruct {
-					// For non-struct, non-interface type aliases, use constructor
-					c.tsw.WriteLiterally("new ")
-					// Use AST type information if available to preserve qualified names
-					if astType != nil {
-						c.WriteTypeExpr(astType)
-					} else {
-						c.WriteGoType(fieldType, GoTypeContextGeneral)
-					}
-					c.tsw.WriteLiterally("(")
-					c.WriteZeroValueForType(alias.Underlying())
-					c.tsw.WriteLiterally(")")
-				} else {
-					c.WriteZeroValueForType(fieldType)
-				}
-			} else {
-				c.WriteZeroValueForType(fieldType)
-			}
-		}
+		c.writeRegularFieldInitializer(fieldName, fieldType, astType)
 	}
 
 	c.tsw.WriteLiterally(")")
 }
 
-func (c *GoToTSCompiler) writeClonedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
-	c.tsw.WriteLiterally(fieldName)
-	c.tsw.WriteLiterally(": $.varRef(")
+func (c *GoToTSCompiler) writeEmbeddedFieldInitializer(fieldName string, fieldType types.Type) {
+	_, isPtr := fieldType.(*types.Pointer)
+	_, isInterface := fieldType.Underlying().(*types.Interface)
 
-	if isEmbedded {
-		isPointerToStruct := false
-		trueType := fieldType
-		if ptr, isPtr := trueType.(*types.Pointer); isPtr {
-			trueType = ptr.Elem()
-			isPointerToStruct = true
-		}
+	if isPtr || isInterface {
+		c.tsw.WriteLiterallyf("init?.%s ?? null", fieldName)
+		return
+	}
 
-		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)
+	// Check if the embedded type is an interface
+	embeddedTypeUnderlying := fieldType
+	if named, isNamed := embeddedTypeUnderlying.(*types.Named); isNamed {
+		embeddedTypeUnderlying = named.Underlying()
+	}
+
+	if _, isInterface := embeddedTypeUnderlying.(*types.Interface); isInterface {
+		// For interfaces, use the provided value or null instead of trying to instantiate
+		c.tsw.WriteLiterallyf("init?.%s ?? null", fieldName)
+		return
+	}
+
+	// For structs, instantiate with provided fields
+	typeForNew := fieldName
+	c.tsw.WriteLiterallyf("new %s(init?.%s)", typeForNew, fieldName)
+}
+
+func (c *GoToTSCompiler) writeRegularFieldInitializer(fieldName string, fieldType types.Type, astType ast.Expr) {
+	// Check if this is a struct value type that needs cloning
+	if c.isStructValueType(fieldType) {
+		structTypeNameForClone := c.getTypeString(fieldType)
+		c.tsw.WriteLiterallyf("init?.%s?.clone() ?? new %s()", fieldName, structTypeNameForClone)
+		return
+	}
+
+	c.tsw.WriteLiterallyf("init?.%s ?? ", fieldName)
+
+	// Debugging: print field type info
+	if astType != nil {
+		if named, ok := fieldType.(*types.Named); ok {
+			if pkgPath := named.Obj().Pkg().Path(); pkgPath != "" {
+				c.tsw.WriteCommentLinef("DEBUG: Field %s has type %s (%T)", fieldName, fieldType, fieldType)
 			}
 		} else {
-			c.tsw.WriteLiterallyf("this._fields.%s.value", fieldName)
+			c.tsw.WriteCommentLinef("DEBUG: Field %s has type %s (%T)", fieldName, fieldType, fieldType)
 		}
-	} else {
-		isValueTypeStruct := false
-		if named, ok := fieldType.(*types.Named); ok {
-			if _, isStruct := named.Underlying().(*types.Struct); isStruct {
-				isValueTypeStruct = true
+		if typeName, ok := c.pkg.TypesInfo.TypeOf(astType).(*types.Named); ok {
+			pkgPath := ""
+			if typeName.Obj().Pkg() != nil {
+				pkgPath = typeName.Obj().Pkg().Path()
 			}
+			c.tsw.WriteCommentLinef("DEBUG: Package=%s, TypeName=%s", pkgPath, typeName)
 		}
+	}
 
-		if isValueTypeStruct {
-			c.tsw.WriteLiterallyf("this._fields.%s.value?.clone() ?? null", fieldName)
+	// Priority 1: Check if this is a wrapper type
+	if c.analysis.IsWrapperType(fieldType) {
+		c.tsw.WriteCommentLinef("DEBUG: Using wrapper type zero value")
+		// For wrapper types, use the zero value of the underlying type with type casting
+		if named, ok := fieldType.(*types.Named); ok {
+			c.WriteZeroValueForType(named.Underlying())
+			c.tsw.WriteLiterally(" as ")
+			c.WriteGoType(fieldType, GoTypeContextGeneral)
+		} else if alias, ok := fieldType.(*types.Alias); ok {
+			c.WriteZeroValueForType(alias.Underlying())
+			c.tsw.WriteLiterally(" as ")
+			c.WriteGoType(fieldType, GoTypeContextGeneral)
 		} else {
-			c.tsw.WriteLiterallyf("this._fields.%s.value", fieldName)
+			// Fallback to original behavior
+			c.WriteZeroValueForType(fieldType)
 		}
+		return
+	}
+
+	// Priority 2: Handle imported types with basic underlying types (like os.FileMode)
+	if c.isImportedBasicType(fieldType) {
+		c.tsw.WriteCommentLinef("DEBUG: Using imported basic type zero value")
+		c.writeImportedBasicTypeZeroValue(fieldType)
+		return
+	}
+
+	// Priority 3: Handle named types
+	if named, isNamed := fieldType.(*types.Named); isNamed {
+		c.tsw.WriteCommentLinef("DEBUG: Using named type zero value")
+		c.writeNamedTypeZeroValue(named)
+		return
+	}
+
+	// Priority 4: Handle type aliases
+	if alias, isAlias := fieldType.(*types.Alias); isAlias {
+		c.tsw.WriteCommentLinef("DEBUG: Using type alias zero value")
+		c.writeTypeAliasZeroValue(alias, astType)
+		return
+	}
+
+	// Default: use WriteZeroValueForType
+	c.tsw.WriteCommentLinef("DEBUG: Using default zero value")
+	c.WriteZeroValueForType(fieldType)
+}
+
+func (c *GoToTSCompiler) isStructValueType(fieldType types.Type) bool {
+	if named, ok := fieldType.(*types.Named); ok {
+		if _, isStruct := named.Underlying().(*types.Struct); isStruct {
+			return true
+		}
+	}
+	return false
+}
+
+func (c *GoToTSCompiler) isImportedBasicType(fieldType types.Type) bool {
+	named, isNamed := fieldType.(*types.Named)
+	if !isNamed {
+		return false
+	}
+
+	obj := named.Obj()
+	if obj == nil || obj.Pkg() == nil || obj.Pkg() == c.pkg.Types {
+		return false // Not imported or is local
+	}
+
+	underlying := named.Underlying()
+	if underlying == nil {
+		return false
 	}
 
+	_, isBasic := underlying.(*types.Basic)
+	return isBasic
+}
+
+func (c *GoToTSCompiler) writeImportedBasicTypeZeroValue(fieldType types.Type) {
+	named := fieldType.(*types.Named)
+	underlying := named.Underlying()
+
+	// Write zero value of underlying type with type casting
+	c.WriteZeroValueForType(underlying)
+	c.tsw.WriteLiterally(" as ")
+	c.WriteGoType(fieldType, GoTypeContextGeneral)
+}
+
+func (c *GoToTSCompiler) writeNamedTypeZeroValue(named *types.Named) {
+	// Check if underlying type is an interface
+	if _, isInterface := named.Underlying().(*types.Interface); isInterface {
+		c.tsw.WriteLiterally("null")
+		return
+	}
+
+	// Check if underlying type is a struct
+	if _, isStruct := named.Underlying().(*types.Struct); isStruct {
+		c.WriteZeroValueForType(named)
+		return
+	}
+
+	// For non-struct, non-interface named types, use constructor
+	c.tsw.WriteLiterally("new ")
+	c.WriteNamedType(named)
+	c.tsw.WriteLiterally("(")
+	c.WriteZeroValueForType(named.Underlying())
+	c.tsw.WriteLiterally(")")
+}
+
+func (c *GoToTSCompiler) writeTypeAliasZeroValue(alias *types.Alias, astType ast.Expr) {
+	// Check if underlying type is an interface
+	if _, isInterface := alias.Underlying().(*types.Interface); isInterface {
+		c.tsw.WriteLiterally("null")
+		return
+	}
+
+	// Check if underlying type is a struct
+	if _, isStruct := alias.Underlying().(*types.Struct); isStruct {
+		c.WriteZeroValueForType(alias)
+		return
+	}
+
+	// For non-struct, non-interface type aliases, use constructor
+	c.tsw.WriteLiterally("new ")
+	// Use AST type information if available to preserve qualified names
+	if astType != nil {
+		c.WriteTypeExpr(astType)
+	} else {
+		c.WriteGoType(alias, GoTypeContextGeneral)
+	}
+	c.tsw.WriteLiterally("(")
+	c.WriteZeroValueForType(alias.Underlying())
 	c.tsw.WriteLiterally(")")
 }
 
@@ -244,7 +317,11 @@ func (c *GoToTSCompiler) hasReceiverMethods(typeName string) bool {
 	return false
 }
 
-// WriteNamedTypeWithMethods generates a TypeScript class for a Go named type that has receiver methods
+// WriteNamedTypeWithMethods generates TypeScript code for Go named types that have methods.
+// Instead of generating a class, it now generates:
+// 1. A type alias for the underlying type
+// 2. Function declarations for each method (TypeName_MethodName)
+// 3. Function implementations for each method
 func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 	className := a.Name.Name
 
@@ -258,49 +335,16 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 		c.tsw.WriteLiterally("export ")
 	}
 
-	c.tsw.WriteLiterallyf("class %s {", className)
-	c.tsw.WriteLine("")
-	c.tsw.Indent(1)
-
-	// Constructor that takes the underlying type value
-	c.tsw.WriteLiterally("constructor(private _value: ")
-	// Use AST-based type writing to preserve qualified names like os.FileInfo
-	c.WriteTypeExpr(a.Type)
-	c.tsw.WriteLine(") {}")
-	c.tsw.WriteLine("")
-
-	// valueOf method to get the underlying value (for type conversions and operations)
-	c.tsw.WriteLiterally("valueOf(): ")
-	// Use AST-based type writing to preserve qualified names like os.FileInfo
-	c.WriteTypeExpr(a.Type)
-	c.tsw.WriteLine(" {")
-	c.tsw.Indent(1)
-	c.tsw.WriteLine("return this._value")
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-	c.tsw.WriteLine("")
-
-	// toString method for string conversion
-	c.tsw.WriteLine("toString(): string {")
-	c.tsw.Indent(1)
-	c.tsw.WriteLine("return String(this._value)")
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-	c.tsw.WriteLine("")
-
-	// Static from method for type conversion
-	c.tsw.WriteLiterallyf("static from(value: ")
+	// Generate type alias instead of class
+	c.tsw.WriteLiterally("type ")
+	c.tsw.WriteLiterally(className)
+	c.tsw.WriteLiterally(" = ")
 	// Use AST-based type writing to preserve qualified names like os.FileInfo
 	c.WriteTypeExpr(a.Type)
-	c.tsw.WriteLiterallyf("): %s {", className)
-	c.tsw.WriteLine("")
-	c.tsw.Indent(1)
-	c.tsw.WriteLiterallyf("return new %s(value)", className)
+	c.tsw.WriteLine(";")
 	c.tsw.WriteLine("")
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
 
-	// Add receiver methods for this type
+	// Generate function declarations and implementations for each method
 	for _, fileSyntax := range c.pkg.Syntax {
 		for _, decl := range fileSyntax.Decls {
 			funcDecl, isFunc := decl.(*ast.FuncDecl)
@@ -324,28 +368,86 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 			}
 
 			if recvTypeName == className {
-				c.tsw.WriteLine("")
-				if err := c.writeNamedTypeMethod(funcDecl); err != nil {
+				if !isInsideFunction {
+					c.tsw.WriteLiterally("export ")
+				}
+
+				// Generate function signature: export function TypeName_MethodName(receiver: TypeName, ...args): ReturnType
+				c.tsw.WriteLiterally("function ")
+				c.tsw.WriteLiterally(className)
+				c.tsw.WriteLiterally("_")
+				c.tsw.WriteLiterally(funcDecl.Name.Name)
+				c.tsw.WriteLiterally("(")
+
+				// First parameter is the receiver - use the original receiver parameter name
+				var receiverParamName string = "receiver" // default fallback
+				if funcDecl.Recv != nil && len(funcDecl.Recv.List) > 0 {
+					if len(funcDecl.Recv.List[0].Names) > 0 {
+						if name := funcDecl.Recv.List[0].Names[0]; name != nil && name.Name != "_" {
+							receiverParamName = name.Name
+						}
+					}
+				}
+				c.tsw.WriteLiterally(receiverParamName)
+				c.tsw.WriteLiterally(": ")
+				c.tsw.WriteLiterally(className)
+
+				// Add other parameters
+				if funcDecl.Type.Params != nil && len(funcDecl.Type.Params.List) > 0 {
+					c.tsw.WriteLiterally(", ")
+					c.WriteFieldList(funcDecl.Type.Params, true) // true = arguments
+				}
+
+				c.tsw.WriteLiterally(")")
+
+				// Add return type
+				if funcDecl.Type.Results != nil && len(funcDecl.Type.Results.List) > 0 {
+					c.tsw.WriteLiterally(": ")
+					if len(funcDecl.Type.Results.List) == 1 {
+						c.WriteTypeExpr(funcDecl.Type.Results.List[0].Type)
+					} else {
+						c.tsw.WriteLiterally("[")
+						for i, field := range funcDecl.Type.Results.List {
+							if i > 0 {
+								c.tsw.WriteLiterally(", ")
+							}
+							c.WriteTypeExpr(field.Type)
+						}
+						c.tsw.WriteLiterally("]")
+					}
+				} else {
+					c.tsw.WriteLiterally(": void")
+				}
+
+				c.tsw.WriteLine(" {")
+				c.tsw.Indent(1)
+
+				// Write method body with receiver as first parameter
+				if err := c.writeWrapperFunctionBody(funcDecl, className); err != nil {
 					return err
 				}
+
+				c.tsw.Indent(-1)
+				c.tsw.WriteLine("}")
+				c.tsw.WriteLine("")
 			}
 		}
 	}
 
-	c.tsw.Indent(-1)
-	c.tsw.WriteLine("}")
-
 	return nil
 }
 
-// writeNamedTypeMethod writes a method for a named type, handling receiver binding properly
-func (c *GoToTSCompiler) writeNamedTypeMethod(decl *ast.FuncDecl) error {
-	_, err := c.writeMethodSignature(decl)
-	if err != nil {
-		return err
+// writeWrapperFunctionBody writes the body of a wrapper function, treating the receiver as the first parameter
+func (c *GoToTSCompiler) writeWrapperFunctionBody(decl *ast.FuncDecl, typeName string) error {
+	// Write function body statements directly - identifier mapping is handled by pre-computed analysis
+	if decl.Body != nil {
+		for _, stmt := range decl.Body.List {
+			if err := c.WriteStmt(stmt); err != nil {
+				return err
+			}
+		}
 	}
-
-	return c.writeMethodBodyWithReceiverBinding(decl, "this._value")
+	return nil
 }
 
 // WriteTypeSpec writes the type specification to the output.
@@ -515,3 +617,43 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 
 	c.tsw.WriteImport(impName, tsImportPath+"/index.js")
 }
+
+func (c *GoToTSCompiler) writeClonedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
+	c.tsw.WriteLiterally(fieldName)
+	c.tsw.WriteLiterally(": $.varRef(")
+
+	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(")")
+}