goscript 0.0.84 → 0.1.1

package/compiler/lit.go

@@ -1,322 +0,0 @@
-package compiler
-
-import (
-	"fmt"
-	"go/ast"
-	"go/token"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-// 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.
-//   - Legacy octal literals (e.g., `0777`) are converted to modern TypeScript
-//     octal syntax (e.g., `0o777`) to avoid ES module compatibility issues.
-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 if exp.Kind == token.INT {
-		// Handle integer literals, including legacy octal conversion
-		value := exp.Value
-
-		// Check for legacy octal literals (starts with 0, followed by octal digits, but not 0x, 0b, or 0o)
-		if len(value) > 1 && value[0] == '0' && value != "0" {
-			// Check if it's already modern syntax (0x, 0b, 0o) or just legacy octal
-			if len(value) > 2 && (value[1] == 'x' || value[1] == 'X' ||
-				value[1] == 'b' || value[1] == 'B' ||
-				value[1] == 'o' || value[1] == 'O') {
-				// Already modern syntax (hex, binary, or modern octal), write as-is
-				c.tsw.WriteLiterally(value)
-			} else {
-				// Check if all remaining characters are valid octal digits (0-7)
-				isLegacyOctal := true
-				for i := 1; i < len(value); i++ {
-					if value[i] < '0' || value[i] > '7' {
-						isLegacyOctal = false
-						break
-					}
-				}
-
-				if isLegacyOctal {
-					// Convert legacy octal 0777 to modern octal 0o777
-					c.tsw.WriteLiterallyf("0o%s", value[1:])
-				} else {
-					// Not a valid octal, write as-is (might be decimal with leading zero)
-					c.tsw.WriteLiterally(value)
-				}
-			}
-		} else {
-			// Regular decimal integer or single zero, write as-is
-			c.tsw.WriteLiterally(value)
-		}
-	} else if exp.Kind == token.STRING {
-		// Handle string literals, with special processing for raw strings
-		value := exp.Value
-
-		// Check if this is a raw string literal (starts and ends with backticks)
-		if len(value) >= 2 && value[0] == '`' && value[len(value)-1] == '`' {
-			// This is a Go raw string
-			content := value[1 : len(value)-1] // Remove surrounding backticks
-
-			// Check if the raw string contains backslashes that would be problematic in template literals
-			if strings.Contains(content, `\`) {
-				// Convert to a regular string literal with proper escaping
-				c.tsw.WriteLiterallyf("%q", content)
-			} else {
-				// No backslashes, safe to use template literal
-				// Escape invalid \x, \u, and \U sequences that would cause TS1125 errors
-				content = c.escapeInvalidEscapeSequences(content)
-				// Write as template literal with corrected content
-				c.tsw.WriteLiterallyf("`%s`", content)
-			}
-		} else {
-			// Regular string literal (double quotes) - write as-is
-			c.tsw.WriteLiterally(value)
-		}
-	} else {
-		// Other literals (FLOAT, 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 {
-	// Check if this function needs reflection metadata
-	needsReflection := c.analysis.NeedsReflectionMetadata(exp)
-
-	if needsReflection {
-		// Start IIFE to attach metadata
-		c.tsw.WriteLiterally("(() => {")
-		c.tsw.Indent(1)
-		c.tsw.WriteLine("")
-		c.tsw.WriteLiterally("const fn = ")
-	}
-
-	// 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("[")
-			first := true
-			for _, field := range exp.Type.Results.List {
-				// Each field may represent multiple return values (e.g., "a, b int")
-				count := len(field.Names)
-				if count == 0 {
-					count = 1 // Unnamed return value
-				}
-				for j := 0; j < count; j++ {
-					if !first {
-						c.tsw.WriteLiterally(", ")
-					}
-					first = false
-					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(" => ")
-
-	if c.hasNamedReturns(exp.Type.Results) {
-		c.tsw.WriteLine("{")
-		c.tsw.Indent(1)
-
-		// Declare named return variables and initialize them to their zero values
-		if err := c.writeNamedReturnDeclarations(exp.Type.Results); err != nil {
-			return fmt.Errorf("failed to write named return declarations: %w", err)
-		}
-	}
-
-	// Write function body
-	if err := c.WriteStmtBlock(exp.Body, true); err != nil {
-		return fmt.Errorf("failed to write block statement: %w", err)
-	}
-
-	if c.hasNamedReturns(exp.Type.Results) {
-		c.tsw.Indent(-1)
-		c.tsw.WriteLiterally("}")
-	}
-
-	// Add reflection metadata if needed
-	if needsReflection {
-		c.tsw.WriteLine("")
-
-		// Attach type metadata to the function
-		if err := c.writeReflectionMetadata(exp); err != nil {
-			return fmt.Errorf("failed to write reflection metadata: %w", err)
-		}
-
-		c.tsw.WriteLine("return fn")
-		c.tsw.Indent(-1)
-		c.tsw.WriteLiterally("})()")
-	}
-
-	return nil
-}
-
-// writeReflectionMetadata attaches function type information to a function for reflection support
-func (c *GoToTSCompiler) writeReflectionMetadata(exp *ast.FuncLit) error {
-	// Get the reflection info for this function
-	reflectInfo := c.analysis.GetFunctionTypeInfo(exp)
-	if reflectInfo == nil || reflectInfo.FuncType == nil {
-		return nil // No reflection info available
-	}
-
-	funcType := reflectInfo.FuncType
-
-	// Build FunctionTypeInfo metadata
-	c.tsw.WriteLiterally("fn.__typeInfo = {")
-	c.tsw.Indent(1)
-	c.tsw.WriteLine("")
-	c.tsw.WriteLiterally("kind: $.TypeKind.Function,")
-	c.tsw.WriteLine("")
-
-	// Add parameters
-	if funcType.Params() != nil && funcType.Params().Len() > 0 {
-		c.tsw.WriteLiterally("params: [")
-		for i := 0; i < funcType.Params().Len(); i++ {
-			if i > 0 {
-				c.tsw.WriteLiterally(", ")
-			}
-			param := funcType.Params().At(i)
-			c.tsw.WriteLiterallyf("'%s'", param.Type().String())
-		}
-		c.tsw.WriteLiterally("],")
-		c.tsw.WriteLine("")
-	}
-
-	// Add results
-	if funcType.Results() != nil && funcType.Results().Len() > 0 {
-		c.tsw.WriteLiterally("results: [")
-		for i := 0; i < funcType.Results().Len(); i++ {
-			if i > 0 {
-				c.tsw.WriteLiterally(", ")
-			}
-			result := funcType.Results().At(i)
-			c.tsw.WriteLiterallyf("'%s'", result.Type().String())
-		}
-		c.tsw.WriteLiterally("],")
-		c.tsw.WriteLine("")
-	}
-
-	// Add variadic flag
-	if funcType.Variadic() {
-		c.tsw.WriteLiterally("isVariadic: true,")
-		c.tsw.WriteLine("")
-	}
-
-	c.tsw.Indent(-1)
-	c.tsw.WriteLiterally("}")
-	c.tsw.WriteLine("")
-
-	return nil
-}
-
-// escapeInvalidEscapeSequences escapes \x, \u, and \U sequences in raw strings that would be invalid in JavaScript template literals.
-// JavaScript template literals expect:
-// - \x to be followed by exactly 2 hexadecimal digits
-// - \u to be followed by exactly 4 hexadecimal digits
-// - \U to be followed by exactly 8 hexadecimal digits
-// This function escapes sequences that don't meet these requirements.
-func (c *GoToTSCompiler) escapeInvalidEscapeSequences(content string) string {
-	// Use regex to find all \x, \u, and \U sequences
-	re := regexp.MustCompile(`\\([xuU])([0-9a-fA-F]*)`)
-
-	return re.ReplaceAllStringFunc(content, func(match string) string {
-		if len(match) < 2 {
-			return match
-		}
-
-		escapeType := match[1] // x, u, or U
-		suffix := match[2:]    // The hex digits that follow
-
-		var expectedLength int
-		switch escapeType {
-		case 'x':
-			expectedLength = 2
-		case 'u':
-			expectedLength = 4
-		case 'U':
-			expectedLength = 8
-		default:
-			return match
-		}
-
-		// Check if it has exactly the expected number of hex digits
-		if len(suffix) == expectedLength {
-			// Check if all characters are hex digits
-			isValidHex := true
-			for _, char := range suffix {
-				if !((char >= '0' && char <= '9') ||
-					(char >= 'a' && char <= 'f') ||
-					(char >= 'A' && char <= 'F')) {
-					isValidHex = false
-					break
-				}
-			}
-			if isValidHex {
-				// Valid escape sequence, keep as-is
-				return match
-			}
-		}
-
-		// Invalid escape sequence, escape the backslash
-		return strings.Replace(match, `\`, `\\`, 1)
-	})
-}

package/compiler/output.go

@@ -1,72 +0,0 @@
-package compiler
-
-import (
-	"fmt"
-	"path/filepath"
-	"strings"
-
-	"golang.org/x/tools/go/packages"
-)
-
-// ComputeModulePath computes the root of the output typescript module.
-func ComputeModulePath(outputRoot, goPkg string) string {
-	return filepath.Join(outputRoot, translateGoPathToTypescriptPath(goPkg))
-}
-
-var typeScriptGoStubPrefix = "@ts/"
-
-const builtinGoImportPath = "github.com/aperturerobotics/goscript/builtin"
-
-// translateGoPathToTypescriptPath translates a go package import path to a typescript import path.
-func translateGoPathToTypescriptPath(goImportPath string) string {
-	if strings.HasPrefix(goImportPath, typeScriptGoStubPrefix) {
-		return goImportPath[len(typeScriptGoStubPrefix):]
-	}
-	return fmt.Sprintf("@goscript/%s", goImportPath)
-}
-
-// translateGoImportPathToTypescriptModulePath maps a Go import path to a TypeScript module path.
-func translateGoImportPathToTypescriptModulePath(goImportPath string) string {
-	if goImportPath == builtinGoImportPath {
-		return "@goscript/builtin"
-	}
-	return translateGoPathToTypescriptPath(goImportPath)
-}
-
-// translateTypescriptModulePathToIndexImportPath maps a TypeScript module path to its index.ts import path.
-func translateTypescriptModulePathToIndexImportPath(modulePath string) string {
-	return modulePath + "/index.ts"
-}
-
-// translateGeneratedFileToImportPath maps a generated file stem to its .ts import path.
-func translateGeneratedFileToImportPath(fileName string) string {
-	return fmt.Sprintf("./%s.ts", fileName)
-}
-
-// translateGeneratedGoFileToImportPath maps a generated Go file stem to its .gs.ts import path.
-func translateGeneratedGoFileToImportPath(fileName string) string {
-	return fmt.Sprintf("./%s.gs.ts", fileName)
-}
-
-// translateGeneratedProtobufFileToImportPath maps a protobuf file stem to its .pb.ts import path.
-func translateGeneratedProtobufFileToImportPath(fileName string) string {
-	return fmt.Sprintf("./%s.pb.ts", fileName)
-}
-
-// getActualPackageName returns the actual Go package name from package information.
-// If the package is not found in the imports map, returns an error instead of falling back.
-// This handles cases where the package name differs from the last segment of the import path.
-func getActualPackageName(importPath string, importsMap map[string]*packages.Package) (string, error) {
-	if pkg, exists := importsMap[importPath]; exists && pkg.Name != "" {
-		return pkg.Name, nil
-	}
-	return "", fmt.Errorf("package %s not found in imports map", importPath)
-}
-
-// TranslateGoFilePathToTypescriptFilePath converts the go package path and typescript filename to output path within the typescript output dir
-func TranslateGoFilePathToTypescriptFilePath(goPkgPath, goCodeFilename string) string {
-	op := translateGoPathToTypescriptPath(goPkgPath)
-	baseFilename := goCodeFilename[:len(goCodeFilename)-3]
-	baseFilename = fmt.Sprintf("%s.gs.ts", baseFilename)
-	return filepath.Join(op, baseFilename)
-}

package/compiler/primitive.go

@@ -1,149 +0,0 @@
-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.AND_NOT: "& ~", // &^ operator: bitwise AND NOT
-
-	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: "&^=", // Handled specially in assignment logic
-
-	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
-}