goscript 0.0.48 → 0.0.50

package/compiler/spec.go

@@ -92,123 +92,240 @@ 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
+		c.writeRegularFieldInitializer(fieldName, fieldType, astType)
+	}
+
+	c.tsw.WriteLiterally(")")
+}
+
+func (c *GoToTSCompiler) writeEmbeddedFieldInitializer(fieldName string, fieldType types.Type) {
+	_, isPtr := fieldType.(*types.Pointer)
+	_, isInterface := fieldType.Underlying().(*types.Interface)
+
+	if isPtr || isInterface {
+		c.tsw.WriteLiterallyf("init?.%s ?? null", fieldName)
+		return
+	}
+
+	// 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)
+
+	// Debug for Mode field specifically
+	if fieldName == "Mode" {
+		fmt.Printf("DEBUG Mode field: Type=%T, String=%s\n", fieldType, fieldType.String())
+	}
+
+	// Priority 1: Check if this is a wrapper type
+	if c.analysis.IsNamedBasicType(fieldType) {
+		// For wrapper types, use the zero value of the underlying type with type casting
 		if named, ok := fieldType.(*types.Named); ok {
-			if _, isStruct := named.Underlying().(*types.Struct); isStruct {
-				isStructValueType = true
-				structTypeNameForClone = c.getTypeString(fieldType)
-			}
+			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 {
+			// Fallback to original behavior
+			c.WriteZeroValueForType(fieldType)
 		}
+		return
+	}
 
-		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)
-			}
+	// Priority 2: Handle imported types with basic underlying types (like os.FileMode)
+	if c.isImportedBasicType(fieldType) {
+		if fieldName == "Mode" {
+			fmt.Printf("DEBUG Mode field: Using imported basic type zero value\n")
 		}
+		c.writeImportedBasicTypeZeroValue(fieldType)
+		return
 	}
 
-	c.tsw.WriteLiterally(")")
+	// Priority 3: Handle named types
+	if named, isNamed := fieldType.(*types.Named); isNamed {
+		if fieldName == "Mode" {
+			fmt.Printf("DEBUG Mode field: Using named type zero value\n")
+		}
+		c.writeNamedTypeZeroValue(named)
+		return
+	}
+
+	// Priority 4: Handle type aliases
+	if alias, isAlias := fieldType.(*types.Alias); isAlias {
+		if fieldName == "Mode" {
+			fmt.Printf("DEBUG Mode field: Using type alias zero value\n")
+		}
+		c.writeTypeAliasZeroValue(alias, astType)
+		return
+	}
+
+	// Default: use WriteZeroValueForType
+	if fieldName == "Mode" {
+		fmt.Printf("DEBUG Mode field: Using default WriteZeroValueForType\n")
+	}
+	c.WriteZeroValueForType(fieldType)
 }
 
-func (c *GoToTSCompiler) writeClonedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
-	c.tsw.WriteLiterally(fieldName)
-	c.tsw.WriteLiterally(": $.varRef(")
+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
+}
 
-	if isEmbedded {
-		isPointerToStruct := false
-		trueType := fieldType
-		if ptr, isPtr := trueType.(*types.Pointer); isPtr {
-			trueType = ptr.Elem()
-			isPointerToStruct = true
+func (c *GoToTSCompiler) isImportedBasicType(fieldType types.Type) bool {
+	// Handle named types
+	if named, isNamed := fieldType.(*types.Named); isNamed {
+		obj := named.Obj()
+		if obj == nil || obj.Pkg() == nil || obj.Pkg() == c.pkg.Types {
+			return false // Not imported or is local
 		}
 
-		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)
+		underlying := named.Underlying()
+		if underlying == nil {
+			return false
 		}
-	} else {
-		isValueTypeStruct := false
-		if named, ok := fieldType.(*types.Named); ok {
-			if _, isStruct := named.Underlying().(*types.Struct); isStruct {
-				isValueTypeStruct = true
-			}
+
+		_, isBasic := underlying.(*types.Basic)
+		return isBasic
+	}
+
+	// Handle type aliases (like os.FileMode = fs.FileMode)
+	if alias, isAlias := fieldType.(*types.Alias); isAlias {
+		obj := alias.Obj()
+		if obj == nil || obj.Pkg() == nil || obj.Pkg() == c.pkg.Types {
+			return false // Not imported or is local
 		}
 
-		if isValueTypeStruct {
-			c.tsw.WriteLiterallyf("this._fields.%s.value?.clone() ?? null", fieldName)
-		} else {
-			c.tsw.WriteLiterallyf("this._fields.%s.value", fieldName)
+		underlying := alias.Underlying()
+		if underlying == nil {
+			return false
 		}
+
+		_, isBasic := underlying.(*types.Basic)
+		return isBasic
+	}
+
+	return false
+}
+
+func (c *GoToTSCompiler) writeImportedBasicTypeZeroValue(fieldType types.Type) {
+	if named, ok := fieldType.(*types.Named); ok {
+		underlying := named.Underlying()
+		fmt.Printf("DEBUG writeImportedBasicTypeZeroValue: Named type, underlying=%T\n", underlying)
+		// Write zero value of underlying type with type casting
+		c.WriteZeroValueForType(underlying)
+		c.tsw.WriteLiterally(" as ")
+		c.WriteGoType(fieldType, GoTypeContextGeneral)
+		return
+	}
+
+	if alias, ok := fieldType.(*types.Alias); ok {
+		underlying := alias.Underlying()
+		fmt.Printf("DEBUG writeImportedBasicTypeZeroValue: Alias type, underlying=%T\n", underlying)
+		// Write zero value of underlying type with type casting
+		c.WriteZeroValueForType(underlying)
+		c.tsw.WriteLiterally(" as ")
+		c.WriteGoType(fieldType, GoTypeContextGeneral)
+		return
+	}
+
+	// Fallback (should not happen if isImportedBasicType was correct)
+	fmt.Printf("DEBUG writeImportedBasicTypeZeroValue: Fallback path\n")
+	c.WriteZeroValueForType(fieldType)
+}
+
+func (c *GoToTSCompiler) writeNamedTypeZeroValue(named *types.Named) {
+	// Check if this is a wrapper type first
+	if c.analysis.IsNamedBasicType(named) {
+		// For wrapper types, use the zero value of the underlying type with type casting
+		c.WriteZeroValueForType(named.Underlying())
+		c.tsw.WriteLiterally(" as ")
+		c.WriteGoType(named, GoTypeContextGeneral)
+		return
+	}
+
+	// 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 this is a wrapper type first
+	if c.analysis.IsNamedBasicType(alias) {
+		// For wrapper types, use the zero value of the underlying type with type casting
+		c.WriteZeroValueForType(alias.Underlying())
+		c.tsw.WriteLiterally(" as ")
+		c.WriteGoType(alias, GoTypeContextGeneral)
+		return
+	}
+
+	// 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 +361,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 +379,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 +412,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 +661,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(")")
+}

package/compiler/stmt-assign.go

@@ -117,6 +117,8 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 					}
 				}
 				c.tsw.WriteLiterally("] = ")
+				// Add await if the call is async
+				c.writeAsyncCallIfNeeded(callExpr)
 				c.WriteValueExpr(callExpr)
 				c.tsw.WriteLine("")
 				return nil
@@ -165,6 +167,8 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 
 			// Write a temporary variable to hold the function call result
 			c.tsw.WriteLiterally("  const _tmp = ")
+			// Add await if the call is async
+			c.writeAsyncCallIfNeeded(callExpr)
 			if err := c.WriteValueExpr(callExpr); err != nil {
 				return fmt.Errorf("failed to write RHS call expression in assignment: %w", err)
 			}
@@ -287,10 +291,9 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 		}
 		c.tsw.WriteLiterally("] = ")
 
-		// Write the right-hand side (the function call)
-		if err := c.WriteValueExpr(callExpr); err != nil {
-			return fmt.Errorf("failed to write RHS call expression in assignment: %w", err)
-		}
+		// Add await if the call is async
+		c.writeAsyncCallIfNeeded(callExpr)
+		c.WriteValueExpr(callExpr)
 
 		c.tsw.WriteLine("")
 		return nil