Remove support for legacy const, part 1

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 1488 matching lines @@
   data.Dispose();
   return i::MessageTemplate::FormatMessage(isolate, message, arg_object);
 }
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
   kAllowHarmonySloppy,
   kAllowHarmonySloppyLet,
   kAllowHarmonyNewTarget,
-  kNoLegacyConst,
   kAllowHarmonyFunctionSent,
   kAllowHarmonyRestrictiveDeclarations,
   kAllowHarmonyExponentiationOperator
 };
 
 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(flags.Contains(kAllowNatives));
   parser->set_allow_harmony_sloppy(flags.Contains(kAllowHarmonySloppy));
   parser->set_allow_harmony_sloppy_let(flags.Contains(kAllowHarmonySloppyLet));
-  parser->set_allow_legacy_const(!flags.Contains(kNoLegacyConst));
   parser->set_allow_harmony_function_sent(
       flags.Contains(kAllowHarmonyFunctionSent));
   parser->set_allow_harmony_restrictive_declarations(
       flags.Contains(kAllowHarmonyRestrictiveDeclarations));
   parser->set_allow_harmony_exponentiation_operator(
       flags.Contains(kAllowHarmonyExponentiationOperator));
 }
 
 
 void TestParserSyncWithFlags(i::Handle<i::String> source,
@@ skipping 1980 matching lines @@
   CcTest::isolate()->SetUseCounterCallback(MockUseCounterCallback);
   CompileRun("\"use asm\";\n"
              "var foo = 1;\n"
              "\"use asm\";\n"  // Only the first one counts.
              "function bar() { \"use asm\"; var baz = 1; }");
   // Optimizing will double-count because the source is parsed twice.
   CHECK_EQ(i::FLAG_always_opt ? 4 : 2, use_counts[v8::Isolate::kUseAsm]);
 }
 
 
-TEST(UseConstLegacyCount) {
-  i::FLAG_legacy_const = true;
-  i::Isolate* isolate = CcTest::i_isolate();
-  i::HandleScope scope(isolate);
-  LocalContext env;
-  int use_counts[v8::Isolate::kUseCounterFeatureCount] = {};
-  global_use_counts = use_counts;
-  CcTest::isolate()->SetUseCounterCallback(MockUseCounterCallback);
-  CompileRun(
-      "const x = 1;\n"
-      "var foo = 1;\n"
-      "const y = 1;\n"
-      "function bar() {\n"
-      "    const z = 1; var baz = 1;\n"
-      "    function q() { const k = 42; }\n"
-      "}");
-  // Optimizing will double-count because the source is parsed twice.
-  CHECK_EQ(i::FLAG_always_opt ? 8 : 4, use_counts[v8::Isolate::kLegacyConst]);
-}
-
-
 TEST(StrictModeUseCount) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::HandleScope scope(isolate);
   LocalContext env;
   int use_counts[v8::Isolate::kUseCounterFeatureCount] = {};
   global_use_counts = use_counts;
   CcTest::isolate()->SetUseCounterCallback(MockUseCounterCallback);
   CompileRun(
       "\"use strict\";\n"
       "function bar() { var baz = 1; }");  // strict mode inherits
@@ skipping 1309 matching lines @@
 TEST(StatementParsingInForIn) {
   const char* context_data[][2] = {{"", ""},
                                    {"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
   const char* data[] = {"for(x in {}, {}) {}", "for(var x in {}, {}) {}",
                         "for(let x in {}, {}) {}", "for(const x in {}, {}) {}",
                         NULL};
 
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonySloppy, kAllowHarmonySloppyLet, kNoLegacyConst};
+  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
+                                            kAllowHarmonySloppyLet};
   RunParserSyncTest(context_data, data, kSuccess, nullptr, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(ConstParsingInForInError) {
   const char* context_data[][2] = {{"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
@@ skipping 168 matching lines @@
 TEST(ForOfInOperator) {
   const char* context_data[][2] = {{"", ""},
                                    {"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
   const char* data[] = {
       "for(x of 'foo' in {}) {}", "for(var x of 'foo' in {}) {}",
       "for(let x of 'foo' in {}) {}", "for(const x of 'foo' in {}) {}", NULL};
 
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonySloppy, kAllowHarmonySloppyLet, kNoLegacyConst};
+  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
+                                            kAllowHarmonySloppyLet};
   RunParserSyncTest(context_data, data, kSuccess, nullptr, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(ForOfYieldIdentifier) {
   const char* context_data[][2] = {{"", ""}, {NULL, NULL}};
 
   const char* data[] = {"for(x of yield) {}", "for(var x of yield) {}",
                         "for(let x of yield) {}", "for(const x of yield) {}",
                         NULL};
 
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonySloppy, kAllowHarmonySloppyLet, kNoLegacyConst};
+  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
+                                            kAllowHarmonySloppyLet};
   RunParserSyncTest(context_data, data, kSuccess, nullptr, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(ForOfYieldExpression) {
   const char* context_data[][2] = {{"", ""},
                                    {"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
   const char* data[] = {"function* g() { for(x of yield) {} }",
                         "function* g() { for(var x of yield) {} }",
                         "function* g() { for(let x of yield) {} }",
                         "function* g() { for(const x of yield) {} }", NULL};
 
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonySloppy, kAllowHarmonySloppyLet, kNoLegacyConst};
+  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
+                                            kAllowHarmonySloppyLet};
   RunParserSyncTest(context_data, data, kSuccess, nullptr, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(ForOfExpressionError) {
   const char* context_data[][2] = {{"", ""},
                                    {"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
   const char* data[] = {
       "for(x of [], []) {}", "for(var x of [], []) {}",
       "for(let x of [], []) {}", "for(const x of [], []) {}",
 
       // AssignmentExpression should be validated statically:
       "for(x of { y = 23 }) {}", "for(var x of { y = 23 }) {}",
       "for(let x of { y = 23 }) {}", "for(const x of { y = 23 }) {}", NULL};
 
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonySloppy, kAllowHarmonySloppyLet, kNoLegacyConst};
+  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
+                                            kAllowHarmonySloppyLet};
   RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(InvalidUnicodeEscapes) {
   const char* context_data[][2] = {{"", ""},
                                    {"'use strict';", ""},
                                    {NULL, NULL}};
   const char* data[] = {
@@ skipping 1680 matching lines @@
   };
   // clang-format on
 
   RunParserSyncTest(good_context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
   RunParserSyncTest(bad_context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
-TEST(ConstLegacy) {
-  // clang-format off
-  const char* context_data[][2] = {
-    {"", ""},
-    {"{", "}"},
-    {NULL, NULL}
-  };
-
-  const char* data[] = {
-    "const x",
-    "const x = 1",
-    "for (const x = 1; x < 1; x++) {}",
-    "for (const x in {}) {}",
-    "for (const x of []) {}",
-    NULL
-  };
-  // clang-format on
-
-
-  static const ParserFlag always_flags[] = {kNoLegacyConst};
-  RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
-  RunParserSyncTest(context_data, data, kSuccess);
-}
-
-
 TEST(ConstSloppy) {
   // clang-format off
   const char* context_data[][2] = {
     {"", ""},
     {"{", "}"},
     {NULL, NULL}
   };
 
   const char* data[] = {
     "const x = 1",
     "for (const x = 1; x < 1; x++) {}",
     "for (const x in {}) {}",
     "for (const x of []) {}",
     NULL
   };
   // clang-format on
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
-                                            kNoLegacyConst};
+  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
   RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(LetSloppy) {
   // clang-format off
   const char* context_data[][2] = {
     {"", ""},
     {"'use strict';", ""},
@@ skipping 79 matching lines @@
     "let",
     "let = 1",
     "for (let = 1; let < 1; let++) {}",
     "for (let in {}) {}",
     "for (var let = 1; let < 1; let++) {}",
     "for (var let in {}) {}",
     "for (var [let] = 1; let < 1; let++) {}",
     "for (var [let] in {}) {}",
     "var let",
     "var [let] = []",
-    "for (const let = 1; let < 1; let++) {}",
-    "for (const let in {}) {}",
-    "for (const [let] = 1; let < 1; let++) {}",
-    "for (const [let] in {}) {}",
-    "const let",
-    "const [let] = []",
     NULL
   };
   // clang-format on
 
   static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
                                             kAllowHarmonySloppyLet};
   RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
 
   // Some things should be rejected even in sloppy mode
@@ skipping 21 matching lines @@
     // Sprinkle in the escaped version too.
     "let l\\u0065t = 1",
     "const l\\u0065t = 1",
     "let [l\\u0065t] = 1",
     "const [l\\u0065t] = 1",
     "for (let l\\u0065t in {}) {}",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag fail_flags[] = {
-      kAllowHarmonySloppy, kAllowHarmonySloppyLet, kNoLegacyConst};
+  static const ParserFlag fail_flags[] = {kAllowHarmonySloppy,
+                                          kAllowHarmonySloppyLet};
   RunParserSyncTest(context_data, fail_data, kError, NULL, 0, fail_flags,
                     arraysize(fail_flags));
 }
 
 
 TEST(EscapedKeywords) {
   // clang-format off
   const char* sloppy_context_data[][2] = {
     {"", ""},
     {NULL, NULL}
@@ skipping 384 matching lines @@
     // "Array() **= 10",
     NULL
   };
   // clang-format on
 
   static const ParserFlag always_flags[] = {
       kAllowHarmonyExponentiationOperator};
   RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }