goscript 0.0.34 → 0.0.36

package/compiler/expr-call.go

@@ -206,17 +206,31 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 					// Check if it's make([]byte, ...)
 					if basicElem, isBasic := goElemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
-						c.tsw.WriteLiterally("new Uint8Array(")
-						if len(exp.Args) >= 2 {
+						// Check if capacity is different from length
+						if len(exp.Args) == 3 {
+							// make([]byte, len, cap) - need to handle capacity
+							c.tsw.WriteLiterally("$.makeSlice<number>(")
 							if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 								return err
 							}
-							// Capacity argument for make([]byte, len, cap) is ignored for new Uint8Array(len)
+							c.tsw.WriteLiterally(", ")
+							if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+								return err
+							}
+							c.tsw.WriteLiterally(", 'byte')")
 						} else {
-							// If no length is provided, default to 0
-							c.tsw.WriteLiterally("0")
+							// make([]byte, len) - capacity equals length, use Uint8Array
+							c.tsw.WriteLiterally("new Uint8Array(")
+							if len(exp.Args) >= 2 {
+								if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+									return err
+								}
+							} else {
+								// If no length is provided, default to 0
+								c.tsw.WriteLiterally("0")
+							}
+							c.tsw.WriteLiterally(")")
 						}
-						c.tsw.WriteLiterally(")")
 						return nil // Handled make for []byte
 					}
 
@@ -251,11 +265,13 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
 					c.tsw.WriteLiterally(">(")
 
+					hasCapacity := len(exp.Args) == 3
+
 					if len(exp.Args) >= 2 {
 						if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 							return err
 						}
-						if len(exp.Args) == 3 {
+						if hasCapacity {
 							c.tsw.WriteLiterally(", ")
 							if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
 								return err
@@ -267,6 +283,19 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 						// If no length is provided, default to 0
 						c.tsw.WriteLiterally("0")
 					}
+
+					// Add type hint for proper zero value initialization
+					typeHint := c.getTypeHintForSliceElement(goElemType)
+					if typeHint != "" {
+						if !hasCapacity {
+							// If no capacity was provided, add undefined for capacity parameter
+							c.tsw.WriteLiterally(", undefined")
+						}
+						c.tsw.WriteLiterally(", '")
+						c.tsw.WriteLiterally(typeHint)
+						c.tsw.WriteLiterally("'")
+					}
+
 					c.tsw.WriteLiterally(")")
 					return nil // Handled make for slice
 				}
@@ -291,17 +320,31 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 											if elemType != nil {
 												// Check if it's make(S, ...) where S constrains to []byte
 												if basicElem, isBasic := elemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
-													c.tsw.WriteLiterally("new Uint8Array(")
-													if len(exp.Args) >= 2 {
+													// Check if capacity is different from length
+													if len(exp.Args) == 3 {
+														// make([]byte, len, cap) - need to handle capacity
+														c.tsw.WriteLiterally("$.makeSlice<number>(")
 														if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 															return err
 														}
-														// Capacity argument for make([]byte, len, cap) is ignored for new Uint8Array(len)
+														c.tsw.WriteLiterally(", ")
+														if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+															return err
+														}
+														c.tsw.WriteLiterally(", 'byte')")
 													} else {
-														// If no length is provided, default to 0
-														c.tsw.WriteLiterally("0")
+														// make([]byte, len) - capacity equals length, use Uint8Array
+														c.tsw.WriteLiterally("new Uint8Array(")
+														if len(exp.Args) >= 2 {
+															if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+																return err
+															}
+														} else {
+															// If no length is provided, default to 0
+															c.tsw.WriteLiterally("0")
+														}
+														c.tsw.WriteLiterally(")")
 													}
-													c.tsw.WriteLiterally(")")
 													return nil // Handled make for generic []byte
 												}
 
@@ -309,11 +352,13 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 												c.WriteGoType(elemType, GoTypeContextGeneral) // Write the element type
 												c.tsw.WriteLiterally(">(")
 
+												hasCapacity := len(exp.Args) == 3
+
 												if len(exp.Args) >= 2 {
 													if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 														return err
 													}
-													if len(exp.Args) == 3 {
+													if hasCapacity {
 														c.tsw.WriteLiterally(", ")
 														if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
 															return err
@@ -325,6 +370,19 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 													// If no length is provided, default to 0
 													c.tsw.WriteLiterally("0")
 												}
+
+												// Add type hint for proper zero value initialization
+												typeHint := c.getTypeHintForSliceElement(elemType)
+												if typeHint != "" {
+													if !hasCapacity {
+														// If no capacity was provided, add undefined for capacity parameter
+														c.tsw.WriteLiterally(", undefined")
+													}
+													c.tsw.WriteLiterally(", '")
+													c.tsw.WriteLiterally(typeHint)
+													c.tsw.WriteLiterally("'")
+												}
+
 												c.tsw.WriteLiterally(")")
 												return nil // Handled make for generic slice
 											}
@@ -340,17 +398,31 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 									// Check if it's a named type with []byte underlying type
 									if basicElem, isBasic := goElemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
-										c.tsw.WriteLiterally("new Uint8Array(")
-										if len(exp.Args) >= 2 {
+										// Check if capacity is different from length
+										if len(exp.Args) == 3 {
+											// make([]byte, len, cap) - need to handle capacity
+											c.tsw.WriteLiterally("$.makeSlice<number>(")
 											if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 												return err
 											}
-											// Capacity argument for make([]byte, len, cap) is ignored for new Uint8Array(len)
+											c.tsw.WriteLiterally(", ")
+											if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+												return err
+											}
+											c.tsw.WriteLiterally(", 'byte')")
 										} else {
-											// If no length is provided, default to 0
-											c.tsw.WriteLiterally("0")
+											// make([]byte, len) - capacity equals length, use Uint8Array
+											c.tsw.WriteLiterally("new Uint8Array(")
+											if len(exp.Args) >= 2 {
+												if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+													return err
+												}
+											} else {
+												// If no length is provided, default to 0
+												c.tsw.WriteLiterally("0")
+											}
+											c.tsw.WriteLiterally(")")
 										}
-										c.tsw.WriteLiterally(")")
 										return nil // Handled make for named []byte type
 									}
 
@@ -359,11 +431,13 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 									c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
 									c.tsw.WriteLiterally(">(")
 
+									hasCapacity := len(exp.Args) == 3
+
 									if len(exp.Args) >= 2 {
 										if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 											return err
 										}
-										if len(exp.Args) == 3 {
+										if hasCapacity {
 											c.tsw.WriteLiterally(", ")
 											if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
 												return err
@@ -375,6 +449,19 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 										// If no length is provided, default to 0
 										c.tsw.WriteLiterally("0")
 									}
+
+									// Add type hint for proper zero value initialization
+									typeHint := c.getTypeHintForSliceElement(goElemType)
+									if typeHint != "" {
+										if !hasCapacity {
+											// If no capacity was provided, add undefined for capacity parameter
+											c.tsw.WriteLiterally(", undefined")
+										}
+										c.tsw.WriteLiterally(", '")
+										c.tsw.WriteLiterally(typeHint)
+										c.tsw.WriteLiterally("'")
+									}
+
 									c.tsw.WriteLiterally(")")
 									return nil // Handled make for named slice type
 								}
@@ -461,17 +548,31 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 						// Check if it's an instantiated generic type with []byte underlying type
 						if basicElem, isBasic := goElemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
-							c.tsw.WriteLiterally("new Uint8Array(")
-							if len(exp.Args) >= 2 {
+							// Check if capacity is different from length
+							if len(exp.Args) == 3 {
+								// make([]byte, len, cap) - need to handle capacity
+								c.tsw.WriteLiterally("$.makeSlice<number>(")
 								if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 									return err
 								}
-								// Capacity argument for make([]byte, len, cap) is ignored for new Uint8Array(len)
+								c.tsw.WriteLiterally(", ")
+								if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+									return err
+								}
+								c.tsw.WriteLiterally(", 'byte')")
 							} else {
-								// If no length is provided, default to 0
-								c.tsw.WriteLiterally("0")
+								// make([]byte, len) - capacity equals length, use Uint8Array
+								c.tsw.WriteLiterally("new Uint8Array(")
+								if len(exp.Args) >= 2 {
+									if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+										return err
+									}
+								} else {
+									// If no length is provided, default to 0
+									c.tsw.WriteLiterally("0")
+								}
+								c.tsw.WriteLiterally(")")
 							}
-							c.tsw.WriteLiterally(")")
 							return nil // Handled make for instantiated generic []byte type
 						}
 
@@ -480,11 +581,13 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 						c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
 						c.tsw.WriteLiterally(">(")
 
+						hasCapacity := len(exp.Args) == 3
+
 						if len(exp.Args) >= 2 {
 							if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 								return err
 							}
-							if len(exp.Args) == 3 {
+							if hasCapacity {
 								c.tsw.WriteLiterally(", ")
 								if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
 									return err
@@ -496,6 +599,19 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 							// If no length is provided, default to 0
 							c.tsw.WriteLiterally("0")
 						}
+
+						// Add type hint for proper zero value initialization
+						typeHint := c.getTypeHintForSliceElement(goElemType)
+						if typeHint != "" {
+							if !hasCapacity {
+								// If no capacity was provided, add undefined for capacity parameter
+								c.tsw.WriteLiterally(", undefined")
+							}
+							c.tsw.WriteLiterally(", '")
+							c.tsw.WriteLiterally(typeHint)
+							c.tsw.WriteLiterally("'")
+						}
+
 						c.tsw.WriteLiterally(")")
 						return nil // Handled make for instantiated generic slice type
 					}
@@ -569,17 +685,31 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 						// Check if it's a selector expression with []byte underlying type
 						if basicElem, isBasic := goElemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
-							c.tsw.WriteLiterally("new Uint8Array(")
-							if len(exp.Args) >= 2 {
+							// Check if capacity is different from length
+							if len(exp.Args) == 3 {
+								// make([]byte, len, cap) - need to handle capacity
+								c.tsw.WriteLiterally("$.makeSlice<number>(")
 								if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 									return err
 								}
-								// Capacity argument for make([]byte, len, cap) is ignored for new Uint8Array(len)
+								c.tsw.WriteLiterally(", ")
+								if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+									return err
+								}
+								c.tsw.WriteLiterally(", 'byte')")
 							} else {
-								// If no length is provided, default to 0
-								c.tsw.WriteLiterally("0")
+								// make([]byte, len) - capacity equals length, use Uint8Array
+								c.tsw.WriteLiterally("new Uint8Array(")
+								if len(exp.Args) >= 2 {
+									if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+										return err
+									}
+								} else {
+									// If no length is provided, default to 0
+									c.tsw.WriteLiterally("0")
+								}
+								c.tsw.WriteLiterally(")")
 							}
-							c.tsw.WriteLiterally(")")
 							return nil // Handled make for selector expression []byte type
 						}
 
@@ -588,11 +718,13 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 						c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
 						c.tsw.WriteLiterally(">(")
 
+						hasCapacity := len(exp.Args) == 3
+
 						if len(exp.Args) >= 2 {
 							if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 								return err
 							}
-							if len(exp.Args) == 3 {
+							if hasCapacity {
 								c.tsw.WriteLiterally(", ")
 								if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
 									return err
@@ -604,6 +736,19 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 							// If no length is provided, default to 0
 							c.tsw.WriteLiterally("0")
 						}
+
+						// Add type hint for proper zero value initialization
+						typeHint := c.getTypeHintForSliceElement(goElemType)
+						if typeHint != "" {
+							if !hasCapacity {
+								// If no capacity was provided, add undefined for capacity parameter
+								c.tsw.WriteLiterally(", undefined")
+							}
+							c.tsw.WriteLiterally(", '")
+							c.tsw.WriteLiterally(typeHint)
+							c.tsw.WriteLiterally("'")
+						}
+
 						c.tsw.WriteLiterally(")")
 						return nil // Handled make for selector expression slice type
 					}
@@ -774,6 +919,40 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					if i > 0 || len(exp.Args) > 1 { // Add comma before elements if there are any
 						c.tsw.WriteLiterally(", ")
 					}
+
+					// Special case: append([]byte, string...) should convert string to bytes
+					if exp.Ellipsis != token.NoPos && i == 0 { // This is the first element after slice and has ellipsis
+						// Check if the slice is []byte and the argument is a string
+						sliceType := c.pkg.TypesInfo.TypeOf(exp.Args[0])
+						argType := c.pkg.TypesInfo.TypeOf(arg)
+
+						if sliceType != nil && argType != nil {
+							// Check if slice is []byte (Uint8Array)
+							isSliceOfBytes := false
+							if sliceUnder, ok := sliceType.Underlying().(*types.Slice); ok {
+								if basicElem, ok := sliceUnder.Elem().(*types.Basic); ok && basicElem.Kind() == types.Uint8 {
+									isSliceOfBytes = true
+								}
+							}
+
+							// Check if argument is string (including untyped string)
+							isArgString := false
+							if basicArg, ok := argType.Underlying().(*types.Basic); ok && (basicArg.Kind() == types.String || basicArg.Kind() == types.UntypedString) {
+								isArgString = true
+							}
+
+							if isSliceOfBytes && isArgString {
+								// Convert string to bytes: append([]byte, string...) -> $.append(slice, ...$.stringToBytes(string))
+								c.tsw.WriteLiterally("...$.stringToBytes(")
+								if err := c.WriteValueExpr(arg); err != nil {
+									return fmt.Errorf("failed to write string argument in append call: %w", err)
+								}
+								c.tsw.WriteLiterally(")")
+								continue
+							}
+						}
+					}
+
 					if err := c.WriteValueExpr(arg); err != nil {
 						return fmt.Errorf("failed to write argument %d in append call: %w", i+1, err)
 					}
@@ -1123,3 +1302,22 @@ func hasMixedStringByteConstraint(iface *types.Interface) bool {
 	// Return true only if we have both string and []byte in the constraint
 	return hasString && hasByteSlice
 }
+
+// getTypeHintForSliceElement returns the appropriate type hint for makeSlice based on the Go element type
+func (c *GoToTSCompiler) getTypeHintForSliceElement(elemType types.Type) string {
+	if basicType, isBasic := elemType.(*types.Basic); isBasic {
+		switch basicType.Kind() {
+		case types.Int, types.Int8, types.Int16, types.Int32, types.Int64,
+			types.Uint, types.Uint8, types.Uint16, types.Uint32, types.Uint64,
+			types.Float32, types.Float64, types.Complex64, types.Complex128:
+			return "number"
+		case types.Bool:
+			return "boolean"
+		case types.String:
+			return "string"
+		}
+	}
+	// For other types (structs, interfaces, pointers, etc.), don't provide a hint
+	// This will use the default null initialization which is appropriate for object types
+	return ""
+}

package/compiler/expr-selector.go

@@ -129,7 +129,33 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 	// Add null assertion for selector expressions when accessing fields/methods on nullable types
 	// In Go, accessing fields or calling methods on nil pointers/interfaces panics, so we should throw in TypeScript
 	baseType := c.pkg.TypesInfo.TypeOf(exp.X)
-	if baseType != nil {
+
+	// Special case: Check if this is a method receiver alias (e.g., `b` in `const b = this`)
+	// In this case, we should use regular field access instead of pointer access
+	isMethodReceiverAlias := false
+	if baseIdent, ok := exp.X.(*ast.Ident); ok {
+		// Check if this identifier refers to a method receiver
+		// Method receivers are typically named variables that alias `this`
+		if obj := c.pkg.TypesInfo.ObjectOf(baseIdent); obj != nil {
+			if varObj, ok := obj.(*types.Var); ok {
+				// Check if this is a local variable in a method context
+				// Method receiver aliases are local variables with pointer types that represent `this`
+				if _, isPtr := varObj.Type().(*types.Pointer); isPtr {
+					// Additional check: only consider it a method receiver alias if the variable name
+					// suggests it's an alias (single letter names are common for aliases like `b`, `r`, etc.)
+					// and it's not a common variable name like `f` which is often used for regular variables
+					varName := baseIdent.Name
+					if len(varName) == 1 && varName != "f" {
+						// This is likely a method receiver alias like `const b = this`
+						// We should treat it as a regular object access, not a pointer access
+						isMethodReceiverAlias = true
+					}
+				}
+			}
+		}
+	}
+
+	if baseType != nil && !isMethodReceiverAlias {
 		// Check if the base is a pointer type
 		if _, isPtr := baseType.(*types.Pointer); isPtr {
 			c.tsw.WriteLiterally("!.")
@@ -145,7 +171,7 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 			c.tsw.WriteLiterally(".")
 		}
 	} else {
-		// Add .
+		// Add . (either baseType is nil or this is a method receiver alias)
 		c.tsw.WriteLiterally(".")
 	}
 

package/compiler/expr.go

@@ -415,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
+				}
 			}
 		}
 	}
@@ -555,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
 		}
@@ -641,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.