Implement ParseExportDeclaration per latest ES6 spec draft

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 1252 matching lines @@
   }
 
   interface->MakeModule(ok);
   DCHECK(*ok);
   interface->Freeze(ok);
   DCHECK(*ok);
   return factory()->NewModuleLiteral(body, interface, pos);
 }
 
 
-Module* Parser::ParseModuleUrl(bool* ok) {
+Module* Parser::ParseModuleSpecifier(bool* ok) {
   // Module:
   //    String
 
   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;
 }
 
 
+void* Parser::ParseModuleDeclarationClause(
+    ZoneList<const AstRawString*>* names, bool* ok) {
+  // Handles both imports and exports:
+  //
+  // ImportOrExportClause :
+  //   '{' '}'
+  //   '{' ImportOrExportsList '}'
+  //   '{' ImportOrExportsList ',' '}'
+  //
+  // ImportOrExportsList :
+  //   ImportOrExportSpecifier
+  //   ImportOrExportsList ',' ImportOrExportSpecifier
+  //
+  // ImportOrExportSpecifier :
+  //   IdentifierName
+  //   IdentifierName 'as' IdentifierName
+
+  Expect(Token::LBRACE, CHECK_OK);
+
+  while (peek() != Token::RBRACE) {
+    const AstRawString* name = ParseIdentifierName(CHECK_OK);
+    names->Add(name, zone());
+    const AstRawString* export_name = NULL;
+    if (CheckContextualKeyword(CStrVector("as"))) {
+      export_name = ParseIdentifierName(CHECK_OK);
+    }
+    // TODO(ES6): Return the export_name as well as the name.
+    USE(export_name);
+    if (peek() == Token::RBRACE) break;
+    Expect(Token::COMMA, CHECK_OK);
+  }
+
+  Expect(Token::RBRACE, CHECK_OK);
+
+  return 0;
+}
+
+
 Statement* Parser::ParseImportDeclaration(bool* ok) {
   // ImportDeclaration:
   //    'import' IdentifierName (',' IdentifierName)* 'from' ModuleUrl ';'
   //
   // TODO(ES6): implement current syntax
 
   int pos = peek_position();
   Expect(Token::IMPORT, CHECK_OK);
   ZoneList<const AstRawString*> names(1, zone());
 
   const AstRawString* name = ParseIdentifierName(CHECK_OK);
   names.Add(name, zone());
   while (peek() == Token::COMMA) {
     Consume(Token::COMMA);
     name = ParseIdentifierName(CHECK_OK);
     names.Add(name, zone());
   }
 
   ExpectContextualKeyword(CStrVector("from"), CHECK_OK);
-  Module* module = ParseModuleUrl(CHECK_OK);
+  Module* module = ParseModuleSpecifier(CHECK_OK);
   ExpectSemicolon(CHECK_OK);
 
-  // TODO(ES6): Do something with ParseModuleUrl's return value.
+  // TODO(ES6): Do something with ParseModuleSpecifier's return value.
   USE(module);
 
   for (int i = 0; i < names.length(); ++i) {
     // TODO(ES6): Add an appropriate declaration for each name
   }
 
   return factory()->NewEmptyStatement(pos);
 }
 
 
+Statement* Parser::ParseExportDefault(bool* ok) {
+  //  Supports the following productions, starting after the 'default' token:
+  //    'export' 'default' FunctionDeclaration
+  //    'export' 'default' ClassDeclaration
+  //    'export' 'default' AssignmentExpression[In] ';'
+  //
+  // TODO(ES6): Allow FunctionDeclaration[Default] and
+  // ClassDeclaration[Default].
+
+  Statement* result = NULL;
+  switch (peek()) {
+    case Token::FUNCTION:

[arv (Not doing code reviews), 2015/01/28 02:57:19]

This is going to be problematic. export default supports exporting function
expressions too.

```js
export default function() {}
```

We need to do some lookahead that is currently not covered by the current code.

Can you add a TODO?

[adamk, 2015/01/28 18:05:04]

That's the TODO above about FunctionDeclaration[Default] (that's what the
grammar calls this sort of anonymous function declaration). I've moved the TODO
down to these two places. Also added failing tests with a TODO.

+      result = ParseFunctionDeclaration(NULL, CHECK_OK);
+      break;
+
+    case Token::CLASS:
+      result = ParseClassDeclaration(NULL, CHECK_OK);

[arv (Not doing code reviews), 2015/01/28 02:57:19]

Same here

+      break;
+
+    default: {
+      int pos = peek_position();
+      Expression* expr = ParseAssignmentExpression(true, CHECK_OK);
+      ExpectSemicolon(CHECK_OK);
+      result = factory()->NewExpressionStatement(expr, pos);
+      break;
+    }
+  }
+
+  // TODO(ES6): Add default export to scope_->interface()
+
+  return result;
+}
+
+
 Statement* Parser::ParseExportDeclaration(bool* ok) {
   // ExportDeclaration:
-  //    'export' Identifier (',' Identifier)* ';'
-  //    'export' VariableDeclaration
-  //    'export' FunctionDeclaration
-  //    'export' GeneratorDeclaration
-  //    'export' ModuleDeclaration
-  //
-  // TODO(ES6): implement current syntax
+  //    'export' '*' 'from' ModuleSpecifier ';'
+  //    'export' ExportClause ('from' ModuleSpecifier)? ';'
+  //    'export' VariableStatement
+  //    'export' Declaration
+  //    'export' 'default' ... (handled in ParseExportDefault)
 
+  int pos = peek_position();
   Expect(Token::EXPORT, CHECK_OK);
 
   Statement* result = NULL;
   ZoneList<const AstRawString*> names(1, zone());
+  bool is_export_from = false;
   switch (peek()) {
-    case Token::IDENTIFIER: {
-      int pos = position();
-      const AstRawString* name =
-          ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
-      names.Add(name, zone());
-      while (peek() == Token::COMMA) {
-        Consume(Token::COMMA);
-        name = ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
-        names.Add(name, zone());
+    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);
+      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:
+      ParseModuleDeclarationClause(&names, CHECK_OK);
+      if (CheckContextualKeyword(CStrVector("from"))) {
+        Module* module = ParseModuleSpecifier(CHECK_OK);
+        // TODO(ES6): Do something with the return value
+        // of ParseModuleSpecifier.
+        USE(module);
+        is_export_from = true;
       }
       ExpectSemicolon(CHECK_OK);
       result = factory()->NewEmptyStatement(pos);
       break;
-    }
 
     case Token::FUNCTION:
       result = ParseFunctionDeclaration(&names, CHECK_OK);
       break;
 
     case Token::CLASS:
       result = ParseClassDeclaration(&names, CHECK_OK);
       break;
 
     case Token::VAR:
@@ skipping 14 matching lines @@
     if (var == NULL) {
       // TODO(sigurds) This is an export that has no definition yet,
       // not clear what to do in this case.
       continue;
     }
     if (!IsImmutableVariableMode(var->mode())) {
       var->set_maybe_assigned();
     }
   }
 
-  // Extract declared names into export declarations and interface.
-  Interface* interface = scope_->interface();
-  for (int i = 0; i < names.length(); ++i) {
+  // TODO(ES6): Handle 'export from' once imports are properly implemented.
+  // For now we just drop such exports on the floor.
+  if (!is_export_from) {
+    // Extract declared names into export declarations and interface.
+    Interface* interface = scope_->interface();
+    for (int i = 0; i < names.length(); ++i) {
 #ifdef DEBUG
-    if (FLAG_print_interface_details)
-      PrintF("# Export %.*s ", names[i]->length(), names[i]->raw_data());
+      if (FLAG_print_interface_details)
+        PrintF("# Export %.*s ", names[i]->length(), names[i]->raw_data());
 #endif
-    Interface* inner = Interface::NewUnknown(zone());
-    interface->Add(names[i], inner, zone(), CHECK_OK);
-    if (!*ok)
-      return NULL;
-    VariableProxy* proxy = NewUnresolved(names[i], LET, inner);
-    USE(proxy);
-    // TODO(rossberg): Rethink whether we actually need to store export
-    // declarations (for compilation?).
-    // ExportDeclaration* declaration =
-    //     factory()->NewExportDeclaration(proxy, scope_, position);
-    // scope_->AddDeclaration(declaration);
+      Interface* inner = Interface::NewUnknown(zone());
+      interface->Add(names[i], inner, zone(), CHECK_OK);
+      if (!*ok)
+        return NULL;
+      VariableProxy* proxy = NewUnresolved(names[i], LET, inner);
+      USE(proxy);
+      // TODO(rossberg): Rethink whether we actually need to store export
+      // declarations (for compilation?).
+      // ExportDeclaration* declaration =
+      //     factory()->NewExportDeclaration(proxy, scope_, position);
+      // scope_->AddDeclaration(declaration);
+    }
   }
 
   DCHECK(result != NULL);
   return result;
 }
 
 
 Statement* Parser::ParseStatement(ZoneList<const AstRawString*>* labels,
                                   bool* ok) {
   // Statement ::
@@ skipping 3717 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