[strong] Implement static restrictions on direct eval

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 5893 matching lines @@
                     arraysize(always_flags));
   RunParserSyncTest(strict_context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
   RunParserSyncTest(strong_context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
   RunParserSyncTest(sloppy_context_data, local_strong, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
+TEST(StrongDirectEval) {
+  const char* context_data[][2] = {{"", ""}, {NULL}};
+
+  const char* error_data[] = {
+      "'use strong'; eval();",
+      "'use strong'; eval([]);",
+      "'use strong'; (eval)();",
+      "'use strong'; (((eval)))();",
+      "'use strong'; eval('function f() {}');",
+      "'use strong'; function f() {eval()}",

[marja, 2015/04/13 19:13:07]

For this kind of a test, it would be useful to put the "use strong" into the
context_data, and then have another non-strong context too.

Then you can test that none of these is an error in the non-strong context. This
protects you from testing errors where you make random typos and other random
syntax errors here (so that the cause of the error is something else than what
you meant).

+      NULL};
+
+  const char* success_data[] = {
+      "'use strong'; eval;",
+      "'use strong'; eval`foo`;",
+      "'use strong'; let foo = eval; foo();",
+      "'use strong'; (1, eval)();",
+      NULL};
+
+  static const ParserFlag always_flags[] = {
+      kAllowStrongMode
+  };
+
+  RunParserSyncTest(context_data, error_data, kError, NULL, 0,
+                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, success_data, kSuccess, NULL, 0,
+                    always_flags, arraysize(always_flags));
+}
+
+
 TEST(ArrowFunctionASIErrors) {
   const char* context_data[][2] = {{"'use strict';", ""}, {"", ""},
                                    {NULL, NULL}};
 
   const char* data[] = {
       "(a\n=> a)(1)",
       "(a/*\n*/=> a)(1)",
       "((a)\n=> a)(1)",
       "((a)/*\n*/=> a)(1)",
       "((a, b)\n=> a + b)(1, 2)",
@@ skipping 146 matching lines @@
     v8::Script::Compile(v8_str(script3));
     CHECK(try_catch2.HasCaught());
     v8::String::Utf8Value exception(try_catch2.Exception());
     CHECK_EQ(0,
              strcmp(
                  "ReferenceError: In strong mode, using an undeclared global "
                  "variable 'not_there3' is not allowed",
                  *exception));
   }
 }