ParserBase: Simplify FuncNameInferrer handling.

src/parsing/parser.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_H_
 #define V8_PARSING_PARSER_H_
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/parsing/parser-base.h"
@@ skipping 691 matching lines @@
     return string->AsArrayIndex(index);
   }
 
   V8_INLINE static Expression* GetPropertyValue(
       ObjectLiteral::Property* property) {
     return property->value();
   }
 
   // Functions for encapsulating the differences between parsing and preparsing;
   // operations interleaved with the recursive descent.
-  V8_INLINE static void PushLiteralName(FuncNameInferrer* fni,
-                                        const AstRawString* id) {
-    fni->PushLiteralName(id);
+  V8_INLINE void PushLiteralName(const AstRawString* id) {
+    DCHECK_NOT_NULL(fni_);
+    fni_->PushLiteralName(id);
   }
 
-  V8_INLINE static void PushVariableName(FuncNameInferrer* fni,
-                                         const AstRawString* id) {
-    fni->PushVariableName(id);
+  V8_INLINE void PushVariableName(const AstRawString* id) {
+    DCHECK_NOT_NULL(fni_);
+    fni_->PushVariableName(id);
   }
 
-  V8_INLINE void PushPropertyName(FuncNameInferrer* fni,
-                                  Expression* expression) {
+  V8_INLINE void PushPropertyName(Expression* expression) {
+    DCHECK_NOT_NULL(fni_);
     if (expression->IsPropertyName()) {
-      fni->PushLiteralName(expression->AsLiteral()->AsRawPropertyName());
+      fni_->PushLiteralName(expression->AsLiteral()->AsRawPropertyName());
     } else {
-      fni->PushLiteralName(ast_value_factory()->anonymous_function_string());
+      fni_->PushLiteralName(ast_value_factory()->anonymous_function_string());
     }
   }
 
-  V8_INLINE static void InferFunctionName(FuncNameInferrer* fni,
-                                          FunctionLiteral* func_to_infer) {
-    fni->AddFunction(func_to_infer);
+  V8_INLINE void InferFunctionName(FunctionLiteral* func_to_infer) {
+    fni_->AddFunction(func_to_infer);
   }
 
   // If we assign a function literal to a property we pretenure the
   // literal so it can be added as a constant function property.
   V8_INLINE static void CheckAssigningFunctionLiteralToProperty(
       Expression* left, Expression* right) {
     DCHECK(left != NULL);
     if (left->IsProperty() && right->IsFunctionLiteral()) {
       right->AsFunctionLiteral()->set_pretenure();
     }
@@ skipping 142 matching lines @@
   Expression* NewSuperPropertyReference(int pos);
   Expression* NewSuperCallReference(int pos);
   Expression* NewTargetExpression(int pos);
   Expression* FunctionSentExpression(int pos);
 
   Literal* ExpressionFromLiteral(Token::Value token, int pos);
 
   V8_INLINE Expression* ExpressionFromIdentifier(
       const AstRawString* name, int start_position, int end_position,
       InferName infer = InferName::kYes) {
-    if (infer == InferName::kYes && fni_ != NULL) {
+    if (infer == InferName::kYes) {
       fni_->PushVariableName(name);
     }
     return NewUnresolved(name, start_position, end_position);
   }
 
   V8_INLINE Expression* ExpressionFromString(int pos) {
     const AstRawString* symbol = GetSymbol();
-    if (fni_ != NULL) fni_->PushLiteralName(symbol);
+    fni_->PushLiteralName(symbol);
     return factory()->NewStringLiteral(symbol, pos);
   }
 
   V8_INLINE ZoneList<Expression*>* NewExpressionList(int size) const {
     return new (zone()) ZoneList<Expression*>(size, zone());
   }
   V8_INLINE ZoneList<ObjectLiteral::Property*>* NewPropertyList(
       int size) const {
     return new (zone()) ZoneList<ObjectLiteral::Property*>(size, zone());
   }
@@ skipping 140 matching lines @@
   static const int kLiteralTypeSlot = 0;
   static const int kElementsSlot = 1;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompileTimeValue);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_