ParserBase: Simplify FuncNameInferrer handling.

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 1936 matching lines @@
     token = peek();
     pos = peek_position();
   }
 
   if (allow_harmony_async_await() && !*is_generator && token == Token::ASYNC &&
       !scanner()->HasAnyLineTerminatorAfterNext()) {
     Consume(Token::ASYNC);
     token = peek();
     if (SetPropertyKindFromToken(token, kind)) {
       *name = impl()->GetSymbol();  // TODO(bakkot) specialize on 'async'
-      if (fni_ != nullptr) {
-        impl()->PushLiteralName(fni_, *name);
-      }
+      impl()->PushLiteralName(*name);
       return factory()->NewStringLiteral(*name, pos);
     }
     *kind = PropertyKind::kMethodProperty;
     *is_async = true;
     pos = peek_position();
   }
 
   if (token == Token::IDENTIFIER && !*is_generator && !*is_async) {
     // This is checking for 'get' and 'set' in particular. Any other identifier
     // must be the property name, and so SetPropertyKindFromToken will return
     // true (unless there's a syntax error).
     Consume(Token::IDENTIFIER);
     token = peek();
     if (SetPropertyKindFromToken(token, kind)) {
       *name = impl()->GetSymbol();
-      if (fni_ != nullptr) {
-        impl()->PushLiteralName(fni_, *name);
-      }
+      impl()->PushLiteralName(*name);
       return factory()->NewStringLiteral(*name, pos);
     }
     scanner()->IsGetOrSet(is_get, is_set);
     if (!*is_get && !*is_set) {  // TODO(bakkot) have IsGetOrSet return a bool
       Token::Value next = Next();
       ReportUnexpectedToken(next);
       *ok = false;
       return impl()->EmptyExpression();
     }
     *kind = PropertyKind::kAccessorProperty;
@@ skipping 53 matching lines @@
       *ok = false;
       return impl()->EmptyExpression();
     }
   }
   DCHECK(*kind != PropertyKind::kNotSet);
 
   if (*is_computed_name) {
     return expression;
   }
 
-  if (fni_ != nullptr) {
-    impl()->PushLiteralName(fni_, *name);
-  }
+  impl()->PushLiteralName(*name);
 
   uint32_t index;
   return impl()->IsArrayIndex(*name, &index)
              ? factory()->NewNumberLiteral(index, pos)
              : factory()->NewStringLiteral(*name, pos);
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::ObjectLiteralPropertyT
 ParserBase<Impl>::ParsePropertyDefinition(ObjectLiteralCheckerBase* checker,
@@ skipping 973 matching lines @@
       case Token::PERIOD: {
         CheckNoTailCallExpressions(CHECK_OK);
         impl()->RewriteNonPattern(CHECK_OK);
         BindingPatternUnexpectedToken();
         ArrowFormalParametersUnexpectedToken();
         Consume(Token::PERIOD);
         int pos = position();
         IdentifierT name = ParseIdentifierName(CHECK_OK);
         result = factory()->NewProperty(
             result, factory()->NewStringLiteral(name, pos), pos);
-        if (fni_ != NULL) impl()->PushLiteralName(fni_, name);
+        impl()->PushLiteralName(name);
         break;
       }
 
       case Token::TEMPLATE_SPAN:
       case Token::TEMPLATE_TAIL: {
         CheckNoTailCallExpressions(CHECK_OK);
         impl()->RewriteNonPattern(CHECK_OK);
         BindingPatternUnexpectedToken();
         ArrowFormalParametersUnexpectedToken();
         result = ParseTemplateLiteral(result, position(), CHECK_OK);
@@ skipping 205 matching lines @@
         *is_async = false;
         impl()->RewriteNonPattern(CHECK_OK);
         BindingPatternUnexpectedToken();
         ArrowFormalParametersUnexpectedToken();
 
         Consume(Token::LBRACK);
         int pos = position();
         ExpressionT index = ParseExpressionCoverGrammar(true, CHECK_OK);
         impl()->RewriteNonPattern(CHECK_OK);
         expression = factory()->NewProperty(expression, index, pos);
-        if (fni_ != NULL) {
-          impl()->PushPropertyName(fni_, index);
-        }
+        impl()->PushPropertyName(index);
         Expect(Token::RBRACK, CHECK_OK);
         break;
       }
       case Token::PERIOD: {
         *is_async = false;
         impl()->RewriteNonPattern(CHECK_OK);
         BindingPatternUnexpectedToken();
         ArrowFormalParametersUnexpectedToken();
 
         Consume(Token::PERIOD);
         int pos = position();
         IdentifierT name = ParseIdentifierName(CHECK_OK);
         expression = factory()->NewProperty(
             expression, factory()->NewStringLiteral(name, pos), pos);
-        if (fni_ != NULL) {
-          impl()->PushLiteralName(fni_, name);
-        }
+        impl()->PushLiteralName(name);
         break;
       }
       case Token::TEMPLATE_SPAN:
       case Token::TEMPLATE_TAIL: {
         *is_async = false;
         impl()->RewriteNonPattern(CHECK_OK);
         BindingPatternUnexpectedToken();
         ArrowFormalParametersUnexpectedToken();
         int pos;
         if (scanner()->current_token() == Token::IDENTIFIER) {
@@ skipping 172 matching lines @@
 
       ValidateBindingPattern(CHECK_OK_CUSTOM(NullBlock));
       if (IsLexicalVariableMode(parsing_result->descriptor.mode)) {
         ValidateLetPattern(CHECK_OK_CUSTOM(NullBlock));
       }
     }
 
     Scanner::Location variable_loc = scanner()->location();
     bool single_name = impl()->IsIdentifier(pattern);
 
-    if (single_name && fni_ != nullptr) {
-      impl()->PushVariableName(fni_, impl()->AsIdentifier(pattern));
+    if (single_name) {
+      impl()->PushVariableName(impl()->AsIdentifier(pattern));
     }
 
     ExpressionT value = impl()->EmptyExpression();
     int initializer_position = kNoSourcePosition;
     if (Check(Token::ASSIGN)) {
       ExpressionClassifier classifier(this);
       value = ParseAssignmentExpression(var_context != kForStatement,
                                         CHECK_OK_CUSTOM(NullBlock));
       impl()->RewriteNonPattern(CHECK_OK_CUSTOM(NullBlock));
       variable_loc.end_pos = scanner()->location().end_pos;
@@ skipping 259 matching lines @@
       FunctionLiteral::kNoDuplicateParameters,
       FunctionLiteral::kAnonymousExpression, eager_compile_hint, arrow_kind,
       formal_parameters.scope->start_position());
 
   function_literal->set_function_token_position(
       formal_parameters.scope->start_position());
   if (should_be_used_once_hint) {
     function_literal->set_should_be_used_once_hint();
   }
 
-  if (fni_ != NULL) impl()->InferFunctionName(fni_, function_literal);
+  impl()->InferFunctionName(function_literal);
 
   return function_literal;
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseTemplateLiteral(
     ExpressionT tag, int start, bool* ok) {
   // A TemplateLiteral is made up of 0 or more TEMPLATE_SPAN tokens (literal
   // text followed by a substitution expression), finalized by a single
   // TEMPLATE_TAIL.
@@ skipping 194 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H