Add strong mode.

test/cctest/test-parsing.cc

 // Copyright 2012 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 1743 matching lines @@
 }
 
 
 TEST(ErrorsEvalAndArguments) {
   // Tests that both preparsing and parsing produce the right kind of errors for
   // using "eval" and "arguments" as identifiers. Without the strict mode, it's
   // ok to use "eval" or "arguments" as identifiers. With the strict mode, it
   // isn't.
   const char* context_data[][2] = {
     { "\"use strict\";", "" },
+    { "\"use sanity\";", "" },
     { "var eval; function test_func() {\"use strict\"; ", "}"},
+    { "var eval; function test_func() {\"use sanity\"; ", "}"},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "var eval;",
     "var arguments",
     "var foo, eval;",
     "var foo, arguments;",
     "try { } catch (eval) { }",
     "try { } catch (arguments) { }",
@@ skipping 120 matching lines @@
 
 
 TEST(ErrorsFutureStrictReservedWords) {
   // Tests that both preparsing and parsing produce the right kind of errors for
   // using future strict reserved words as identifiers. Without the strict mode,
   // it's ok to use future strict reserved words as identifiers. With the strict
   // mode, it isn't.
   const char* context_data[][2] = {
     { "function test_func() {\"use strict\"; ", "}"},
     { "() => { \"use strict\"; ", "}" },
+    { "function test_func() {\"use sanity\"; ", "}"},
+    { "() => { \"use sanity\"; ", "}" },
     { NULL, NULL }
   };
 
   const char* statement_data[] {
     LIMITED_FUTURE_STRICT_RESERVED_WORDS(FUTURE_STRICT_RESERVED_STATEMENTS)
     NULL
   };
 
   RunParserSyncTest(context_data, statement_data, kError);
   RunParserSyncTest(context_data, statement_data, kError);
@@ skipping 174 matching lines @@
 
 TEST(ErrorsYieldStrict) {
   const char* context_data[][2] = {
     { "\"use strict\";", "" },
     { "\"use strict\"; function not_gen() {", "}" },
     { "function test_func() {\"use strict\"; ", "}"},
     { "\"use strict\"; function * gen() { function not_gen() {", "} }" },
     { "\"use strict\"; (function not_gen() {", "})" },
     { "\"use strict\"; (function * gen() { (function not_gen() {", "}) })" },
     { "() => {\"use strict\"; ", "}" },
+    { "\"use sanity\";", "" },
+    { "\"use sanity\"; function not_gen() {", "}" },
+    { "function test_func() {\"use sanity\"; ", "}"},
+    { "\"use sanity\"; function * gen() { function not_gen() {", "} }" },
+    { "\"use sanity\"; (function not_gen() {", "})" },
+    { "\"use sanity\"; (function * gen() { (function not_gen() {", "}) })" },
+    { "() => {\"use sanity\"; ", "}" },
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "var yield;",
     "var foo, yield;",
     "try { } catch (yield) { }",
     "function yield() { }",
     "(function yield() { })",
     "function foo(yield) { }",
@@ skipping 119 matching lines @@
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(ErrorsNameOfStrictFunction) {
   // Tests that illegal tokens as names of a strict function produce the correct
   // errors.
   const char* context_data[][2] = {
     { "function ", ""},
     { "\"use strict\"; function", ""},
+    { "\"use sanity\"; function", ""},
     { "function * ", ""},
     { "\"use strict\"; function * ", ""},
+    { "\"use sanity\"; function * ", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "eval() {\"use strict\";}",
     "arguments() {\"use strict\";}",
     "interface() {\"use strict\";}",
     "yield() {\"use strict\";}",
     // Future reserved words are always illegal
     "function super() { }",
@@ skipping 58 matching lines @@
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(ErrorsIllegalWordsAsLabelsStrict) {
   // Tests that illegal tokens as labels produce the correct errors.
   const char* context_data[][2] = {
     { "\"use strict\";", "" },
     { "function test_func() {\"use strict\"; ", "}"},
     { "() => {\"use strict\"; ", "}" },
+    { "\"use sanity\";", "" },
+    { "function test_func() {\"use sanity\"; ", "}"},
+    { "() => {\"use sanity\"; ", "}" },
     { NULL, NULL }
   };
 
 #define LABELLED_WHILE(NAME) #NAME ": while (true) { break " #NAME "; }",
   const char* statement_data[] = {
     "super: while(true) { break super; }",
     FUTURE_STRICT_RESERVED_WORDS(LABELLED_WHILE)
     NULL
   };
 #undef LABELLED_WHILE
@@ skipping 68 matching lines @@
 
 TEST(NoErrorsParenthesizedDirectivePrologue) {
   // Parenthesized directive prologue shouldn't be recognized.
   const char* context_data[][2] = {
     { "", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "(\"use strict\"); var eval;",
+    "(\"use sanity\"); var eval;",
     NULL
   };
 
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(ErrorsNotAnIdentifierName) {
   const char* context_data[][2] = {
     { "", ""},
@@ skipping 107 matching lines @@
     {"function foo(bar, eval) {", "}"},
     {"function foo(bar, arguments) {", "}"},
     {"function foo(bar, yield) {", "}"},
     {"function foo(bar, interface) {", "}"},
     {"function foo(bar, bar) {", "}"},
     { NULL, NULL }
   };
 
   const char* strict_statement_data[] = {
     "\"use strict\";",
+    "\"use sanity\";",
     NULL
   };
 
   const char* non_strict_statement_data[] = {
     ";",
     NULL
   };
 
   RunParserSyncTest(context_data, strict_statement_data, kError);
   RunParserSyncTest(context_data, non_strict_statement_data, kSuccess);
@@ skipping 281 matching lines @@
   // The test is quite slow, so run it with a reduced set of flags.
   static const ParserFlag empty_flags[] = {kAllowLazy};
   RunParserSyncTest(context_data, statement_data, kError, empty_flags, 1);
 }
 
 
 TEST(StrictDelete) {
   // "delete <Identifier>" is not allowed in strict mode.
   const char* strict_context_data[][2] = {
     {"\"use strict\"; ", ""},
+    {"\"use sanity\"; ", ""},
     { NULL, NULL }
   };
 
   const char* sloppy_context_data[][2] = {
     {"", ""},
     { NULL, NULL }
   };
 
   // These are errors in the strict mode.
   const char* sloppy_statement_data[] = {
@@ skipping 2119 matching lines @@
 }
 
 
 TEST(DeclarationsError) {
   const char* context_data[][2] = {{"'use strict'; if (true)", ""},
                                    {"'use strict'; if (false) {} else", ""},
                                    {"'use strict'; while (false)", ""},
                                    {"'use strict'; for (;;)", ""},
                                    {"'use strict'; for (x in y)", ""},
                                    {"'use strict'; do ", " while (false)"},
+                                   {"'use sanity'; if (true)", ""},
+                                   {"'use sanity'; if (false) {} else", ""},
+                                   {"'use sanity'; while (false)", ""},
+                                   {"'use sanity'; for (;;)", ""},
+                                   {"'use sanity'; for (x in y)", ""},
+                                   {"'use sanity'; do ", " while (false)"},
                                    {NULL, NULL}};

[rossberg, 2015/02/04 16:18:09]

Maybe add a test checking multiple directives.

[marja, 2015/02/05 12:11:37]

Done.

 
   const char* statement_data[] = {
     "let x = 1;",
     "const x = 1;",
     "class C {}",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyClasses, kAllowHarmonyScoping
   };
   RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }