[modules] Refactor parsing of anonymous declarations in default exports.

src/parsing/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/parsing/parser.h"
 
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 1267 matching lines @@
 
 
 Statement* Parser::ParseStatementListItem(bool* ok) {
   // (Ecma 262 6th Edition, 13.1):
   // StatementListItem:
   //    Statement
   //    Declaration
   const Token::Value peeked = peek();
   switch (peeked) {
     case Token::FUNCTION:
-      return ParseHoistableDeclaration(NULL, ok);
+      return ParseHoistableDeclaration(NULL, false, ok);
     case Token::CLASS:
       Consume(Token::CLASS);
-      return ParseClassDeclaration(NULL, ok);
+      return ParseClassDeclaration(NULL, false, ok);
     case Token::CONST:
       return ParseVariableStatement(kStatementListItem, NULL, ok);
     case Token::VAR:
       return ParseVariableStatement(kStatementListItem, NULL, ok);
     case Token::LET:
       if (IsNextLetKeyword()) {
         return ParseVariableStatement(kStatementListItem, NULL, ok);
       }
       break;
     case Token::ASYNC:
       if (allow_harmony_async_await() && PeekAhead() == Token::FUNCTION &&
           !scanner()->HasAnyLineTerminatorAfterNext()) {
         Consume(Token::ASYNC);
-        return ParseAsyncFunctionDeclaration(NULL, ok);
+        return ParseAsyncFunctionDeclaration(NULL, false, ok);
       }
     /* falls through */
     default:
       break;
   }
   return ParseStatement(NULL, kAllowLabelledFunctionStatement, ok);
 }
 
 
 Statement* Parser::ParseModuleItem(bool* ok) {
@@ skipping 253 matching lines @@
   //    'export' 'default' AssignmentExpression[In] ';'
 
   Expect(Token::DEFAULT, CHECK_OK);
   Scanner::Location default_loc = scanner()->location();
 
   const AstRawString* default_string = ast_value_factory()->default_string();
   ZoneList<const AstRawString*> names(1, zone());
   Statement* result = nullptr;
   Expression* default_export = nullptr;
   switch (peek()) {
     case Token::FUNCTION: {

[adamk, 2016/06/30 16:30:38]

This no longer needs to be in a block.

-      Consume(Token::FUNCTION);
-      int pos = position();
-      bool is_generator = Check(Token::MUL);
-      if (peek() == Token::LPAREN) {
-        // FunctionDeclaration[+Default] ::
-        //   'function' '(' FormalParameters ')' '{' FunctionBody '}'
-        //
-        // GeneratorDeclaration[+Default] ::
-        //   'function' '*' '(' FormalParameters ')' '{' FunctionBody '}'
-        default_export = ParseFunctionLiteral(
-            default_string, Scanner::Location::invalid(),
-            kSkipFunctionNameCheck,
-            is_generator ? FunctionKind::kGeneratorFunction
-                         : FunctionKind::kNormalFunction,
-            pos, FunctionLiteral::kDeclaration, language_mode(), CHECK_OK);
-        result = factory()->NewEmptyStatement(kNoSourcePosition);
-      } else {
-        result = ParseHoistableDeclaration(
-            pos, is_generator ? ParseFunctionFlags::kIsGenerator
-                              : ParseFunctionFlags::kIsNormal,
-            &names, CHECK_OK);
-      }
+      result = ParseHoistableDeclaration(&names, true, CHECK_OK);
       break;
     }
 
-    case Token::CLASS:
+    case Token::CLASS: {

[adamk, 2016/06/30 16:30:38]

You can leave out this block too.

       Consume(Token::CLASS);
-      if (peek() == Token::EXTENDS || peek() == Token::LBRACE) {
-        // ClassDeclaration[+Default] ::
-        //   'class' ('extends' LeftHandExpression)? '{' ClassBody '}'
-        default_export = ParseClassLiteral(nullptr, default_string,
-                                           Scanner::Location::invalid(), false,
-                                           position(), CHECK_OK);
-        result = factory()->NewEmptyStatement(kNoSourcePosition);
-      } else {
-        result = ParseClassDeclaration(&names, CHECK_OK);
-      }
+      result = ParseClassDeclaration(&names, true, CHECK_OK);
       break;
+    }
 
     case Token::ASYNC:
       if (allow_harmony_async_await() && PeekAhead() == Token::FUNCTION &&
           !scanner()->HasAnyLineTerminatorAfterNext()) {
         Consume(Token::ASYNC);
-        Consume(Token::FUNCTION);
-        int pos = position();
-        if (peek() == Token::LPAREN) {
-          // AsyncFunctionDeclaration[+Default] ::
-          //   async [no LineTerminator here] function ( FormalParameters ) {
-          //      AsyncFunctionBody
-          //   }
-          default_export = ParseFunctionLiteral(
-              default_string, Scanner::Location::invalid(),
-              kSkipFunctionNameCheck, FunctionKind::kAsyncFunction, pos,
-              FunctionLiteral::kDeclaration, language_mode(), CHECK_OK);
-          result = factory()->NewEmptyStatement(kNoSourcePosition);
-        } else {
-          result = ParseHoistableDeclaration(pos, ParseFunctionFlags::kIsAsync,
-                                             &names, CHECK_OK);
-        }
+        result = ParseAsyncFunctionDeclaration(&names, true, CHECK_OK);
         break;
       }
     /* falls through */
 
     default: {
       int pos = peek_position();
       ExpressionClassifier classifier(this);
       Expression* expr = ParseAssignmentExpression(true, &classifier, CHECK_OK);
       RewriteNonPattern(&classifier, CHECK_OK);
 
@@ skipping 94 matching lines @@
         scope_->module()->AddModuleRequest(indirect_export_module_specifier,
                                            zone());
         for (int i = 0; i < length; ++i) {
           // TODO(ES6): scope_->module()->AddIndirectExport(...);(
         }
       }
       return factory()->NewEmptyStatement(pos);
     }
 
     case Token::FUNCTION:
-      result = ParseHoistableDeclaration(&names, CHECK_OK);
+      result = ParseHoistableDeclaration(&names, false, CHECK_OK);
       break;
 
     case Token::CLASS:
       Consume(Token::CLASS);
-      result = ParseClassDeclaration(&names, CHECK_OK);
+      result = ParseClassDeclaration(&names, false, CHECK_OK);
       break;
 
     case Token::VAR:
     case Token::LET:
     case Token::CONST:
       result = ParseVariableStatement(kStatementListItem, &names, CHECK_OK);
       break;
 
     case Token::ASYNC:
       if (allow_harmony_async_await()) {
+        // TODO(neis): Why don't we have the same check here as in
+        // ParseStatementListItem?
         Consume(Token::ASYNC);
-        result = ParseAsyncFunctionDeclaration(&names, CHECK_OK);
+        result = ParseAsyncFunctionDeclaration(&names, false, CHECK_OK);
         break;
       }
     /* falls through */
 
     default:
       *ok = false;
       ReportUnexpectedToken(scanner()->current_token());
       return NULL;
   }
 
@@ skipping 351 matching lines @@
   Declaration* declaration =
       factory()->NewVariableDeclaration(proxy, VAR, scope_, pos);
   Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   NativeFunctionLiteral* lit =
       factory()->NewNativeFunctionLiteral(name, extension_, kNoSourcePosition);
   return factory()->NewExpressionStatement(
       factory()->NewAssignment(Token::INIT, proxy, lit, kNoSourcePosition),
       pos);
 }
 
-
 Statement* Parser::ParseHoistableDeclaration(
-    ZoneList<const AstRawString*>* names, bool* ok) {
+    ZoneList<const AstRawString*>* names, bool default_export, bool* ok) {
   Expect(Token::FUNCTION, CHECK_OK);
   int pos = position();
   ParseFunctionFlags flags = ParseFunctionFlags::kIsNormal;
   if (Check(Token::MUL)) {
     flags |= ParseFunctionFlags::kIsGenerator;
   }
-  return ParseHoistableDeclaration(pos, flags, names, ok);
+  return ParseHoistableDeclaration(pos, flags, names, default_export, ok);
 }
 
 Statement* Parser::ParseAsyncFunctionDeclaration(
-    ZoneList<const AstRawString*>* names, bool* ok) {
+    ZoneList<const AstRawString*>* names, bool default_export, bool* ok) {
   DCHECK_EQ(scanner()->current_token(), Token::ASYNC);
   int pos = position();
   if (scanner()->HasAnyLineTerminatorBeforeNext()) {
     *ok = false;
     ReportUnexpectedToken(scanner()->current_token());
     return nullptr;
   }
   Expect(Token::FUNCTION, CHECK_OK);
   ParseFunctionFlags flags = ParseFunctionFlags::kIsAsync;
-  return ParseHoistableDeclaration(pos, flags, names, ok);
+  return ParseHoistableDeclaration(pos, flags, names, default_export, ok);
 }
 
 Statement* Parser::ParseHoistableDeclaration(
     int pos, ParseFunctionFlags flags, ZoneList<const AstRawString*>* names,
-    bool* ok) {
+    bool default_export, bool* ok) {
   // FunctionDeclaration ::
   //   'function' Identifier '(' FormalParameters ')' '{' FunctionBody '}'
+  //   'function' '(' FormalParameters ')' '{' FunctionBody '}'
   // GeneratorDeclaration ::
   //   'function' '*' Identifier '(' FormalParameters ')' '{' FunctionBody '}'
+  //   'function' '*' '(' FormalParameters ')' '{' FunctionBody '}'
+  //
+  // The anonymous forms are allowed iff [default_export] is true.
   //
   // 'function' and '*' (if present) have been consumed by the caller.
+
   const bool is_generator = flags & ParseFunctionFlags::kIsGenerator;
   const bool is_async = flags & ParseFunctionFlags::kIsAsync;
   DCHECK(!is_generator || !is_async);
 
-  bool is_strict_reserved = false;
-  const AstRawString* name = ParseIdentifierOrStrictReservedWord(
-      &is_strict_reserved, CHECK_OK);
+  const AstRawString* name;
+  FunctionNameValidity name_validity;
+  const AstRawString* variable_name;
+  if (default_export && peek() == Token::LPAREN) {
+    name = ast_value_factory()->default_string();
+    name_validity = kSkipFunctionNameCheck;
+    variable_name = ast_value_factory()->star_default_star_string();
+  } else {
+    bool is_strict_reserved;
+    name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
+    name_validity = is_strict_reserved ? kFunctionNameIsStrictReserved
+                                       : kFunctionNameValidityUnknown;
+    variable_name = name;
+  }
 
   if (V8_UNLIKELY(is_async_function() && this->IsAwait(name))) {
     ReportMessageAt(scanner()->location(),
                     MessageTemplate::kAwaitBindingIdentifier);
     *ok = false;
     return nullptr;
   }
 
   FuncNameInferrer::State fni_state(fni_);
   if (fni_ != NULL) fni_->PushEnclosingName(name);
   FunctionLiteral* fun = ParseFunctionLiteral(
-      name, scanner()->location(),
-      is_strict_reserved ? kFunctionNameIsStrictReserved
-                         : kFunctionNameValidityUnknown,
+      name, scanner()->location(), name_validity,
       is_generator ? FunctionKind::kGeneratorFunction
                    : is_async ? FunctionKind::kAsyncFunction
                               : FunctionKind::kNormalFunction,
       pos, FunctionLiteral::kDeclaration, language_mode(), CHECK_OK);
 
+  // TODO(neis): Update/clarify comment.
   // Even if we're not at the top-level of the global or a function
   // scope, we treat it as such and introduce the function with its
   // initial value upon entering the corresponding scope.
   // In ES6, a function behaves as a lexical binding, except in
   // a script scope, or the initial scope of eval or another function.
   VariableMode mode =
       (!scope_->is_declaration_scope() || scope_->is_module_scope()) ? LET
                                                                      : VAR;
-  VariableProxy* proxy = NewUnresolved(name, mode);
+  VariableProxy* proxy = NewUnresolved(variable_name, mode);
   Declaration* declaration =
       factory()->NewFunctionDeclaration(proxy, mode, fun, scope_, pos);
   Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
-  if (names) names->Add(name, zone());
+  if (names) names->Add(variable_name, zone());
   EmptyStatement* empty = factory()->NewEmptyStatement(kNoSourcePosition);
   // Async functions don't undergo sloppy mode block scoped hoisting, and don't
   // allow duplicates in a block. Both are represented by the
   // sloppy_block_function_map. Don't add them to the map for async functions.
   // Generators are also supposed to be prohibited; currently doing this behind
   // a flag and UseCounting violations to assess web compatibility.
   if (is_sloppy(language_mode()) && !scope_->is_declaration_scope() &&
       !is_async && !(allow_harmony_restrictive_generators() && is_generator)) {
     SloppyBlockFunctionStatement* delegate =
         factory()->NewSloppyBlockFunctionStatement(empty, scope_);
-    scope_->DeclarationScope()->sloppy_block_function_map()->Declare(name,
-                                                                     delegate);
+    scope_->DeclarationScope()->sloppy_block_function_map()->Declare(
+        variable_name, delegate);
     return delegate;
   }
   return empty;
 }
 
-
 Statement* Parser::ParseClassDeclaration(ZoneList<const AstRawString*>* names,
-                                         bool* ok) {
+                                         bool default_export, bool* ok) {
   // ClassDeclaration ::
   //   'class' Identifier ('extends' LeftHandExpression)? '{' ClassBody '}'
+  //   'class' ('extends' LeftHandExpression)? '{' ClassBody '}'
+  //
+  // The anonymous form is allowed iff [default_export] is true.
   //
   // 'class' is expected to be consumed by the caller.
   //
   // A ClassDeclaration
   //
   //   class C { ... }
   //
   // has the same semantics as:
   //
   //   let C = class C { ... };
   //
   // so rewrite it as such.
 
   int pos = position();
-  bool is_strict_reserved = false;
-  const AstRawString* name =
-      ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
+
+  const AstRawString* name;
+  bool is_strict_reserved;
+  const AstRawString* variable_name;
+  if (default_export && (peek() == Token::EXTENDS || peek() == Token::LBRACE)) {
+    name = ast_value_factory()->default_string();
+    is_strict_reserved = false;
+    variable_name = ast_value_factory()->star_default_star_string();
+  } else {
+    name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
+    variable_name = name;
+  }
+
   ClassLiteral* value = ParseClassLiteral(nullptr, name, scanner()->location(),
                                           is_strict_reserved, pos, CHECK_OK);
 
-  VariableProxy* proxy = NewUnresolved(name, LET);
+  VariableProxy* proxy = NewUnresolved(variable_name, LET);
   Declaration* declaration =
       factory()->NewVariableDeclaration(proxy, LET, scope_, pos);
   Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   proxy->var()->set_initializer_position(position());
   Assignment* assignment =
       factory()->NewAssignment(Token::INIT, proxy, value, pos);
   Statement* assignment_statement =
       factory()->NewExpressionStatement(assignment, kNoSourcePosition);
-  if (names) names->Add(name, zone());
+  if (names) names->Add(variable_name, zone());
   return assignment_statement;
 }
 
 
 Block* Parser::ParseBlock(ZoneList<const AstRawString*>* labels,
                           bool finalize_block_scope, bool* ok) {
   // The harmony mode uses block elements instead of statements.
   //
   // Block ::
   //   '{' StatementList '}'
@@ skipping 225 matching lines @@
   if (labels != NULL) {
     for (int i = labels->length(); i-- > 0; ) {
       if (labels->at(i) == label) {
         return true;
       }
     }
   }
   return false;
 }
 
+// TODO(neis): Better name.
 Statement* Parser::ParseFunctionDeclaration(bool* ok) {
   Consume(Token::FUNCTION);
   int pos = position();
   ParseFunctionFlags flags = ParseFunctionFlags::kIsNormal;
   if (Check(Token::MUL)) {
     flags |= ParseFunctionFlags::kIsGenerator;
     if (allow_harmony_restrictive_declarations()) {
       ParserTraits::ReportMessageAt(scanner()->location(),
                                     MessageTemplate::kGeneratorInLegacyContext);
       *ok = false;
       return nullptr;
     }
   }
 
-  return ParseHoistableDeclaration(pos, flags, nullptr, CHECK_OK);
+  return ParseHoistableDeclaration(pos, flags, nullptr, false, CHECK_OK);
 }
 
 Statement* Parser::ParseExpressionOrLabelledStatement(
     ZoneList<const AstRawString*>* labels,
     AllowLabelledFunctionStatement allow_function, bool* ok) {
   // ExpressionStatement | LabelledStatement ::
   //   Expression ';'
   //   Identifier ':' Statement
   //
   // ExpressionStatement[Yield] :
@@ skipping 4480 matching lines @@
                         try_block, target);
     final_loop = target;
   }
 
   return final_loop;
 }
 
 
 }  // namespace internal
 }  // namespace v8