goscript 0.0.21 → 0.0.23

package/compiler/field.go

@@ -0,0 +1,169 @@
+package compiler
+
+import "go/ast"
+
+// WriteFieldList translates a Go field list (`ast.FieldList`), which can represent
+// function parameters, function results, or struct fields, into its TypeScript equivalent.
+//   - If `isArguments` is true (for function parameters/results):
+//     It iterates through `a.List`, writing each field as `name: type`. Parameter
+//     names and types are written using `WriteField` and `WriteGoType` respectively.
+//     Multiple parameters are comma-separated.
+//   - If `isArguments` is false (for struct fields):
+//     It writes an opening brace `{`, indents, then writes each field definition
+//     using `WriteField`, followed by a closing brace `}`. If the field list is
+//     empty or nil, it simply writes `{}`.
+//
+// This function is a key part of generating TypeScript type signatures for functions
+// and interfaces, as well as struct type definitions.
+func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
+	if !isArguments && (a == nil || a.NumFields() == 0) {
+		c.tsw.WriteLiterally("{}")
+		return
+	}
+
+	if !isArguments && a.Opening.IsValid() {
+		c.tsw.WriteLine("{")
+		c.tsw.Indent(1)
+	}
+
+	// Check if this is a variadic function parameter list
+	isVariadic := false
+	if isArguments && a != nil && len(a.List) > 0 {
+		lastParam := a.List[len(a.List)-1]
+		if _, ok := lastParam.Type.(*ast.Ellipsis); ok {
+			isVariadic = true
+		}
+	}
+
+	if isArguments && isVariadic {
+		// Handle non-variadic parameters first
+		for i, field := range a.List[:len(a.List)-1] {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+
+			// Handle multiple parameter names for the same type
+			for j, name := range field.Names {
+				if j > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.tsw.WriteLiterally(name.Name)
+				c.tsw.WriteLiterally(": ")
+				typ := c.pkg.TypesInfo.TypeOf(field.Type)
+				c.WriteGoType(typ, GoTypeContextGeneral)
+			}
+		}
+
+		// Handle the variadic parameter
+		lastParam := a.List[len(a.List)-1]
+		if len(a.List) > 1 {
+			c.tsw.WriteLiterally(", ")
+		}
+
+		for i, name := range lastParam.Names {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.tsw.WriteLiterally("...")
+			c.tsw.WriteLiterally(name.Name)
+		}
+
+		c.tsw.WriteLiterally(": ")
+		if ellipsis, ok := lastParam.Type.(*ast.Ellipsis); ok {
+			c.WriteTypeExpr(ellipsis.Elt)
+			c.tsw.WriteLiterally("[]")
+		}
+	} else {
+		// Handle regular parameter list for function declarations
+		for i, field := range a.List {
+			if i > 0 && isArguments {
+				c.tsw.WriteLiterally(", ")
+			}
+
+			if isArguments {
+				// For function parameters with multiple names, write each with its type
+				for j, name := range field.Names {
+					if j > 0 {
+						c.tsw.WriteLiterally(", ")
+					}
+					c.tsw.WriteLiterally(name.Name)
+					c.tsw.WriteLiterally(": ")
+					typ := c.pkg.TypesInfo.TypeOf(field.Type)
+					c.WriteGoType(typ, GoTypeContextGeneral) // Use WriteGoType for parameter type
+				}
+			} else {
+				// For struct fields and other non-argument fields
+				c.WriteField(field, false)
+			}
+		}
+	}
+
+	if !isArguments && a.Closing.IsValid() {
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("}")
+	}
+}
+
+// WriteField translates a single Go field (`ast.Field`) from a field list
+// (e.g., in a struct type or function signature) into its TypeScript representation.
+// - If `isArguments` is false (struct field):
+//   - Documentation comments (`field.Doc`, `field.Comment`) are preserved.
+//   - If the field is anonymous (embedded), it's skipped as promotions are handled
+//     elsewhere (e.g., during struct class generation).
+//   - For named fields, it writes `public fieldName: FieldType_ts`. The field name
+//     retains its Go casing. The type is translated using `WriteGoType`.
+//   - Go struct tags (`field.Tag`) are written as a trailing comment.
+//
+// - If `isArguments` is true (function parameter):
+//   - It writes the parameter name (retaining Go casing). The type is handled
+//     by the caller (`WriteFieldList`).
+//
+// This function is used by `WriteFieldList` to process individual items within
+// parameter lists and struct field definitions.
+func (c *GoToTSCompiler) WriteField(field *ast.Field, isArguments bool) {
+	if !isArguments {
+		if field.Doc != nil {
+			c.WriteDoc(field.Doc)
+		}
+		if field.Comment != nil {
+			c.WriteDoc(field.Comment)
+		}
+	}
+
+	// Check if this is an embedded field (anonymous field)
+	if len(field.Names) == 0 && !isArguments {
+		// This is an embedded field, so we're adding promotions instead of declaring it directly
+		return
+	}
+
+	for i, name := range field.Names {
+		if i > 0 && isArguments {
+			c.tsw.WriteLiterally(", ")
+		}
+
+		// argument names: keep original casing, no access modifier
+		if isArguments {
+			c.tsw.WriteLiterally(name.Name)
+			// Argument type is handled in WriteFieldList, so continue
+			continue
+		} else {
+			// All struct fields are public in TypeScript, keeping original Go casing
+			c.tsw.WriteLiterally("public ")
+			c.tsw.WriteLiterally(name.Name)
+		}
+
+		// write type for struct fields (not arguments)
+		c.tsw.WriteLiterally(": ")
+		typ := c.pkg.TypesInfo.TypeOf(field.Type)
+		c.WriteGoType(typ, GoTypeContextGeneral) // Use WriteGoType for field type
+
+		if !isArguments {
+			// write tag comment if any for struct fields
+			if field.Tag != nil {
+				c.tsw.WriteCommentLinef("tag: %s", field.Tag.Value)
+			} else {
+				c.tsw.WriteLine("") // No semicolon
+			}
+		}
+	}
+}

package/compiler/lit.go

@@ -0,0 +1,131 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"strconv"
+)
+
+// WriteBasicLit translates a Go basic literal (`ast.BasicLit`) into its
+// TypeScript equivalent.
+//   - Character literals (e.g., `'a'`, `'\n'`) are translated to their numeric
+//     Unicode code point (e.g., `97`, `10`). Escape sequences are handled.
+//   - Integer, float, imaginary, and string literals are written directly as their
+//     `exp.Value` string, which typically corresponds to valid TypeScript syntax
+//     (e.g., `123`, `3.14`, `"hello"`). Imaginary literals might need special
+//     handling if they are to be fully supported beyond direct string output.
+func (c *GoToTSCompiler) WriteBasicLit(exp *ast.BasicLit) {
+	if exp.Kind == token.CHAR {
+		// Go char literal 'x' is a rune (int32). Translate to its numeric code point.
+		// Use strconv.UnquoteChar to handle escape sequences correctly.
+		val, _, _, err := strconv.UnquoteChar(exp.Value[1:len(exp.Value)-1], '\'')
+		if err != nil {
+			c.tsw.WriteCommentInlinef("error parsing char literal %s: %v", exp.Value, err)
+			c.tsw.WriteLiterally("0") // Default to 0 on error
+		} else {
+			c.tsw.WriteLiterallyf("%d", val)
+		}
+	} else {
+		// Other literals (INT, FLOAT, STRING, IMAG)
+		c.tsw.WriteLiterally(exp.Value)
+	}
+}
+
+// WriteFuncLitValue translates a Go function literal (`ast.FuncLit`) into a
+// TypeScript arrow function.
+// The translation results in: `[async] (param1: type1, ...) : returnType => { ...body... }`.
+//   - The `async` keyword is prepended if `c.analysis.IsFuncLitAsync(exp)`
+//     indicates the function literal contains asynchronous operations.
+//   - Parameters are translated using `WriteFieldList`.
+//   - The return type is determined similarly to `WriteFuncType`:
+//   - `void` for no results.
+//   - `resultType` for a single unnamed result.
+//   - `[typeA, typeB]` for multiple or named results.
+//   - Wrapped in `Promise<>` if `async`.
+//   - The function body (`exp.Body`) is translated using `WriteStmt`.
+func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
+	// Determine if the function literal should be async
+	isAsync := c.analysis.IsFuncLitAsync(exp)
+
+	if isAsync {
+		c.tsw.WriteLiterally("async ")
+	}
+
+	// Write arrow function: (params) => { body }
+	c.tsw.WriteLiterally("(")
+
+	// Use WriteFieldList which now handles variadic parameters
+	c.WriteFieldList(exp.Type.Params, true) // true = arguments
+
+	c.tsw.WriteLiterally(")")
+
+	// Handle return type for function literals
+	if exp.Type.Results != nil && len(exp.Type.Results.List) > 0 {
+		c.tsw.WriteLiterally(": ")
+		if isAsync {
+			c.tsw.WriteLiterally("Promise<")
+		}
+		if len(exp.Type.Results.List) == 1 && len(exp.Type.Results.List[0].Names) == 0 {
+			c.WriteTypeExpr(exp.Type.Results.List[0].Type)
+		} else {
+			c.tsw.WriteLiterally("[")
+			for i, field := range exp.Type.Results.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.WriteTypeExpr(field.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+		if isAsync {
+			c.tsw.WriteLiterally(">")
+		}
+	} else {
+		if isAsync {
+			c.tsw.WriteLiterally(": Promise<void>")
+		} else {
+			c.tsw.WriteLiterally(": void")
+		}
+	}
+
+	c.tsw.WriteLiterally(" => ")
+
+	hasNamedReturns := false
+	if exp.Type.Results != nil {
+		for _, field := range exp.Type.Results.List {
+			if len(field.Names) > 0 {
+				hasNamedReturns = true
+				break
+			}
+		}
+	}
+
+	if hasNamedReturns {
+		c.tsw.WriteLine("{")
+		c.tsw.Indent(1)
+
+		// Declare named return variables and initialize them to their zero values
+		for _, field := range exp.Type.Results.List {
+			for _, name := range field.Names {
+				c.tsw.WriteLiterallyf("let %s: ", name.Name)
+				c.WriteTypeExpr(field.Type)
+				c.tsw.WriteLiterally(" = ")
+				c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
+				c.tsw.WriteLine("")
+			}
+		}
+	}
+
+	// Write function body
+	if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+		return fmt.Errorf("failed to write block statement: %w", err)
+	}
+
+	if hasNamedReturns {
+		c.tsw.Indent(-1)
+		c.tsw.WriteLiterally("}")
+	}
+
+	return nil
+}

package/compiler/primitive.go

@@ -0,0 +1,148 @@
+package compiler
+
+import "go/token"
+
+// goToTypescriptPrimitives maps Go built-in primitive type names (as strings)
+// to their corresponding TypeScript type names. This map is used by
+// `GoBuiltinToTypescript` for direct type name translation.
+//
+// Key mappings include:
+// - `bool` -> `boolean`
+// - `string` -> `string`
+// - `int`, `int8`, `int16`, `int32`, `rune` (alias for int32) -> `number`
+// - `uint`, `uint8` (`byte`), `uint16`, `uint32` -> `number`
+// - `int64`, `uint64` -> `bigint` (requires ES2020+ TypeScript target)
+// - `float32`, `float64` -> `number`
+//
+// This mapping assumes a target environment similar to GOOS=js, GOARCH=wasm,
+// where Go's `int` and `uint` are 32-bit and fit within TypeScript's `number`.
+var goToTypescriptPrimitives = map[string]string{
+	// Boolean
+	"bool": "boolean",
+
+	// Strings
+	"string": "string",
+
+	// Signed Integers
+	"int":   "number",
+	"int8":  "number",
+	"int16": "number",
+	"int32": "number",
+	"rune":  "number", // alias for int32
+
+	// TODO: add bigint support
+	// "int64": "bigint", // Requires TypeScript target >= ES2020
+	"int64": "number",
+
+	// Unsigned Integers
+	"uint":   "number",
+	"uint8":  "number", // byte is an alias for uint8
+	"byte":   "number",
+	"uint16": "number",
+	"uint32": "number",
+
+	// TODO: add bigint support
+	// "uint64": "bigint", // Requires TypeScript target >= ES2020
+	"uint64": "number",
+
+	// Floating Point Numbers
+	"float32": "number",
+	"float64": "number",
+}
+
+func isPrimitiveType(name string) bool {
+	_, ok := goToTypescriptPrimitives[name]
+	return ok
+}
+
+// GoBuiltinToTypescript translates a Go built-in primitive type name (string)
+// to its TypeScript equivalent. It uses the `goToTypescriptPrimitives` map
+// for the conversion.
+// It returns the TypeScript type name and `true` if the Go type name is found
+// in the map. Otherwise, it returns an empty string and `false`.
+// This function only handles primitive types listed in the map; composite types
+// or custom types are not processed here.
+func GoBuiltinToTypescript(typeName string) (string, bool) {
+	val, ok := goToTypescriptPrimitives[typeName]
+	return val, ok
+}
+
+// tokenMap provides a mapping from Go `token.Token` types (representing operators
+// and punctuation) to their corresponding string representations in TypeScript.
+// This map is used by `TokenToTs` to translate Go operators during expression
+// and statement compilation.
+//
+// Examples:
+// - `token.ADD` (Go `+`) -> `"+"` (TypeScript `+`)
+// - `token.LAND` (Go `&&`) -> `"&&"` (TypeScript `&&`)
+// - `token.ASSIGN` (Go `=`) -> `"="` (TypeScript `=`)
+// - `token.DEFINE` (Go `:=`) -> `"="` (TypeScript `=`, as `let` is handled separately)
+//
+// Some tokens like `token.ARROW` (channel send/receive) are handled specially
+// in their respective expression/statement writers and might not be directly mapped here.
+// Bitwise AND NOT (`&^=`) is also mapped but may require specific runtime support if not directly translatable.
+var tokenMap = map[token.Token]string{
+	token.ADD: "+",
+	token.SUB: "-",
+	token.MUL: "*",
+	token.QUO: "/",
+	token.REM: "%",
+	token.AND: "&",
+	token.OR:  "|",
+	token.XOR: "^",
+	token.SHL: "<<",
+	token.SHR: ">>",
+
+	token.ADD_ASSIGN: "+=",
+	token.SUB_ASSIGN: "-=",
+	token.MUL_ASSIGN: "*=",
+	token.QUO_ASSIGN: "/=",
+	token.REM_ASSIGN: "%=",
+
+	token.AND_ASSIGN:     "&=",
+	token.OR_ASSIGN:      "|=",
+	token.XOR_ASSIGN:     "^=", // TODO: check if this works
+	token.SHL_ASSIGN:     "<<=",
+	token.SHR_ASSIGN:     ">>=",
+	token.AND_NOT_ASSIGN: "&^=",
+
+	token.LAND: "&&",
+	token.LOR:  "||",
+	// token.ARROW: ""
+	token.INC:    "++",
+	token.DEC:    "--",
+	token.EQL:    "==",
+	token.LSS:    "<",
+	token.GTR:    ">",
+	token.ASSIGN: "=",
+	token.NOT:    "!",
+
+	token.NEQ:      "!=",
+	token.LEQ:      "<=",
+	token.GEQ:      ">=",
+	token.DEFINE:   "=",   // :=
+	token.ELLIPSIS: "...", // TODO
+
+	token.LPAREN: "(",
+	token.LBRACK: "[",
+	token.LBRACE: "{",
+	token.COMMA:  ",",
+	token.PERIOD: ".",
+
+	token.RPAREN:    ")",
+	token.RBRACK:    "]",
+	token.RBRACE:    "}",
+	token.SEMICOLON: ";",
+	token.COLON:     ":",
+}
+
+// TokenToTs converts a Go `token.Token` (representing an operator or punctuation)
+// into its corresponding TypeScript string representation using the `tokenMap`.
+// It returns the TypeScript string and `true` if the token is found in the map.
+// Otherwise, it returns an empty string and `false`. This function is essential
+// for translating expressions involving operators (e.g., arithmetic, logical,
+// assignment operators).
+func TokenToTs(tok token.Token) (string, bool) {
+	t, ok := tokenMap[tok]
+	return t, ok
+}