[parser] improve inferred function names for async arrow functions

src/parsing/parser-base.h

 // 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.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/base/hashmap.h"
@@ skipping 2307 matching lines @@
                                               &is_async, CHECK_OK);
   } else {
     expression = this->ParseConditionalExpression(
         accept_IN, &arrow_formals_classifier, CHECK_OK);
   }
 
   if (is_async && peek_any_identifier() && PeekAhead() == Token::ARROW) {
     // async Identifier => AsyncConciseBody
     IdentifierT name =
         ParseAndClassifyIdentifier(&arrow_formals_classifier, CHECK_OK);
-    expression = this->ExpressionFromIdentifier(name, position(),
-                                                scanner()->location().end_pos);
+    expression = this->ExpressionFromIdentifier(
+        name, position(), scanner()->location().end_pos, InferName::No);
+    if (fni_) {
+      // Remove `async` keyword from inferred name stack.
+      DCHECK_EQ(fni_->LastName(), ast_value_factory()->async_string());
+      fni_->RemoveLastName();
+    }
   }
 
   if (peek() == Token::ARROW) {
     Scanner::Location arrow_loc = scanner()->peek_location();
     ValidateArrowFormalParameters(&arrow_formals_classifier, expression,
                                   parenthesized_formals, is_async, CHECK_OK);
     // This reads strangely, but is correct: it checks whether any
     // sub-expression of the parameter list failed to be a valid formal
     // parameter initializer. Since YieldExpressions are banned anywhere
     // in an arrow parameter list, this is correct.
@@ skipping 536 matching lines @@
           // Also the trailing parenthesis are a hint that the function will
           // be called immediately. If we happen to have parsed a preceding
           // function literal eagerly, we can also compile it eagerly.
           if (result->IsFunctionLiteral() && mode() == PARSE_EAGERLY) {
             result->AsFunctionLiteral()->set_should_eager_compile();
           }
         }
         Scanner::Location spread_pos;
         typename Traits::Type::ExpressionList args;
         if (V8_UNLIKELY(is_async)) {
+          int async_index = fni_ ? fni_->LastNameIndex() : -1;
           ExpressionClassifier async_classifier(this);
           args = ParseArguments(&spread_pos, true, &async_classifier, CHECK_OK);
           if (peek() == Token::ARROW) {
+            if (fni_) {
+              fni_->RemoveNameAtIndex(async_index);

[Dan Ehrenberg, 2016/08/12 18:16:40]

DCHECK that it is removing async? Maybe the fni API should be 'remove async at'
and do the DCHECK there, rather than exposing LastName() just for the sake of
the DCHECK in the caller.

+            }
             ValidateBindingPattern(&async_classifier, CHECK_OK);
             if (!async_classifier.is_valid_async_arrow_formal_parameters()) {
               ReportClassifierError(
                   async_classifier.async_arrow_formal_parameters_error());
               *ok = false;
               return this->EmptyExpression();
             }
             if (args->length()) {
               // async ( Arguments ) => ...
               return Traits::ExpressionListToExpression(args);
@@ skipping 823 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H