Merge branch 'main' into kai/nodevm-dynamic-import

Author: heimskr

JSTests/stress/new-array-with-spread-ai-structure.js

@@ -0,0 +1,17 @@
+//@ runDefault("--useConcurrentJIT=0", "--jitPolicyScale=0")
+const a = new Int8Array(4);
+a[3];
+function opt() {
+  const arr = [...[1, 2, 3]];
+  const func = arr?.constructor;
+  try {
+    new func(arr); // JSC use GetLocal to get Constructor, GetLocal is converted into Undefined in constant folding
+    describe(1234)
+  } catch (e) {
+    throw e;
+  }
+  for (let i = 0; i < 100; i++) {}
+}
+for (let i = 0; i < 5; i++) {
+  opt();
+}

JSTests/stress/property-enumeration-object-with-indexed-property-and-string-prototype.js

@@ -0,0 +1,32 @@
+function assert(actual, expected) {
+    if (actual.length !== expected.length)
+        throw new Error(`Length mismatch: got [${actual}], expected [${expected}]`);
+
+    for (let i = 0; i < expected.length; i++) {
+        if (actual[i] !== expected[i])
+            throw new Error(`Mismatch at index ${i}: got "${actual[i]}", expected "${expected[i]}"`);
+    }
+}
+
+function getKey(x) {
+    var arr = [];
+    for (var i in x) {
+        arr.push(i);
+    }
+    return arr;
+}
+
+function opt() {
+    var x = new String("ab");
+    function B() {
+        this[0] = 4;
+        this.bar = 77;
+    }
+    B.prototype = x;
+    var y = new B();
+    return getKey(y);
+}
+
+for (let i = 0; i < testLoopCount; i++) {
+    assert(opt(), ['0', 'bar', '1']);
+}

JSTests/stress/regexp-property-escape-script-unknown.js

@@ -0,0 +1,19 @@
+function shouldBe(a, b) {
+    if (a !== b)
+        throw new Error(`Expected ${b} but got ${a}`);
+}
+
+const unknownChar = "\uE000";
+const knownChar = "A";
+
+shouldBe(/\p{Script=Unknown}/u.test(unknownChar), true);
+shouldBe(/\p{Script=Unknown}/u.test(knownChar), false);
+
+shouldBe(/\p{Script=Zzzz}/u.test(unknownChar), true);
+shouldBe(/\p{Script=Zzzz}/u.test(knownChar), false);
+
+shouldBe(/\p{Script_Extensions=Unknown}/u.test(unknownChar), true);
+shouldBe(/\p{Script_Extensions=Unknown}/u.test(knownChar), false);
+
+shouldBe(/\p{Script_Extensions=Zzzz}/u.test(unknownChar), true);
+shouldBe(/\p{Script_Extensions=Zzzz}/u.test(knownChar), false);

JSTests/stress/regexp-vflag-property-of-strings.js

@@ -1,6 +1,8 @@
 // With verbose set to false, this test is successful if there is no output.  Set verbose to true to see expected matches.
 let verbose = false;
 
+let errors = 0;
+
 function arrayToString(arr)
 {
     let str = '';
@@ -30,7 +32,7 @@ function objectToString(obj)
 
         firstEntry = false;
     }
-    
+
     return "{ " + str + " }";
 }
 
@@ -139,17 +141,21 @@ function testRegExp(re, str, exp, groups)
     if (result) {
         if (verbose)
             print(re.toString() + ".exec(" + dumpValue(str) + "), passed ", dumpValue(exp));
-    } else
+    } else {
         print(re.toString() + ".exec(" + dumpValue(str) + "), FAILED test #" + testNumber + ", Expected ", dumpValue(exp), " got ", dumpValue(actual));
+        errors++;
+    }
 }
 
 function testRegExpSyntaxError(reString, flags, expError)
 {
     testNumber++;
 
+
     try {
         let re = new RegExp(reString, flags);
-        print("FAILED test #" + testNumber + ", Expected /" + reString + "/" + flags + " to throw \"" + expError);
+        print("FAILED test #" + testNumber + ", Expected /" + reString + "/" + flags + " to throw \"" + expError + "\", but it didn't");
+        errors++;
     } catch (e) {
         if (e != expError)
             print("FAILED test #" + testNumber + ", Expected /" + reString + "/" + flags + " to throw \"" + expError + "\" got \"" + e + "\"");
@@ -158,6 +164,12 @@ function testRegExpSyntaxError(reString, flags, expError)
     }
 }
 
+function printErrors()
+{
+    if (errors)
+        throw "Test had " + errors + " errors";
+}
+
 // Test 1
 testRegExpSyntaxError("[\\p{RGI_Emoji_Tag_Sequence}a]", "u", "SyntaxError: Invalid regular expression: invalid property expression");
 testRegExpSyntaxError("\\P{Emoji_Keycap_Sequence}", "v", "SyntaxError: Invalid regular expression: negated class set may contain strings");
@@ -520,58 +532,105 @@ testRegExpSyntaxError("\\%", "u", "SyntaxError: Invalid regular expression: inva
 testRegExpSyntaxError("\\,", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\:", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 
-// Test 256
+// Test 261
 testRegExpSyntaxError("\\;", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\<", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\=", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\>", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\@", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 
-// Test 261
+// Test 266
 testRegExpSyntaxError("\\`", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\~", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("[\\&]", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("[\\!]", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("[\\#]", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 
-// Test 255
+// Test 260
 testRegExpSyntaxError("[\\%]", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("[\\,]", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("[\\:]", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("[\\;]", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("[\\<]", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 
-// Test 271
+// Test 276
 testRegExpSyntaxError("[\\=]", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("[\\>]", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("[\\@]", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("[\\`]", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("[\\~]", "u", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 
-// Test 276
+// Test 281
 testRegExpSyntaxError("\\&", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\-", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\!", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\#", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\%", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 
-// Test 281
+// Test 286
 testRegExpSyntaxError("\\,", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\:", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\;", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\<", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\=", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 
-// Test 286
+// Test 291
 testRegExpSyntaxError("\\>", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\@", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\`", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\~", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 testRegExpSyntaxError("\\q{a}", "v", "SyntaxError: Invalid regular expression: invalid escaped character for Unicode pattern");
 
-// Test 291
+// Test 296
 testRegExp(/[\&\-\!\#\%\,\:\;\<\=\>\@\`\~]*/v, "&-!#%,:;<=>@`~", ["&-!#%,:;<=>@`~"]);
 testRegExp(/[\q{\&\-\!\#\%\,\:\;\<\=\>\@\`\~}X]*/v, "X&-!#%,:;<=>@`~X", ["X&-!#%,:;<=>@`~X"]);
 testRegExp(/[\q{}]/v, "", [""]);
 testRegExp(/[\q{\u{0095}|k}]/vi, "k", ["k"]);
 testRegExp(/[\q{\u{0095}|s}]/vi, "s", ["s"]);
+
+// Test 301
+testRegExp(/[f[^a-z]]/v, "f", ["f"]);
+testRegExp(/[f[^a-z]]/v, "a", null);
+testRegExp(/[f[^a-z]]/v, "2", ["2"]);
+
+// Test 304
+testRegExp(/[^f[^a-z]]/v, "f", null);
+testRegExp(/[^f[^a-z]]/v, "a", ["a"]);
+testRegExp(/[^f[^a-z]]/v, "2", null);
+
+// Test 307
+testRegExp(/[^f[a-z]]/v, "f", null);
+testRegExp(/[^f[a-z]]/v, "a", null);
+testRegExp(/[^f[a-z]]/v, "2", ["2"]);
+
+// Test 310
+testRegExp(/[^[^[^[^[^[^[^[^[^[^[^[^abc]]]]]]]]]]]]/v, "a", ["a"]);
+testRegExp(/[^[^[^[^[^[^[^[^[^[^[^[^abc]]]]]]]]]]]]/v, "d", null);
+
+testRegExp(/[^[^[^[^[^[^[^[^[^[^[^abc]]]]]]]]]]]/v, "a", null);
+testRegExp(/[^[^[^[^[^[^[^[^[^[^[^abc]]]]]]]]]]]/v, "d", ["d"]);
+
+// Test 314
+testRegExp(/[a\u{1813}[^\u{0250}-\u{3373}a]]/v, "\u{0250}", null);
+testRegExp(/[a\u{1813}[^\u{0250}-\u{3373}a]]/v, "\u{1813}", ["\u{1813}"]);
+testRegExp(/[a\u{1813}[^\u{0250}-\u{3373}a]]/v, "a", ["a"]);
+
+// Test 317
+testRegExpSyntaxError("[a-[^a-z]]", "v", "SyntaxError: Invalid regular expression: invalid class set character");
+
+// Test 318
+testRegExp(/[f[^[a-m][n-z]]]/v, "f", "f");
+testRegExp(/[f[^[a-m][n-z]]]/v, "a", null);
+testRegExp(/[f[^[a-m][n-z]]]/v, "2", "2");
+
+// Test 321
+testRegExp(/[f[^[a-z]&&[a-f]]]/v, "f", "f");
+testRegExp(/[f[^[a-z]&&[a-f]]]/v, "a", null);
+testRegExp(/[f[^[a-z]&&[a-f]]]/v, "g", "g");
+testRegExp(/[f[^[a-z]&&[a-f]]]/v, "2", "2");
+
+testRegExp(/[f[^[a-z]--[a-f]]]/v, "f", "f");
+testRegExp(/[f[^[a-z]--[a-f]]]/v, "a", "a");
+testRegExp(/[f[^[a-z]--[a-f]]]/v, "g", null);
+testRegExp(/[f[^[a-z]--[a-f]]]/v, "2", "2");
+

JSTests/stress/value-bit-urshift-should-have-must-generate.js

@@ -0,0 +1,24 @@
+//@ runDefault("--useConcurrentJIT=0", "--jitPolicyScale=0")
+function shouldBe(actual, expected) {
+    if (actual !== expected)
+        throw new Error('bad value: ' + actual);
+}
+
+function f1(o, value) {
+    function f2()
+    {
+        o.x=value
+        return 2
+    }
+    let y={}
+    y.toString = f2
+    y >>> 1;
+  }
+
+  noInline(f1)
+  let obj={}
+  for (let v25 = 0; v25 < 100; v25++) {
+    f1(obj, v25);
+
+  }
+shouldBe(obj.x, 99)

JSTests/test262/expectations.yaml

@@ -76,9 +76,6 @@ test/built-ins/Proxy/construct/return-not-object-throws-undefined-realm.js:
 test/built-ins/Proxy/construct/trap-is-not-callable-realm.js:
   default: 'Test262Error: Expected a TypeError but got a different error constructor with the same name'
   strict mode: 'Test262Error: Expected a TypeError but got a different error constructor with the same name'
-test/built-ins/RegExp/property-escapes/special-property-value-Script_Extensions-Unknown.js:
-  default: 'SyntaxError: Invalid regular expression: invalid property expression'
-  strict mode: 'SyntaxError: Invalid regular expression: invalid property expression'
 test/built-ins/Temporal/Duration/compare/compare-no-precision-loss.js:
   default: 'Test262Error: Expected SameValue(«0», «0») to be false'
   strict mode: 'Test262Error: Expected SameValue(«0», «0») to be false'