Fix pre-parsing function declarations.

test/mjsunit/harmony/block-let-declaration.js

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 30 matching lines @@
 
 assertEquals(undefined, x);
 assertEquals(2,y);
 
 if (true) {
   let y;
   assertEquals(undefined, y);
 }
 
 function TestLocalThrows(str, expect) {
   assertThrows("(function(){" + str + "})()", expect);

[Lasse Reichstein, 2011/09/21 10:29:34]

If this is early errors (and I guess it is), you shouldn't call the generated
function. It should fail even if the function is never compiled.

[Steven, 2011/09/21 12:03:28]

Yes they are early errors. Done.
On 2011/09/21 10:29:34, Lasse Reichstein wrote:

 }
 
 function TestLocalDoesNotThrow(str) {
   assertDoesNotThrow("(function(){" + str + "})()");

[Lasse Reichstein, 2011/09/21 10:29:34]

But keep the call here. It should never fail, not even if compiled lazily.

[Steven, 2011/09/21 12:03:28]

Done.

 }
 
-// Unprotected statement
+// Test let declarations statement positions.
 TestLocalThrows("if (true) let x;", SyntaxError);
+TestLocalThrows("if (true) {} else let x;", SyntaxError);
 TestLocalThrows("do let x; while (false)", SyntaxError);
 TestLocalThrows("while (false) let x;", SyntaxError);
+TestLocalThrows("label: let x;", SyntaxError);
+TestLocalThrows("for (;false;) let x;", SyntaxError);
+TestLocalThrows("switch (true) { case true: let x; }", SyntaxError);
+TestLocalThrows("switch (true) { default: let x; }", SyntaxError);
 
+// Test var declarations statement positions.
 TestLocalDoesNotThrow("if (true) var x;");
+TestLocalDoesNotThrow("if (true) {} else var x;");
 TestLocalDoesNotThrow("do var x; while (false)");
 TestLocalDoesNotThrow("while (false) var x;");
+TestLocalDoesNotThrow("label: var x;");
+TestLocalDoesNotThrow("for (;false;) var x;");
+TestLocalDoesNotThrow("switch (true) { case true: var x; }");
+TestLocalDoesNotThrow("switch (true) { default: var x; }");
+
+// Test function declarations in source element and
+// non-strict statement positions.

[Lasse Reichstein, 2011/09/21 10:29:34]

Can you have a non-strict statement position in harmony-block-scoping mode?
I would assume that any harmony enabling flag would make everything strict mode
code (or if not, perhaps it should?)

[Steven, 2011/09/21 12:03:28]

Indeed the harmony proposals actually take the ES5 strict mode as a base, so in
general yes it should be all strict mode code and ultimately we should do that.
For now I have refrained from doing that yet and just added it orthogonally so
that I can use some features from ES5 normal mode for test cases (notably
forcing dynamic lookups using 'with').
On 2011/09/21 10:29:34, Lasse Reichstein wrote:

+function f() {
+  // Non-strict source element positions.
+  function g0() {
+    "use strict";
+    // Strict source element positions.
+    function h() { }
+    {
+      function h1() { }
+    }
+  }
+  {
+    function g1() { }
+  }
+  // Non-strict statement positions.
+  if (true) function g2() { }
+  if (true) {} else function g3() { }
+  do function g4() { } while (false)
+  while (false) function g5() { }
+  label: function g6() { }
+  for (;false;) function g7() { }
+  switch (true) { case true: function g8() { } }
+  switch (true) { default: function g9() { } }
+
+}

[Lasse Reichstein, 2011/09/21 10:29:34]

Call f here, to ensure that it isn't lazily compiled and throws at runtime.

[Steven, 2011/09/21 12:03:28]

Done.

+
+// Test function declarations in statement position in strict mode.
+TestLocalThrows("function f() { 'use strict'; if (true) function g() {}", SyntaxError);
+TestLocalThrows("function f() { 'use strict'; if (true) {} else function g() {}", SyntaxError);
+TestLocalThrows("function f() { 'use strict'; do function g() {} while (false)", SyntaxError);
+TestLocalThrows("function f() { 'use strict'; while (false) function g() {}", SyntaxError);
+TestLocalThrows("function f() { 'use strict'; label: function g() {}", SyntaxError);
+TestLocalThrows("function f() { 'use strict'; for (;false;) function g() {}", SyntaxError);
+TestLocalThrows("function f() { 'use strict'; switch (true) { case true: function g() {} }", SyntaxError);
+TestLocalThrows("function f() { 'use strict'; switch (true) { default: function g() {} }", SyntaxError);