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

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.
 
 
 // Defined when linking against shared lib on Windows.
 #if defined(USING_V8_SHARED) && !defined(V8_SHARED)
 #define V8_SHARED
 #endif
 
@@ skipping 442 matching lines @@
   temp_isolate->Dispose();
   delete[] source_buffer;
   delete[] name_buffer;
   return result;
 }
 
 
 // Compile a string within the current v8 context.
 MaybeLocal<Script> Shell::CompileString(
     Isolate* isolate, Local<String> source, Local<Value> name,
-    ScriptCompiler::CompileOptions compile_options, SourceType source_type) {
+    ScriptCompiler::CompileOptions compile_options) {
   Local<Context> context(isolate->GetCurrentContext());
   ScriptOrigin origin(name);
-  // TODO(adamk): Make use of compile options for Modules.
-  if (compile_options == ScriptCompiler::kNoCompileOptions ||
-      source_type == MODULE) {
+  if (compile_options == ScriptCompiler::kNoCompileOptions) {
     ScriptCompiler::Source script_source(source, origin);
-    return source_type == SCRIPT
-               ? ScriptCompiler::Compile(context, &script_source,
-                                         compile_options)
-               : ScriptCompiler::CompileModule(context, &script_source,
-                                               compile_options);
+    return ScriptCompiler::Compile(context, &script_source, compile_options);
   }
 
   ScriptCompiler::CachedData* data =
       CompileForCachedData(source, name, compile_options);
   ScriptCompiler::Source cached_source(source, origin, data);
   if (compile_options == ScriptCompiler::kProduceCodeCache) {
     compile_options = ScriptCompiler::kConsumeCodeCache;
   } else if (compile_options == ScriptCompiler::kProduceParserCache) {
     compile_options = ScriptCompiler::kConsumeParserCache;
   } else {
     DCHECK(false);  // A new compile option?
   }
   if (data == NULL) compile_options = ScriptCompiler::kNoCompileOptions;
-  DCHECK_EQ(SCRIPT, source_type);
   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) {
   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);
-    Local<Script> script;
-    if (!Shell::CompileString(isolate, source, name, options.compile_options,
-                              source_type).ToLocal(&script)) {
-      // Print errors that happened during compilation.
-      if (report_exceptions) ReportException(isolate, &try_catch);
-      return false;
+    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);
     }
-    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;
   }
@@ skipping 2187 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif