@@ -1,3 +1,19 @@
+2021-02-18  Caio Lima  <ticaiolima@gmail.com>
+
+        [JSC] Implement private static method
+        https://bugs.webkit.org/show_bug.cgi?id=219181
+
+        Reviewed by Yusuke Suzuki.
+
+        * stress/class-private-method-access.js: Added.
+        * stress/private-accessor-static-non-static.js: Added.
+        * stress/private-getter-inner-class.js:
+        * stress/static-private-methods-and-accessor-inner-class.js: Added.
+        * stress/static-private-methods-and-accessor-multiple-evaluation.js: Added.
+        * stress/static-private-methods-and-accessors-postfix-node.js: Added.
+        * stress/static-private-methods-and-accessors-prefix-node.js: Added.
+        * test262/config.yaml:
+
 2021-02-18  Michael Saboff  <msaboff@apple.com>
 
         [JSC] Implement RegExp Match Indices proposal
 
@@ -0,0 +1,113 @@
+//@ requireOptions("--usePrivateMethods=true")
+
+function assert(a, e) {
+    if (a !== e)
+        throw new Error("Expected: " + e + " but got: " + a);
+}
+
+function assertThrows(expectedError, f) {
+    try {
+        f();
+    } catch (e) {
+        assert(e instanceof expectedError, true);
+    }
+}
+
+(() => {
+    class C {
+        static get #m() {
+            return 'static';
+        }
+
+        static staticAccess() {
+            return this.#m;
+        }
+
+        get #f() {
+            return 'instance';
+        }
+
+        instanceAccess() {
+            return this.#f;
+        }
+    }
+
+    let c = new C();
+    assert(C.staticAccess(), 'static');
+    assert(c.instanceAccess(), 'instance');
+
+    assertThrows(TypeError, () => {
+        C.staticAccess.call(c);
+    });
+
+    assertThrows(TypeError, () => {
+        c.instanceAccess.call(C);
+    });
+})();
+
+(() => {
+    class C {
+        static #m() {
+            return 'static';
+        }
+
+        static staticAccess() {
+            return this.#m();
+        }
+
+        #f() {
+            return 'instance';
+        }
+
+        instanceAccess() {
+            return this.#f();
+        }
+    }
+
+    let c = new C();
+    assert(C.staticAccess(), 'static');
+    assert(c.instanceAccess(), 'instance');
+
+    assertThrows(TypeError, () => {
+        C.staticAccess.call(c);
+    });
+
+    assertThrows(TypeError, () => {
+        c.instanceAccess.call(C);
+    });
+})();
+
+(() => {
+    class C {
+        static set #m(v) {
+            this._m = v;
+        }
+
+        static staticAccess() {
+            this.#m = 'static';
+        }
+
+        set #f(v) {
+            this._f = v;
+        }
+
+        instanceAccess() {
+            this.#f = 'instance';
+        }
+    }
+
+    let c = new C();
+    C.staticAccess();
+    assert(C._m, 'static');
+    c.instanceAccess()
+    assert(c._f, 'instance');
+
+    assertThrows(TypeError, () => {
+        C.staticAccess.call(c);
+    });
+
+    assertThrows(TypeError, () => {
+        c.instanceAccess.call(C);
+    });
+})();
+
@@ -0,0 +1,44 @@
+//@ run("--useClassFields=true --usePrivateMethods=true")
+
+function assert(a, e, m) {
+    if (a !== e)
+        throw new Error(m);
+}
+
+function assertSyntaxError(code) {
+    try {
+        eval(code);
+        throw new Error("Code executed without throwing SyntaxError");
+    } catch (e) {
+        assert(e instanceof SyntaxError, true, e.message);
+    }
+}
+
+assertSyntaxError(`
+    class C {
+        static get #m() {}
+        set #m(v) {}
+    }
+`);
+
+assertSyntaxError(`
+    class C {
+        get #m() {}
+        static set #m(v) {}
+    }
+`);
+
+assertSyntaxError(`
+    class C {
+        static set #m(v) {}
+        get #m() {}
+    }
+`);
+
+assertSyntaxError(`
+    class C {
+        set #m(v) {}
+        static get #m() {}
+    }
+`);
+
@@ -126,7 +126,7 @@ let assert = {
     assert.sameValue(c.method(), 'outer class');
 
     assert.throws(TypeError, function() {
-        innerB.method(c);
+        C.prototype.method.call(innerB);
     });
 })();