Test for miscellaneous (pre)parse errors.

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 1357 matching lines @@
     "try { } catch (eval) { }",
     "try { } catch (arguments) { }",
     "function eval() { }",
     "function arguments() { }",
     "function foo(eval) { }",
     "function foo(arguments) { }",
     "function foo(bar, eval) { }",
     "function foo(bar, arguments) { }",
     "eval = 1;",
     "arguments = 1;",
+    "var foo = eval = 1;",
+    "var foo = arguments = 1;",
     "++eval;",
     "++arguments;",
     "eval++;",
     "arguments++;",
     NULL
   };
 
   v8::HandleScope handles(CcTest::isolate());
   v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate());
   v8::Context::Scope context_scope(context);
@@ skipping 34 matching lines @@
   // mode, it isn't.
   const char* context_data[][2] = {
     { "", "" },
     { "\"use strict\";", "}" },
     { "var eval; function test_func() {", "}"},
     { "var eval; function test_func() {\"use strict\"; ", "}"},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
-    "var interface = 42;",
+    "var interface;",
     "var foo, interface;",
     "try { } catch (interface) { }",
     "function interface() { }",
     "function foo(interface) { }",
     "function foo(bar, interface) { }",
     "interface = 1;",
+    "var foo = interface = 1;",
     "++interface;",
     "interface++;",
     NULL
   };
 
   v8::HandleScope handles(CcTest::isolate());
   v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate());
   v8::Context::Scope context_scope(context);
 
   int marker;
@@ skipping 31 matching lines @@
   // strict mode.
   const char* context_data[][2] = {
     { "", "" },
     { "\"use strict\";", "}" },
     { "var eval; function test_func() {", "}"},
     { "var eval; function test_func() {\"use strict\"; ", "}"},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
-    "var super = 42;",
+    "var super;",
     "var foo, super;",
     "try { } catch (super) { }",
     "function super() { }",
     "function foo(super) { }",
     "function foo(bar, super) { }",
     "super = 1;",
+    "var foo = super = 1;",
     "++super;",
     "super++;",
     "function foo super",
     NULL
   };
 
   v8::HandleScope handles(CcTest::isolate());
   v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate());
   v8::Context::Scope context_scope(context);
 
@@ skipping 44 matching lines @@
   };
 
   const char* statement_data[] = {
     "var yield;",
     "var foo, yield;",
     "try { } catch (yield) { }",
     "function yield() { }",
     "function foo(yield) { }",
     "function foo(bar, yield) { }",
     "yield = 1;",
+    "var foo = yield = 1;",
     "++yield;",
     "yield++;",
     "yield 2;",  // this is legal inside generator
     "yield * 2;",  // this is legal inside generator
     NULL
   };
 
   v8::HandleScope handles(CcTest::isolate());
   v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate());
   v8::Context::Scope context_scope(context);
@@ skipping 18 matching lines @@
       int length = i::OS::SNPrintF(program,
                                    "%s%s%s",
                                    context_data[i][0],
                                    statement_data[j],
                                    context_data[i][1]);
       CHECK(length == kProgramSize);
       TestParserSync(program.start(), flags, ARRAY_SIZE(flags));
     }
   }
 }
+
+
+TEST(ErrorsNameOfStrictFunction) {
+  // Tests that illegal tokens as names of a strict function produce the correct
+  // errors.
+  const char* statement_data[] = {
+    "function eval() { }",  // legal
+    "function eval() {\"use strict\";}",  // illegal
+    "function arguments() { }",  // legal
+    "function arguments() {\"use strict\";}",  // illegal
+    // Future reserved words are always illegal
+    "function super() { }",  // illegal
+    "function super() {\"use strict\";}",  // illegal
+    "function interface() { }",  // legal
+    "function interface() {\"use strict\";}",  // illegal
+    "function yield() { }",  // legal
+    "function yield() {\"use strict\";}",  // illegal
+    NULL
+  };
+
+  v8::HandleScope handles(CcTest::isolate());
+  v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate());
+  v8::Context::Scope context_scope(context);
+
+  int marker;
+  CcTest::i_isolate()->stack_guard()->SetStackLimit(
+      reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);
+
+  static const ParserFlag flags[] = {
+    kAllowLazy, kAllowHarmonyScoping, kAllowModules, kAllowGenerators,
+    kAllowForOf
+  };
+  for (int j = 0; statement_data[j] != NULL; ++j) {
+    TestParserSync(statement_data[j], flags, ARRAY_SIZE(flags));
+  }
+}
+
+
+TEST(ErrorsIllegalWordsAsLabels) {
+  // Tests that illegal tokens as labels produce the correct errors.
+  const char* context_data[][2] = {
+    { "", "" },
+    { "\"use strict\";", "}" },
+    { NULL, NULL }
+  };
+
+  const char* statement_data[] = {
+    "mylabel: while(true) { break mylabel; }",
+    "eval: while(true) { break eval; }",
+    "arguments: while(true) { break arguments; }",
+    "super: while(true) { break super; }",  // always illegal
+    "interface: while(true) { break interface; }",
+    "yield: while(true) { break yield; }",
+    NULL
+  };
+
+  v8::HandleScope handles(CcTest::isolate());
+  v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate());
+  v8::Context::Scope context_scope(context);
+
+  int marker;
+  CcTest::i_isolate()->stack_guard()->SetStackLimit(
+      reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);
+
+  static const ParserFlag flags[] = {
+    kAllowLazy, kAllowHarmonyScoping, kAllowModules, kAllowGenerators,
+    kAllowForOf
+  };
+  for (int i = 0; context_data[i][0] != NULL; ++i) {
+    for (int j = 0; statement_data[j] != NULL; ++j) {
+      int kPrefixLen = i::StrLength(context_data[i][0]);
+      int kStatementLen = i::StrLength(statement_data[j]);
+      int kSuffixLen = i::StrLength(context_data[i][1]);
+      int kProgramSize = kPrefixLen + kStatementLen + kSuffixLen;
+
+      // Plug the source code pieces together.
+      i::ScopedVector<char> program(kProgramSize + 1);
+      int length = i::OS::SNPrintF(program,
+                                   "%s%s%s",
+                                   context_data[i][0],
+                                   statement_data[j],
+                                   context_data[i][1]);
+      CHECK(length == kProgramSize);
+      TestParserSync(program.start(), flags, ARRAY_SIZE(flags));
+    }
+  }
+}