Make the ParserSync test faster (and re-enable it).

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 1501 matching lines @@
     }
     for (size_t flag_index = 0; flag_index < always_false_flags_length;
          ++flag_index) {
       flags.Remove(always_false_flags[flag_index]);
     }
     TestParserSyncWithFlags(str, flags, result);
   }
 }
 
 
-// TODO(marja) This needs to be turned into a fuzzing test, trying all those
-// combinations below takes at least 2 orders of magnitude too long.
-DISABLED_TEST(ParserSync) {
+TEST(ParserSync) {
   const char* context_data[][2] = {
     { "", "" },
     { "{", "}" },
     { "if (true) ", " else {}" },
     { "if (true) {} else ", "" },
     { "if (true) ", "" },
     { "do ", " while (false)" },
     { "while (false) ", "" },
     { "for (;;) ", "" },
     { "with ({})", "" },
     { "switch (12) { case 12: ", "}" },
     { "switch (12) { default: ", "}" },
     { "switch (12) { ", "case 12: }" },
     { "label2: ", "" },
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "{}",
     "var x",
     "var x = 1",
     "const x",
     "const x = 1",
     ";",
     "12",
     "if (false) {} else ;",
     "if (false) {} else {}",
     "if (false) {} else 12",
-    "if (false) ;"
+    "if (false) ;",
     "if (false) {}",
     "if (false) 12",
     "do {} while (false)",
     "for (;;) ;",
     "for (;;) {}",
     "for (;;) 12",
     "continue",
     "continue label",
     "continue\nlabel",
     "break",
     "break label",
     "break\nlabel",
     // TODO(marja): activate once parsing 'return' is merged into ParserBase.
     // "return",
     // "return  12",
     // "return\n12",
     "with ({}) ;",
     "with ({}) {}",
     "with ({}) 12",
-    "switch ({}) { default: }"
-    "label3: "
+    "switch ({}) { default: }",
+    "label3: ",
     "throw",
     "throw  12",
     "throw\n12",
     "try {} catch(e) {}",
     "try {} finally {}",
     "try {} catch(e) {} finally {}",
     "debugger",
     NULL
   };
 
   const char* termination_data[] = {
     "",
     ";",
     "\n",
     ";\n",
     "\n;",
     NULL
   };
 
   v8::HandleScope handles(CcTest::isolate());
   v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate());
   v8::Context::Scope context_scope(context);
 
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       i::GetCurrentStackPosition() - 128 * 1024);
 
-  static const ParserFlag flags1[] = {
-    kAllowHarmonyArrowFunctions,
-    kAllowHarmonyClasses,
-    kAllowHarmonyNumericLiterals,
-    kAllowHarmonyObjectLiterals,
-    kAllowHarmonyScoping,
-    kAllowHarmonyModules,
-    kAllowHarmonySloppy,
-    kAllowLazy,
-  };
-
   for (int i = 0; context_data[i][0] != NULL; ++i) {
     for (int j = 0; statement_data[j] != NULL; ++j) {
       for (int k = 0; termination_data[k] != NULL; ++k) {
         int kPrefixLen = i::StrLength(context_data[i][0]);
         int kStatementLen = i::StrLength(statement_data[j]);
         int kTerminationLen = i::StrLength(termination_data[k]);
         int kSuffixLen = i::StrLength(context_data[i][1]);
         int kProgramSize = kPrefixLen + kStatementLen + kTerminationLen
             + kSuffixLen + i::StrLength("label: for (;;) {  }");
 
         // Plug the source code pieces together.
         i::ScopedVector<char> program(kProgramSize + 1);
         int length = i::SNPrintF(program,
             "label: for (;;) { %s%s%s%s }",
             context_data[i][0],
             statement_data[j],
             termination_data[k],
             context_data[i][1]);
         CHECK(length == kProgramSize);
-        TestParserSync(program.start(), flags1, arraysize(flags1));
+        TestParserSync(program.start(), NULL, 0);
       }
     }
   }
 
   // Neither Harmony numeric literals nor our natives syntax have any
   // interaction with the flags above, so test these separately to reduce
   // the combinatorial explosion.
   static const ParserFlag flags2[] = { kAllowHarmonyNumericLiterals };
   TestParserSync("0o1234", flags2, arraysize(flags2));
   TestParserSync("0b1011", flags2, arraysize(flags2));
@@ skipping 2872 matching lines @@
                     always_false_flags, arraysize(always_false_flags));
 
   const char* good_data[] = {
     "let = 1;",
     "for(let = 1;;){}",
     NULL};
   RunParserSyncTest(context_data, good_data, kSuccess, NULL, 0,
                     always_true_flags, arraysize(always_true_flags),
                     always_false_flags, arraysize(always_false_flags));
 }