[ESnext] Implement Object Rest

test/mjsunit/harmony/object-rest-basic.js

Index: test/mjsunit/harmony/object-rest-basic.js
diff --git a/test/mjsunit/harmony/object-rest-basic.js b/test/mjsunit/harmony/object-rest-basic.js
new file mode 100644
index 0000000000000000000000000000000000000000..a6a055480b632edff86ce25da3aa08e47b84ad46
--- /dev/null
+++ b/test/mjsunit/harmony/object-rest-basic.js
@@ -0,0 +1,104 @@
+// // Copyright 2016 the V8 project authors. All rights reserved.
+// // Use of this source code is governed by a BSD-style license that can be
+// // found in the LICENSE file.
+
+// Flags: --harmony-object-rest-spread

[adamk, 2017/01/17 19:56:33]

Some more ideas for tests:

- Patterns where there are keys which are Smis (1, 2)
- Patterns where the keys are doubles (e.g., 2.5)
- Rest in function params
- Rest in arrow parameters
- Further destructuring (both object and array patterns) in the rest position

[gsathya, 2017/01/17 21:59:23]

Done.

+var { ...x } = { a: 1 };
+assertEquals({ a: 1 }, x);
+
+var { ...x } = { a: 1, b: 1 };
+assertEquals({ a: 1, b: 1 }, x);
+
+var { x, ...x } = { a: 1, b: 1 };
+assertEquals({ a: 1, b: 1 }, x);
+
+var { x = {}, ...x } = { a: 1, b: 1 };
+assertEquals({ a: 1, b: 1 }, x);
+
+var { y, ...x } = { y: 1, a: 1 };
+assertEquals({ a: 1 }, x);
+assertEquals(1, y);
+
+var { z, y, ...x } = { z:1, y: 1, a: 1, b: 1 };
+assertEquals({ a: 1, b:1 }, x);
+assertEquals(1, y);
+assertEquals(1, z);
+
+({ a, ...b } = { a: 1, b: 2 });
+assertEquals(1, a);
+assertEquals({ b: 2 }, b);
+
+var { ...x } = {};
+assertEquals({}, x);
+
+var key = "b";
+var { [key]: y, ...x } = { b: 1, a: 1 };
+assertEquals({ a: 1 }, x);
+assertEquals(1, y);
+
+var key = 1;
+var { [key++]: y, ...x } = { 1: 1, a: 1 };
+assertEquals({ a: 1 }, x);
+assertEquals(key, 2);
+assertEquals(1, y);
+
+function example({a, ...rest}, { b = rest }) {
+    assertEquals(1, a);
+    assertEquals({ b: 2, c: 3}, rest);
+    assertEquals({ b: 2, c: 3}, b);
+};
+example({ a: 1, b: 2, c: 3}, { b: undefined });
+
+var x = { a: 3 };
+var y = {
+  set a(val) { assertUnreachable(); },
+  ...x,
+};
+assertEquals(y.a, 3);
+
+var x = {
+  get a() { throw new Error(); },
+};
+assertThrows(() => { var { ...y } = x });
+
+var p = new Proxy({}, {
+  ownKeys() { throw new Error(); }
+});
+assertThrows(() => { var { ...y } = p });
+
+var p = new Proxy({}, {
+  ownKeys() { [1]; },
+  get() { throw new Error(); }
+});
+assertThrows(() => { var { ...y } = p });
+
+var p = new Proxy({}, {
+  ownKeys() { [1]; },
+  getOwnPropertyDescriptor() { throw new Error(); }
+});
+assertThrows(() => { var { ...y } = p });
+
+var z = { b: 1}
+var p = new Proxy(z, {
+  ownKeys() { return Object.keys(z); },
+  get(_, prop) { return z[prop]; },
+  getOwnPropertyDescriptor(_, prop) {
+    return Object.getOwnPropertyDescriptor(z, prop);
+  },
+});
+var { ...y } = p ;
+assertEquals(z, y);
+
+var z = { b: 1}
+var { ...y } =  { ...z} ;
+assertEquals(z, y);
+
+var count = 0;
+class Foo {
+  constructor(x) { this.x = x; }
+  toString() { count++; return this.x.toString(); }
+}
+var f = new Foo(1);
+var { [f] : x, ...y } = { 1: 1, 2: 2}
+assertEquals(1, count);
+assertEquals({2: 2}, y);