[es6] Implement inner scope for functions with destructuring

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 --harmony-computed-property-names
 // Flags: --harmony-arrow-functions
 
 (function TestObjectLiteralPattern() {
   var { x : x, y : y } = { x : 1, y : 2 };
   assertEquals(1, x);
@@ skipping 698 matching lines @@
   assertEquals(8, g1(7, {a : 6, b : 5}));
 
   var g2 = ({c, d}, {a, b}) => { return c - d + a - b; };
   assertEquals(7, g2({c : 7, d : 1}, {a : 6, b : 5}));
 
   var g3 = ([{a, b}]) => { return a - b; };
   assertEquals(1, g3([{a : 6, b : 5}]));
 }());
 
 
+(function TestParameterScoping() {
+  var x = 1;
+
+  function f1({a = x}) { var x = 2; return a; }
+  assertEquals(1, f1({}));
+  function f2({a = x}) { function x() {}; return a; }
+  assertEquals(1, f2({}));
+  function f3({a = x}) { 'use strict'; let x = 2; return a; }
+  assertEquals(1, f3({}));
+  function f4({a = x}) { 'use strict'; const x = 2; return a; }
+  assertEquals(1, f4({}));
+  function f5({a = x}) { 'use strict'; function x() {}; return a; }
+  assertEquals(1, f5({}));
+
+  var g1 = ({a = x}) => { var x = 2; return a; };
+  assertEquals(1, g1({}));
+  var g2 = ({a = x}) => { function x() {}; return a; };
+  assertEquals(1, g2({}));
+  var g3 = ({a = x}) => { 'use strict'; let x = 2; return a; };
+  assertEquals(1, g3({}));
+  var g4 = ({a = x}) => { 'use strict'; const x = 2; return a; };
+  assertEquals(1, g4({}));
+  var g5 = ({a = x}) => { 'use strict'; function x() {}; return a; };
+  assertEquals(1, g5({}));
+
+  var y = 'a';
+  function f6({[y]: x}) { var y = 'b'; return x; }
+  assertEquals(1, f6({a: 1, b: 2}));
+  var g6 = ({[y]: x}) => { var y = 'b'; return x; };
+  assertEquals(1, g6({a: 1, b: 2}));
+})();
+
+
 (function TestDuplicatesInParameters() {
   assertThrows("'use strict';function f(x,x){}", SyntaxError);
   assertThrows("'use strict';function f({x,x}){}", SyntaxError);
   assertThrows("'use strict';function f(x, {x}){}", SyntaxError);
   assertThrows("'use strict';var f = (x,x) => {};", SyntaxError);
   assertThrows("'use strict';var f = ({x,x}) => {};", SyntaxError);
   assertThrows("'use strict';var f = (x, {x}) => {};", SyntaxError);
 
   function ok(x) { var x; }; ok();
-  assertThrows("function f({x}) { var x; }; f({});", SyntaxError);
-  assertThrows("'use strict'; function f({x}) { let x = 0; }; f({});", SyntaxError);
+  // TODO(rossberg): Check for variable collision.

[adamk, 2015/07/13 19:27:31]

Do you mean to take care of this in this patch or a followup?

[rossberg, 2015/07/14 06:24:51]

I leave that for a future CL. Leaving out this check for now does not break
anything, other than allowing a few more programs.

+  // assertThrows("function f({x}) { var x; }; f({});", SyntaxError);
+  // assertThrows("'use strict'; function f({x}) { let x = 0; }; f({});", SyntaxError);
 }());
 
 
 (function TestForInOfTDZ() {
   assertThrows("'use strict'; let x = {}; for (let [x, y] of {x});", ReferenceError);
   assertThrows("'use strict'; let x = {}; for (let [y, x] of {x});", ReferenceError);
   assertThrows("'use strict'; let x = {}; for (let [x, y] in {x});", ReferenceError);
   assertThrows("'use strict'; let x = {}; for (let [y, x] in {x});", ReferenceError);
 }());