[modules] Move implementation of Instantiate to i::Module

This allows the CreateExport/ResolveExport methods to be private to Module.

R=neis@chromium.org
BUG=v8:1569

Review-Url: https://codereview.chromium.org/2368393002
Cr-Commit-Position: refs/heads/master@{#39738}

src/api.cc

@@ -1915,108 +1915,12 @@ Local<Value> Module::GetEmbedderData() const {
       i::handle(self->embedder_data(), self->GetIsolate()));
 }
 
-MUST_USE_RESULT
-static bool InstantiateModule(Local<Module> v8_module,
-                              Local<Context> v8_context,
-                              Module::ResolveCallback callback,
-                              Local<Value> callback_data) {
-  i::Handle<i::Module> module = Utils::OpenHandle(*v8_module);
-  i::Isolate* isolate = module->GetIsolate();
-
-  // Already instantiated.
-  if (module->code()->IsJSFunction()) return true;
-
-  i::Handle<i::SharedFunctionInfo> shared(
-      i::SharedFunctionInfo::cast(module->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));
-  module->set_code(*function);
-
-  i::Handle<i::FixedArray> regular_exports = i::handle(
-      shared->scope_info()->ModuleDescriptorInfo()->regular_exports(), isolate);
-  i::Handle<i::FixedArray> regular_imports = i::handle(
-      shared->scope_info()->ModuleDescriptorInfo()->regular_imports(), isolate);
-  i::Handle<i::FixedArray> special_exports = i::handle(
-      shared->scope_info()->ModuleDescriptorInfo()->special_exports(), isolate);
-
-  // Set up local exports.
-  for (int i = 0, n = regular_exports->length(); i < n; i += 2) {
-    i::Handle<i::FixedArray> export_names(
-        i::FixedArray::cast(regular_exports->get(i + 1)), isolate);
-    i::Module::CreateExport(module, export_names);
-  }
-
-  // Partially set up indirect exports.
-  // For each indirect export, we create the appropriate slot in the export
-  // table and store its ModuleInfoEntry there.  When we later find the correct
-  // Cell in the module that actually provides the value, we replace the
-  // ModuleInfoEntry by that Cell (see ResolveExport).
-  for (int i = 0, n = special_exports->length(); i < n; ++i) {
-    i::Handle<i::ModuleInfoEntry> entry(
-        i::ModuleInfoEntry::cast(special_exports->get(i)), isolate);
-    i::Handle<i::Object> export_name(entry->export_name(), isolate);
-    if (export_name->IsUndefined(isolate)) continue;  // Star export.
-    i::Module::CreateIndirectExport(
-        module, i::Handle<i::String>::cast(export_name), entry);
-  }
-
-  for (int i = 0, length = v8_module->GetModuleRequestsLength(); i < length;
-       ++i) {
-    Local<Module> requested_module;
-    // 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, v8_module->GetModuleRequest(i), v8_module,
-                  callback_data)
-             .ToLocal(&requested_module)) {
-      // TODO(adamk): Give this a better error message. But this is a
-      // misuse of the API anyway.
-      isolate->ThrowIllegalOperation();
-      return false;
-    }
-    module->requested_modules()->set(i, *Utils::OpenHandle(*requested_module));
-    if (!InstantiateModule(requested_module, v8_context, callback,
-                           callback_data)) {
-      return false;
-    }
-  }
-
-  // Resolve imports.
-  for (int i = 0, n = regular_imports->length(); i < n; ++i) {
-    i::Handle<i::ModuleInfoEntry> entry(
-        i::ModuleInfoEntry::cast(regular_imports->get(i)), isolate);
-    i::Handle<i::String> name(i::String::cast(entry->import_name()), isolate);
-    int module_request = i::Smi::cast(entry->module_request())->value();
-    if (i::Module::ResolveImport(module, name, module_request, true)
-            .is_null()) {
-      return false;
-    }
-  }
-
-  // Resolve indirect exports.
-  for (int i = 0, n = special_exports->length(); i < n; ++i) {
-    i::Handle<i::ModuleInfoEntry> entry(
-        i::ModuleInfoEntry::cast(special_exports->get(i)), isolate);
-    i::Handle<i::Object> name(entry->export_name(), isolate);
-    if (name->IsUndefined(isolate)) continue;  // Star export.
-    if (i::Module::ResolveExport(module, i::Handle<i::String>::cast(name), true)
-            .is_null()) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
 bool Module::Instantiate(Local<Context> context,
                          Module::ResolveCallback callback,
                          Local<Value> callback_data) {
   PREPARE_FOR_EXECUTION_BOOL(context, Module, Instantiate);
-  has_pending_exception =
-      !InstantiateModule(Utils::ToLocal(Utils::OpenHandle(this)), context,
-                         callback, callback_data);
+  has_pending_exception = !i::Module::Instantiate(
+      Utils::OpenHandle(this), context, callback, callback_data);
   RETURN_ON_FAILED_EXECUTION_BOOL();
   return true;
 }

src/objects.cc

@@ -19727,5 +19727,93 @@ MaybeHandle<Cell> Module::ResolveExportUsingStarExports(Handle<Module> module,
   return MaybeHandle<Cell>();
 }
 
+bool Module::Instantiate(Handle<Module> module, v8::Local<v8::Context> context,
+                         v8::Module::ResolveCallback callback,
+                         v8::Local<v8::Value> callback_data) {
+  // Already instantiated.
+  if (module->code()->IsJSFunction()) return true;
+
+  Isolate* isolate = module->GetIsolate();
+  Handle<SharedFunctionInfo> shared(SharedFunctionInfo::cast(module->code()),
+                                    isolate);
+  Handle<JSFunction> function =
+      isolate->factory()->NewFunctionFromSharedFunctionInfo(
+          shared,
+          handle(Utils::OpenHandle(*context)->native_context(), isolate));
+  module->set_code(*function);
+
+  Handle<ModuleInfo> module_info(shared->scope_info()->ModuleDescriptorInfo(),
+                                 isolate);
+
+  // Set up local exports.
+  Handle<FixedArray> regular_exports(module_info->regular_exports(), isolate);
+  for (int i = 0, n = regular_exports->length(); i < n; i += 2) {
+    Handle<FixedArray> export_names(
+        FixedArray::cast(regular_exports->get(i + 1)), isolate);
+    CreateExport(module, export_names);
+  }
+
+  // Partially set up indirect exports.
+  // For each indirect export, we create the appropriate slot in the export
+  // table and store its ModuleInfoEntry there.  When we later find the correct
+  // Cell in the module that actually provides the value, we replace the
+  // ModuleInfoEntry by that Cell (see ResolveExport).
+  Handle<FixedArray> special_exports(module_info->special_exports(), isolate);
+  for (int i = 0, n = special_exports->length(); i < n; ++i) {
+    Handle<ModuleInfoEntry> entry(
+        ModuleInfoEntry::cast(special_exports->get(i)), isolate);
+    Handle<Object> export_name(entry->export_name(), isolate);
+    if (export_name->IsUndefined(isolate)) continue;  // Star export.
+    CreateIndirectExport(module, Handle<String>::cast(export_name), entry);
+  }
+
+  Handle<FixedArray> module_requests(module_info->module_requests(), isolate);
+  for (int i = 0, length = module_requests->length(); i < length; ++i) {
+    Handle<String> specifier(String::cast(module_requests->get(i)), isolate);
+    v8::Local<v8::Module> api_requested_module;
+    // 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(context, v8::Utils::ToLocal(specifier),
+                  v8::Utils::ToLocal(module), callback_data)
+             .ToLocal(&api_requested_module)) {
+      // TODO(adamk): Give this a better error message. But this is a
+      // misuse of the API anyway.
+      isolate->ThrowIllegalOperation();
+      return false;
+    }
+    Handle<Module> requested_module = Utils::OpenHandle(*api_requested_module);
+    module->requested_modules()->set(i, *requested_module);
+    if (!Instantiate(requested_module, context, callback, callback_data)) {
+      return false;
+    }
+  }
+
+  // Resolve imports.
+  Handle<FixedArray> regular_imports(module_info->regular_imports(), isolate);
+  for (int i = 0, n = regular_imports->length(); i < n; ++i) {
+    Handle<ModuleInfoEntry> entry(
+        ModuleInfoEntry::cast(regular_imports->get(i)), isolate);
+    Handle<String> name(String::cast(entry->import_name()), isolate);
+    int module_request = Smi::cast(entry->module_request())->value();
+    if (ResolveImport(module, name, module_request, true).is_null()) {
+      return false;
+    }
+  }
+
+  // Resolve indirect exports.
+  for (int i = 0, n = special_exports->length(); i < n; ++i) {
+    Handle<ModuleInfoEntry> entry(
+        ModuleInfoEntry::cast(special_exports->get(i)), isolate);
+    Handle<Object> name(entry->export_name(), isolate);
+    if (name->IsUndefined(isolate)) continue;  // Star export.
+    if (ResolveExport(module, Handle<String>::cast(name), true).is_null()) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 }  // namespace internal
 }  // namespace v8

src/objects.h

@@ -7953,17 +7953,35 @@ class Module : public Struct {
   // Get the ModuleInfo associated with the code.
   inline ModuleInfo* info() const;
 
-  static void CreateExport(Handle<Module> module, Handle<FixedArray> names);
+  // Implementation of spec operation ModuleDeclarationInstantiation.
+  // Returns false if an exception occurred during instantiation, true
+  // otherwise.
+  static MUST_USE_RESULT bool Instantiate(Handle<Module> module,
+                                          v8::Local<v8::Context> context,
+                                          v8::Module::ResolveCallback callback,
+                                          v8::Local<v8::Value> callback_data);
+
   static Handle<Object> LoadExport(Handle<Module> module, Handle<String> name);
   static void StoreExport(Handle<Module> module, Handle<String> name,
                           Handle<Object> value);
 
-  static void CreateIndirectExport(Handle<Module> module, Handle<String> name,
-                                   Handle<ModuleInfoEntry> entry);
-
   static Handle<Object> LoadImport(Handle<Module> module, Handle<String> name,
                                    int module_request);
 
+  static const int kCodeOffset = HeapObject::kHeaderSize;
+  static const int kExportsOffset = kCodeOffset + kPointerSize;
+  static const int kRequestedModulesOffset = kExportsOffset + kPointerSize;
+  static const int kFlagsOffset = kRequestedModulesOffset + kPointerSize;
+  static const int kEmbedderDataOffset = kFlagsOffset + kPointerSize;
+  static const int kSize = kEmbedderDataOffset + kPointerSize;
+
+ private:
+  enum { kEvaluatedBit };
+
+  static void CreateExport(Handle<Module> module, Handle<FixedArray> names);
+  static void CreateIndirectExport(Handle<Module> module, Handle<String> name,
+                                   Handle<ModuleInfoEntry> entry);
+
   // The [must_resolve] argument indicates whether or not an exception should be
   // thrown if the module does not provide an export named [name].
   //
@@ -7981,16 +7999,6 @@ class Module : public Struct {
                                                          int module_request,
                                                          bool must_resolve);
 
-  static const int kCodeOffset = HeapObject::kHeaderSize;
-  static const int kExportsOffset = kCodeOffset + kPointerSize;
-  static const int kRequestedModulesOffset = kExportsOffset + kPointerSize;
-  static const int kFlagsOffset = kRequestedModulesOffset + kPointerSize;
-  static const int kEmbedderDataOffset = kFlagsOffset + kPointerSize;
-  static const int kSize = kEmbedderDataOffset + kPointerSize;
-
- private:
-  enum { kEvaluatedBit };
-
   // Helper for ResolveExport.
   static MUST_USE_RESULT MaybeHandle<Cell> ResolveExportUsingStarExports(
       Handle<Module> module, Handle<String> name, bool must_resolve);