[es6] Scoping & initialization for var shadowing non-simple parameters

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-arrow-functions
 // Flags: --harmony-default-parameters --harmony-rest-parameters
 
 (function TestObjectLiteralPattern() {
   var { x : x, y : y, get, set } = { x : 1, y : 2, get: 3, set: 4 };
   assertEquals(1, x);
@@ skipping 939 matching lines @@
   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 ok1(x) { var x; return x; };
   assertEquals(1, ok1(1));
   function ok2(x) { 'use strict'; { let x = 2; return x; } };
   assertEquals(2, ok2(1));
-
-  assertThrows("function f({x}) { var x; }; f({});", SyntaxError);
-  assertThrows("function f({x}) { { var x; } }; f({});", SyntaxError);
-  assertThrows("'use strict'; function f(x) { let x = 0; }; f({});", SyntaxError);
-  assertThrows("'use strict'; function f({x}) { let x = 0; }; f({});", SyntaxError);
 }());
 
 
+(function TestShadowingOfParameters() {

[adamk, 2015/09/29 18:28:29]

Can you add tests with multiple parameters that get matching vars? Also a test
where both destructured and simple parameters get matching vars.

[rossberg, 2015/09/30 14:50:48]

Done.

+  function f1({x}) { var x = 2; return x }
+  assertEquals(2, f1({x: 1}));
+  function f2({x}) { { var x = 2; } return x; }
+  assertEquals(2, f2({x: 1}));
+  function f3({x}) { var y = x; var x = 2; return y; }
+  assertEquals(1, f3({x: 1}));
+  function f4({x}, g = () => x) { { var y = x; var x = 2; } return y; }
+  assertEquals(1, f4({x: 1}));
+  function f5({x}, g = () => x) { var x = 2; return g(); }
+  assertEquals(1, f5({x: 1}));
+  function f6({x}, g = () => x) { { var x = 2; } return g(); }
+  assertEquals(1, f6({x: 1}));
+  function f7({x}) { var g = () => x; var x = 2; return g(); }
+  assertEquals(2, f7({x: 1}));
+  function f8({x}) { { var g = () => x; var x = 2; } return g(); }
+  assertEquals(2, f8({x: 1}));
+  function f9({x}, g = () => eval("x")) { var x = 2; return g(); }
+  assertEquals(1, f9({x: 1}));
+
+  function f10({x}) { function x() { return 2 }; return x(); }
+  assertEquals(2, f10({x: 1}));
+  function f11({x}) { { function x() { return 2 } } return x(); }
+  assertEquals(2, f11({x: 1}));
+
+  var g1 = ({x}) => { var x = 2; return x };
+  assertEquals(2, g1({x: 1}));
+  var g2 = ({x}) => { { var x = 2; } return x; };
+  assertEquals(2, g2({x: 1}));
+  var g3 = ({x}) => { var y = x; var x = 2; return y; };
+  assertEquals(1, g3({x: 1}));
+  var g4 = ({x}, g = () => x) => { { var y = x; var x = 2; } return y; };
+  assertEquals(1, g4({x: 1}));
+  var g5 = ({x}, g = () => x) => { var x = 2; return g(); };
+  assertEquals(1, g5({x: 1}));
+  var g6 = ({x}, g = () => x) => { { var x = 2; } return g(); };
+  assertEquals(1, g6({x: 1}));
+  var g7 = ({x}) => { var g = () => x; var x = 2; return g(); };
+  assertEquals(2, g7({x: 1}));
+  var g8 = ({x}) => { { var g = () => x; var x = 2; } return g(); };
+  assertEquals(2, g8({x: 1}));
+  var g9 = ({x}, g = () => eval("x")) => { var x = 2; return g(); };
+  assertEquals(1, g9({x: 1}));
+
+  var g10 = ({x}) => { function x() { return 2 }; return x(); }
+  assertEquals(2, g10({x: 1}));
+  var g11 = ({x}) => { { function x() { return 2 } } return x(); }
+  assertEquals(2, g11({x: 1}));
+
+  assertThrows("'use strict'; function f(x) { let x = 0; }; f({});", SyntaxError);
+  assertThrows("'use strict'; function f({x}) { let x = 0; }; f({});", SyntaxError);
+  assertThrows("'use strict'; function f(x) { const x = 0; }; f({});", SyntaxError);
+  assertThrows("'use strict'; function f({x}) { const x = 0; }; f({});", SyntaxError);
+
+  assertThrows("'use strict'; let g = (x) => { let x = 0; }; f({});", SyntaxError);
+  assertThrows("'use strict'; let g = ({x}) => { let x = 0; }; f({});", SyntaxError);
+  assertThrows("'use strict'; let g = (x) => { const x = 0; }; f({});", SyntaxError);
+  assertThrows("'use strict'; let g = ({x}) => { const x = 0; }; f({});", SyntaxError);
+}());
+
+
 (function TestArgumentsForNonSimpleParameters() {
   function f1({}, x) { arguments[1] = 0; return x }
   assertEquals(6, f1({}, 6));
   function f2({}, x) { x = 2; return arguments[1] }
   assertEquals(7, f2({}, 7));
   function f3(x, {}) { arguments[0] = 0; return x }
   assertEquals(6, f3(6, {}));
   function f4(x, {}) { x = 2; return arguments[0] }
   assertEquals(7, f4(7, {}));
   function f5(x, ...a) { arguments[0] = 0; return x }
@@ skipping 38 matching lines @@
   assertThrows(function(){ eval("({}) => {'use strict';}") }, SyntaxError);
   assertThrows(
     function(){ eval("(class{foo({}) {'use strict';}});") }, SyntaxError);
 
   assertThrows(
     function(){ eval("function(a, {}){'use strict';}") }, SyntaxError);
   assertThrows(function(){ eval("(a, {}) => {'use strict';}") }, SyntaxError);
   assertThrows(
     function(){ eval("(class{foo(a, {}) {'use strict';}});") }, SyntaxError);
 })();