[interpreter] Add some bytecode tests for modules.

test/cctest/interpreter/bytecode-expectations-printer.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "test/cctest/interpreter/bytecode-expectations-printer.h"
 
 #include <iomanip>
 #include <iostream>
 #include <vector>
 
@@ skipping 28 matching lines @@
 std::string BytecodeExpectationsPrinter::WrapCodeInFunction(
     const char* function_name, const std::string& function_body) const {
   std::ostringstream program_stream;
   program_stream << "function " << function_name << "() {" << function_body
                  << "}\n"
                  << function_name << "();";
 
   return program_stream.str();
 }
 
-v8::Local<v8::Script> BytecodeExpectationsPrinter::Compile(
+v8::Local<v8::Script> BytecodeExpectationsPrinter::CompileScript(
     const char* program) const {
   v8::Local<v8::String> source = V8StringFromUTF8(program);
   return v8::Script::Compile(isolate_->GetCurrentContext(), source)
       .ToLocalChecked();
 }
 
+v8::Local<v8::Module> BytecodeExpectationsPrinter::CompileModule(
+    const char* program) const {
+  v8::ScriptCompiler::Source source(V8StringFromUTF8(program));
+  return v8::ScriptCompiler::CompileModule(isolate_, &source).ToLocalChecked();
+}
+
 void BytecodeExpectationsPrinter::Run(v8::Local<v8::Script> script) const {
   (void)script->Run(isolate_->GetCurrentContext());
 }
 
 i::Handle<v8::internal::BytecodeArray>
 BytecodeExpectationsPrinter::GetBytecodeArrayForGlobal(
     const char* global_name) const {
   const v8::Local<v8::Context>& context = isolate_->GetCurrentContext();
   v8::Local<v8::String> v8_global_name = V8StringFromUTF8(global_name);
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
       context->Global()->Get(context, v8_global_name).ToLocalChecked());
   i::Handle<i::JSFunction> js_function =
       i::Handle<i::JSFunction>::cast(v8::Utils::OpenHandle(*function));
 
   i::Handle<i::BytecodeArray> bytecodes =
       i::handle(js_function->shared()->bytecode_array(), i_isolate());
 
   return bytecodes;
 }
 
 i::Handle<i::BytecodeArray>
+BytecodeExpectationsPrinter::GetBytecodeArrayForModule(
+    v8::Local<v8::Module> module) const {
+  i::Handle<i::Module> i_module = v8::Utils::OpenHandle(*module);
+  return i::handle(i_module->shared()->bytecode_array(), i_isolate());
+}
+
+i::Handle<i::BytecodeArray>
 BytecodeExpectationsPrinter::GetBytecodeArrayForScript(
     v8::Local<v8::Script> script) const {
   i::Handle<i::JSFunction> js_function = v8::Utils::OpenHandle(*script);
   return i::handle(js_function->shared()->bytecode_array(), i_isolate());
 }
 
 void BytecodeExpectationsPrinter::PrintEscapedString(
     std::ostream& stream, const std::string& string) const {
   for (char c : string) {
     switch (c) {
@@ skipping 232 matching lines @@
   PrintConstantPool(stream, bytecode_array->constant_pool());
   PrintHandlers(stream, bytecode_array);
 }
 
 void BytecodeExpectationsPrinter::PrintExpectation(
     std::ostream& stream, const std::string& snippet) const {
   std::string source_code =
       wrap_ ? WrapCodeInFunction(test_function_name_.c_str(), snippet)
             : snippet;
 
-  v8::Local<v8::Script> script = Compile(source_code.c_str());
-
   i::Handle<i::BytecodeArray> bytecode_array;
-  if (top_level_) {
-    bytecode_array = GetBytecodeArrayForScript(script);
+  if (module_) {
+    CHECK(top_level_ && !wrap_);
+    v8::Local<v8::Module> module = CompileModule(source_code.c_str());
+    bytecode_array = GetBytecodeArrayForModule(module);
   } else {
-    Run(script);
-    bytecode_array = GetBytecodeArrayForGlobal(test_function_name_.c_str());
+    v8::Local<v8::Script> script = CompileScript(source_code.c_str());
+    if (top_level_) {
+      bytecode_array = GetBytecodeArrayForScript(script);
+    } else {
+      Run(script);
+      bytecode_array = GetBytecodeArrayForGlobal(test_function_name_.c_str());
+    }
   }
 
   stream << "---\n";
   PrintCodeSnippet(stream, snippet);
   PrintBytecodeArray(stream, bytecode_array);
   stream << '\n';
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8