Parse harmony let 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
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// Flags: --allow-natives-syntax --harmony-block-scoping
-// Test functionality of block scopes.
+// Flags: --harmony-block-scoping
 
-// Hoisting of var declarations.
-function f1() {
-  {
-    var x = 1;
-    var y;
-  }
-  assertEquals(1, x)
-  assertEquals(undefined, y)
+// Test let declarations in various settings.
+
+// Global
+let x;
+let y = 2;
+
+// Block local
+{
+  let y;
+  let x = 3;
 }
-f1();
 
-// Dynamic lookup through block scopes.
-function f2(one) {
-  var x = one + 1;
-  // TODO(keuchel): introduce let
-  // let y = one + 2;
-  if (one == 1) {
-    // Parameter
-    assertEquals(1, eval('one'));
-    // Function local var variable
-    assertEquals(2, eval('x'));
-    // Function local let variable
-    // TODO(keuchel): introduce let
-    // assertEquals(3, eval('y'));
-  }
+if (true) {
+  let x;
 }
-f2(1);
 

[Lasse Reichstein, 2011/08/16 11:00:46]

Try checking the value of x and y here, just for sanity.

[Steven, 2011/08/16 15:06:08]

Done.

+// Unprotected statement
+assertThrows("if (true) let x;", SyntaxError);
+assertThrows("with ({}) let x;", SyntaxError);
+assertThrows("do let x; while (false)", SyntaxError);
+assertThrows("while (false) let x;", SyntaxError);
+

[Lasse Reichstein, 2011/08/16 11:00:46]

Notic that these code blocks are executed using a direct call to eval in
non-strict code - i.e., they use the declaration environment of its surrounding
code (which is inside a block).
If that eval turned into an indirect call (which it REALLY should), the code
would be global (and no longer throw?).

If you want to explicitly check eval code, wrap a call to eval in a function
instead of relying on the implementation of assertThrows.

[Steven, 2011/08/16 15:06:08]

It's more like checking the parser.

On 2011/08/16 11:00:46, Lasse Reichstein wrote:

+assertDoesNotThrow("if (true) var x;");
+assertDoesNotThrow("with ({}) var x;");
+assertDoesNotThrow("do var x; while (false)");
+assertDoesNotThrow("while (false) var x;");