Add basic compilation support for modules

src/compiler.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/v8.h"
 
 #include "src/compiler.h"
 
 #include "src/ast-numbering.h"
 #include "src/ast-this-access-visitor.h"
@@ skipping 1117 matching lines @@
   PostponeInterruptsScope postpone(isolate);
   DCHECK(!isolate->native_context().is_null());
   Handle<Script> script = info->script();
 
   // TODO(svenpanne) Obscure place for this, perhaps move to OnBeforeCompile?
   FixedArray* array = isolate->native_context()->embedder_data();
   script->set_context_data(array->get(0));
 
   isolate->debug()->OnBeforeCompile(script);
 
-  DCHECK(info->is_eval() || info->is_global());
+  DCHECK(info->is_eval() || info->is_global() || info->is_module());

[rossberg, 2015/02/06 12:36:56]

Yeah, this is starting to get me worried. Module code is not "toplevel", so I'm
wondering what assumptions might break with this. At some point we'll probably
have to rethink/refactor this.

[adamk, 2015/02/06 17:29:08]

I wouldn't be too worried, yet anyway. This is why I wanted to get the compiler
working, so I can get some more tests in and then refactor as need-be. In the
mid-term run, I think we probably do want to make module compilation more
separate from toplevel compilation. But doing that right now would lead either
to too much code duplication or too much brokenness.

If you have concrete suggestions for refactoring that could happen earlier,
please let me know.

 
   info->MarkAsToplevel();
 
   Handle<SharedFunctionInfo> result;
 
   { VMState<COMPILER> state(info->isolate());
     if (info->function() == NULL) {
       // Parse the script if needed (if it's already parsed, function() is
       // non-NULL).
       bool parse_allow_lazy =
@@ skipping 124 matching lines @@
   return isolate->factory()->NewFunctionFromSharedFunctionInfo(
       shared_info, context, NOT_TENURED);
 }
 
 
 Handle<SharedFunctionInfo> Compiler::CompileScript(
     Handle<String> source, Handle<Object> script_name, int line_offset,
     int column_offset, bool is_embedder_debug_script,
     bool is_shared_cross_origin, Handle<Context> context,
     v8::Extension* extension, ScriptData** cached_data,
-    ScriptCompiler::CompileOptions compile_options, NativesFlag natives) {
+    ScriptCompiler::CompileOptions compile_options, NativesFlag natives,
+    bool is_module) {
   Isolate* isolate = source->GetIsolate();
   if (compile_options == ScriptCompiler::kNoCompileOptions) {
     cached_data = NULL;
   } else if (compile_options == ScriptCompiler::kProduceParserCache ||
              compile_options == ScriptCompiler::kProduceCodeCache) {
     DCHECK(cached_data && !*cached_data);
     DCHECK(extension == NULL);
     DCHECK(!isolate->debug()->is_loaded());
   } else {
     DCHECK(compile_options == ScriptCompiler::kConsumeParserCache ||
@@ skipping 44 matching lines @@
     if (!script_name.is_null()) {
       script->set_name(*script_name);
       script->set_line_offset(Smi::FromInt(line_offset));
       script->set_column_offset(Smi::FromInt(column_offset));
     }
     script->set_is_shared_cross_origin(is_shared_cross_origin);
     script->set_is_embedder_debug_script(is_embedder_debug_script);
 
     // Compile the function and add it to the cache.
     CompilationInfoWithZone info(script);
-    info.MarkAsGlobal();
+    if (FLAG_harmony_modules && is_module) {
+      info.MarkAsModule();
+    } else {
+      info.MarkAsGlobal();
+    }
     info.SetCachedData(cached_data, compile_options);
     info.SetExtension(extension);
     info.SetContext(context);
     if (FLAG_serialize_toplevel &&
         compile_options == ScriptCompiler::kProduceCodeCache) {
       info.PrepareForSerializing();
     }
     if (FLAG_use_strict) {
       info.SetLanguageMode(
           static_cast<LanguageMode>(info.language_mode() | STRICT_BIT));
@@ skipping 250 matching lines @@
 }
 
 
 #if DEBUG
 void CompilationInfo::PrintAstForTesting() {
   PrintF("--- Source from AST ---\n%s\n",
          PrettyPrinter(isolate(), zone()).PrintProgram(function()));
 }
 #endif
 } }  // namespace v8::internal