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

src/api.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 "src/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 1866 matching lines @@
   RETURN_TO_LOCAL_UNCHECKED(Run(context), Value);
 }
 
 
 Local<UnboundScript> Script::GetUnboundScript() {
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   return ToApiHandle<UnboundScript>(
       i::Handle<i::SharedFunctionInfo>(i::JSFunction::cast(*obj)->shared()));
 }
 
-bool Module::Instantiate(Local<Context> v8_context) {
+int Module::GetModuleRequestsLength() const {
+  i::Handle<i::Module> self = Utils::OpenHandle(this);
+  i::Isolate* isolate = self->GetIsolate();
+  i::Handle<i::SharedFunctionInfo> shared;
+  if (self->code()->IsSharedFunctionInfo()) {
+    shared = i::handle(i::SharedFunctionInfo::cast(self->code()), isolate);
+  } else {
+    shared = i::handle(i::JSFunction::cast(self->code())->shared(), isolate);
+  }
+  return shared->scope_info()
+      ->ModuleDescriptorInfo()
+      ->module_requests()
+      ->length();
+}
+
+Local<String> Module::GetModuleRequest(int i) const {
+  CHECK_GE(i, 0);
+  i::Handle<i::Module> self = Utils::OpenHandle(this);
+  i::Isolate* isolate = self->GetIsolate();
+  i::Handle<i::SharedFunctionInfo> shared;
+  if (self->code()->IsSharedFunctionInfo()) {
+    shared = i::handle(i::SharedFunctionInfo::cast(self->code()), isolate);
+  } else {
+    shared = i::handle(i::JSFunction::cast(self->code())->shared(), isolate);
+  }
+  i::Handle<i::FixedArray> module_requests(
+      shared->scope_info()->ModuleDescriptorInfo()->module_requests(), isolate);
+  CHECK_LT(i, module_requests->length());
+  return ToApiHandle<String>(i::handle(module_requests->get(i), isolate));
+}
+
+bool Module::Instantiate(Local<Context> v8_context,
+                         Module::ResolveCallback callback,
+                         Local<Value> callback_data) {
   i::Handle<i::Module> self = Utils::OpenHandle(this);
   i::Isolate* isolate = self->GetIsolate();
 
   // Already instantiated.
   if (self->code()->IsJSFunction()) return true;
 
   i::Handle<i::SharedFunctionInfo> shared(
       i::SharedFunctionInfo::cast(self->code()), isolate);
   i::Handle<i::Context> context = Utils::OpenHandle(*v8_context);
   i::Handle<i::JSFunction> function =
       isolate->factory()->NewFunctionFromSharedFunctionInfo(
           shared, handle(context->native_context(), isolate));
   self->set_code(*function);
 
-  // TODO(adamk): This could fail in the future when Instantiate
-  // does linking.
+  for (int i = 0, length = GetModuleRequestsLength(); i < length; ++i) {
+    Local<Module> import;
+    // TODO(adamk): Revisit these failure cases once d8 knows how to
+    // persist a module_map across multiple top-level module loads, as
+    // the current module is left in a "half-instantiated" state.
+    if (!callback(v8_context, GetModuleRequest(i), Utils::ToLocal(self),
+                  callback_data)
+             .ToLocal(&import)) {
+      // TODO(adamk): Throw an exception.
+      return false;
+    }
+    if (!import->Instantiate(v8_context, callback, callback_data)) {
+      return false;
+    }
+    self->requested_modules()->set(i, *Utils::OpenHandle(*import));
+  }
+
+  // TODO(neis): This will create multiple cells for the same local variable if
+  // exported under multiple names, which is wrong but cannot be observed at the
+  // moment. This will be fixed by doing the full-fledged linking here once we
+  // get there.
+  i::Handle<i::FixedArray> regular_exports = i::handle(
+      shared->scope_info()->ModuleDescriptorInfo()->regular_exports(), isolate);
+  for (int i = 0, length = regular_exports->length(); i < length; ++i) {
+    i::Handle<i::ModuleInfoEntry> entry =
+        i::handle(i::ModuleInfoEntry::cast(regular_exports->get(i)), isolate);
+    DCHECK(entry->import_name()->IsUndefined(isolate));
+    i::Handle<i::String> export_name =
+        handle(i::String::cast(entry->export_name()), isolate);
+    i::Module::CreateExport(self, export_name);
+  }
+
   return true;
 }
 
 MaybeLocal<Value> Module::Evaluate(Local<Context> context) {
   PREPARE_FOR_EXECUTION_WITH_CONTEXT_IN_RUNTIME_CALL_STATS_SCOPE(
       "v8", "V8.Execute", context, Script, Run, MaybeLocal<Value>(),
       InternalEscapableScope, true);
   i::HistogramTimerScope execute_timer(isolate->counters()->execute(), true);
   i::AggregatingHistogramTimerScope timer(isolate->counters()->compile_lazy());
   i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
 
   i::Handle<i::Module> self = Utils::OpenHandle(this);
   // It's an API error to call Evaluate before Instantiate.
   CHECK(self->code()->IsJSFunction());
 
+  // Each module can only be evaluated once.
+  if (self->evaluated()) return Undefined(reinterpret_cast<Isolate*>(isolate));
+  self->set_evaluated(true);
+
+  i::Handle<i::FixedArray> requested_modules(self->requested_modules(),
+                                             isolate);
+  for (int i = 0, length = requested_modules->length(); i < length; ++i) {
+    i::Handle<i::Module> import(i::Module::cast(requested_modules->get(i)),
+                                isolate);
+    MaybeLocal<Value> maybe_result = Utils::ToLocal(import)->Evaluate(context);
+    if (maybe_result.IsEmpty()) return maybe_result;
+  }
+
   i::Handle<i::JSFunction> function(i::JSFunction::cast(self->code()), isolate);
   DCHECK_EQ(i::MODULE_SCOPE, function->shared()->scope_info()->scope_type());
   i::Handle<i::Object> receiver = isolate->factory()->undefined_value();
 
   Local<Value> result;
   i::Handle<i::Object> argv[] = {self};
   has_pending_exception = !ToLocal<Value>(
       i::Execution::Call(isolate, function, receiver, arraysize(argv), argv),
       &result);
 
@@ skipping 113 matching lines @@
 MaybeLocal<Module> ScriptCompiler::CompileModule(Isolate* isolate,
                                                  Source* source) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
 
   auto maybe = CompileUnboundInternal(isolate, source, kNoCompileOptions, true);
   Local<UnboundScript> unbound;
   if (!maybe.ToLocal(&unbound)) return MaybeLocal<Module>();
 
   i::Handle<i::SharedFunctionInfo> shared = Utils::OpenHandle(*unbound);
   i::Handle<i::Module> module = i_isolate->factory()->NewModule(shared);
-
-  // TODO(neis): This will create multiple cells for the same local variable if
-  // exported under multiple names, which is wrong but cannot be observed at the
-  // moment. This will be fixed by doing the full-fledged linking here once we
-  // get there.
-  i::Handle<i::FixedArray> regular_exports =
-      i::handle(shared->scope_info()->ModuleDescriptorInfo()->regular_exports(),
-                i_isolate);
-  for (int i = 0, length = regular_exports->length(); i < length; ++i) {
-    i::Handle<i::ModuleInfoEntry> entry =
-        i::handle(i::ModuleInfoEntry::cast(regular_exports->get(i)), i_isolate);
-    DCHECK(entry->import_name()->IsUndefined(i_isolate));
-    i::Handle<i::String> export_name =
-        handle(i::String::cast(entry->export_name()), i_isolate);
-    i::Module::CreateExport(module, export_name);
-  }
-
   return ToApiHandle<Module>(module);
 }
 
 
 class IsIdentifierHelper {
  public:
   IsIdentifierHelper() : is_identifier_(false), first_char_(true) {}
 
   bool Check(i::String* string) {
     i::ConsString* cons_string = i::String::VisitFlat(this, string, 0);
@@ skipping 7289 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8