[destructuring] Support computed property names in patterns.

test/mjsunit/harmony/destructuring.js

 // Copyright 2015 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-destructuring
+// Flags: --harmony-destructuring --harmony-computed-property-names
 
 (function TestObjectLiteralPattern() {
   var { x : x, y : y } = { x : 1, y : 2 };
   assertEquals(1, x);
   assertEquals(2, y);
 
   var {z} = { z : 3 };
   assertEquals(3, z);
 
 
@@ skipping 260 matching lines @@
   }, ReferenceError);
 
   (function() {
     'use strict';
     let {x = (function() { x = 2; }())} = {x:1};
     assertSame(1, x);
   }());
 }());
 
 
+(function TestComputedNames() {

[rossberg, 2015/05/19 11:50:34]

Add tests with computed accessor and method names. Do they actually work
already?

[Dmitry Lomov (no reviews), 2015/05/19 14:07:28]

Uhm, accessors and method names are not allowed in patterns :)

+  var x = 1;
+  var {[x]:y} = {1:2};
+  assertSame(2, y);
+
+  (function(){
+    'use strict';
+    let {[x]:y} = {1:2};
+    assertSame(2, y);
+  }());
+
+  var callCount = 0;
+  function foo(v) { callCount++; return v; }
+
+  (function() {
+    callCount = 0;
+    var {[foo("abc")]:x} = {abc:42};
+    assertSame(42, x);
+    assertEquals(1, callCount);
+  }());
+
+  (function() {
+    'use strict';
+    callCount = 0;
+    let {[foo("abc")]:x} = {abc:42};
+    assertSame(42, x);
+    assertEquals(1, callCount);
+  }());
+
+  (function() {
+    callCount = 0;
+    var {[foo("abc")]:x} = {};
+    assertSame(undefined, x);
+    assertEquals(1, callCount);
+  }());
+
+  (function() {
+    'use strict';
+    callCount = 0;
+    let {[foo("abc")]:x} = {};
+    assertSame(undefined, x);
+    assertEquals(1, callCount);
+  }());
+
+  for (val of [null, undefined]) {
+    callCount = 0;
+    assertThrows(function() {
+      var {[foo()]:x} = val;
+    }, TypeError);
+    assertEquals(0, callCount);
+
+    callCount = 0;
+    assertThrows(function() {
+      'use strict';
+      let {[foo()]:x} = val;
+    }, TypeError);
+    assertEquals(0, callCount);
+  }
+}());

[arv (Not doing code reviews), 2015/05/19 14:19:56]

Can haz order tests?

var log = [];
var obj = {
  get x() {
    log.push('get x');
    return 1;
  },
  get y() {
    log.push('get y');
    return 2;
  },
};
function f(name) {
  log.push(`f ${name}`);
}
var {[f('x')]: x, [f('y')]: y} = obj;
assertArrayEquals(log, ['f x', 'f y', 'get x', get y']);

[Dmitry Lomov (no reviews), 2015/05/19 14:52:00]

Done.

+
+
 (function TestExceptions() {
   for (var val of [null, undefined]) {
     assertThrows(function() { var {} = val; }, TypeError);
     assertThrows(function() { var {x} = val; }, TypeError);
     assertThrows(function() { var { x : {} } = { x : val }; }, TypeError);
     assertThrows(function() { 'use strict'; let {} = val; }, TypeError);
     assertThrows(function() { 'use strict'; let {x} = val; }, TypeError);
     assertThrows(function() { 'use strict'; let { x : {} } = { x : val }; },
                  TypeError);
   }
 }());