[es6] conditionally ignore TDZ semantics for formals

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 } = { x : 1, y : 2 };
   assertEquals(1, x);
@@ skipping 938 matching lines @@
   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);
+  assertDoesNotThrow("function f({x}) { var x; }; f({});");

[adamk, 2015/09/09 00:07:02]

So this is no longer an error, but yet

function f({x = undefined}) { var x; }

is an error.

Seems like there's a deeper problem here. I need to tech up my spec-reading to
fully grok IteratorBindingInitialization, but it seems like the let-binding-ness
shouldn't have anything to do with the ContainsExpression bit.

[caitp (gmail), 2015/09/09 00:24:48]

That's a known issue. I have two plans to fix it. But, there's a cost: one
requires the implementation of the spec change from July 29th re: directives in
functions with non-simple parameters, and the other requires a change to the ast
node to track the declaration kind of a variable declaration. So i thought I'd
keep that as a TODO for now. What do you think? The AST change is just so the
redeclaration error can be avoided for lexical parameters.

+  assertDoesNotThrow("function f({x}) { { var x; } }; f({});");
+  assertDoesNotThrow("'use strict'; function f({x}) { var x; }; f({});");
+  assertDoesNotThrow("'use strict'; function f({x}) { { var x; } }; f({});");
   assertThrows("'use strict'; function f(x) { let x = 0; }; f({});", SyntaxError);
   assertThrows("'use strict'; function f({x}) { let 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));
@@ skipping 43 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);
 })();