[modules] Introduce v8::Module to the API and return it from CompileModule

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 1840 matching lines @@
 
 MaybeLocal<Value> Script::Run(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);
   auto fun = i::Handle<i::JSFunction>::cast(Utils::OpenHandle(this));
 
-  i::Handle<i::Object> receiver;
+  i::Handle<i::Object> receiver = isolate->global_proxy();
   Local<Value> result;
-
-  if (fun->shared()->scope_info()->scope_type() == i::MODULE_SCOPE) {
-    receiver = isolate->factory()->undefined_value();
-    i::Handle<i::Object> argv[] = {
-        handle(isolate->native_context()->current_module())};
-    has_pending_exception = !ToLocal<Value>(
-        i::Execution::Call(isolate, fun, receiver, 1, argv), &result);
-  } else {
-    receiver = isolate->global_proxy();
-    has_pending_exception = !ToLocal<Value>(
-        i::Execution::Call(isolate, fun, receiver, 0, nullptr), &result);
-  }
+  has_pending_exception = !ToLocal<Value>(
+      i::Execution::Call(isolate, fun, receiver, 0, nullptr), &result);
 
   RETURN_ON_FAILED_EXECUTION(Value);
   RETURN_ESCAPED(result);
 }
 
 
 Local<Value> Script::Run() {
   auto self = Utils::OpenHandle(this, true);
   // If execution is terminating, Compile(..)->Run() requires this
   // check.
   if (self.is_null()) return Local<Value>();
   auto context = ContextFromHeapObject(self);
   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()));
 }
 
+Maybe<bool> Module::Instantiate(Local<Context> v8_context) {
+  i::Handle<i::Module> self = Utils::OpenHandle(this);
+  i::Isolate* isolate = self->GetIsolate();
+
+  // Already instantiated.
+  if (self->code()->IsJSFunction()) return Just(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.
+  return Just(true);

[neis, 2016/09/16 20:53:33]

Will this ever return Just(false)? Or can we just use bool?

[adamk, 2016/09/16 20:58:05]

This method will be able to throw exceptions in the future. We don't have a good
type for "Maybe<void>", though, and Maybe types are the way we usually signal
exceptions to the embedder.

I'll defer to Jochen on this though.

+}
+
+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());
+
+  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);
+
+  RETURN_ON_FAILED_EXECUTION(Value);
+  RETURN_ESCAPED(result);
+}
 
 MaybeLocal<UnboundScript> ScriptCompiler::CompileUnboundInternal(
     Isolate* v8_isolate, Source* source, CompileOptions options,
     bool is_module) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
   PREPARE_FOR_EXECUTION_WITH_ISOLATE(isolate, ScriptCompiler, CompileUnbound,
                                      UnboundScript);
   TRACE_EVENT_CALL_STATS_SCOPED(isolate, "v8", "V8.ScriptCompiler");
 
   // Don't try to produce any kind of cache when the debugger is loaded.
@@ skipping 90 matching lines @@
 
 
 Local<Script> ScriptCompiler::Compile(
     Isolate* v8_isolate,
     Source* source,
     CompileOptions options) {
   auto context = v8_isolate->GetCurrentContext();
   RETURN_TO_LOCAL_UNCHECKED(Compile(context, source, options), Script);
 }
 
-
-MaybeLocal<Script> ScriptCompiler::CompileModule(Local<Context> context,
-                                                 Source* source,
-                                                 CompileOptions options) {
-  auto isolate = context->GetIsolate();
+MaybeLocal<Module> ScriptCompiler::CompileModule(Isolate* isolate,
+                                                 Source* source) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
 
-  auto maybe = CompileUnboundInternal(isolate, source, options, true);
-  Local<UnboundScript> generic;
-  if (!maybe.ToLocal(&generic)) return MaybeLocal<Script>();
-  v8::Context::Scope scope(context);
-  auto result = generic->BindToCurrentContext();
+  auto maybe = CompileUnboundInternal(isolate, source, kNoCompileOptions, true);
+  Local<UnboundScript> unbound;
+  if (!maybe.ToLocal(&unbound)) return MaybeLocal<Module>();
 
-  i::Handle<i::SharedFunctionInfo> shared = Utils::OpenHandle(*generic);
+  i::Handle<i::SharedFunctionInfo> shared = Utils::OpenHandle(*unbound);
   i::Handle<i::FixedArray> regular_exports =
       i::handle(shared->scope_info()->ModuleDescriptorInfo()->regular_exports(),
                 i_isolate);
   int regular_exports_length = regular_exports->length();
 
   i::Handle<i::Module> module =
-      i_isolate->factory()->NewModule(regular_exports_length);
-
-  // TODO(neis): Storing the module into the native context is a temporary hack
-  // to pass it to the Script::Run function.  This will be removed once we
-  // support modules in the API.
-  i_isolate->native_context()->set_current_module(*module);
+      i_isolate->factory()->NewModule(shared, regular_exports_length);
 
   // 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.
   for (int i = 0; i < regular_exports_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 result;
+  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);
     if (cons_string == NULL) return is_identifier_;
@@ 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