@@ -1,3 +1,25 @@
+2021-04-26  Alexey Shvayka  <shvaikalesh@gmail.com>
+
+        [JSC] OrdinarySet should invoke custom [[Set]] methods
+        https://bugs.webkit.org/show_bug.cgi?id=217916
+
+        Reviewed by Yusuke Suzuki.
+
+        * microbenchmarks/put-slow-no-cache-array.js: Added.
+        * microbenchmarks/put-slow-no-cache-function.js: Added.
+        * microbenchmarks/put-slow-no-cache-js-proxy.js: Added.
+        * microbenchmarks/put-slow-no-cache-long-prototype-chain.js: Added.
+        * microbenchmarks/put-slow-no-cache.js: Added.
+        * microbenchmarks/reflect-set-with-receiver.js: Added.
+        * stress/custom-get-set-proto-chain-put.js:
+        * stress/module-namespace-access-set-fails.js: Added.
+        * stress/put-non-reified-static-accessor-or-custom.js: Added.
+        * stress/put-non-reified-static-function-or-custom.js: Added.
+        * stress/put-to-primitive-non-reified-static-custom.js: Added.
+        * stress/put-to-primitive.js: Added.
+        * stress/put-to-proto-chain-overrides-put.js: Added.
+        * stress/typed-array-canonical-numeric-index-string-set.js: Added.
+
 2021-04-22  Yusuke Suzuki  <ysuzuki@apple.com>
 
         [JSC] Baseline should have fast path for switch_imm
 
@@ -0,0 +1,6 @@
+(function() {
+    var array = [];
+
+    for (var j = 0; j < 1e5; j++)
+        array["foo" + j] = j;
+})();
@@ -0,0 +1,8 @@
+(function() {
+    class A {}
+    class B extends A {}
+    class C extends B {}
+
+    for (var j = 0; j < 1e5; j++)
+        C["foo" + j] = j;
+})();
@@ -0,0 +1,6 @@
+(function() {
+    var proxy = $vm.createProxy({ set foo(_v) {} });
+
+    for (var j = 0; j < 1e5; j++)
+        proxy["foo" + j] = j;
+})();
@@ -0,0 +1,8 @@
+(function() {
+    var base = { set foo(_v) {} };
+    for (var i = 0; i < 1e3; i++)
+        base = Object.create(base);
+
+    for (var j = 0; j < 3e3; j++)
+        base["foo" + j] = j;
+})();
@@ -0,0 +1,6 @@
+(function() {
+    var base = { set foo(_v) {} };
+
+    for (var j = 0; j < 1e5; j++)
+        base["foo" + j] = j;
+})();
@@ -0,0 +1,6 @@
+(function() {
+    var target = new (class {});
+
+    for (var i = 0; i < 1e6; i++)
+        Reflect.set(target, "foo", 1, {});
+})();
@@ -37,8 +37,8 @@ function getObjects() {
         ...primitives.map(Object),
         Object.create(customTestGetterSetter),
         Object.create(Object.create(customTestGetterSetter)),
-        // FIXME: ordinarySetSlow() should handle Custom{Accessor,Value} descriptors.
-        // new Proxy(customTestGetterSetter, {}),
+        Object.create(new Proxy(customTestGetterSetter, {})),
+        Object.create($vm.createProxy(customTestGetterSetter)),
     ];
 }
 
@@ -85,13 +85,13 @@ function getBases() {
 })();
 
 // CustomValue: setter returns |false|
+// FIXME: Once legacy RegExp features are implemented, there would be no use case for calling CustomValue setter if receiver is altered.
 (() => {
     for (let base of getBases()) {
         for (let i = 0; i < 100; ++i)
             base.customValue = 1;
-        // This is weird, but it isn't exposed to userland code:
         assert(!base.hasOwnProperty("customValue"));
-        assert(!Reflect.set(Object(base), "customValue", 1));
+        assert(Reflect.set(Object(base), "customValue", 1));
     }
 })();
 
 
@@ -0,0 +1,90 @@
+const existingKeys = ["cocoa", "test", Symbol.toStringTag];
+const nonExistingKeys = ["foo", Symbol("foo")];
+const allKeys = [...existingKeys, ...nonExistingKeys];
+const testValue = Object.freeze({});
+
+function assert(x, key) {
+    if (!x)
+        throw new Error(`Bad assertion! Key: ${String(key)}`);
+}
+
+function shouldThrow(func, errorMessage) {
+    let errorThrown = false;
+    try {
+        func();
+    } catch (error) {
+        errorThrown = true;
+        if (String(error) !== errorMessage)
+            throw new Error(`Bad error: ${error}`);
+    }
+    if (!errorThrown)
+        throw new Error("Didn't throw!");
+}
+
+function testDirectSet(ns) {
+    for (const key of allKeys) {
+        ns[key] = testValue;
+        assert(ns[key] !== testValue, key);
+
+        shouldThrow(() => { "use strict"; ns[key] = testValue; }, "TypeError: Attempted to assign to readonly property.");
+        assert(ns[key] !== testValue, key);
+    }
+}
+
+function testPrototypeChainSet(ns) {
+    for (const key of allKeys) {
+        const heir = Object.create(ns);
+
+        heir[key] = testValue;
+        assert(Object.getOwnPropertyDescriptor(heir, key) === undefined, key);
+
+        shouldThrow(() => { "use strict"; heir[key] = testValue; }, "TypeError: Attempted to assign to readonly property.");
+        assert(Object.getOwnPropertyDescriptor(heir, key) === undefined, key);
+    }
+}
+
+function testReflectSet(ns) {
+    "use strict";
+
+    for (const existingKey of existingKeys) {
+        assert(!Reflect.set(ns, existingKey, testValue), existingKey);
+
+        const target = {};
+        assert(!Reflect.set(target, existingKey, testValue, ns), existingKey);
+
+        const isWritable = existingKey !== Symbol.toStringTag;
+        assert(Reflect.set(target, existingKey, ns[existingKey], ns) === isWritable, existingKey);
+
+        assert(ns[existingKey] !== testValue, existingKey);
+        assert(target[existingKey] === undefined, existingKey);
+    }
+
+    for (const nonExistingKey of nonExistingKeys) {
+        assert(!Reflect.set(ns, nonExistingKey, testValue), nonExistingKey);
+        assert(ns[nonExistingKey] === undefined, nonExistingKey);
+
+        const target = {};
+        assert(!Reflect.set(target, nonExistingKey, testValue, ns), nonExistingKey);
+        assert(target[nonExistingKey] === undefined, nonExistingKey);
+    }
+
+    for (const key of allKeys) {
+        const target = Object.create(ns);
+        const receiver = {};
+
+        assert(!Reflect.set(target, key, testValue, receiver), key);
+        assert(Object.getOwnPropertyDescriptor(target, key) === undefined, key);
+        assert(Object.getOwnPropertyDescriptor(receiver, key) === undefined, key);
+    }
+}
+
+import("./resources/module-namespace-access.js").then(ns => {
+    testDirectSet(ns);
+    testPrototypeChainSet(ns);
+    testReflectSet(ns);
+}).catch(err => {
+    print(`!!! ${err}\n${err.stack}`);
+    $vm.abort();
+});
+
+drainMicrotasks();
@@ -0,0 +1,58 @@
+"use strict";
+const testValue = Object.freeze({});
+
+function assert(x, key) {
+    if (!x)
+        throw new Error(`Key: "${key}". Bad assertion!`);
+}
+
+function* testCases() {
+    for (const key of ["description"])
+        yield [$vm.createGlobalObject().Symbol.prototype, key];
+    for (const key of ["buffer", "byteLength", "byteOffset"])
+        yield [$vm.createGlobalObject().DataView.prototype, key];
+    for (const key of ["baseName", "caseFirst", "hourCycle", "numeric", "region"])
+        yield [$vm.createGlobalObject().Intl.Locale.prototype, key];
+
+    for (const key of ["testStaticAccessorDontEnum", "testStaticAccessorReadOnly"])
+        yield [$vm.createStaticCustomAccessor(), key];
+    yield [$vm.createStaticCustomValue(), "testStaticValueReadOnly"];
+}
+
+for (const [object, key] of testCases()) {
+    const target = {};
+    assert(!Reflect.set(target, key, testValue, object), key);
+    assert(!target.hasOwnProperty(key), key);
+    assert(Object.getOwnPropertyDescriptor(object, key).value !== testValue, key);
+}
+
+for (const [object, key] of testCases()) {
+    Object.defineProperty(object, key, { value: {}, writable: false });
+    const target = {};
+    assert(!Reflect.set(target, key, testValue, object), key);
+    assert(!target.hasOwnProperty(key), key);
+    assert(Object.getOwnPropertyDescriptor(object, key).value !== testValue, key);
+}
+
+for (const [object, key] of testCases()) {
+    Object.defineProperty(object, key, { value: {}, writable: true, configurable: false });
+    object[key] = testValue;
+
+    const desc = Object.getOwnPropertyDescriptor(object, key);
+    assert(desc.value === testValue, key);
+    assert(desc.writable, key);
+    assert(!desc.enumerable, key);
+    assert(!desc.configurable, key);
+}
+
+for (const [object, key] of testCases()) {
+    Object.defineProperty(object, key, { value: {}, writable: true, enumerable: true });
+    const target = {};
+    assert(Reflect.set(target, key, testValue, object), key);
+
+    const desc = Object.getOwnPropertyDescriptor(object, key);
+    assert(desc.value === testValue, key);
+    assert(desc.writable, key);
+    assert(desc.enumerable, key);
+    assert(desc.configurable, key);
+}