Merge remote-tracking branch 'dop251/master' into updateGoja

Author: mstoykov

builtin_array.go

@@ -176,8 +176,40 @@ func (r *Runtime) arrayproto_pop(call FunctionCall) Value {
 	}
 }
 
+// pushToStringStack checks for circular references and pushes an object onto the toString stack.
+// Returns true if the object is already in the stack (circular reference detected), false otherwise.
+// If false is returned, the caller must ensure the object is popped from the stack when done.
+func (r *Runtime) pushToStringStack(o *Object) bool {
+	// Check for circular reference in the toString stack
+	for _, obj := range r.toStringStack {
+		if o == obj {
+			// Circular reference detected
+			return true
+		}
+	}
+
+	// Push this object onto the stack
+	r.toStringStack = append(r.toStringStack, o)
+	return false
+}
+
+// popFromStringStack removes an object from the toString stack.
+func (r *Runtime) popFromStringStack() {
+	// Set the last element to nil to allow GC to collect it
+	r.toStringStack[len(r.toStringStack)-1] = nil
+	r.toStringStack = r.toStringStack[:len(r.toStringStack)-1]
+}
+
 func (r *Runtime) arrayproto_join(call FunctionCall) Value {
 	o := call.This.ToObject(r)
+
+	if r.pushToStringStack(o) {
+		// Circular reference detected, return empty string to avoid infinite recursion
+		// This matches the behavior of mainstream JavaScript engines (V8, SpiderMonkey)
+		return stringEmpty
+	}
+	defer r.popFromStringStack()
+
 	l := int(toLength(o.self.getStr("length", nil)))
 	var sep String
 	if s := call.Argument(0); s != _undefined {
@@ -249,6 +281,13 @@ func (r *Runtime) writeItemLocaleString(item Value, buf *StringBuilder) {
 
 func (r *Runtime) arrayproto_toLocaleString(call FunctionCall) Value {
 	array := call.This.ToObject(r)
+
+	if r.pushToStringStack(array) {
+		// Circular reference detected, return empty string to avoid infinite recursion
+		return stringEmpty
+	}
+	defer r.popFromStringStack()
+
 	var buf StringBuilder
 	if a := r.checkStdArrayObj(array); a != nil {
 		for i, item := range a.values {

builtin_array_circular_test.go

@@ -0,0 +1,123 @@
+package sobek
+
+import (
+	"testing"
+)
+
+func TestArrayCircularReferenceToString(t *testing.T) {
+	const SCRIPT = `
+	var T = [1, 2, 3];
+	T[42] = T;  // Create circular reference
+	var str = String(T);
+	// Circular reference should be replaced with empty string
+	str === "1,2,3,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,";
+	`
+	testScript(SCRIPT, valueTrue, t)
+}
+
+func TestArrayCircularReferenceNumericOperation(t *testing.T) {
+	const SCRIPT = `
+	var T = [1, 2, 3];
+	T[42] = T;  // Create circular reference
+	try {
+		var x = T % 2;  // This should not crash
+		true;
+	} catch (e) {
+		false;
+	}
+	`
+	testScript(SCRIPT, valueTrue, t)
+}
+
+func TestArrayCircularReferenceJoin(t *testing.T) {
+	const SCRIPT = `
+	var T = [1, 2, 3];
+	T[42] = T;  // Create circular reference
+	var str = T.join(',');
+	// Circular reference should be replaced with empty string
+	str === "1,2,3,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,";
+	`
+	testScript(SCRIPT, valueTrue, t)
+}
+
+func TestArrayCircularReferenceConcat(t *testing.T) {
+	const SCRIPT = `
+	var T = [1, 2, 3];
+	T[42] = T;  // Create circular reference
+	var str = '' + T;  // String concatenation
+	// Circular reference should be replaced with empty string
+	str === "1,2,3,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,";
+	`
+	testScript(SCRIPT, valueTrue, t)
+}
+
+func TestArrayCircularReferenceToLocaleString(t *testing.T) {
+	const SCRIPT = `
+	var T = [1, 2, 3];
+	T[42] = T;  // Create circular reference
+	var str = T.toLocaleString();
+	// Circular reference should be replaced with empty string
+	str === "1,2,3,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,";
+	`
+	testScript(SCRIPT, valueTrue, t)
+}
+
+func TestArrayMultipleCircularReferences(t *testing.T) {
+	const SCRIPT = `
+	var T = [1, 2, 3];
+	T[42] = T;
+	T[76] = T;
+	T[80] = T;
+	var str = String(T);
+	// Should handle multiple circular references - all should be empty strings
+	str.split(',').length === 81;
+	`
+	testScript(SCRIPT, valueTrue, t)
+}
+
+func TestArrayNestedCircularReference(t *testing.T) {
+	const SCRIPT = `
+	var A = [1, 2];
+	var B = [3, 4];
+	A[2] = B;
+	B[2] = A;  // Mutual circular reference
+	var str = String(A);
+	// A contains B which contains A - circular refs should be empty
+	str === "1,2,3,4,";
+	`
+	testScript(SCRIPT, valueTrue, t)
+}
+
+func TestArrayCircularReferenceAccessOK(t *testing.T) {
+	const SCRIPT = `
+	// These operations should still work fine
+	var T = [1, 2, 3];
+	T[42] = T;
+	
+	// Accessing circular reference is OK
+	var same = T[42] === T;
+	
+	// Accessing elements through circular reference is OK
+	var first = T[42][0];
+	
+	// Deep nesting is OK
+	var deep = T[42][42][42][42][42][0];
+	
+	same && first === 1 && deep === 1;
+	`
+	testScript(SCRIPT, valueTrue, t)
+}
+
+func TestArrayCircularReferenceComparison(t *testing.T) {
+	const SCRIPT = `
+	var T = [1, 2, 3];
+	T[42] = T;  // Create circular reference
+	try {
+		var result = T == 5;  // Comparison should not crash
+		true;
+	} catch (e) {
+		false;
+	}
+	`
+	testScript(SCRIPT, valueTrue, t)
+}

builtin_proxy_test.go

@@ -1273,3 +1273,13 @@ func TestProxyEnumerableSymbols(t *testing.T) {
 
 	testScriptWithTestLib(SCRIPT, valueTrue, t)
 }
+
+func TestProxyUnicodeProps(t *testing.T) {
+	const SCRIPT = `
+    const proxy = new Proxy({}, {
+		ownKeys: () => ["â"]
+	});
+	compareArray(Reflect.ownKeys(proxy), ["â"]);
+	`
+	testScriptWithTestLib(SCRIPT, valueTrue, t)
+}

builtin_string.go

@@ -524,7 +524,7 @@ func (r *Runtime) _stringPad(call FunctionCall, start bool) Value {
 		return asciiString(sb.String())
 	}
 	var sb unicodeStringBuilder
-	sb.ensureStarted(toIntStrict(maxLength))
+	sb.Grow(toIntStrict(maxLength))
 	if !start {
 		sb.writeString(s)
 	}

builtin_typedarrays.go

@@ -1060,8 +1060,8 @@ func (r *Runtime) typedArrayProto_set(call FunctionCall) Value {
 			}
 			for i := 0; i < srcLen; i++ {
 				val := nilSafe(srcObj.self.getIdx(valueInt(i), nil))
-				if ta.isValidIntegerIndex(i) {
-					ta.typedArray.set(targetOffset+i, val)
+				if ta.isValidIntegerIndex(targetOffset + i) {
+					ta.typedArray.set(ta.offset+targetOffset+i, val)
 				}
 			}
 		}

builtin_typedarrays_test.go

@@ -367,3 +367,19 @@ func TestDataViewExportToBytes(t *testing.T) {
 		t.Fatal("unexpected value", b)
 	}
 }
+
+func TestTypedArraySubarraySet(t *testing.T) {
+	const SCRIPT = `
+	const u = new Uint8Array(4)
+	const s = u.subarray(1, 4);
+	s.set([1,2,3], 0);
+	if (s.length !== 3) {
+		throw new Error("s.length=" + s.length + ", expected 3");
+	}
+	if (s[0] !== 1 || s[1] !== 2 || s[2] !== 3) {
+		throw new Error("s=[" + s.join(",") + "], expected [1,2,3]");
+	}
+	`
+
+	testScript(SCRIPT, _undefined, t)
+}

destruct.go

@@ -1,14 +1,15 @@
 package sobek
 
 import (
-	"github.com/grafana/sobek/unistring"
 	"reflect"
+
+	"github.com/grafana/sobek/unistring"
 )
 
 type destructKeyedSource struct {
 	r        *Runtime
 	wrapped  Value
-	usedKeys map[Value]struct{}
+	usedKeys propNameSet
 }
 
 func newDestructKeyedSource(r *Runtime, wrapped Value) *destructKeyedSource {
@@ -30,10 +31,7 @@ func (d *destructKeyedSource) w() objectImpl {
 }
 
 func (d *destructKeyedSource) recordKey(key Value) {
-	if d.usedKeys == nil {
-		d.usedKeys = make(map[Value]struct{})
-	}
-	d.usedKeys[key] = struct{}{}
+	d.usedKeys.add(key)
 }
 
 func (d *destructKeyedSource) sortLen() int {
@@ -202,7 +200,7 @@ func (i *destructKeyedSourceIter) next() (propIterItem, iterNextFunc) {
 			return item, nil
 		}
 		i.wrapped = next
-		if _, exists := i.d.usedKeys[item.name]; !exists {
+		if !i.d.usedKeys.has(item.name) {
 			return item, i.next
 		}
 	}
@@ -268,7 +266,7 @@ func (d *destructKeyedSource) stringKeys(all bool, accum []Value) []Value {
 func (d *destructKeyedSource) filterUsedKeys(keys []Value) []Value {
 	k := 0
 	for i, key := range keys {
-		if _, exists := d.usedKeys[key]; exists {
+		if d.usedKeys.has(key) {
 			continue
 		}
 		if k != i {

object.go

@@ -1816,3 +1816,43 @@ func (i *privateId) String() string {
 func (i *privateId) string() unistring.String {
 	return privateIdString(i.name)
 }
+
+type propNameSet struct {
+	stringProps map[unistring.String]struct{}
+	symbolProps map[*Symbol]struct{}
+}
+
+func (s *propNameSet) add(prop Value) {
+	if sym, ok := prop.(*Symbol); ok {
+		if s.symbolProps == nil {
+			s.symbolProps = make(map[*Symbol]struct{})
+		}
+		s.symbolProps[sym] = struct{}{}
+	} else {
+		if s.stringProps == nil {
+			s.stringProps = make(map[unistring.String]struct{})
+		}
+		s.stringProps[prop.string()] = struct{}{}
+	}
+}
+
+func (s *propNameSet) has(prop Value) bool {
+	if sym, ok := prop.(*Symbol); ok {
+		_, exists := s.symbolProps[sym]
+		return exists
+	}
+	_, exists := s.stringProps[prop.string()]
+	return exists
+}
+
+func (s *propNameSet) delete(prop Value) {
+	if sym, ok := prop.(*Symbol); ok {
+		delete(s.symbolProps, sym)
+	} else {
+		delete(s.stringProps, prop.string())
+	}
+}
+
+func (s *propNameSet) size() int {
+	return len(s.stringProps) + len(s.symbolProps)
+}

parser/parser_test.go

@@ -930,6 +930,12 @@ func TestParser(t *testing.T) {
 		`, nil)
 		is(len(program.Body), 1)
 
+		test("function f() { if (true) { return class A {} } let A; if (true) { A = class A {} } }", nil)
+		test("function f() { if (true) return class A {} }", nil)
+		test("function f() { let A; if (true) A = class A {} }", nil)
+		test("function f() { if (false) {} else return class A {} }", nil)
+		test("function f() { let A; if (false) {} else A = class A {} }", nil)
+
 		{
 			program := test(`(-2)**53`, nil)
 			st := program.Body[0].(*ast.ExpressionStatement).Expression.(*ast.BinaryExpression)

parser/statement.go

@@ -337,7 +337,7 @@ func (self *_parser) parseArrowFunctionBody(async bool) (ast.ConciseBody, []*ast
 }
 
 func (self *_parser) parseClass(declaration bool) *ast.ClassLiteral {
-	if !self.scope.allowLet && self.token == token.CLASS {
+	if declaration && !self.scope.allowLet && self.token == token.CLASS {
 		self.errorUnexpectedToken(token.CLASS)
 	}