[ESnext] Parse dynamic import expression

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 1267 matching lines @@
 }
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
   kAllowHarmonyFunctionSent,
   kAllowHarmonyRestrictiveGenerators,
   kAllowHarmonyTrailingCommas,
   kAllowHarmonyClassFields,
   kAllowHarmonyObjectRestSpread,
+  kAllowHarmonyDynamicImport,
 };
 
 enum ParserSyncTestResult {
   kSuccessOrError,
   kSuccess,
   kError
 };
 
 void SetGlobalFlags(i::EnumSet<ParserFlag> flags) {
   i::FLAG_allow_natives_syntax = flags.Contains(kAllowNatives);
   i::FLAG_harmony_function_sent = flags.Contains(kAllowHarmonyFunctionSent);
   i::FLAG_harmony_restrictive_generators =
       flags.Contains(kAllowHarmonyRestrictiveGenerators);
   i::FLAG_harmony_trailing_commas = flags.Contains(kAllowHarmonyTrailingCommas);
   i::FLAG_harmony_class_fields = flags.Contains(kAllowHarmonyClassFields);
   i::FLAG_harmony_object_rest_spread =
       flags.Contains(kAllowHarmonyObjectRestSpread);
+  i::FLAG_harmony_dynamic_import = flags.Contains(kAllowHarmonyDynamicImport);
 }
 
 void SetParserFlags(i::PreParser* parser, i::EnumSet<ParserFlag> flags) {
   parser->set_allow_natives(flags.Contains(kAllowNatives));
   parser->set_allow_harmony_function_sent(
       flags.Contains(kAllowHarmonyFunctionSent));
   parser->set_allow_harmony_restrictive_generators(
       flags.Contains(kAllowHarmonyRestrictiveGenerators));
   parser->set_allow_harmony_trailing_commas(
       flags.Contains(kAllowHarmonyTrailingCommas));
   parser->set_allow_harmony_class_fields(
       flags.Contains(kAllowHarmonyClassFields));
   parser->set_allow_harmony_object_rest_spread(
       flags.Contains(kAllowHarmonyObjectRestSpread));
+  parser->set_allow_harmony_dynamic_import(
+      flags.Contains(kAllowHarmonyDynamicImport));
 }
 
 void TestParserSyncWithFlags(i::Handle<i::String> source,
                              i::EnumSet<ParserFlag> flags,
                              ParserSyncTestResult result,
-                             bool is_module = false,
-                             bool test_preparser = true) {
+                             bool is_module = false, bool test_preparser = true,
+                             bool ignore_error_msg = false) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
 
   uintptr_t stack_limit = isolate->stack_guard()->real_climit();
   int preparser_materialized_literals = -1;
   int parser_materialized_literals = -2;
 
   // Preparse the data.
   i::PendingCompilationErrorHandler pending_error_handler;
   if (test_preparser) {
@@ skipping 56 matching lines @@
       v8::base::OS::Print(
           "Parser failed on:\n"
           "\t%s\n"
           "with error:\n"
           "\t%s\n"
           "However, the preparser succeeded",
           source->ToCString().get(), message_string->ToCString().get());
       CHECK(false);
     }
     // Check that preparser and parser produce the same error.
-    if (test_preparser) {
+    if (test_preparser && !ignore_error_msg) {
       i::Handle<i::String> preparser_message =
           pending_error_handler.FormatMessage(CcTest::i_isolate());
       if (!i::String::Equals(message_string, preparser_message)) {
         v8::base::OS::Print(
             "Expected parser and preparser to produce the same error on:\n"
             "\t%s\n"
             "However, found the following error messages\n"
             "\tparser:    %s\n"
             "\tpreparser: %s\n",
             source->ToCString().get(), message_string->ToCString().get(),
@@ skipping 26 matching lines @@
         "Preparser materialized literals (%d) differ from Parser materialized "
         "literals (%d) on:\n"
         "\t%s\n"
         "However, parser and preparser succeeded",
         preparser_materialized_literals, parser_materialized_literals,
         source->ToCString().get());
     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,
                     const ParserFlag* always_false_flags = NULL,
                     size_t always_false_flags_length = 0,
-                    bool is_module = false, bool test_preparser = true) {
+                    bool is_module = false, bool test_preparser = true,
+                    bool ignore_error_msg = false) {
   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, is_module, test_preparser);
+    TestParserSyncWithFlags(str, flags, result, is_module, test_preparser,
+                            ignore_error_msg);
   }
 }
 
 
 TEST(ParserSync) {
   const char* context_data[][2] = {
     { "", "" },
     { "{", "}" },
     { "if (true) ", " else {}" },
     { "if (true) {} else ", "" },
@@ skipping 119 matching lines @@
       "  };                  \n"
       "};                    \n";
   v8_compile(v8_str(script));
   CHECK(try_catch.HasCaught());
   v8::String::Utf8Value exception(try_catch.Exception());
   CHECK_EQ(0,
            strcmp("SyntaxError: Octal literals are not allowed in strict mode.",
                   *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_len = 0,
-                       const ParserFlag* always_false_flags = NULL,
-                       int always_false_len = 0, bool is_module = false,
-                       bool test_preparser = true) {
+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_len = 0, const ParserFlag* always_false_flags = NULL,
+    int always_false_len = 0, bool is_module = false,
+    bool test_preparser = true, bool ignore_error_msg = false) {
   v8::HandleScope handles(CcTest::isolate());
   v8::Local<v8::Context> context = v8::Context::New(CcTest::isolate());
   v8::Context::Scope context_scope(context);
 
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       i::GetCurrentStackPosition() - 128 * 1024);
 
   // Experimental feature flags should not go here; pass the flags as
   // always_true_flags if the test needs them.
   static const ParserFlag default_flags[] = {
@@ skipping 34 matching lines @@
       // 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_len, always_false_flags,
-                     always_false_len, is_module, test_preparser);
+                     always_false_len, is_module, test_preparser,
+                     ignore_error_msg);
     }
   }
   delete[] generated_flags;
 }
 
-
-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 test_preparser = true) {
+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 test_preparser = true,
+    bool ignore_error_msg = false) {
   RunParserSyncTest(context_data, statement_data, result, flags, flags_len,
                     always_true_flags, always_true_len, always_false_flags,
-                    always_false_len, true, test_preparser);
+                    always_false_len, true, test_preparser, ignore_error_msg);
 }
 
 
 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 2428 matching lines @@
     "new super(12, 45)",
     "new new super",
     "new new super()",
     "new new super()()",
     NULL
   };
 
   RunParserSyncTest(context_data, expression_data, kError);
 }
 
+TEST(ImportExpressionSuccess) {
+  // clang-format off
+  const char* context_data[][2] = {
+    {"", ""},
+    {NULL, NULL}
+  };
+
+  const char* data[] = {
+    "new import(x)",
+    "import(1)",
+    "import(y=x)",
+    "f(...[import(y=x)])",
+    "x = {[import(y=x)]: 1}",
+    "var {[import(y=x)]: x} = {}",
+    "({[import(y=x)]: x} = {})",
+    "async () => { await import(x) }",
+    "() => { import(x) }",
+    "(import(y=x))",
+    "{import(y=x)}",
+    "import(import(x))",
+    "x = import(x)",
+    "var x = import(x)",
+    "let x = import(x)",
+    "for(x of import(x)) {}",
+    "import(x).then()",
+    NULL
+  };
+
+  // clang-format on
+
+  // We ignore test error messages because the error message from the
+  // parser/preparser is different for the same data depending on the
+  // context.
+  // For example, a top level "import(" is parsed as an
+  // import declaration. The parser parses the import token correctly
+  // and then shows an "Unexpected token (" error message. The
+  // preparser does not understand the import keyword (this test is
+  // run without kAllowHarmonyDynamicImport flag), so this results in
+  // an "Unexpected token import" error.
+  RunParserSyncTest(context_data, data, kError);
+  RunModuleParserSyncTest(context_data, data, kError, NULL, 0, NULL, 0, NULL, 0,
+                          true, true);
+  static const ParserFlag flags[] = {kAllowHarmonyDynamicImport};
+  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, flags,
+                    arraysize(flags));
+  RunModuleParserSyncTest(context_data, data, kSuccess, NULL, 0, flags,
+                          arraysize(flags));
+}
+
+TEST(ImportExpressionErrors) {
+  {
+    // clang-format off
+    const char* context_data[][2] = {
+      {"", ""},
+      {"var ", ""},
+      {"let ", ""},
+      {"new ", ""},
+      {NULL, NULL}
+    };
+
+    const char* data[] = {
+      "import(",
+      "import)",
+      "import()",
+      "import('x",
+      "import('x']",
+      "import['x')",
+      "import = x",
+      "import[",
+      "import[]",
+      "import]",
+      "import[x]",
+      "import{",
+      "import{x",
+      "import{x}",
+      "import(x, y)",
+      "import(...y)",
+      "import(x,)",
+      "import(,)",
+      "import(,y)",
+      "import(;)",
+      "[import]",
+      "{import}",
+      "import+",
+      "import = 1",
+      "import.wat",
+      NULL
+    };
+
+    // clang-format on
+    RunParserSyncTest(context_data, data, kError);
+    // We ignore the error messages for the reason explained in the
+    // ImportExpressionSuccess test.
+    RunModuleParserSyncTest(context_data, data, kError, NULL, 0, NULL, 0, NULL,
+                            0, true, true);
+    static const ParserFlag flags[] = {kAllowHarmonyDynamicImport};
+    RunParserSyncTest(context_data, data, kError, NULL, 0, flags,
+                      arraysize(flags));
+
+    // We ignore test error messages because the error message from
+    // the parser/preparser is different for the same data depending
+    // on the context.  For example, a top level "import{" is parsed
+    // as an import declaration. The parser parses the import token
+    // correctly and then shows an "Unexpected end of input" error
+    // message because of the '{'. The preparser shows an "Unexpected
+    // token {" because it's not a valid token in a CallExpression.
+    RunModuleParserSyncTest(context_data, data, kError, NULL, 0, flags,
+                            arraysize(flags), NULL, 0, true, true);
+  }
+
+  {
+    // clang-format off
+    const char* context_data[][2] = {
+      {"var ", ""},
+      {"let ", ""},
+      {NULL, NULL}
+    };
+
+    const char* data[] = {
+      "import('x')",
+      NULL
+    };
+
+    // clang-format on
+    RunParserSyncTest(context_data, data, kError);
+    RunModuleParserSyncTest(context_data, data, kError);
+
+    static const ParserFlag flags[] = {kAllowHarmonyDynamicImport};
+    RunParserSyncTest(context_data, data, kError, NULL, 0, flags,
+                      arraysize(flags));
+    RunModuleParserSyncTest(context_data, data, kError, NULL, 0, flags,
+                            arraysize(flags));
+  }
+}
 
 TEST(SuperCall) {
   const char* context_data[][2] = {{"", ""},
                                    {NULL, NULL}};
 
   const char* success_data[] = {
     "class C extends B { constructor() { super(); } }",
     "class C extends B { constructor() { () => super(); } }",
     NULL
   };
@@ skipping 5007 matching lines @@
         eager_info.literal()->scope()->inner_scope()->inner_scope();
     DCHECK_NOT_NULL(scope);
     DCHECK_NULL(scope->sibling());
     DCHECK(scope->is_function_scope());
 
     size_t index = 0;
     i::ScopeTestHelper::CompareScopeToData(
         scope, lazy_info.preparsed_scope_data(), index);
   }
 }