goscript 0.0.22 → 0.0.23

package/compiler/type.go

@@ -4,17 +4,34 @@ import (
 	"fmt"
 	"go/ast"
 	"go/types"
-	"sort"
 	"strings"
 )
 
+// GoTypeContext specifies the context in which a Go type is being translated to TypeScript.
+// This affects how certain types (especially pointers) are handled.
+type GoTypeContext int
+
+const (
+	// GoTypeContextGeneral is used for general type translation
+	GoTypeContextGeneral GoTypeContext = iota
+	// GoTypeContextFunctionReturn is used when translating types for function return values.
+	// In this context, pointer-to-struct types become `ClassName | null` instead of
+	// `$.Box<ClassName> | null` because function return values cannot be addressed.
+	GoTypeContextFunctionReturn
+)
+
 // WriteGoType is the main dispatcher for translating Go types to their TypeScript
 // equivalents. It examines the type and delegates to more specialized type writer
 // functions based on the specific Go type encountered.
 //
+// The context parameter controls how certain types (especially pointers) are handled:
+//   - GoTypeContextGeneral: Standard type translation
+//   - GoTypeContextFunctionReturn: Special handling for function return types where
+//     pointer-to-struct types become `ClassName | null` instead of `$.Box<ClassName> | null`
+//
 // It handles nil types as 'any' with a comment, and dispatches to appropriate
 // type-specific writers for all other recognized Go types.
-func (c *GoToTSCompiler) WriteGoType(typ types.Type) {
+func (c *GoToTSCompiler) WriteGoType(typ types.Type, context GoTypeContext) {
 	if typ == nil {
 		c.tsw.WriteLiterally("any")
 		c.tsw.WriteCommentInline("nil type")
@@ -27,7 +44,11 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type) {
 	case *types.Named:
 		c.WriteNamedType(t)
 	case *types.Pointer:
-		c.WritePointerType(t)
+		if context == GoTypeContextFunctionReturn {
+			c.writePointerTypeForFunctionReturn(t)
+		} else {
+			c.WritePointerType(t)
+		}
 	case *types.Slice:
 		c.WriteSliceType(t)
 	case *types.Array:
@@ -43,7 +64,10 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type) {
 	case *types.Struct:
 		c.WriteStructType(t)
 	case *types.Alias:
-		c.WriteGoType(t.Underlying())
+		c.WriteGoType(t.Underlying(), context)
+	case *types.TypeParam:
+		// For type parameters, write the type parameter name (e.g., "T", "K", etc.)
+		c.tsw.WriteLiterally(t.Obj().Name())
 	default:
 		// For other types, just write "any" and add a comment
 		c.tsw.WriteLiterally("any")
@@ -51,12 +75,38 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type) {
 	}
 }
 
+// writePointerTypeForFunctionReturn translates a Go pointer type (*T) to its TypeScript
+// equivalent for function return types. Unlike WritePointerType, this function
+// handles pointer-to-struct types specially: they become `ClassName | null` instead
+// of `$.Box<ClassName> | null` because function return values cannot be addressed.
+func (c *GoToTSCompiler) writePointerTypeForFunctionReturn(t *types.Pointer) {
+	elemType := t.Elem()
+
+	// Check if the element type is a struct (directly or via a named type)
+	isStructType := false
+	if _, ok := elemType.Underlying().(*types.Struct); ok {
+		isStructType = true
+	}
+
+	if isStructType {
+		// For pointer-to-struct in function returns, generate ClassName | null
+		c.WriteGoType(elemType, GoTypeContextFunctionReturn)
+		c.tsw.WriteLiterally(" | null")
+	} else {
+		// For pointer-to-primitive in function returns, still use boxing
+		c.tsw.WriteLiterally("$.Box<")
+		c.WriteGoType(elemType, GoTypeContextFunctionReturn)
+		c.tsw.WriteLiterally("> | null")
+	}
+}
+
 // WriteZeroValueForType writes the TypeScript representation of the zero value
 // for a given Go type.
 // It handles `types.Array` by recursively writing zero values for each element
 // to form a TypeScript array literal (e.g., `[0, 0, 0]`).
 // For `types.Basic` (like `bool`, `string`, numeric types), it writes the
 // corresponding TypeScript zero value (`false`, `""`, `0`).
+// For `[]byte`, it writes `new Uint8Array(0)`.
 // Other types default to `null`. This function is primarily used for initializing
 // arrays and variables where an explicit initializer is absent.
 func (c *GoToTSCompiler) WriteZeroValueForType(typ any) {
@@ -97,9 +147,21 @@ func (c *GoToTSCompiler) WriteZeroValueForType(typ any) {
 		}
 		// For other named types, use the zero value of the underlying type
 		c.WriteZeroValueForType(t.Underlying())
+	case *types.Slice:
+		// Check if it's a []byte slice
+		if elem, ok := t.Elem().(*types.Basic); ok && elem.Kind() == types.Uint8 {
+			c.tsw.WriteLiterally("new Uint8Array(0)")
+			return
+		}
+		// For other slice types, default to null
+		c.tsw.WriteLiterally("null")
 	case *types.Struct:
 		// For anonymous struct types, initialize with {}
 		c.tsw.WriteLiterally("{}")
+	case *types.TypeParam:
+		// For type parameters, use null! (non-null assertion) to avoid TypeScript
+		// casting errors with union types like string | Uint8Array
+		c.tsw.WriteLiterally("null!")
 	default:
 		c.tsw.WriteLiterally("null")
 	}
@@ -140,14 +202,27 @@ func (c *GoToTSCompiler) WriteBasicType(t *types.Basic) {
 
 // WriteNamedType translates a Go named type to its TypeScript equivalent.
 // It specially handles the error interface as $.GoError, and uses the original
-// type name for other named types.
+// type name for other named types. For generic types, it includes type arguments.
 func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 	// Check if the named type is the error interface
 	if iface, ok := t.Underlying().(*types.Interface); ok && iface.String() == "interface{Error() string}" {
 		c.tsw.WriteLiterally("$.GoError")
-	} else {
-		// Use Obj().Name() for the original defined name
-		c.tsw.WriteLiterally(t.Obj().Name())
+		return
+	}
+
+	// Use Obj().Name() for the original defined name
+	c.tsw.WriteLiterally(t.Obj().Name())
+
+	// For generic types, include type arguments
+	if t.TypeArgs() != nil && t.TypeArgs().Len() > 0 {
+		c.tsw.WriteLiterally("<")
+		for i := 0; i < t.TypeArgs().Len(); i++ {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.WriteGoType(t.TypeArgs().At(i), GoTypeContextGeneral)
+		}
+		c.tsw.WriteLiterally(">")
 	}
 }
 
@@ -155,22 +230,28 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 // It generates $.Box<T_ts> | null, where T_ts is the translated element type.
 func (c *GoToTSCompiler) WritePointerType(t *types.Pointer) {
 	c.tsw.WriteLiterally("$.Box<")
-	c.WriteGoType(t.Elem())
+	c.WriteGoType(t.Elem(), GoTypeContextGeneral)
 	c.tsw.WriteLiterally("> | null") // Pointers are always nullable
 }
 
 // WriteSliceType translates a Go slice type ([]T) to its TypeScript equivalent.
 // It generates $.Slice<T_ts>, where T_ts is the translated element type.
+// For []byte, it generates Uint8Array.
 func (c *GoToTSCompiler) WriteSliceType(t *types.Slice) {
+	// Check if it's a []byte slice
+	if elem, ok := t.Elem().(*types.Basic); ok && elem.Kind() == types.Uint8 {
+		c.tsw.WriteLiterally("Uint8Array")
+		return
+	}
 	c.tsw.WriteLiterally("$.Slice<")
-	c.WriteGoType(t.Elem())
+	c.WriteGoType(t.Elem(), GoTypeContextGeneral)
 	c.tsw.WriteLiterally(">")
 }
 
 // WriteArrayType translates a Go array type ([N]T) to its TypeScript equivalent.
 // It generates T_ts[], where T_ts is the translated element type.
 func (c *GoToTSCompiler) WriteArrayType(t *types.Array) {
-	c.WriteGoType(t.Elem())
+	c.WriteGoType(t.Elem(), GoTypeContextGeneral)
 	c.tsw.WriteLiterally("[]") // Arrays cannot be nil
 }
 
@@ -179,18 +260,19 @@ func (c *GoToTSCompiler) WriteArrayType(t *types.Array) {
 // and element types respectively.
 func (c *GoToTSCompiler) WriteMapType(t *types.Map) {
 	c.tsw.WriteLiterally("Map<")
-	c.WriteGoType(t.Key())
+	c.WriteGoType(t.Key(), GoTypeContextGeneral)
 	c.tsw.WriteLiterally(", ")
-	c.WriteGoType(t.Elem())
+	c.WriteGoType(t.Elem(), GoTypeContextGeneral)
 	c.tsw.WriteLiterally(">")
 }
 
 // WriteChannelType translates a Go channel type (chan T) to its TypeScript equivalent.
-// It generates $.Channel<T_ts>, where T_ts is the translated element type.
+// It generates $.Channel<T_ts> | null, where T_ts is the translated element type.
+// Channels are nilable in Go, so they are represented as nullable types in TypeScript.
 func (c *GoToTSCompiler) WriteChannelType(t *types.Chan) {
 	c.tsw.WriteLiterally("$.Channel<")
-	c.WriteGoType(t.Elem())
-	c.tsw.WriteLiterally(">")
+	c.WriteGoType(t.Elem(), GoTypeContextGeneral)
+	c.tsw.WriteLiterally("> | null")
 }
 
 // WriteFuncType translates a Go function type (`ast.FuncType`) into a TypeScript
@@ -217,7 +299,7 @@ func (c *GoToTSCompiler) WriteFuncType(exp *ast.FuncType, isAsync bool) {
 		if len(exp.Results.List) == 1 && len(exp.Results.List[0].Names) == 0 {
 			// Single unnamed return type
 			typ := c.pkg.TypesInfo.TypeOf(exp.Results.List[0].Type)
-			c.WriteGoType(typ)
+			c.WriteGoType(typ, GoTypeContextFunctionReturn)
 		} else {
 			// Multiple or named return types -> tuple
 			c.tsw.WriteLiterally("[")
@@ -226,7 +308,7 @@ func (c *GoToTSCompiler) WriteFuncType(exp *ast.FuncType, isAsync bool) {
 					c.tsw.WriteLiterally(", ")
 				}
 				typ := c.pkg.TypesInfo.TypeOf(field.Type)
-				c.WriteGoType(typ)
+				c.WriteGoType(typ, GoTypeContextFunctionReturn)
 			}
 			c.tsw.WriteLiterally("]")
 		}
@@ -288,10 +370,10 @@ func (c *GoToTSCompiler) WriteSignatureType(t *types.Signature) {
 		c.tsw.WriteLiterally(": ")
 
 		if paramVariadic && paramIsSlice {
-			c.WriteGoType(paramSlice.Elem())
+			c.WriteGoType(paramSlice.Elem(), GoTypeContextGeneral)
 			c.tsw.WriteLiterally("[]")
 		} else {
-			c.WriteGoType(param.Type())
+			c.WriteGoType(param.Type(), GoTypeContextGeneral)
 		}
 	}
 	c.tsw.WriteLiterally(")")
@@ -302,7 +384,7 @@ func (c *GoToTSCompiler) WriteSignatureType(t *types.Signature) {
 	if results.Len() == 0 {
 		c.tsw.WriteLiterally("void")
 	} else if results.Len() == 1 {
-		c.WriteGoType(results.At(0).Type())
+		c.WriteGoType(results.At(0).Type(), GoTypeContextFunctionReturn)
 	} else {
 		// Multiple return values -> tuple
 		c.tsw.WriteLiterally("[")
@@ -310,7 +392,7 @@ func (c *GoToTSCompiler) WriteSignatureType(t *types.Signature) {
 			if i > 0 {
 				c.tsw.WriteLiterally(", ")
 			}
-			c.WriteGoType(results.At(i).Type())
+			c.WriteGoType(results.At(i).Type(), GoTypeContextFunctionReturn)
 		}
 		c.tsw.WriteLiterally("]")
 	}
@@ -378,7 +460,7 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 				}
 				c.tsw.WriteLiterally(paramName)
 				c.tsw.WriteLiterally(": ")
-				c.WriteGoType(paramVar.Type()) // Recursive call for param type
+				c.WriteGoType(paramVar.Type(), GoTypeContextGeneral) // Recursive call for param type
 			}
 			c.tsw.WriteLiterally(")") // End params
 
@@ -388,14 +470,14 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 			if results.Len() == 0 {
 				c.tsw.WriteLiterally("void")
 			} else if results.Len() == 1 {
-				c.WriteGoType(results.At(0).Type()) // Recursive call for result type
+				c.WriteGoType(results.At(0).Type(), GoTypeContextFunctionReturn) // Recursive call for result type
 			} else {
 				c.tsw.WriteLiterally("[")
 				for j := 0; j < results.Len(); j++ {
 					if j > 0 {
 						c.tsw.WriteLiterally(", ")
 					}
-					c.WriteGoType(results.At(j).Type()) // Recursive call for result type
+					c.WriteGoType(results.At(j).Type(), GoTypeContextFunctionReturn) // Recursive call for result type
 				}
 				c.tsw.WriteLiterally("]")
 			}
@@ -419,7 +501,7 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 			// When WriteGoType encounters an interface, it will call WriteInterfaceType
 			// which will pass nil for astNode, so comments for deeply embedded interface literals
 			// might not be available unless they are named types.
-			c.WriteGoType(embeddedType)
+			c.WriteGoType(embeddedType, GoTypeContextGeneral)
 		}
 	}
 }
@@ -433,107 +515,10 @@ func (c *GoToTSCompiler) getTypeString(goType types.Type) string {
 	var typeStr strings.Builder
 	writer := NewTSCodeWriter(&typeStr)
 	tempCompiler := NewGoToTSCompiler(writer, c.pkg, c.analysis)
-	tempCompiler.WriteGoType(goType)
+	tempCompiler.WriteGoType(goType, GoTypeContextGeneral)
 	return typeStr.String()
 }
 
-// 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 "{}"
-	}
-
-	// 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 i := 0; i < underlying.NumFields(); i++ {
-		field := underlying.Field(i)
-		fieldName := field.Name()
-
-		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, ", ") + "}"
-}
-
 // WriteStructType translates a Go struct type definition (`ast.StructType`)
 // into a TypeScript anonymous object type (e.g., `{ Field1: Type1; Field2: Type2 }`).
 // If the struct has no fields, it writes `{}`. Otherwise, it delegates to
@@ -550,7 +535,84 @@ func (c *GoToTSCompiler) WriteStructType(t *types.Struct) {
 			c.tsw.WriteLiterally("; ")
 		}
 		c.tsw.WriteLiterally(field.Name() + "?: ")
-		c.WriteGoType(field.Type())
+		c.WriteGoType(field.Type(), GoTypeContextGeneral)
 	}
 	c.tsw.WriteLiterally(" }")
 }
+
+// WriteTypeParameters translates Go type parameters to TypeScript generic parameters.
+// It handles the TypeParams field of ast.FuncDecl and ast.TypeSpec to generate
+// TypeScript generic parameter lists like <T extends SomeConstraint, U extends OtherConstraint>.
+func (c *GoToTSCompiler) WriteTypeParameters(typeParams *ast.FieldList) {
+	if typeParams == nil || len(typeParams.List) == 0 {
+		return
+	}
+
+	c.tsw.WriteLiterally("<")
+	for i, field := range typeParams.List {
+		if i > 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+		// Write each type parameter name and constraint
+		for j, name := range field.Names {
+			if j > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.tsw.WriteLiterally(name.Name)
+
+			// Write constraint if present
+			if field.Type != nil {
+				c.tsw.WriteLiterally(" extends ")
+				c.WriteTypeConstraint(field.Type)
+			}
+		}
+	}
+	c.tsw.WriteLiterally(">")
+}
+
+// WriteTypeConstraint translates Go type constraints to TypeScript constraint expressions.
+// It handles different constraint types including:
+// - Union types: []byte | string -> string | Uint8Array
+// - Interface types: interface{Method()} -> {Method(): void}
+// - Basic types: any -> any, comparable -> $.Comparable
+func (c *GoToTSCompiler) WriteTypeConstraint(constraint ast.Expr) {
+	switch t := constraint.(type) {
+	case *ast.Ident:
+		// Handle predeclared constraints
+		switch t.Name {
+		case "any":
+			c.tsw.WriteLiterally("any")
+		case "comparable":
+			c.tsw.WriteLiterally("$.Comparable")
+		default:
+			// Use the type directly
+			c.WriteTypeExpr(t)
+		}
+	case *ast.BinaryExpr:
+		// Handle union types like []byte | string
+		if t.Op.String() == "|" {
+			c.WriteTypeConstraint(t.X)
+			c.tsw.WriteLiterally(" | ")
+			c.WriteTypeConstraint(t.Y)
+		} else {
+			// Fallback for other binary expressions
+			c.WriteTypeExpr(constraint)
+		}
+	case *ast.InterfaceType:
+		// Handle interface constraints
+		c.WriteTypeExpr(constraint)
+	case *ast.ArrayType:
+		// Handle []byte specifically
+		if ident, ok := t.Elt.(*ast.Ident); ok && ident.Name == "byte" {
+			c.tsw.WriteLiterally("Uint8Array")
+		} else {
+			c.WriteTypeExpr(constraint)
+		}
+	case *ast.SliceExpr:
+		// Handle slice types in constraints
+		c.WriteTypeExpr(constraint)
+	default:
+		// Fallback: use the standard type expression writer
+		c.WriteTypeExpr(constraint)
+	}
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",
@@ -34,10 +34,10 @@
         "default": "./dist/compiler/index.js"
       }
     },
-    "./builtin": {
+    "./gs/builtin": {
       "import": {
-        "types": "./dist/builtin/builtin.d.ts",
-        "default": "./dist/builtin/builtin.js"
+        "types": "./dist/gs/builtin/builtin.d.ts",
+        "default": "./dist/gs/builtin/builtin.js"
       }
     }
   },
@@ -52,7 +52,7 @@
     "format": "npm run format:go && npm run format:js && npm run format:config",
     "format:config": "prettier --write tsconfig.json package.json",
     "format:go": "gofumpt -w .",
-    "format:js": "prettier --write './{src,builtin,example}/**/(*.ts|*.tsx|*.html|*.css|*.scss)'",
+    "format:js": "prettier --write './{src,gs,example}/**/(*.ts|*.tsx|*.html|*.css|*.scss)'",
     "release": "npm run release:version && npm run release:commit",
     "release:minor": "npm run release:version:minor && npm run release:commit",
     "release:version": "npm version patch -m \"release: v%s\" --no-git-tag-version",

package/builtin/builtin.go

@@ -1,11 +0,0 @@
-package builtin
-
-import (
-	_ "embed"
-)
-
-// BuiltinTs contains the contents of the builtin.ts file which provides
-// runtime support for GoScript compiled code.
-//
-//go:embed builtin.ts
-var BuiltinTs string