Upgrade to upstream WebKit 33ce3bf11a71

Configurations/CommonBase.xcconfig

@@ -137,6 +137,16 @@ WK_SWIFT_MEMORY_SAFETY_ERROR_FLAGS = -Werror StrictMemorySafety -Werror ForeignR
 // rdar://164903024: Work around false positives in some SDK versions.
 WK_SWIFT_MEMORY_SAFETY_ERROR_FLAGS[sdk=*26.3*] = ;
 
+// Treat VariableNeverMutated warnings as errors only with SDKs that ship Swift 6.4 or later. Swift 6.3
+// needs `var` bindings in some places to work around rdar://170907318.
+WK_SWIFT_VARIABLE_NEVER_MUTATED_ERROR_FLAGS = -Werror VariableNeverMutated;
+WK_SWIFT_VARIABLE_NEVER_MUTATED_ERROR_FLAGS[sdk=*26.*] = ;
+
+// Treat UnusedImportAccess warnings as errors only with SDKs that ship Swift 6.4 or later. Swift 6.3
+// doesn't support the `@diagnose` attribute used to suppress existing violations.
+WK_SWIFT_UNUSED_IMPORT_ACCESS_ERROR_FLAGS = -Werror UnusedImportAccess;
+WK_SWIFT_UNUSED_IMPORT_ACCESS_ERROR_FLAGS[sdk=*26.*] = ;
+
 // rdar://168992837 requires us to tell swiftc to tell clang how to set version macros
 // when interpreting C++ headers as clang modules, so that we get identical feature
 // enablement to C++ interpretation of those headers (otherwise we get mismatched data members etc.)
@@ -145,6 +155,6 @@ WK_SWIFT_CLANG_DEPLOYMENT_TARGET_macosx = -clang-target $(CURRENT_ARCH)-apple-ma
 
 // rdar://170129992: remove -track-system-dependencies when resolved
 // FIXME(rdar://189511928, rdar://189512247): remove -disable-round-trip-debug-types when both are resolved
-OTHER_SWIFT_FLAGS = $(inherited) $(WK_AVAILABILITY_OVERLAY_SWIFT_FLAGS) -Xcc -fvisibility=hidden -Werror ExistentialAny -Werror NoUseUnstructuredThrowingTask -Werror NoUsage -enable-upcoming-feature ExistentialAny $(WK_SWIFT_MEMORY_SAFETY_FLAGS) $(WK_SWIFT_MEMORY_SAFETY_ERROR_FLAGS) $(WK_SWIFT_CLANG_DEPLOYMENT_TARGET) $(WK_SANITIZER_OTHER_SWIFT_FLAGS) -enable-upcoming-feature InternalImportsByDefault -enable-upcoming-feature MemberImportVisibility -track-system-dependencies -enable-experimental-feature ImportCxxMembersLazily -enable-experimental-feature SuppressedAssociatedTypes -enable-experimental-feature SuppressedAssociatedTypesWithDefaults -enable-experimental-feature ForeignReferenceTypeInheritance -Xfrontend -disable-round-trip-debug-types -enable-experimental-feature SafeInteropWrappers;
+OTHER_SWIFT_FLAGS = $(inherited) $(WK_AVAILABILITY_OVERLAY_SWIFT_FLAGS) -Xcc -fvisibility=hidden -Werror ExistentialAny -Werror NoUseUnstructuredThrowingTask -Werror NoUsage $(WK_SWIFT_VARIABLE_NEVER_MUTATED_ERROR_FLAGS) $(WK_SWIFT_UNUSED_IMPORT_ACCESS_ERROR_FLAGS) -enable-upcoming-feature ExistentialAny $(WK_SWIFT_MEMORY_SAFETY_FLAGS) $(WK_SWIFT_MEMORY_SAFETY_ERROR_FLAGS) $(WK_SWIFT_CLANG_DEPLOYMENT_TARGET) $(WK_SANITIZER_OTHER_SWIFT_FLAGS) -enable-upcoming-feature InternalImportsByDefault -enable-upcoming-feature MemberImportVisibility -track-system-dependencies -enable-experimental-feature ImportCxxMembersLazily -enable-experimental-feature SuppressedAssociatedTypes -enable-experimental-feature SuppressedAssociatedTypesWithDefaults -enable-experimental-feature ForeignReferenceTypeInheritance -Xfrontend -disable-round-trip-debug-types -enable-experimental-feature SafeInteropWrappers;
 
 OTHER_LIBTOOLFLAGS = -no_warning_for_no_symbols;

Configurations/Version.xcconfig

@@ -23,7 +23,7 @@
 
 MAJOR_VERSION = 627;
 MINOR_VERSION = 1;
-TINY_VERSION = 4;
+TINY_VERSION = 5;
 MICRO_VERSION = 0;
 NANO_VERSION = 0;
 FULL_VERSION = $(MAJOR_VERSION).$(MINOR_VERSION).$(TINY_VERSION);

JSTests/microbenchmarks/array-literal-with-only-holes.js

@@ -0,0 +1,16 @@
+function test(x) {
+    let pair = [,,];
+    pair[0] = x + 0.5;
+    pair[1] = x - 0.5;
+    let quad = [,,,,];
+    quad[0] = x;
+    quad[3] = x;
+    return pair[0] + pair[1] + quad.length;
+}
+noInline(test);
+
+let result = 0;
+for (let i = 0; i < 2e6; ++i)
+    result += test(i);
+if (result !== 3999998000000 + 8e6)
+    throw new Error("bad result " + result);

JSTests/microbenchmarks/for-of-map-set-mixed.js

@@ -0,0 +1,19 @@
+function test(iterable) {
+    let sum = 0;
+    for (const e of iterable) {
+        if (typeof e === "number")
+            sum += e;
+        else
+            sum += e[0] + e[1];
+    }
+    return sum;
+}
+noInline(test);
+
+const map = new Map([[1, 10], [2, 20], [3, 30], [4, 40], [5, 50]]);
+const set = new Set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+
+for (let i = 0; i < 1e5; ++i) {
+    test(map);
+    test(set);
+}

JSTests/microbenchmarks/intl-collator-compare-16bit-long-prefix-primary-diff.js

@@ -0,0 +1,15 @@
+function test(collator, a, b, n) {
+    let result = 0;
+    for (let i = 0; i < n; ++i)
+        result += collator.compare(a, b);
+    return result;
+}
+
+let collator = new Intl.Collator("en");
+let prefix = "The quick brown fox jumps over the lazy dog 0123456789 ABCDEFGHIJ";
+let a = $vm.make16BitStringIfPossible(prefix + "a");
+let b = $vm.make16BitStringIfPossible(prefix + "b");
+
+let result = test(collator, a, b, 2e6);
+if (result !== -2e6)
+    throw new Error("Bad result: " + result);

JSTests/microbenchmarks/intl-collator-compare-equal-long.js

@@ -0,0 +1,15 @@
+function test(collator, a, b, n) {
+    let result = 0;
+    for (let i = 0; i < n; ++i)
+        result += collator.compare(a, b);
+    return result;
+}
+
+let collator = new Intl.Collator("en");
+let text = "The quick brown fox jumps over the lazy dog 0123456789 ABCDEFGHIJ";
+let a = text.split("").join("");
+let b = text.split("").join("");
+
+let result = test(collator, a, b, 2e6);
+if (result !== 0)
+    throw new Error("Bad result: " + result);

JSTests/microbenchmarks/intl-collator-compare-first-char-diff.js

@@ -0,0 +1,15 @@
+function test(collator, a, b, n) {
+    let result = 0;
+    for (let i = 0; i < n; ++i)
+        result += collator.compare(a, b);
+    return result;
+}
+
+let collator = new Intl.Collator("en");
+let suffix = "he quick brown fox jumps over the lazy dog 0123456789 ABCDEFGHIJ";
+let a = ("a" + suffix).split("").join("");
+let b = ("b" + suffix).split("").join("");
+
+let result = test(collator, a, b, 2e6);
+if (result !== -2e6)
+    throw new Error("Bad result: " + result);

JSTests/microbenchmarks/intl-collator-compare-long-prefix-case-diff.js

@@ -0,0 +1,15 @@
+function test(collator, a, b, n) {
+    let result = 0;
+    for (let i = 0; i < n; ++i)
+        result += collator.compare(a, b);
+    return result;
+}
+
+let collator = new Intl.Collator("en");
+let prefix = "The quick brown fox jumps over the lazy dog 0123456789 ABCDEFGHIJ";
+let a = (prefix + "a").split("").join("");
+let b = (prefix + "A").split("").join("");
+
+let result = test(collator, a, b, 2e6);
+if (result !== -2e6)
+    throw new Error("Bad result: " + result);

JSTests/microbenchmarks/intl-collator-compare-long-prefix-different-length.js

@@ -0,0 +1,15 @@
+function test(collator, a, b, n) {
+    let result = 0;
+    for (let i = 0; i < n; ++i)
+        result += collator.compare(a, b);
+    return result;
+}
+
+let collator = new Intl.Collator("en");
+let prefix = "The quick brown fox jumps over the lazy dog 0123456789 ABCDEFGHIJ";
+let a = prefix.split("").join("");
+let b = (prefix + "z").split("").join("");
+
+let result = test(collator, a, b, 2e6);
+if (result !== -2e6)
+    throw new Error("Bad result: " + result);

JSTests/microbenchmarks/intl-collator-compare-long-prefix-primary-diff.js

@@ -0,0 +1,15 @@
+function test(collator, a, b, n) {
+    let result = 0;
+    for (let i = 0; i < n; ++i)
+        result += collator.compare(a, b);
+    return result;
+}
+
+let collator = new Intl.Collator("en");
+let prefix = "The quick brown fox jumps over the lazy dog 0123456789 ABCDEFGHIJ";
+let a = (prefix + "a").split("").join("");
+let b = (prefix + "b").split("").join("");
+
+let result = test(collator, a, b, 2e6);
+if (result !== -2e6)
+    throw new Error("Bad result: " + result);

JSTests/microbenchmarks/intl-collator-compare-sort-short-keys.js

@@ -0,0 +1,38 @@
+function makeKeys(count)
+{
+    let syllables = ["ka", "ri", "to", "Mo", "su", "Na", "be", "lo", "Ze", "pi", "du", "fa", "ge", "ho", "Ji", "wu"];
+    let keys = [];
+    let seed = 1;
+    for (let i = 0; i < count; ++i) {
+        let key = "";
+        let length = 4 + (i % 5);
+        for (let j = 0; j < length; ++j) {
+            seed = (seed * 1103515245 + 12345) & 0x7fffffff;
+            key += syllables[seed % syllables.length];
+        }
+        keys.push(key);
+    }
+    return keys;
+}
+
+function test(collator, keys, n) {
+    let checksum = 0;
+    for (let i = 0; i < n; ++i) {
+        let sorted = keys.slice().sort(collator.compare);
+        checksum += sorted[0].length + sorted[sorted.length - 1].length;
+    }
+    return checksum;
+}
+
+let collator = new Intl.Collator("en");
+let keys = makeKeys(500);
+let sorted = keys.slice().sort(collator.compare);
+for (let i = 1; i < sorted.length; ++i) {
+    if (collator.compare(sorted[i - 1], sorted[i]) > 0)
+        throw new Error("Bad order at " + i);
+}
+
+let expected = (sorted[0].length + sorted[sorted.length - 1].length) * 3000;
+let result = test(collator, keys, 3000);
+if (result !== expected)
+    throw new Error("Bad result: " + result);

JSTests/microbenchmarks/new-regexp-with-flags.js

@@ -0,0 +1,10 @@
+var patterns = ["fo+", "ba[rz]", "x.*y", "^f$"];
+var flags = ["g", "i", "gi", "m"];
+
+function test(pattern, flags) {
+    return new RegExp(pattern, flags);
+}
+noInline(test);
+
+for (var i = 0; i < 1e6; ++i)
+    test(patterns[i & 3], flags[(i >> 2) & 3]);

JSTests/microbenchmarks/put-by-id-transition-on-array.js

@@ -0,0 +1,15 @@
+(function() {
+    function tag(array, value) {
+        array.tag = value;
+        return array;
+    }
+    noInline(tag);
+
+    var result = 0;
+    for (var i = 0; i < 2000000; ++i) {
+        var array = tag([i, i + 1], i);
+        result += array.tag + array[1];
+    }
+    if (result !== 4000000000000)
+        throw new Error("Bad result: " + result);
+})();

JSTests/microbenchmarks/put-by-val-with-symbol-transition-on-empty-array.js

@@ -0,0 +1,16 @@
+(function() {
+    var symbol = Symbol("tag");
+
+    function tag(array, value) {
+        array[symbol] = value;
+        return array;
+    }
+
+    var result = 0;
+    for (var i = 0; i < 2000000; ++i) {
+        var array = tag([], i);
+        result += array[symbol] + array.length;
+    }
+    if (result !== 1999999000000)
+        throw new Error("Bad result: " + result);
+})();

JSTests/microbenchmarks/spread-typed-array.js

@@ -0,0 +1,11 @@
+function test(typedArray) {
+    return [...typedArray];
+}
+noInline(test);
+
+const typedArray = new Uint8Array(32);
+for (let i = 0; i < typedArray.length; i++)
+    typedArray[i] = i;
+
+for (let i = 0; i < 1e6; i++)
+    test(typedArray);

JSTests/microbenchmarks/string-pad-start-short.js

@@ -0,0 +1,9 @@
+var strings = ["1", "2", "3", "4", "15", "26", "37", "48"];
+
+function test(string) {
+    return string.padStart(2, "0") + string.padStart(8, "0") + string.padEnd(8);
+}
+noInline(test);
+
+for (var i = 0; i < 1e6; ++i)
+    test(strings[i & 7]);

JSTests/microbenchmarks/string-replace-all-short-string.js

@@ -0,0 +1,13 @@
+var strings = ["foo", "bar", "xfoooy", "baz", "fo", "f"];
+
+function replacer(match) {
+    return "0";
+}
+
+function test(string) {
+    return string.replaceAll("o", "0") + string.replaceAll("o", replacer) + string.replace("o", replacer);
+}
+noInline(test);
+
+for (var i = 0; i < 1e6; ++i)
+    test(strings[i % 6]);

JSTests/microbenchmarks/string-split-regexp-optional-cr-then-lf.js

@@ -0,0 +1,17 @@
+function splitLines(text)
+{
+    return text.split(/\r?\n/);
+}
+noInline(splitLines);
+
+const lines = [];
+for (let i = 0; i < 200; ++i)
+    lines.push("line " + i + " " + "x".repeat((i * 7) % 60));
+const lf = lines.join("\n");
+const crlf = lines.join("\r\n");
+
+let count = 0;
+for (let i = 0; i < 1e4; ++i)
+    count += splitLines(lf).length + splitLines(crlf).length;
+if (count !== 4e6)
+    throw new Error("bad count: " + count);

JSTests/microbenchmarks/typed-array-set-concat.js

@@ -0,0 +1,25 @@
+function concat(chunks, result) {
+    let offset = 0;
+    for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return offset;
+}
+noInline(concat);
+
+const chunks = [];
+for (let i = 0; i < 16; i++) {
+    const chunk = new Uint8Array(8 + i * 8);
+    chunk.fill(i + 1);
+    chunks.push(chunk);
+}
+const result = new Uint8Array(1088);
+
+let total = 0;
+for (let i = 0; i < 1e6; i++)
+    total += concat(chunks, result);
+
+if (total !== 1088e6 || result[0] !== 1 || result[1087] !== 16)
+    throw new Error("bad: " + total);

JSTests/microbenchmarks/typed-array-set-small.js

@@ -0,0 +1,15 @@
+function test(target, source, offset) {
+    target.set(source, offset);
+}
+noInline(test);
+
+const target = new Uint8Array(64);
+const source = new Uint8Array(16);
+for (let i = 0; i < source.length; i++)
+    source[i] = i + 1;
+
+for (let i = 0; i < 1e7; i++)
+    test(target, source, i & 31);
+
+if (target[46] !== 16)
+    throw new Error("bad: " + target[46]);