[modules] Expand API to allow linking and use it in d8

src/d8.cc

 // Copyright 2012 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 <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 
 #include <algorithm>
 #include <fstream>
+#include <map>
+#include <utility>
 #include <vector>
 
 #ifdef ENABLE_VTUNE_JIT_INTERFACE
 #include "src/third_party/vtune/v8-vtune.h"
 #endif
 
 #include "src/d8.h"
 #include "src/ostreams.h"
 
 #include "include/libplatform/libplatform.h"
@@ skipping 432 matching lines @@
   MaybeLocal<Script> result =
       ScriptCompiler::Compile(context, &cached_source, compile_options);
   CHECK(data == NULL || !data->rejected);
   return result;
 }
 
 
 // Executes a string within the current v8 context.
 bool Shell::ExecuteString(Isolate* isolate, Local<String> source,
                           Local<Value> name, bool print_result,
-                          bool report_exceptions, SourceType source_type) {
+                          bool report_exceptions) {
   HandleScope handle_scope(isolate);
   TryCatch try_catch(isolate);
   try_catch.SetVerbose(true);
 
   MaybeLocal<Value> maybe_result;
   {
     PerIsolateData* data = PerIsolateData::Get(isolate);
     Local<Context> realm =
         Local<Context>::New(isolate, data->realms_[data->realm_current_]);
     Context::Scope context_scope(realm);
-    if (source_type == SCRIPT) {
-      Local<Script> script;
-      if (!Shell::CompileString(isolate, source, name, options.compile_options)
-               .ToLocal(&script)) {
-        // Print errors that happened during compilation.
-        if (report_exceptions) ReportException(isolate, &try_catch);
-        return false;
-      }
-      maybe_result = script->Run(realm);
-    } else {
-      DCHECK_EQ(MODULE, source_type);
-      Local<Module> module;
-      ScriptOrigin origin(name);
-      ScriptCompiler::Source script_source(source, origin);
-      // TODO(adamk): Make use of compile options for Modules.
-      if (!ScriptCompiler::CompileModule(isolate, &script_source)
-               .ToLocal(&module)) {
-        // Print errors that happened during compilation.
-        if (report_exceptions) ReportException(isolate, &try_catch);
-        return false;
-      }
-      // This can't fail until we support linking.
-      CHECK(module->Instantiate(realm));
-      maybe_result = module->Evaluate(realm);
+    Local<Script> script;
+    if (!Shell::CompileString(isolate, source, name, options.compile_options)
+             .ToLocal(&script)) {
+      // Print errors that happened during compilation.
+      if (report_exceptions) ReportException(isolate, &try_catch);
+      return false;
     }
+    maybe_result = script->Run(realm);
     EmptyMessageQueues(isolate);
     data->realm_current_ = data->realm_switch_;
   }
   Local<Value> result;
   if (!maybe_result.ToLocal(&result)) {
     DCHECK(try_catch.HasCaught());
     // Print errors that happened during execution.
     if (report_exceptions) ReportException(isolate, &try_catch);
     return false;
   }
   DCHECK(!try_catch.HasCaught());
   if (print_result) {
     if (options.test_shell) {
       if (!result->IsUndefined()) {
         // If all went well and the result wasn't undefined then print
         // the returned value.
         v8::String::Utf8Value str(result);
         fwrite(*str, sizeof(**str), str.length(), stdout);
         printf("\n");
       }
     } else {
       v8::String::Utf8Value str(Stringify(isolate, result));
       fwrite(*str, sizeof(**str), str.length(), stdout);
       printf("\n");
     }
   }
   return true;
 }
 
+MaybeLocal<Module> Shell::FetchModuleTree(
+    Isolate* isolate, const std::string& file_name,
+    std::map<std::string, Global<Module>>* module_map) {
+  TryCatch try_catch(isolate);
+  try_catch.SetVerbose(true);
+  Local<String> source_text = ReadFile(isolate, file_name.c_str());
+  if (source_text.IsEmpty()) {
+    printf("Error reading '%s'\n", file_name.c_str());
+    Shell::Exit(1);
+  }
+  ScriptOrigin origin(
+      String::NewFromUtf8(isolate, file_name.c_str(), NewStringType::kNormal)
+          .ToLocalChecked());
+  ScriptCompiler::Source source(source_text, origin);
+  Local<Module> module;
+  if (!ScriptCompiler::CompileModule(isolate, &source).ToLocal(&module)) {
+    ReportException(isolate, &try_catch);
+    return MaybeLocal<Module>();
+  }
+  module_map->insert(
+      std::make_pair(file_name, Global<Module>(isolate, module)));
+  int num_imports = module->GetModuleRequestsLength();

[neis, 2016/09/20 21:07:30]

Please rename to length and move into the for.

[adamk, 2016/09/20 21:13:58]

Done.

+  for (int i = 0; i < num_imports; ++i) {
+    Local<String> import_name = module->GetModuleRequest(i);

[neis, 2016/09/20 21:07:30]

Please rename to name.

[adamk, 2016/09/20 21:13:58]

Done.

+    // TODO(adamk): Resolve the imported module to a full path.
+    std::string str = *String::Utf8Value(import_name);
+    if (!module_map->count(str)) {
+      if (FetchModuleTree(isolate, str, module_map).IsEmpty()) {
+        return MaybeLocal<Module>();
+      }
+    }
+  }
+
+  return module;
+}
+
+namespace {
+
+MaybeLocal<Module> ResolveModuleCallback(Local<Context> context,
+                                         Local<String> specifier,
+                                         Local<Module> referrer,
+                                         Local<Value> data) {
+  Isolate* isolate = context->GetIsolate();
+  auto module_map = static_cast<std::map<std::string, Global<Module>>*>(
+      External::Cast(*data)->Value());
+  std::string str_specifier = *String::Utf8Value(specifier);
+  // TODO(adamk): Resolve the specifier using the referrer
+  auto it = module_map->find(str_specifier);
+  if (it != module_map->end()) {
+    return it->second.Get(isolate);
+  }
+  return MaybeLocal<Module>();
+}
+
+}  // anonymous namespace
+
+bool Shell::ExecuteModule(Isolate* isolate, const char* file_name) {
+  HandleScope handle_scope(isolate);
+
+  Local<Module> root_module;
+  std::map<std::string, Global<Module>> module_map;
+  if (!FetchModuleTree(isolate, file_name, &module_map).ToLocal(&root_module)) {
+    return false;
+  }
+
+  TryCatch try_catch(isolate);
+  try_catch.SetVerbose(true);
+
+  MaybeLocal<Value> maybe_result;
+  {
+    PerIsolateData* data = PerIsolateData::Get(isolate);
+    Local<Context> realm =
+        Local<Context>::New(isolate, data->realms_[data->realm_current_]);
+    Context::Scope context_scope(realm);
+
+    // This can't fail until we support linking.
+    CHECK(root_module->Instantiate(realm, ResolveModuleCallback,
+                                   External::New(isolate, &module_map)));
+    maybe_result = root_module->Evaluate(realm);
+    EmptyMessageQueues(isolate);
+    data->realm_current_ = data->realm_switch_;

[neis, 2016/09/20 21:07:30]

Please remove this if possible.

[adamk, 2016/09/20 21:13:58]

Removed this. I'm still using the current realm to figure out the
context to use, but that seems fine.

Realm.switch is only used for interactive use cases, and we'll probably need a
whole lot of support here to figure out how to use modules interactively.

+  }
+  Local<Value> result;
+  if (!maybe_result.ToLocal(&result)) {
+    DCHECK(try_catch.HasCaught());
+    // Print errors that happened during execution.
+    ReportException(isolate, &try_catch);
+    return false;
+  }
+  DCHECK(!try_catch.HasCaught());
+  return true;
+}
 
 PerIsolateData::RealmScope::RealmScope(PerIsolateData* data) : data_(data) {
   data_->realm_count_ = 1;
   data_->realm_current_ = 0;
   data_->realm_switch_ = 0;
   data_->realms_ = new Global<Context>[1];
   data_->realms_[0].Reset(data_->isolate_,
                           data_->isolate_->GetEnteredContext());
 }
 
@@ skipping 1034 matching lines @@
 SourceGroup::~SourceGroup() {
   delete thread_;
   thread_ = NULL;
 }
 
 
 void SourceGroup::Execute(Isolate* isolate) {
   bool exception_was_thrown = false;
   for (int i = begin_offset_; i < end_offset_; ++i) {
     const char* arg = argv_[i];
-    Shell::SourceType source_type = Shell::SCRIPT;
     if (strcmp(arg, "-e") == 0 && i + 1 < end_offset_) {
       // Execute argument given to -e option directly.
       HandleScope handle_scope(isolate);
       Local<String> file_name =
           String::NewFromUtf8(isolate, "unnamed", NewStringType::kNormal)
               .ToLocalChecked();
       Local<String> source =
           String::NewFromUtf8(isolate, argv_[i + 1], NewStringType::kNormal)
               .ToLocalChecked();
       Shell::options.script_executed = true;
       if (!Shell::ExecuteString(isolate, source, file_name, false, true)) {
         exception_was_thrown = true;
         break;
       }
       ++i;
       continue;
     } else if (strcmp(arg, "--module") == 0 && i + 1 < end_offset_) {
       // Treat the next file as a module.
-      source_type = Shell::MODULE;
       arg = argv_[++i];
+      Shell::options.script_executed = true;
+      if (!Shell::ExecuteModule(isolate, arg)) {
+        exception_was_thrown = true;
+        break;
+      }
+      continue;
     } else if (arg[0] == '-') {
       // Ignore other options. They have been parsed already.
       continue;
     }
 
     // Use all other arguments as names of files to load and run.
     HandleScope handle_scope(isolate);
     Local<String> file_name =
         String::NewFromUtf8(isolate, arg, NewStringType::kNormal)
             .ToLocalChecked();
     Local<String> source = ReadFile(isolate, arg);
     if (source.IsEmpty()) {
       printf("Error reading '%s'\n", arg);
       Shell::Exit(1);
     }
     Shell::options.script_executed = true;
-    if (!Shell::ExecuteString(isolate, source, file_name, false, true,
-                              source_type)) {
+    if (!Shell::ExecuteString(isolate, source, file_name, false, true)) {
       exception_was_thrown = true;
       break;
     }
   }
   if (exception_was_thrown != Shell::options.expected_to_throw) {
     Shell::Exit(1);
   }
 }
 
 
@@ skipping 986 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif