LibJS: Use a custom property_name_to_value method instead of to_value

Userland/Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-defineProperty.js

@@ -27,6 +27,25 @@ describe("[[DefineProperty]] trap normal behavior", () => {
         Object.defineProperty(p, "foo", { configurable: true, writable: true, value: 10 });
     });
 
+    test("correct arguments passed to trap even for number", () => {
+        let o = {};
+        p = new Proxy(o, {
+            defineProperty(target, name, descriptor) {
+                expect(target).toBe(o);
+                expect(name).toBe("1");
+                expect(descriptor.configurable).toBeTrue();
+                expect(descriptor.enumerable).toBeUndefined();
+                expect(descriptor.writable).toBeTrue();
+                expect(descriptor.value).toBe(10);
+                expect(descriptor.get).toBeUndefined();
+                expect(descriptor.set).toBeUndefined();
+                return true;
+            },
+        });
+
+        Object.defineProperty(p, 1, { configurable: true, writable: true, value: 10 });
+    });
+
     test("optionally ignoring the define call", () => {
         let o = {};
         let p = new Proxy(o, {

Userland/Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-deleteProperty.js

@@ -18,6 +18,19 @@ describe("[[Delete]] trap normal behavior", () => {
         delete p.foo;
     });
 
+    test("correct arguments passed to trap even for number", () => {
+        let o = {};
+        let p = new Proxy(o, {
+            deleteProperty(target, property) {
+                expect(target).toBe(o);
+                expect(property).toBe("1");
+                return true;
+            },
+        });
+
+        delete p[1];
+    });
+
     test("conditional deletion", () => {
         o = { foo: 1, bar: 2 };
         p = new Proxy(o, {

Userland/Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-get.js

@@ -18,6 +18,19 @@ describe("[[Get]] trap normal behavior", () => {
         p.foo;
     });
 
+    test("correct arguments passed to trap even for number", () => {
+        let o = {};
+        let p = new Proxy(o, {
+            get(target, property, receiver) {
+                expect(target).toBe(o);
+                expect(property).toBe("1");
+                expect(receiver).toBe(p);
+            },
+        });
+
+        p[1];
+    });
+
     test("conditional return", () => {
         let o = { foo: 1 };
         let p = new Proxy(o, {

Userland/Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-getOwnPropertyDescriptor.js

@@ -24,6 +24,18 @@ describe("[Call][GetOwnProperty]] trap normal behavior", () => {
         Object.getOwnPropertyDescriptor(p, "foo");
     });
 
+    test("correct arguments passed to trap even for number", () => {
+        let o = {};
+        let p = new Proxy(o, {
+            getOwnPropertyDescriptor(target, property) {
+                expect(target).toBe(o);
+                expect(property).toBe("1");
+            },
+        });
+
+        Object.getOwnPropertyDescriptor(p, 1);
+    });
+
     test("conditional returned descriptor", () => {
         let o = { foo: "bar" };
         Object.defineProperty(o, "baz", {

Userland/Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-has.js

@@ -18,6 +18,19 @@ describe("[[Has]] trap normal behavior", () => {
         "foo" in p;
     });
 
+    test("correct arguments passed to trap even for number", () => {
+        let o = {};
+        let p = new Proxy(o, {
+            has(target, prop) {
+                expect(target).toBe(o);
+                expect(prop).toBe("1");
+                return true;
+            },
+        });
+
+        1 in p;
+    });
+
     test("conditional return", () => {
         let o = {};
         let p = new Proxy(o, {

Userland/Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-set.js

@@ -20,6 +20,21 @@ describe("[[Set]] trap normal behavior", () => {
         p.foo = 10;
     });
 
+    test("correct arguments passed to trap even for number", () => {
+        let o = {};
+        let p = new Proxy(o, {
+            set(target, prop, value, receiver) {
+                expect(target).toBe(o);
+                expect(prop).toBe("1");
+                expect(value).toBe(10);
+                expect(receiver).toBe(p);
+                return true;
+            },
+        });
+
+        p[1] = 10;
+    });
+
     test("conditional return value", () => {
         let p = new Proxy(
             {},