Add class to existing lexical scoping tests

test/mjsunit/harmony/block-let-declaration-sloppy.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 15 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Test let declarations in various settings.
 
 // Flags: --no-legacy-const --harmony-sloppy --harmony-sloppy-let
 
 // Global
 let x;
 let y = 2;
 const z = 4;
+class c { static foo() { return 1; } }
 
 // Block local
 {
   let y;
   let x = 3;
   const z = 5;
+  class c { static foo() { return 2; } }
 }
 
 assertEquals(undefined, x);
 assertEquals(2,y);
 assertEquals(4,z);
+assertEquals(1, c.foo());
 
 if (true) {
   let y;
   assertEquals(undefined, y);
 }
 
 // Invalid declarations are early errors in harmony mode and thus should trigger
 // an exception in eval code during parsing, before even compiling or executing
 // the code. Thus the generated function is not called here.
 function TestLocalThrows(str, expect) {
@@ skipping 42 matching lines @@
 // Test var declarations in 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 class declarations with initialisers in statement positions.
+TestLocalThrows("if (true) class x { };", SyntaxError);
+TestLocalThrows("if (true) {} else class x { };", SyntaxError);
+TestLocalThrows("do class x { }; while (false)", SyntaxError);
+TestLocalThrows("while (false) class x { };", SyntaxError);
+TestLocalThrows("label: class x { };", SyntaxError);
+TestLocalThrows("for (;false;) class x { };", SyntaxError);
+TestLocalDoesNotThrow("switch (true) { case true: class x { }; }");
+TestLocalDoesNotThrow("switch (true) { default: class x { }; }");
+
 // Test that redeclarations of functions are only allowed in outermost scope.
 TestLocalThrows("{ let f; var f; }");
 TestLocalThrows("{ var f; let f; }");
 TestLocalThrows("{ function f() {} let f; }");
 TestLocalThrows("{ let f; function f() {} }");
 TestLocalThrows("{ function f() {} var f; }");
 TestLocalThrows("{ var f; function f() {} }");
+TestLocalThrows("{ function f() {} class f {} }");
+TestLocalThrows("{ class f {}; function f() {} }");
 TestLocalThrows("{ function f() {} function f() {} }");
 TestLocalThrows("function f() {} let f;");
 TestLocalThrows("let f; function f() {}");
+TestLocalThrows("function f() {} class f {}");
+TestLocalThrows("class f {}; function f() {}");
 TestLocalDoesNotThrow("function arg() {}");
 TestLocalDoesNotThrow("function f() {} var f;");
 TestLocalDoesNotThrow("var f; function f() {}");
 TestLocalDoesNotThrow("function f() {} function f() {}");
 
 function g(f) {
   function f() { return 1 }
   return f()
 }
 assertEquals(1, g(function() { return 2 }))
@@ skipping 19 matching lines @@
 
 // Test function declarations in statement position in strict mode.
 TestLocalThrows("function f() { if (true) function g() {} }", SyntaxError);
 TestLocalThrows("function f() { if (true) {} else function g() {} }", SyntaxError);
 TestLocalThrows("function f() { do function g() {} while (false) }", SyntaxError);
 TestLocalThrows("function f() { while (false) function g() {} }", SyntaxError);
 TestLocalThrows("function f() { label: function g() {} }", SyntaxError);
 TestLocalThrows("function f() { for (;false;) function g() {} }", SyntaxError);
 TestLocalDoesNotThrow("function f() { switch (true) { case true: function g() {} } }");
 TestLocalDoesNotThrow("function f() { switch (true) { default: function g() {} } }");