Add basic compilation support for modules

src/parser.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/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 936 matching lines @@
     AstNodeFactory function_factory(ast_value_factory());
     FunctionState function_state(&function_state_, &scope_, *scope,
                                  &function_factory);
 
     scope_->SetLanguageMode(info->language_mode());
     ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16, zone());
     bool ok = true;
     int beg_pos = scanner()->location().beg_pos;
     if (info->is_module()) {
       DCHECK(allow_harmony_modules());
-      Module* module = ParseModule(&ok);
+      Statement* stmt = ParseModule(&ok);
       if (ok) {
-        // TODO(adamk): Do something with returned Module
-        CHECK(module);
-        body->Add(factory()->NewEmptyStatement(RelocInfo::kNoPosition), zone());
+        body->Add(stmt, zone());
       }
     } else {
       ParseStatementList(body, Token::EOS, info->is_eval(), eval_scope, &ok);
     }
 
     if (ok && is_strict(language_mode())) {
       CheckStrictOctalLiteral(beg_pos, scanner()->location().end_pos, &ok);
     }
 
     if (ok && allow_harmony_scoping() && is_strict(language_mode())) {
@@ skipping 275 matching lines @@
     case Token::IMPORT:
       return ParseImportDeclaration(ok);
     case Token::EXPORT:
       return ParseExportDeclaration(ok);
     default:
       return ParseStatementListItem(ok);
   }
 }
 
 
-Module* Parser::ParseModule(bool* ok) {
+Statement* Parser::ParseModule(bool* ok) {
   // (Ecma 262 6th Edition, 15.2):
   // Module :
   //    ModuleBody?
   //
   // ModuleBody :
   //    ModuleItem*
 
-  int pos = peek_position();
-  // Construct block expecting 16 statements.
   Block* body = factory()->NewBlock(NULL, 16, false, RelocInfo::kNoPosition);
-#ifdef DEBUG
-  if (FLAG_print_interface_details) PrintF("# Literal ");
-#endif
   Scope* scope = NewScope(scope_, MODULE_SCOPE);
-
   scope->set_start_position(scanner()->location().beg_pos);
   scope->SetLanguageMode(
       static_cast<LanguageMode>(scope->language_mode() | STRICT_BIT));
 
   {
     BlockState block_state(&scope_, scope);
-    Target target(&this->target_stack_, body);
 
     while (peek() != Token::EOS) {
       Statement* stat = ParseModuleItem(CHECK_OK);
       if (stat && !stat->IsEmpty()) {
         body->AddStatement(stat, zone());
       }
     }
   }
 
   scope->set_end_position(scanner()->location().end_pos);
   body->set_scope(scope);
 
   // Check that all exports are bound.
   Interface* interface = scope->interface();
   for (Interface::Iterator it = interface->iterator();
        !it.done(); it.Advance()) {
     if (scope->LookupLocal(it.name()) == NULL) {
       ParserTraits::ReportMessage("module_export_undefined", it.name());
       *ok = false;
       return NULL;
     }
   }
 
   interface->MakeModule(ok);
   DCHECK(*ok);
   interface->Freeze(ok);
   DCHECK(*ok);
-  return factory()->NewModuleLiteral(body, interface, pos);
+  return body;
 }
 
 
-Module* Parser::ParseModuleSpecifier(bool* ok) {
-  // Module:
-  //    String
+Literal* Parser::ParseModuleSpecifier(bool* ok) {
+  // ModuleSpecifier :
+  //    StringLiteral
 
   int pos = peek_position();
   Expect(Token::STRING, CHECK_OK);
-  const AstRawString* symbol = GetSymbol(scanner());
-
-  // TODO(ES6): Request JS resource from environment...
-
-#ifdef DEBUG
-  if (FLAG_print_interface_details) PrintF("# Url ");
-#endif
-
-  // Create an empty literal as long as the feature isn't finished.
-  USE(symbol);
-  Scope* scope = NewScope(scope_, MODULE_SCOPE);
-  Block* body = factory()->NewBlock(NULL, 1, false, RelocInfo::kNoPosition);
-  body->set_scope(scope);
-  Interface* interface = scope->interface();
-  Module* result = factory()->NewModuleLiteral(body, interface, pos);
-  interface->Freeze(ok);
-  DCHECK(*ok);
-  interface->Unify(scope->interface(), zone(), ok);
-  DCHECK(*ok);
-  return result;
+  return factory()->NewStringLiteral(GetSymbol(scanner()), pos);
 }
 
 
 void* Parser::ParseExportClause(ZoneList<const AstRawString*>* names,
                                 Scanner::Location* reserved_loc, bool* ok) {
   // ExportClause :
   //   '{' '}'
   //   '{' ExportsList '}'
   //   '{' ExportsList ',' '}'
   //
@@ skipping 132 matching lines @@
         break;
 
       default:
         *ok = false;
         ReportUnexpectedToken(scanner()->current_token());
         return NULL;
     }
   }
 
   ExpectContextualKeyword(CStrVector("from"), CHECK_OK);
-  Module* module = ParseModuleSpecifier(CHECK_OK);
+  Literal* module = ParseModuleSpecifier(CHECK_OK);
   USE(module);
 
   ExpectSemicolon(CHECK_OK);
 
   if (module_instance_binding != NULL) {
     // TODO(ES6): Bind name to the Module Instance Object of module.
   }
 
   if (imported_default_binding != NULL) {
     // TODO(ES6): Add an appropriate declaration.
@@ skipping 55 matching lines @@
   ZoneList<const AstRawString*> names(1, zone());
   bool is_export_from = false;
   switch (peek()) {
     case Token::DEFAULT:
       Consume(Token::DEFAULT);
       return ParseExportDefault(ok);
 
     case Token::MUL: {
       Consume(Token::MUL);
       ExpectContextualKeyword(CStrVector("from"), CHECK_OK);
-      Module* module = ParseModuleSpecifier(CHECK_OK);
+      Literal* module = ParseModuleSpecifier(CHECK_OK);
       ExpectSemicolon(CHECK_OK);
       // TODO(ES6): Do something with the return value
       // of ParseModuleSpecifier.
       USE(module);
       is_export_from = true;
       result = factory()->NewEmptyStatement(pos);
       break;
     }
 
     case Token::LBRACE: {
       // There are two cases here:
       //
       // 'export' ExportClause ';'
       // and
       // 'export' ExportClause FromClause ';'
       //
       // In the first case, the exported identifiers in ExportClause must
       // not be reserved words, while in the latter they may be. We
       // pass in a location that gets filled with the first reserved word
       // encountered, and then throw a SyntaxError if we are in the
       // non-FromClause case.
       Scanner::Location reserved_loc = Scanner::Location::invalid();
       ParseExportClause(&names, &reserved_loc, CHECK_OK);
       if (CheckContextualKeyword(CStrVector("from"))) {
-        Module* module = ParseModuleSpecifier(CHECK_OK);
+        Literal* module = ParseModuleSpecifier(CHECK_OK);
         // TODO(ES6): Do something with the return value
         // of ParseModuleSpecifier.
         USE(module);
         is_export_from = true;
       } else if (reserved_loc.IsValid()) {
         // No FromClause, so reserved words are invalid in ExportClause.
         *ok = false;
         ReportMessageAt(reserved_loc, "unexpected_reserved");
         return NULL;
       }
@@ skipping 3828 matching lines @@
     } else {
       const uc16* data = reinterpret_cast<const uc16*>(raw_string->raw_data());
       running_hash = StringHasher::ComputeRunningHash(running_hash, data,
                                                       raw_string->length());
     }
   }
 
   return running_hash;
 }
 } }  // namespace v8::internal