feat: rune literal and string rune conversion fix

Signed-off-by: Christian Stewart <christian@aperture.us>

Author: paralin

builtin/builtin.ts

@@ -92,3 +92,15 @@ export const deleteMapEntry = <K, V>(map: Map<K, V>, key: K): void => {
 export const mapHas = <K, V>(map: Map<K, V>, key: K): boolean => {
     return map.has(key);
 };
+/**
+ * Appends elements to a slice (TypeScript array).
+ * Note: In Go, append can return a new slice if the underlying array is reallocated.
+ * This helper emulates that by returning the modified array.
+ * @param slice The slice (TypeScript array) to append to.
+ * @param elements The elements to append.
+ * @returns The modified slice (TypeScript array).
+ */
+export const append = <T>(slice: Array<T>, ...elements: T[]): Array<T> => {
+    slice.push(...elements);
+    return slice;
+};

compiler/compile_expr.go

@@ -6,6 +6,7 @@ import (
 	"go/ast"
 	"go/token"
 	gtypes "go/types"
+	"strconv"
 
 	gstypes "github.com/paralin/goscript/types"
 )
@@ -383,21 +384,62 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 		case "string":
 			// Handle string() conversion, specifically for rune to string
 			if len(exp.Args) == 1 {
-				// Check if the argument is a rune (int32)
-				if tv, ok := c.pkg.TypesInfo.Types[exp.Args[0]]; ok {
+				// Check if the argument is a rune (int32) or a call to rune()
+				arg := exp.Args[0]
+				innerCall, isCallExpr := arg.(*ast.CallExpr)
+
+				if isCallExpr {
+					// Check if it's a call to rune()
+					if innerFunIdent, innerFunIsIdent := innerCall.Fun.(*ast.Ident); innerFunIsIdent && innerFunIdent.String() == "rune" {
+						// Translate string(rune(val)) to String.fromCharCode(val)
+						if len(innerCall.Args) == 1 {
+							c.tsw.WriteLiterally("String.fromCharCode(")
+							if err := c.WriteValueExpr(innerCall.Args[0]); err != nil {
+								return fmt.Errorf("failed to write argument for string(rune) conversion: %w", err)
+							}
+							c.tsw.WriteLiterally(")")
+							return nil // Handled string(rune)
+						}
+					}
+				}
+
+				// Handle direct string(int32) conversion
+				// This assumes 'rune' is int32
+				if tv, ok := c.pkg.TypesInfo.Types[arg]; ok {
 					if basic, isBasic := tv.Type.Underlying().(*gtypes.Basic); isBasic && basic.Kind() == gtypes.Int32 {
 						// Translate string(rune_val) to String.fromCharCode(rune_val)
 						c.tsw.WriteLiterally("String.fromCharCode(")
-						if err := c.WriteValueExpr(exp.Args[0]); err != nil {
-							return fmt.Errorf("failed to write argument for string(rune) conversion: %w", err)
+						if err := c.WriteValueExpr(arg); err != nil {
+							return fmt.Errorf("failed to write argument for string(int32) conversion: %w", err)
 						}
 						c.tsw.WriteLiterally(")")
-						return nil // Handled string(rune)
+						return nil // Handled string(int32)
 					}
 				}
 			}
 			// Return error for other unhandled string conversions
 			return fmt.Errorf("unhandled string conversion: %s", exp.Fun)
+		case "append":
+			// Translate append(slice, elements...) to goscript.append(slice, elements...)
+			if len(exp.Args) >= 1 {
+				c.tsw.WriteLiterally("goscript.append(")
+				// The first argument is the slice
+				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+					return fmt.Errorf("failed to write slice in append call: %w", err)
+				}
+				// The remaining arguments are the elements to append
+				for i, arg := range exp.Args[1:] {
+					if i > 0 || len(exp.Args) > 1 { // Add comma before elements if there are any
+						c.tsw.WriteLiterally(", ")
+					}
+					if err := c.WriteValueExpr(arg); err != nil {
+						return fmt.Errorf("failed to write argument %d in append call: %w", i+1, err)
+					}
+				}
+				c.tsw.WriteLiterally(")")
+				return nil // Handled append
+			}
+			return errors.New("unhandled append call with incorrect number of arguments")
 		default:
 			// Not a special built-in, treat as a regular function call
 			if err := c.WriteValueExpr(expFun); err != nil {
@@ -480,7 +522,20 @@ func (c *GoToTSCompiler) WriteBinaryExprValue(exp *ast.BinaryExpr) error {
 
 // WriteBasicLitValue writes a basic literal value.
 func (c *GoToTSCompiler) WriteBasicLitValue(exp *ast.BasicLit) {
-	c.tsw.WriteLiterally(exp.Value)
+	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.WriteCommentInline(fmt.Sprintf("error parsing char literal %s: %v", exp.Value, err))
+			c.tsw.WriteLiterally("0") // Default to 0 on error
+		} else {
+			c.tsw.WriteLiterally(fmt.Sprintf("%d", val))
+		}
+	} else {
+		// Other literals (INT, FLOAT, STRING, IMAG)
+		c.tsw.WriteLiterally(exp.Value)
+	}
 }
 
 /*

compiler/compile_spec.go

@@ -190,6 +190,11 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 		if a.Type != nil {
 			c.tsw.WriteLiterally(": ")
 			c.WriteTypeExpr(a.Type) // Variable type annotation
+
+			// Check if it's an array type declaration without an initial value
+			if _, isArrayType := a.Type.(*ast.ArrayType); isArrayType && len(a.Values) == 0 {
+				c.tsw.WriteLiterally(" = []")
+			}
 		}
 		if len(a.Values) > 0 {
 			c.tsw.WriteLiterally(" = ")

compiler/compile_stmt.go

@@ -370,16 +370,49 @@ func (c *GoToTSCompiler) WriteStmtBlock(exp *ast.BlockStmt, suppressNewline bool
 // writeAssignmentCore writes the core LHS, operator, and RHS of an assignment.
 // It does NOT handle blank identifiers, 'let' keyword, or trailing semicolons/comments/newlines.
 func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Token) error {
+	// Special handling for integer division assignment (/=)
+	if tok == token.QUO_ASSIGN && len(lhs) == 1 && len(rhs) == 1 {
+		lhsType := c.pkg.TypesInfo.TypeOf(lhs[0])
+		rhsType := c.pkg.TypesInfo.TypeOf(rhs[0])
+
+		if lhsType != nil && rhsType != nil {
+			lhsBasic, lhsIsBasic := lhsType.Underlying().(*gtypes.Basic)
+			rhsBasic, rhsIsBasic := rhsType.Underlying().(*gtypes.Basic)
+
+			if lhsIsBasic && rhsIsBasic && (lhsBasic.Info()&gtypes.IsInteger != 0) && (rhsBasic.Info()&gtypes.IsInteger != 0) {
+				// Integer division assignment: lhs = Math.floor(lhs / rhs)
+				if err := c.WriteValueExpr(lhs[0]); err != nil {
+					return err
+				}
+				c.tsw.WriteLiterally(" = Math.floor(")
+				if err := c.WriteValueExpr(lhs[0]); err != nil { // Write LHS again for the division
+					return err
+				}
+				c.tsw.WriteLiterally(" / ")
+				if err := c.WriteValueExpr(rhs[0]); err != nil {
+					return err
+				}
+				c.tsw.WriteLiterally(")")
+				return nil // Handled integer division assignment
+			}
+		}
+	}
+
+	// --- Original logic for other assignments ---
+	isMapIndexLHS := false // Track if the first LHS is a map index
 	for i, l := range lhs {
 		if i != 0 {
 			c.tsw.WriteLiterally(", ")
 		}
 		// Handle map indexing assignment specially
-		isMapIndexLHS := false
+		currentIsMapIndex := false
 		if indexExpr, ok := l.(*ast.IndexExpr); ok {
 			if tv, ok := c.pkg.TypesInfo.Types[indexExpr.X]; ok {
 				if _, isMap := tv.Type.Underlying().(*gtypes.Map); isMap {
-					isMapIndexLHS = true
+					currentIsMapIndex = true
+					if i == 0 {
+						isMapIndexLHS = true
+					}
 					// Use mapSet helper
 					c.tsw.WriteLiterally("goscript.mapSet(")
 					if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
@@ -395,14 +428,15 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 			}
 		}
 
-		if !isMapIndexLHS {
+		if !currentIsMapIndex {
 			if err := c.WriteValueExpr(l); err != nil { // LHS is a value
 				return err
 			}
 		}
 	}
-	// Only write the assignment operator for regular variables, not for map assignments
-	if len(lhs) == 1 && isLHSMapIndex(lhs[0], c.pkg) {
+
+	// Only write the assignment operator for regular variables, not for map assignments handled by mapSet
+	if isMapIndexLHS && len(lhs) == 1 { // Only skip operator if it's a single map assignment
 		// Continue, we've already written part of the mapSet() function call
 	} else {
 		c.tsw.WriteLiterally(" ")
@@ -415,6 +449,7 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		}
 		c.tsw.WriteLiterally(" ")
 	}
+
 	for i, r := range rhs {
 		if i != 0 {
 			c.tsw.WriteLiterally(", ")
@@ -432,12 +467,11 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		}
 	}
 	// If the LHS was a single map index, close the mapSet call
-	if len(lhs) == 1 && isLHSMapIndex(lhs[0], c.pkg) {
+	if isMapIndexLHS && len(lhs) == 1 {
 		c.tsw.WriteLiterally(")")
 	}
 	return nil
 }
-
 func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 	// writeTypeAssertion handles multi-variable assignment from a type assertion.
 	writeTypeAssertion := func(typeAssertExpr *ast.TypeAssertExpr) error {

compliance/.gitignore

@@ -1,2 +1,2 @@
-
-/gobyexample
+WIP.md
+/gobyexample

compliance/COMPLIANCE.md

@@ -14,6 +14,7 @@ The following tests are currently implemented in the `/compliance/tests` directo
 *   **`if_statement/`**: Covers basic `if`/`else` conditional statements, including correct `} else {` formatting.
 *   **`switch_statement/`**: Verifies basic `switch` statements with integer and string tags and default cases.
 *   **`for_loop_basic/`**: Verifies basic counter-based `for` loops (`for init; cond; post {}`).
+*   **`map_support/`**: Covers map creation (`make`, literal), access, assignment, deletion, length, and iteration (`range`).
 *   **`method_call_on_pointer_receiver/`**: Verifies calling methods with pointer receivers (`*T`) on pointer variables.
 *   **`method_call_on_value_receiver/`**: Verifies calling methods with value receivers (`T`) on value variables. (Note: Go often implicitly takes the address for pointer receivers, this tests the explicit value receiver case).
 *   **`pointer_deref_multiassign/`**: Tests dereferencing a pointer during a multi-variable assignment (`:=` or `=`), including the use of the blank identifier (`_`).
@@ -46,6 +47,7 @@ Based on the existing tests, GoScript aims to support the following Go features:
 *   **Data Structures:**
     *   Arrays (`[N]T`) - Including array literals and indexing.
     *   Slices (`[]T`) - Creation using `make([]T, len)` and `make([]T, len, cap)`.
+    *   Maps (`map[K]V`) - Creation using `make`, literals, access, assignment, `delete`, `len`, `range`.
     *   `struct` definitions (including exported/unexported fields).
     *   Composite Literals for structs (`MyStruct{...}`).
 *   **Functions & Methods:**
@@ -80,7 +82,6 @@ The following Go constructs, present in the "Go By Example" guide, do not appear
     *   `defer` statement
     *   `panic` / `recover`
 *   **Data Structures:**
-    *   Maps (`map[K]V`, `make`, `delete`)
     *   Struct Embedding
 *   **Functions:**
     *   Variadic functions (`...T`)

compliance/WIP.md

@@ -186,13 +186,20 @@ func WriteTypeScriptRunner(t *testing.T, tempDir string) string {
 }
 
 // RunTypeScriptRunner runs the runner.ts file using tsx and returns its stdout.
-func RunTypeScriptRunner(t *testing.T, tempDir, tsRunner string) string {
+func RunTypeScriptRunner(t *testing.T, workspaceDir, tempDir, tsRunner string) string {
 	t.Helper()
 	cmd := exec.Command("tsx", tsRunner)
 	cmd.Dir = tempDir
+
+	// Prepend node_modules/.bin to PATH
+	nodeBinDir := filepath.Join(workspaceDir, "node_modules", ".bin")
+	currentPath := os.Getenv("PATH")
+	newPath := fmt.Sprintf("%s%c%s", nodeBinDir, os.PathListSeparator, currentPath)
+	cmd.Env = append(os.Environ(), "PATH="+newPath) // Set the modified PATH
+
 	var outBuf, errBuf bytes.Buffer
 	cmd.Stdout = io.MultiWriter(&outBuf, os.Stderr)
-	cmd.Stderr = os.Stderr
+	cmd.Stderr = os.Stderr // Keep stderr going to the test output for debugging
 	if err := cmd.Run(); err != nil {
 		t.Fatalf("run failed: %v\nstderr: %s", err, errBuf.String())
 	}
@@ -271,7 +278,7 @@ func RunGoScriptTestDir(t *testing.T, workspaceDir, testDir string) {
 	}
 
 	tsRunner := WriteTypeScriptRunner(t, tempDir)
-	actual := strings.TrimSpace(RunTypeScriptRunner(t, tempDir, tsRunner))
+	actual := strings.TrimSpace(RunTypeScriptRunner(t, workspaceDir, tempDir, tsRunner)) // Pass workspaceDir
 
 	expectedLogPath := filepath.Join(testDir, "expected.log")
 	expected, err := os.ReadFile(expectedLogPath)

compliance/compliance.go

@@ -45,7 +45,7 @@ export function main(): void {
 	// Iterate over a map with range
 	console.log("Iterating over scores map:")
 	// Note: Map iteration is not ordered in Go, so we will collect the results and sort them for consistent test output.
-	let scoreResults: string[];
+	let scoreResults: string[] = [];
 
 	// Using string concatenation to build the output string
 	for (const [k, v] of scores.entries()) {
@@ -54,7 +54,7 @@ export function main(): void {
 		{
 			// Using string concatenation to build the output string
 			let result = "  - Name: " + name + " Score: " + itoa(score)
-			scoreResults = append(scoreResults, result)
+			scoreResults = goscript.append(scoreResults, result)
 		}
 	}
 
@@ -91,8 +91,8 @@ function itoa(i: number): string {
 		i = -i
 	}
 	for (; i > 0; ) {
-		s = string(rune(i % 10 + '0')) + s
-		i /= 10
+		s = String.fromCharCode(i % 10 + 48) + s
+		i = Math.floor(i / 10)
 	}
 	if (isNegative) {
 		s = "-" + s