Proper handling of future reserved words in strict and normal mode.

test/mjsunit/strict-mode.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 49 matching lines @@
     Function.apply(this, args);
   }, SyntaxError);
 }
 
 // Incorrect 'use strict' directive.
 (function UseStrictEscape() {
   "use\\x20strict";
   with ({}) {};
 })();
 
+// Incorrectly place 'use strict' directive.
+assertThrows("function foo (x) 'use strict'; {}", SyntaxError);
+
 // 'use strict' in non-directive position.
 (function UseStrictNonDirective() {
   void(0);
   "use strict";
   with ({}) {};
 })();
 
 // Multiple directives, including "use strict".
 assertThrows('\
 "directive 1";\
@@ skipping 232 matching lines @@
 })();
 
 // Prefix unary operators other than delete, ++, -- are valid in strict mode
 (function StrictModeUnaryOperators() {
   "use strict";
   var x = [void eval, typeof eval, +eval, -eval, ~eval, !eval];
   var y = [void arguments, typeof arguments,
            +arguments, -arguments, ~arguments, !arguments];
 })();
 
-// 7.6.1.2 Future Reserved Words
-var future_reserved_words = [
-  "class",
-  "enum",
-  "export",
-  "extends",
-  "import",
-  "super",
+// 7.6.1.2 Future Reserved Words in strict mode
+var future_strict_reserved_words = [
   "implements",
   "interface",
   "let",
   "package",
   "private",
   "protected",
   "public",
   "static",
   "yield" ];
 
-function testFutureReservedWord(word) {
+function testFutureStrictReservedWord(word) {
   // Simple use of each reserved word
   CheckStrictMode("var " + word + " = 1;", SyntaxError);
+  CheckStrictMode("typeof (" + word + ");", SyntaxError);
 
   // object literal properties
   eval("var x = { " + word + " : 42 };");
   eval("var x = { get " + word + " () {} };");
   eval("var x = { set " + word + " (value) {} };");
+  eval("var x = { get " + word + " () { 'use strict'; } };");
+  eval("var x = { set " + word + " (value) { 'use strict'; } };");
 
   // object literal with string literal property names
   eval("var x = { '" + word + "' : 42 };");
   eval("var x = { get '" + word + "' () { } };");
   eval("var x = { set '" + word + "' (value) { } };");
   eval("var x = { get '" + word + "' () { 'use strict'; } };");
   eval("var x = { set '" + word + "' (value) { 'use strict'; } };");
 
   // Function names and arguments, strict and non-strict contexts
   CheckStrictMode("function " + word + " () {}", SyntaxError);
   CheckStrictMode("function foo (" + word + ") {}", SyntaxError);
   CheckStrictMode("function foo (" + word + ", " + word + ") {}", SyntaxError);
   CheckStrictMode("function foo (a, " + word + ") {}", SyntaxError);
   CheckStrictMode("function foo (" + word + ", a) {}", SyntaxError);
   CheckStrictMode("function foo (a, " + word + ", b) {}", SyntaxError);
   CheckStrictMode("var foo = function (" + word + ") {}", SyntaxError);
 
   // Function names and arguments when the body is strict
   assertThrows("function " + word + " () { 'use strict'; }", SyntaxError);
-  assertThrows("function foo (" + word + ")  'use strict'; {}", SyntaxError);
   assertThrows("function foo (" + word + ", " + word + ") { 'use strict'; }",
                SyntaxError);
   assertThrows("function foo (a, " + word + ") { 'use strict'; }", SyntaxError);
   assertThrows("function foo (" + word + ", a) { 'use strict'; }", SyntaxError);
   assertThrows("function foo (a, " + word + ", b) { 'use strict'; }",
                SyntaxError);
   assertThrows("var foo = function (" + word + ") { 'use strict'; }",
                SyntaxError);
 
   // get/set when the body is strict
-  eval("var x = { get " + word + " () { 'use strict'; } };");
-  eval("var x = { set " + word + " (value) { 'use strict'; } };");
+  // Getters don't have formal parameters, so particularly future reserved
+  // keywords are disallowed.
   assertThrows("var x = { get foo(" + word + ") { 'use strict'; } };",
                SyntaxError);
   assertThrows("var x = { set foo(" + word + ") { 'use strict'; } };",
                SyntaxError);
 }
 
-for (var i = 0; i < future_reserved_words.length; i++) {
-  testFutureReservedWord(future_reserved_words[i]);
+for (var i = 0; i < future_strict_reserved_words.length; i++) {
+  testFutureStrictReservedWord(future_strict_reserved_words[i]);
 }
 
 function testAssignToUndefined(test, should_throw) {
   try {
     test();
   } catch (e) {
     assertTrue(should_throw, "strict mode");
     assertInstanceof(e, ReferenceError, "strict mode");
     return;
   }
@@ skipping 783 matching lines @@
     assertEquals(test(i), true);
   }
 })();
 
 
 (function TestStrictModeEval() {
   "use strict";
   eval("var eval_local = 10;");
   assertThrows(function() { return eval_local; }, ReferenceError);
 })();