Disable classes in sloppy mode unless --harmony-sloppy is set

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 301 matching lines @@
     const char* program = programs[i];
     i::Utf8ToUtf16CharacterStream stream(
         reinterpret_cast<const i::byte*>(program),
         static_cast<unsigned>(strlen(program)));
     i::CompleteParserRecorder log;
     i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
     scanner.Initialize(&stream);
 
     i::PreParser preparser(&scanner, &log, stack_limit);
     preparser.set_allow_lazy(true);
-    preparser.set_allow_natives_syntax(true);
-    preparser.set_allow_arrow_functions(true);
+    preparser.set_allow_natives(true);
+    preparser.set_allow_harmony_arrow_functions(true);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     CHECK(!log.HasError());
   }
 }
 
 
 TEST(StandAlonePreParserNoNatives) {
   v8::V8::Initialize();
 
@@ skipping 158 matching lines @@
 
   i::Utf8ToUtf16CharacterStream stream(
       reinterpret_cast<const i::byte*>(program.get()),
       static_cast<unsigned>(kProgramSize));
   i::CompleteParserRecorder log;
   i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
   scanner.Initialize(&stream);
 
   i::PreParser preparser(&scanner, &log, stack_limit);
   preparser.set_allow_lazy(true);
-  preparser.set_allow_arrow_functions(true);
+  preparser.set_allow_harmony_arrow_functions(true);
   i::PreParser::PreParseResult result = preparser.PreParseProgram();
   CHECK_EQ(i::PreParser::kPreParseStackOverflow, result);
 }
 
 
 class TestExternalResource: public v8::String::ExternalStringResource {
  public:
   explicit TestExternalResource(uint16_t* data, int length)
       : data_(data), length_(static_cast<size_t>(length)) { }
 
@@ skipping 497 matching lines @@
                   source_data[i].body, surroundings[j].suffix);
       i::Handle<i::String> source =
           factory->NewStringFromUtf8(i::CStrVector(program.start()))
               .ToHandleChecked();
       i::Handle<i::Script> script = factory->NewScript(source);
       i::CompilationInfoWithZone info(script);
       i::Parser::ParseInfo parse_info = {isolate->stack_guard()->real_climit(),
                                          isolate->heap()->HashSeed(),
                                          isolate->unicode_cache()};
       i::Parser parser(&info, &parse_info);
-      parser.set_allow_arrow_functions(true);
-      parser.set_allow_classes(true);
+      parser.set_allow_harmony_arrow_functions(true);
+      parser.set_allow_harmony_classes(true);
       parser.set_allow_harmony_scoping(true);
       info.MarkAsGlobal();
       parser.Parse();
       CHECK(i::Rewriter::Rewrite(&info));
       CHECK(i::Scope::Analyze(&info));
       CHECK(info.function() != NULL);
 
       i::Scope* script_scope = info.function()->scope();
       CHECK(script_scope->is_script_scope());
       CHECK_EQ(1, script_scope->inner_scopes()->length());
@@ skipping 226 matching lines @@
         i::CStrVector(program.start())).ToHandleChecked();
     CHECK_EQ(source->length(), kProgramSize);
     i::Handle<i::Script> script = factory->NewScript(source);
     i::CompilationInfoWithZone info(script);
     i::Parser::ParseInfo parse_info = {isolate->stack_guard()->real_climit(),
                                        isolate->heap()->HashSeed(),
                                        isolate->unicode_cache()};
     i::Parser parser(&info, &parse_info);
     parser.set_allow_lazy(true);
     parser.set_allow_harmony_scoping(true);
-    parser.set_allow_arrow_functions(true);
+    parser.set_allow_harmony_arrow_functions(true);
     info.MarkAsGlobal();
     info.SetStrictMode(source_data[i].strict_mode);
     parser.Parse();
     CHECK(info.function() != NULL);
 
     // Check scope types and positions.
     i::Scope* scope = info.function()->scope();
     CHECK(scope->is_script_scope());
     CHECK_EQ(scope->start_position(), 0);
     CHECK_EQ(scope->end_position(), kProgramSize);
@@ skipping 53 matching lines @@
   CHECK(result->IsString());
   i::DeleteArray(message);
   i::DeleteArray(arg);
   data.Dispose();
   return i::Handle<i::String>::cast(result);
 }
 
 
 enum ParserFlag {
   kAllowLazy,
-  kAllowNativesSyntax,
+  kAllowNatives,
   kAllowHarmonyScoping,
-  kAllowModules,
+  kAllowHarmonyModules,
   kAllowHarmonyNumericLiterals,
-  kAllowArrowFunctions,
-  kAllowClasses,
+  kAllowHarmonyArrowFunctions,
+  kAllowHarmonyClasses,
   kAllowHarmonyObjectLiterals,
-  kAllowHarmonyTemplates
+  kAllowHarmonyTemplates,
+  kAllowHarmonySloppy
 };
 
 
 enum ParserSyncTestResult {
   kSuccessOrError,
   kSuccess,
   kError
 };
 
 template <typename Traits>
 void SetParserFlags(i::ParserBase<Traits>* parser,
                     i::EnumSet<ParserFlag> flags) {
   parser->set_allow_lazy(flags.Contains(kAllowLazy));
-  parser->set_allow_natives_syntax(flags.Contains(kAllowNativesSyntax));
+  parser->set_allow_natives(flags.Contains(kAllowNatives));
   parser->set_allow_harmony_scoping(flags.Contains(kAllowHarmonyScoping));
-  parser->set_allow_modules(flags.Contains(kAllowModules));
+  parser->set_allow_harmony_modules(flags.Contains(kAllowHarmonyModules));
   parser->set_allow_harmony_numeric_literals(
       flags.Contains(kAllowHarmonyNumericLiterals));
   parser->set_allow_harmony_object_literals(
       flags.Contains(kAllowHarmonyObjectLiterals));
-  parser->set_allow_arrow_functions(flags.Contains(kAllowArrowFunctions));
-  parser->set_allow_classes(flags.Contains(kAllowClasses));
+  parser->set_allow_harmony_arrow_functions(
+      flags.Contains(kAllowHarmonyArrowFunctions));
+  parser->set_allow_harmony_classes(flags.Contains(kAllowHarmonyClasses));
   parser->set_allow_harmony_templates(flags.Contains(kAllowHarmonyTemplates));
+printf("SetParserFlags: %d\n", flags.Contains(kAllowHarmonySloppy));

[arv (Not doing code reviews), 2014/11/19 16:51:04]

Remove?

[rossberg, 2014/11/19 17:23:43]

Oops.

+  parser->set_allow_harmony_sloppy(flags.Contains(kAllowHarmonySloppy));
 }
 
 
 void TestParserSyncWithFlags(i::Handle<i::String> source,
                              i::EnumSet<ParserFlag> flags,
                              ParserSyncTestResult result) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
 
   uintptr_t stack_limit = isolate->stack_guard()->real_climit();
@@ skipping 92 matching lines @@
     CHECK(false);
   }
 }
 
 
 void TestParserSync(const char* source,
                     const ParserFlag* varying_flags,
                     size_t varying_flags_length,
                     ParserSyncTestResult result = kSuccessOrError,
                     const ParserFlag* always_true_flags = NULL,
-                    size_t always_true_flags_length = 0) {
+                    size_t always_true_flags_length = 0,
+                    const ParserFlag* always_false_flags = NULL,
+                    size_t always_false_flags_length = 0) {
   i::Handle<i::String> str =
       CcTest::i_isolate()->factory()->NewStringFromAsciiChecked(source);
   for (int bits = 0; bits < (1 << varying_flags_length); bits++) {
     i::EnumSet<ParserFlag> flags;
     for (size_t flag_index = 0; flag_index < varying_flags_length;
          ++flag_index) {
       if ((bits & (1 << flag_index)) != 0) flags.Add(varying_flags[flag_index]);
     }
     for (size_t flag_index = 0; flag_index < always_true_flags_length;
          ++flag_index) {
       flags.Add(always_true_flags[flag_index]);
     }
+    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);
   }
 }
 
 
 TEST(ParserSync) {
   const char* context_data[][2] = {
     { "", "" },
     { "{", "}" },
     { "if (true) ", " else {}" },
@@ skipping 63 matching lines @@
   };
 
   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[] = {
-    kAllowArrowFunctions,
-    kAllowClasses,
+    kAllowHarmonyArrowFunctions,
+    kAllowHarmonyClasses,
     kAllowHarmonyNumericLiterals,
     kAllowHarmonyObjectLiterals,
     kAllowHarmonyScoping,
+    kAllowHarmonyModules,
+    kAllowHarmonySloppy,
     kAllowLazy,
-    kAllowModules,
   };
 
   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
@@ skipping 13 matching lines @@
     }
   }
 
   // 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));
 
-  static const ParserFlag flags3[] = { kAllowNativesSyntax };
+  static const ParserFlag flags3[] = { kAllowNatives };
   TestParserSync("%DebugPrint(123)", flags3, arraysize(flags3));
 }
 
 
 TEST(StrictOctal) {
   // Test that syntax error caused by octal literal is reported correctly as
   // such (issue 2220).
   v8::V8::Initialize();
   v8::HandleScope scope(CcTest::isolate());
   v8::Context::Scope context_scope(
@@ skipping 13 matching lines @@
            *exception);
 }
 
 
 void RunParserSyncTest(const char* context_data[][2],
                        const char* statement_data[],
                        ParserSyncTestResult result,
                        const ParserFlag* flags = NULL,
                        int flags_len = 0,
                        const ParserFlag* always_true_flags = NULL,
-                       int always_true_flags_len = 0) {
+                       int always_true_len = 0,
+                       const ParserFlag* always_false_flags = NULL,
+                       int always_false_len = 0) {
   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 default_flags[] = {
-    kAllowArrowFunctions,
-    kAllowClasses,
+    kAllowHarmonyArrowFunctions,
+    kAllowHarmonyClasses,
     kAllowHarmonyNumericLiterals,
     kAllowHarmonyObjectLiterals,
     kAllowHarmonyScoping,
+    kAllowHarmonyModules,
+    kAllowHarmonyTemplates,
+    kAllowHarmonySloppy,
     kAllowLazy,
-    kAllowModules,
-    kAllowNativesSyntax,
-    kAllowHarmonyTemplates
+    kAllowNatives,
   };
   ParserFlag* generated_flags = NULL;
   if (flags == NULL) {
     flags = default_flags;
     flags_len = arraysize(default_flags);
-    if (always_true_flags != NULL) {
-      // Remove always_true_flags from default_flags.
-      CHECK(always_true_flags_len < flags_len);
-      generated_flags = new ParserFlag[flags_len - always_true_flags_len];
+    if (always_true_flags != NULL || always_false_flags != NULL) {
+      // Remove always_true/false_flags from default_flags.
+      CHECK((always_true_flags != NULL) == (always_true_len > 0));
+      CHECK((always_false_flags != NULL) == (always_false_len > 0));
+      CHECK(always_true_flags == NULL || always_true_len < flags_len);
+      CHECK(always_false_flags == NULL || always_false_len < flags_len);
+      generated_flags =
+          new ParserFlag[flags_len - always_true_len - always_false_len];
       int flag_index = 0;
       for (int i = 0; i < flags_len; ++i) {
         bool use_flag = true;
-        for (int j = 0; j < always_true_flags_len; ++j) {
-          if (flags[i] == always_true_flags[j]) {
-            use_flag = false;
-            break;
-          }
+        for (int j = 0; use_flag && j < always_true_len; ++j) {
+          if (flags[i] == always_true_flags[j]) use_flag = false;
+        }
+        for (int j = 0; use_flag && j < always_false_len; ++j) {
+          if (flags[i] == always_false_flags[j]) use_flag = false;
         }
         if (use_flag) generated_flags[flag_index++] = flags[i];
       }
-      CHECK(flag_index == flags_len - always_true_flags_len);
+      CHECK(flag_index == flags_len - always_true_len - always_false_len);
       flags_len = flag_index;
       flags = generated_flags;
     }
   }
   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::SNPrintF(program,
                                "%s%s%s",
                                context_data[i][0],
                                statement_data[j],
                                context_data[i][1]);
       CHECK(length == kProgramSize);
       TestParserSync(program.start(),
                      flags,
                      flags_len,
                      result,
                      always_true_flags,
-                     always_true_flags_len);
+                     always_true_len,
+                     always_false_flags,
+                     always_false_len);
     }
   }
   delete[] generated_flags;
 }
 
 
 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
@@ skipping 86 matching lines @@
     "arguments;",
     "var foo = eval;",
     "var foo = arguments;",
     "var foo = { eval: 1 };",
     "var foo = { arguments: 1 };",
     "var foo = { }; foo.eval = {};",
     "var foo = { }; foo.arguments = {};",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 #define FUTURE_STRICT_RESERVED_WORDS(V) \
   V(implements)                         \
   V(interface)                          \
   V(let)                                \
   V(package)                            \
@@ skipping 29 matching lines @@
     { "function test_func() {\"use strict\"; ", "}"},
     { "() => { \"use strict\"; ", "}" },
     { NULL, NULL }
   };
 
   const char* statement_data[] {
     FUTURE_STRICT_RESERVED_WORDS(FUTURE_STRICT_RESERVED_STATEMENTS)
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions};
   RunParserSyncTest(context_data, statement_data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 
   static const ParserFlag classes_flags[] = {
-      kAllowArrowFunctions, kAllowClasses, kAllowHarmonyScoping};
+      kAllowHarmonyArrowFunctions, kAllowHarmonyClasses, kAllowHarmonyScoping};
   RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
                     classes_flags, arraysize(classes_flags));
 }
 
 
 TEST(NoErrorsFutureStrictReservedWords) {
   const char* context_data[][2] = {
     { "", "" },
     { "function test_func() {", "}"},
     { "() => {", "}" },
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     FUTURE_STRICT_RESERVED_WORDS(FUTURE_STRICT_RESERVED_STATEMENTS)
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 
   static const ParserFlag classes_flags[] = {
-      kAllowArrowFunctions, kAllowClasses, kAllowHarmonyScoping};
+      kAllowHarmonyArrowFunctions, kAllowHarmonyClasses, kAllowHarmonyScoping};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     classes_flags, arraysize(classes_flags));
 }
 
 
 TEST(ErrorsReservedWords) {
   // Tests that both preparsing and parsing produce the right kind of errors for
   // using future reserved words as identifiers. These tests don't depend on the
   // strict mode.
   const char* context_data[][2] = {
@@ skipping 392 matching lines @@
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "mylabel: while(true) { break mylabel; }",
     "eval: while(true) { break eval; }",
     "arguments: while(true) { break arguments; }",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(NoErrorsFutureStrictReservedAsLabelsSloppy) {
   const char* context_data[][2] = {
     { "", ""},
     { "function test_func() {", "}" },
     { "() => {", "}" },
     { NULL, NULL }
   };
 
 #define LABELLED_WHILE(NAME) #NAME ": while (true) { break " #NAME "; }",
   const char* statement_data[] {
     FUTURE_STRICT_RESERVED_WORDS(LABELLED_WHILE)
     NULL
   };
 #undef LABELLED_WHILE
 
-  static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ErrorsParenthesizedLabels) {
   // Parenthesized identifiers shouldn't be recognized as labels.
   const char* context_data[][2] = {
     { "", ""},
     { "function test_func() {", "}" },
@@ skipping 231 matching lines @@
   const char* context_data[][2] = {
     {"", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "%someintrinsic(arg)",
     NULL
   };
 
-  // This test requires kAllowNativesSyntax to succeed.
+  // This test requires kAllowNatives to succeed.
   static const ParserFlag always_true_flags[] = {
-    kAllowNativesSyntax
+    kAllowNatives
   };
 
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_true_flags, 1);
 }
 
 
 TEST(NoErrorsNewExpression) {
   const char* context_data[][2] = {
     {"", ""},
@@ skipping 864 matching lines @@
     "(a = b, c) => {}",
     "(a, b = c) => {}",
     "(foo ? bar : baz) => {}",
     "(a, foo ? bar : baz) => {}",
     "(foo ? bar : baz, a) => {}",
     NULL
   };
 
   // The test is quite slow, so run it with a reduced set of flags.
   static const ParserFlag flags[] = {kAllowLazy, kAllowHarmonyScoping};
-  static const ParserFlag always_flags[] = { kAllowArrowFunctions };
+  static const ParserFlag always_flags[] = { kAllowHarmonyArrowFunctions };
   RunParserSyncTest(context_data, statement_data, kError, flags,
                     arraysize(flags), always_flags, arraysize(always_flags));
 }
 
 
 TEST(NoErrorsArrowFunctions) {
   // Tests that parser and preparser accept valid arrow functions syntax.
   const char* context_data[][2] = {
     {"", ";"},
     {"bar ? (", ") : baz;"},
@@ skipping 33 matching lines @@
     "(a, b) => 0, (c, d) => 1",
     "(a, b => {}, a => a + 1)",
     "((a, b) => {}, (a => a + 1))",
     "(a, (a, (b, c) => 0))",
 
     // Arrow has more precedence, this is the same as: foo ? bar : (baz = {})
     "foo ? bar : baz => {}",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(NoErrorsSuper) {
   // Tests that parser and preparser accept 'super' keyword in right places.
   const char* context_data[][2] = {{"", ";"},
                                    {"k = ", ";"},
                                    {"foo(", ");"},
                                    {NULL, NULL}};
 
   const char* statement_data[] = {
     "super.x",
     "super[27]",
     "new super",
     "new super()",
     "new super(12, 45)",
     "new new super",
     "new new super()",
     "new new super()()",
     "z.super",  // Ok, property lookup.
     NULL};
 
-  static const ParserFlag always_flags[] = {kAllowClasses};
+  static const ParserFlag always_flags[] = {kAllowHarmonyClasses};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ErrorsSuper) {
   // Tests that parser and preparser generate same errors for 'super'.
   const char* context_data[][2] = {{"", ";"},
                                    {"k = ", ";"},
                                    {"foo(", ");"},
                                    {NULL, NULL}};
 
   const char* statement_data[] = {
     "super = x",
     "y = super",
     "f(super)",
     NULL};
 
-  static const ParserFlag always_flags[] = {kAllowClasses};
+  static const ParserFlag always_flags[] = {kAllowHarmonyClasses};
   RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(NoErrorsMethodDefinition) {
   const char* context_data[][2] = {{"({", "});"},
                                    {"'use strict'; ({", "});"},
                                    {"({*", "});"},
                                    {"'use strict'; ({*", "});"},
@@ skipping 162 matching lines @@
     "class extends F {}",
     "class name extends F {}",
     "class extends (F, G) {}",
     "class name extends (F, G) {}",
     "class extends class {} {}",
     "class name extends class {} {}",
     "class extends class base {} {}",
     "class name extends class base {} {}",
     NULL};
 
-  static const ParserFlag always_flags[] = {kAllowClasses};
+  static const ParserFlag always_flags[] = {
+      kAllowHarmonyClasses, kAllowHarmonySloppy};
   RunParserSyncTest(context_data, class_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassDeclarationNoErrors) {
   const char* context_data[][2] = {{"", ""},
                                    {"{", "}"},
                                    {"if (true) {", "}"},
                                    {NULL, NULL}};
   const char* statement_data[] = {
     "class name {}",
     "class name extends F {}",
     "class name extends (F, G) {}",
     "class name extends class {} {}",
     "class name extends class base {} {}",
     NULL};
 
-  static const ParserFlag always_flags[] = {kAllowClasses};
+  static const ParserFlag always_flags[] = {
+      kAllowHarmonyClasses, kAllowHarmonySloppy};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassBodyNoErrors) {
   // Tests that parser and preparser accept valid class syntax.
   const char* context_data[][2] = {{"(class {", "});"},
                                    {"(class extends Base {", "});"},
                                    {"class C {", "}"},
@@ skipping 23 matching lines @@
     "static static() {}",
     "static get static() {}",
     "static set static(v) {}",
     "*static() {}",
     "*get() {}",
     "*set() {}",
     "static *g() {}",
     NULL};
 
   static const ParserFlag always_flags[] = {
-    kAllowClasses,
-    kAllowHarmonyObjectLiterals
+    kAllowHarmonyClasses,
+    kAllowHarmonyObjectLiterals,
+    kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassPropertyNameNoErrors) {
   const char* context_data[][2] = {{"(class {", "() {}});"},
                                    {"(class { get ", "() {}});"},
                                    {"(class { set ", "(v) {}});"},
@@ skipping 36 matching lines @@
     "else",
     "for",
     "while",
     "do",
     "try",
     "catch",
     "finally",
     NULL};
 
   static const ParserFlag always_flags[] = {
-    kAllowClasses,
-    kAllowHarmonyObjectLiterals
+    kAllowHarmonyClasses,
+    kAllowHarmonyObjectLiterals,
+    kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, name_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassExpressionErrors) {
   const char* context_data[][2] = {{"(", ");"},
                                    {"var C = ", ";"},
                                    {"bar, ", ";"},
                                    {NULL, NULL}};
   const char* class_data[] = {
     "class",
     "class name",
     "class name extends",
     "class extends",
     "class {",
     "class { m }",
     "class { m; n }",
     "class { m: 1 }",
     "class { m(); n() }",
     "class { get m }",
     "class { get m() }",
     "class { get m() { }",
     "class { set m() {} }",  // Missing required parameter.
     "class { m() {}, n() {} }",  // No commas allowed.
     NULL};
 
   static const ParserFlag always_flags[] = {
-    kAllowClasses,
-    kAllowHarmonyObjectLiterals
+    kAllowHarmonyClasses,
+    kAllowHarmonyObjectLiterals,
+    kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassDeclarationErrors) {
   const char* context_data[][2] = {{"", ""},
                                    {"{", "}"},
                                    {"if (true) {", "}"},
@@ skipping 15 matching lines @@
     "class extends base {}",
     "class name { *",
     "class name { * }",
     "class name { *; }",
     "class name { *get x() {} }",
     "class name { *set x(_) {} }",
     "class name { *static m() {} }",
     NULL};
 
   static const ParserFlag always_flags[] = {
-    kAllowClasses,
-    kAllowHarmonyNumericLiterals
+    kAllowHarmonyClasses,
+    kAllowHarmonyNumericLiterals,
+    kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassNameErrors) {
   const char* context_data[][2] = {{"class ", "{}"},
                                    {"(class ", "{});"},
                                    {"'use strict'; class ", "{}"},
                                    {"'use strict'; (class ", "{});"},
                                    {NULL, NULL}};
   const char* class_name[] = {
     "arguments",
     "eval",
     "implements",
     "interface",
     "let",
     "package",
     "private",
     "protected",
     "public",
     "static",
     "var",
     "yield",
     NULL};
 
   static const ParserFlag always_flags[] = {
-    kAllowClasses,
-    kAllowHarmonyObjectLiterals
+    kAllowHarmonyClasses,
+    kAllowHarmonyObjectLiterals,
+    kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_name, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassGetterParamNameErrors) {
   const char* context_data[][2] = {
     {"class C { get name(", ") {} }"},
     {"(class { get name(", ") {} });"},
@@ skipping 11 matching lines @@
     "package",
     "private",
     "protected",
     "public",
     "static",
     "var",
     "yield",
     NULL};
 
   static const ParserFlag always_flags[] = {
-    kAllowClasses,
-    kAllowHarmonyObjectLiterals
+    kAllowHarmonyClasses,
+    kAllowHarmonyObjectLiterals,
+    kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_name, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassStaticPrototypeErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "static prototype() {}",
     "static get prototype() {}",
     "static set prototype(_) {}",
     "static *prototype() {}",
     "static 'prototype'() {}",
     "static *'prototype'() {}",
     "static prot\\u006ftype() {}",
     "static 'prot\\u006ftype'() {}",
     "static get 'prot\\u006ftype'() {}",
     "static set 'prot\\u006ftype'(_) {}",
     "static *'prot\\u006ftype'() {}",
     NULL};
 
   static const ParserFlag always_flags[] = {
-    kAllowClasses,
-    kAllowHarmonyObjectLiterals
+    kAllowHarmonyClasses,
+    kAllowHarmonyObjectLiterals,
+    kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassSpecialConstructorErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "get constructor() {}",
     "get constructor(_) {}",
     "*constructor() {}",
     "get 'constructor'() {}",
     "*'constructor'() {}",
     "get c\\u006fnstructor() {}",
     "*c\\u006fnstructor() {}",
     "get 'c\\u006fnstructor'() {}",
     "get 'c\\u006fnstructor'(_) {}",
     "*'c\\u006fnstructor'() {}",
     NULL};
 
   static const ParserFlag always_flags[] = {
-    kAllowClasses,
-    kAllowHarmonyObjectLiterals
+    kAllowHarmonyClasses,
+    kAllowHarmonyObjectLiterals,
+    kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassConstructorNoErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "constructor() {}",
     "static constructor() {}",
     "static get constructor() {}",
     "static set constructor(_) {}",
     "static *constructor() {}",
     NULL};
 
   static const ParserFlag always_flags[] = {
-    kAllowClasses,
-    kAllowHarmonyObjectLiterals
+    kAllowHarmonyClasses,
+    kAllowHarmonyObjectLiterals,
+    kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassMultipleConstructorErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "constructor() {}; constructor() {}",
     NULL};
 
   static const ParserFlag always_flags[] = {
-    kAllowClasses,
-    kAllowHarmonyObjectLiterals
+    kAllowHarmonyClasses,
+    kAllowHarmonyObjectLiterals,
+    kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassMultiplePropertyNamesNoErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "constructor() {}; static constructor() {}",
     "m() {}; static m() {}",
     "m() {}; m() {}",
     "static m() {}; static m() {}",
     "get m() {}; set m(_) {}; get m() {}; set m(_) {};",
     NULL};
 
   static const ParserFlag always_flags[] = {
-    kAllowClasses,
-    kAllowHarmonyObjectLiterals
+    kAllowHarmonyClasses,
+    kAllowHarmonyObjectLiterals,
+    kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassesAreStrictErrors) {
   const char* context_data[][2] = {{"", ""},
                                    {"(", ");"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "class C { method() { with ({}) {} } }",
     "class C extends function() { with ({}) {} } {}",
     "class C { *method() { with ({}) {} } }",
     NULL};
 
   static const ParserFlag always_flags[] = {
-    kAllowClasses,
-    kAllowHarmonyObjectLiterals
+    kAllowHarmonyClasses,
+    kAllowHarmonyObjectLiterals,
+    kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ObjectLiteralPropertyShorthandKeywordsError) {
   const char* context_data[][2] = {{"({", "});"},
                                    {"'use strict'; ({", "});"},
                                    {NULL, NULL}};
@@ skipping 279 matching lines @@
   const char* context_data[][2] = {
       {"", ""},
       {"function f() {", "}"},
       {"{", "}"},
       {NULL, NULL}};
   const char* bad_data[] = {
     "let x = 1;",
     "for(let x = 1;;){}",
     "for(let x of []){}",
     "for(let x in []){}",
+    "class C {}",
+    "class C extends D {}",
+    "(class {})",
+    "(class extends D {})",
+    "(class C {})",
+    "(class C extends D {})",
     NULL};
-  static const ParserFlag always_flags[] = {kAllowHarmonyScoping};
-  RunParserSyncTest(context_data, bad_data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  static const ParserFlag always_true_flags[] = {
+      kAllowHarmonyScoping, kAllowHarmonyClasses};
+  static const ParserFlag always_false_flags[] = {kAllowHarmonySloppy};
+  RunParserSyncTest(context_data, bad_data, kError, NULL, 0,
+                    always_true_flags, arraysize(always_true_flags),
+                    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_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, good_data, kSuccess, NULL, 0,
+                    always_true_flags, arraysize(always_true_flags),
+                    always_false_flags, arraysize(always_false_flags));
 }