[modules] Move Evaluate from api.cc into internal Module implementation

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 1919 matching lines @@
       "v8", "V8.Execute", context, Module, Evaluate, 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);
-
+  has_pending_exception = !ToLocal(i::Module::Evaluate(self), &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);
@@ skipping 7417 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