Remove --harmony-modules flag and let embedder decide when modules are used

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 1884 matching lines @@
 
 
 void RunModuleParserSyncTest(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_len = 0,
                              const ParserFlag* always_false_flags = NULL,
                              int always_false_len = 0) {
-  bool flag = i::FLAG_harmony_modules;
-  i::FLAG_harmony_modules = true;
   RunParserSyncTest(context_data, statement_data, result, flags, flags_len,
                     always_true_flags, always_true_len, always_false_flags,
                     always_false_len, true);
-  i::FLAG_harmony_modules = flag;
 }
 
 
 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
   // isn't.
   const char* context_data[][2] = {
       {"\"use strict\";", ""},
@@ skipping 3651 matching lines @@
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonySloppy,
   };
   RunParserSyncTest(context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(BasicImportExportParsing) {
-  i::FLAG_harmony_modules = true;
-
   // clang-format off
   const char* kSources[] = {
       "export let x = 0;",
       "export var y = 0;",
       "export const z = 0;",
       "export function func() { };",
       "export class C { };",
       "export { };",
       "function f() {}; f(); export { f };",
       "var a, b, c; export { a, b as baz, c };",
@@ skipping 78 matching lines @@
       i::ParseInfo info(&zone, script);
       i::Parser parser(&info);
       info.set_global();
       CHECK(!parser.Parse(&info));
     }
   }
 }
 
 
 TEST(ImportExportParsingErrors) {
-  i::FLAG_harmony_modules = true;
-
   // clang-format off
   const char* kErrorSources[] = {
       "export {",
       "var a; export { a",
       "var a; export { a,",
       "var a; export { a, ;",
       "var a; export { a as };",
       "var a, b; export { a as , b};",
       "export }",
       "var foo, bar; export { foo bar };",
@@ skipping 69 matching lines @@
     i::Zone zone;
     i::ParseInfo info(&zone, script);
     i::Parser parser(&info);
     info.set_module();
     CHECK(!parser.Parse(&info));
   }
 }
 
 
 TEST(ModuleParsingInternals) {
-  i::FLAG_harmony_modules = true;
-
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
   v8::HandleScope handles(CcTest::isolate());
   v8::Local<v8::Context> context = v8::Context::New(CcTest::isolate());
   v8::Context::Scope context_scope(context);
   isolate->stack_guard()->SetStackLimit(i::GetCurrentStackPosition() -
                                         128 * 1024);
 
   static const char kSource[] =
       "let x = 5;"
@@ skipping 1509 matching lines @@
   RunParserSyncTest(sloppy_context, error_data, kError);
   RunParserSyncTest(sloppy_context, error_data, kError, NULL, 0,
                     restrictive_flags, arraysize(restrictive_flags));
   RunParserSyncTest(sloppy_context, unrestricted_data, kSuccess);
   RunParserSyncTest(sloppy_context, unrestricted_data, kError, NULL, 0,
                     restrictive_flags, arraysize(restrictive_flags));
   RunParserSyncTest(sloppy_context, sloppy_data, kSuccess);
   RunParserSyncTest(sloppy_context, sloppy_data, kSuccess, restrictive_flags,
                     arraysize(restrictive_flags));
 }