goscript 0.0.33 → 0.0.35

package/compiler/expr.go

@@ -52,7 +52,7 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 
 			// Generate the zero value as the default value for mapGet
 			c.WriteZeroValueForType(mapType.Elem())
-			c.tsw.WriteLiterally(")")
+			c.tsw.WriteLiterally(")[0]") // Extract the value from the tuple
 			return nil
 		}
 
@@ -77,6 +77,31 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 			if constraint != nil {
 				underlying := constraint.Underlying()
 				if iface, isInterface := underlying.(*types.Interface); isInterface {
+					// Check if this is a map constraint (like ~map[K]V)
+					if hasMapConstraint(iface) {
+						// This is a map type parameter, use map access
+						c.tsw.WriteLiterally("$.mapGet(")
+						if err := c.WriteValueExpr(exp.X); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally(", ")
+						if err := c.WriteValueExpr(exp.Index); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally(", ")
+
+						// Generate the zero value as the default value for mapGet
+						// For type parameters, we need to get the value type from the constraint
+						mapValueType := getMapValueTypeFromConstraint(iface)
+						if mapValueType != nil {
+							c.WriteZeroValueForType(mapValueType)
+						} else {
+							c.tsw.WriteLiterally("null")
+						}
+						c.tsw.WriteLiterally(")[0]") // Extract the value from the tuple
+						return nil
+					}
+
 					// Check if this is a mixed string/byte constraint (like string | []byte)
 					if hasMixedStringByteConstraint(iface) {
 						// For mixed constraints, use specialized function that returns number (byte value)
@@ -390,13 +415,18 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 
 	// Handle large bit shift expressions that would overflow in JavaScript
 	if exp.Op == token.SHL {
-		// Check if this is 1 << 63 pattern
-		if leftLit, leftIsLit := exp.X.(*ast.BasicLit); leftIsLit && leftLit.Value == "1" {
-			if rightLit, rightIsLit := exp.Y.(*ast.BasicLit); rightIsLit && rightLit.Value == "63" {
-				// Replace 1 << 63 with Number.MAX_SAFE_INTEGER (9007199254740991)
-				// This is the largest integer that can be exactly represented in JavaScript
-				c.tsw.WriteLiterally("Number.MAX_SAFE_INTEGER")
-				return nil
+		// Check if this is 1 << 63 pattern using constant evaluation
+		leftValue := c.evaluateConstantExpr(exp.X)
+		rightValue := c.evaluateConstantExpr(exp.Y)
+
+		if leftValue != nil && rightValue != nil {
+			if leftInt, leftOk := leftValue.(int); leftOk && leftInt == 1 {
+				if rightInt, rightOk := rightValue.(int); rightOk && rightInt == 63 {
+					// Replace 1 << 63 with Number.MAX_SAFE_INTEGER (9007199254740991)
+					// This is the largest integer that can be exactly represented in JavaScript
+					c.tsw.WriteLiterally("Number.MAX_SAFE_INTEGER")
+					return nil
+				}
 			}
 		}
 	}
@@ -530,23 +560,17 @@ func (c *GoToTSCompiler) WriteUnaryExpr(exp *ast.UnaryExpr) error {
 
 // WriteSliceExpr translates a Go slice expression (e.g., `s[low:high:max]`) to its TypeScript equivalent.
 // If `s` is a string and it's not a 3-index slice, it uses `s.substring(low, high)`.
-// If `s` is `[]byte` (Uint8Array) and it's not a 3-index slice, it uses `s.subarray(low, high)`.
+// If `s` is `[]byte` (Uint8Array) and it's not a 3-index slice, it uses $.goSlice.
 // Otherwise, it falls back to the `$.goSlice(s, low, high, max)` runtime helper.
 func (c *GoToTSCompiler) WriteSliceExpr(exp *ast.SliceExpr) error {
 	// Check if the expression being sliced is a string
 	tv := c.pkg.TypesInfo.TypeOf(exp.X)
 	isString := false
-	isByteSlice := false
 	isTypeParam := false
 	if tv != nil {
 		if basicType, isBasic := tv.Underlying().(*types.Basic); isBasic && (basicType.Info()&types.IsString) != 0 {
 			isString = true
 		}
-		if sliceType, isSlice := tv.Underlying().(*types.Slice); isSlice {
-			if basicElem, isBasic := sliceType.Elem().(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
-				isByteSlice = true
-			}
-		}
 		if _, isTP := tv.(*types.TypeParam); isTP {
 			isTypeParam = true
 		}
@@ -616,29 +640,6 @@ func (c *GoToTSCompiler) WriteSliceExpr(exp *ast.SliceExpr) error {
 			c.tsw.WriteLiterally("undefined")
 		}
 		c.tsw.WriteLiterally(")")
-	} else if isByteSlice && !exp.Slice3 {
-		// Use s.subarray(low, high) for []byte slices
-		if err := c.WriteValueExpr(exp.X); err != nil {
-			return err
-		}
-		c.tsw.WriteLiterally(".subarray(")
-		if exp.Low != nil {
-			if err := c.WriteValueExpr(exp.Low); err != nil {
-				return err
-			}
-		} else {
-			c.tsw.WriteLiterally("0") // Default low for subarray is 0
-		}
-		if exp.High != nil {
-			c.tsw.WriteLiterally(", ")
-			if err := c.WriteValueExpr(exp.High); err != nil {
-				return err
-			}
-		} else {
-			// If high is omitted, subarray goes to the end of the array.
-			// No need to write undefined or length, just close the parenthesis if low was the last arg.
-		}
-		c.tsw.WriteLiterally(")")
 	} else {
 		// Fallback to $.goSlice for actual slices (arrays) or 3-index string slices (which are rare and might need $.goSlice's complexity)
 		// Or if it's a string but has Slice3, it's not handled by simple substring.
@@ -694,3 +695,43 @@ func (c *GoToTSCompiler) WriteKeyValueExpr(exp *ast.KeyValueExpr) error {
 	}
 	return nil
 }
+
+// hasMapConstraint checks if an interface constraint includes map types
+// For constraints like ~map[K]V, this returns true
+func hasMapConstraint(iface *types.Interface) bool {
+	// Check if the interface has type terms that include map types
+	for i := 0; i < iface.NumEmbeddeds(); i++ {
+		embedded := iface.EmbeddedType(i)
+		if union, ok := embedded.(*types.Union); ok {
+			for j := 0; j < union.Len(); j++ {
+				term := union.Term(j)
+				if _, isMap := term.Type().Underlying().(*types.Map); isMap {
+					return true
+				}
+			}
+		} else if _, isMap := embedded.Underlying().(*types.Map); isMap {
+			return true
+		}
+	}
+	return false
+}
+
+// getMapValueTypeFromConstraint extracts the value type from a map constraint
+// For constraints like ~map[K]V, this returns V
+func getMapValueTypeFromConstraint(iface *types.Interface) types.Type {
+	// Check if the interface has type terms that include map types
+	for i := 0; i < iface.NumEmbeddeds(); i++ {
+		embedded := iface.EmbeddedType(i)
+		if union, ok := embedded.(*types.Union); ok {
+			for j := 0; j < union.Len(); j++ {
+				term := union.Term(j)
+				if mapType, isMap := term.Type().Underlying().(*types.Map); isMap {
+					return mapType.Elem()
+				}
+			}
+		} else if mapType, isMap := embedded.Underlying().(*types.Map); isMap {
+			return mapType.Elem()
+		}
+	}
+	return nil
+}

package/compiler/lit.go

@@ -4,7 +4,9 @@ import (
 	"fmt"
 	"go/ast"
 	"go/token"
+	"regexp"
 	"strconv"
+	"strings"
 )
 
 // WriteBasicLit translates a Go basic literal (`ast.BasicLit`) into its
@@ -15,6 +17,8 @@ import (
 //     `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.
@@ -26,8 +30,60 @@ func (c *GoToTSCompiler) WriteBasicLit(exp *ast.BasicLit) {
 		} 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 - need to escape invalid \x sequences for JavaScript
+			content := value[1 : len(value)-1] // Remove surrounding backticks
+
+			// 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 (INT, FLOAT, STRING, IMAG)
+		// Other literals (FLOAT, IMAG)
 		c.tsw.WriteLiterally(exp.Value)
 	}
 }
@@ -108,7 +164,7 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 		// 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.tsw.WriteLiterallyf("let %s: ", c.sanitizeIdentifier(name.Name))
 				c.WriteTypeExpr(field.Type)
 				c.tsw.WriteLiterally(" = ")
 				c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
@@ -118,7 +174,7 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 	}
 
 	// Write function body
-	if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+	if err := c.WriteStmtBlock(exp.Body, true); err != nil {
 		return fmt.Errorf("failed to write block statement: %w", err)
 	}
 
@@ -129,3 +185,56 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 
 	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/primitive.go

@@ -100,12 +100,12 @@ var tokenMap = map[token.Token]string{
 	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.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:  "||",

package/compiler/protobuf.go

@@ -61,11 +61,6 @@ func isProtobufGoLitePackage(pkgPath string) bool {
 	if strings.HasPrefix(pkgPath, "github.com/aperturerobotics/json-iterator-lite") {
 		return true
 	}
-	// Skip other packages commonly used only by .pb.go files
-	switch pkgPath {
-	case "encoding/json", "encoding/base64", "strconv", "fmt":
-		return true
-	}
 	return false
 }
 

package/compiler/sanitize.go

@@ -0,0 +1,101 @@
+package compiler
+
+// sanitizeIdentifier checks if an identifier is a JavaScript/TypeScript reserved word
+// or conflicts with built-in types, and transforms it if needed. This prevents
+// compilation errors when Go identifiers conflict with JS/TS keywords or built-ins.
+func sanitizeIdentifier(name string) string {
+	// Don't sanitize boolean literals - they are valid in both Go and JS/TS
+	if name == "true" || name == "false" {
+		return name
+	}
+
+	// Handle TypeScript built-in types that conflict with Go type parameter names
+	builtinTypes := map[string]string{
+		"Map": "MapType",
+		// Add other built-in types as needed
+	}
+
+	if replacement, exists := builtinTypes[name]; exists {
+		return replacement
+	}
+
+	// List of JavaScript/TypeScript reserved words that could conflict
+	reservedWords := map[string]bool{
+		"abstract":    true,
+		"any":         true,
+		"as":          true,
+		"asserts":     true,
+		"async":       true,
+		"await":       true,
+		"boolean":     true,
+		"break":       true,
+		"case":        true,
+		"catch":       true,
+		"class":       true,
+		"const":       true,
+		"constructor": true,
+		"continue":    true,
+		"debugger":    true,
+		"declare":     true,
+		"default":     true,
+		"delete":      true,
+		"do":          true,
+		"else":        true,
+		"enum":        true,
+		"export":      true,
+		"extends":     true,
+		"finally":     true,
+		"for":         true,
+		"from":        true,
+		"function":    true,
+		"get":         true,
+		"if":          true,
+		"implements":  true,
+		"import":      true,
+		"in":          true,
+		"instanceof":  true,
+		"interface":   true,
+		"is":          true,
+		"keyof":       true,
+		"let":         true,
+		"module":      true,
+		"namespace":   true,
+		"never":       true,
+		"new":         true,
+		"null":        true,
+		"number":      true,
+		"object":      true,
+		"of":          true,
+		"package":     true,
+		"private":     true,
+		"protected":   true,
+		"public":      true,
+		"readonly":    true,
+		"require":     true,
+		"return":      true,
+		"set":         true,
+		"static":      true,
+		"string":      true,
+		"super":       true,
+		"switch":      true,
+		"symbol":      true,
+		"this":        true,
+		"throw":       true,
+		"try":         true,
+		"type":        true,
+		"typeof":      true,
+		"undefined":   true,
+		"unique":      true,
+		"unknown":     true,
+		"var":         true,
+		"void":        true,
+		"while":       true,
+		"with":        true,
+		"yield":       true,
+	}
+
+	if reservedWords[name] {
+		return "_" + name
+	}
+	return name
+}

package/compiler/spec-value.go

@@ -91,7 +91,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 			c.tsw.WriteLiterally("export ")
 		}
 		c.tsw.WriteLiterally("let ")
-		c.tsw.WriteLiterally(name.Name)
+		c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
 
 		// Write type annotation if:
 		// 1. Not a slice conversion (normal case), OR
@@ -193,27 +193,34 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 			if hasInitializer {
 				// Handle &v initializer specifically for unvarrefed variables
 				if unaryExpr, isUnary := initializerExpr.(*ast.UnaryExpr); isUnary && unaryExpr.Op == token.AND {
-					// Initializer is &v
-					// Check if v is varrefed
-					needsVarRefOperand := false
-					unaryExprXIdent, ok := unaryExpr.X.(*ast.Ident)
-					if ok {
+					// Initializer is &expr
+					// Check if expr is an identifier (variable) or something else (e.g., composite literal)
+					if unaryExprXIdent, ok := unaryExpr.X.(*ast.Ident); ok {
+						// Case: &variable
+						// Check if the variable is varrefed
 						innerObj := c.pkg.TypesInfo.Uses[unaryExprXIdent]
-						needsVarRefOperand = innerObj != nil && c.analysis.NeedsVarRef(innerObj)
-					}
+						needsVarRefOperand := innerObj != nil && c.analysis.NeedsVarRef(innerObj)
 
-					// If v is varrefed, assign the varRef itself (v)
-					// If v is not varrefed, assign $.varRef(v)
-					if needsVarRefOperand {
-						// do not write .value here.
-						c.WriteIdent(unaryExprXIdent, false)
+						// If variable is varrefed, assign the varRef itself (variable)
+						// If variable is not varrefed, assign $.varRef(variable)
+						if needsVarRefOperand {
+							// do not write .value here.
+							c.WriteIdent(unaryExprXIdent, false)
+						} else {
+							// &unvarrefedVar -> $.varRef(unvarrefedVar)
+							c.tsw.WriteLiterally("$.varRef(")
+							if err := c.WriteValueExpr(unaryExpr.X); err != nil { // Write 'variable'
+								return err
+							}
+							c.tsw.WriteLiterally(")")
+						}
 					} else {
-						// &unvarrefedVar -> $.varRef(unvarrefedVar)
-						c.tsw.WriteLiterally("$.varRef(")
-						if err := c.WriteValueExpr(unaryExpr.X); err != nil { // Write 'v'
+						// Case: &compositeLiteral or &otherExpression
+						// For composite literals and other expressions, just write the expression directly
+						// Example: &MyStruct{} -> new MyStruct({})
+						if err := c.WriteValueExpr(unaryExpr.X); err != nil {
 							return err
 						}
-						c.tsw.WriteLiterally(")")
 					}
 				} else {
 					// Check if this is a named type with methods and the initializer is a basic value
@@ -315,7 +322,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 		if i != 0 {
 			c.tsw.WriteLiterally(", ")
 		}
-		c.tsw.WriteLiterally(name.Name)
+		c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
 		// TODO: Add type annotations for multi-var declarations if possible/needed
 	}
 	c.tsw.WriteLiterally("]")