Reduce number of scope() accesses

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 <memory>
 
 #include "src/api.h"
 #include "src/ast/ast.h"
@@ skipping 672 matching lines @@
   char array[100];
   const char* string = DoubleToCString(double_value, ArrayVector(array));
   return parser_->ast_value_factory()->GetOneByteString(string);
 }
 
 
 const AstRawString* ParserTraits::GetNextSymbol(Scanner* scanner) {
   return parser_->scanner()->NextSymbol(parser_->ast_value_factory());
 }
 
-
-Expression* ParserTraits::ThisExpression(Scope* scope, AstNodeFactory* factory,
-                                         int pos) {
-  return scope->NewUnresolved(factory,
-                              parser_->ast_value_factory()->this_string(),
-                              Variable::THIS, pos, pos + 4);
+Expression* ParserTraits::ThisExpression(AstNodeFactory* factory, int pos) {
+  return parser_->scope()->NewUnresolved(
+      factory, parser_->ast_value_factory()->this_string(), Variable::THIS, pos,
+      pos + 4);
 }
 
-Expression* ParserTraits::NewSuperPropertyReference(Scope* scope,
-                                                    AstNodeFactory* factory,
+Expression* ParserTraits::NewSuperPropertyReference(AstNodeFactory* factory,
                                                     int pos) {
   // this_function[home_object_symbol]
-  VariableProxy* this_function_proxy = scope->NewUnresolved(
+  VariableProxy* this_function_proxy = parser_->scope()->NewUnresolved(
       factory, parser_->ast_value_factory()->this_function_string(),
       Variable::NORMAL, pos);
   Expression* home_object_symbol_literal =
       factory->NewSymbolLiteral("home_object_symbol", kNoSourcePosition);
   Expression* home_object = factory->NewProperty(
       this_function_proxy, home_object_symbol_literal, pos);
   return factory->NewSuperPropertyReference(
-      ThisExpression(scope, factory, pos)->AsVariableProxy(), home_object, pos);
+      ThisExpression(factory, pos)->AsVariableProxy(), home_object, pos);
 }
 
-Expression* ParserTraits::NewSuperCallReference(Scope* scope,
-                                                AstNodeFactory* factory,
+Expression* ParserTraits::NewSuperCallReference(AstNodeFactory* factory,
                                                 int pos) {
-  VariableProxy* new_target_proxy = scope->NewUnresolved(
+  VariableProxy* new_target_proxy = parser_->scope()->NewUnresolved(
       factory, parser_->ast_value_factory()->new_target_string(),
       Variable::NORMAL, pos);
-  VariableProxy* this_function_proxy = scope->NewUnresolved(
+  VariableProxy* this_function_proxy = parser_->scope()->NewUnresolved(
       factory, parser_->ast_value_factory()->this_function_string(),
       Variable::NORMAL, pos);
   return factory->NewSuperCallReference(
-      ThisExpression(scope, factory, pos)->AsVariableProxy(), new_target_proxy,
+      ThisExpression(factory, pos)->AsVariableProxy(), new_target_proxy,
       this_function_proxy, pos);
 }
 
-
-Expression* ParserTraits::NewTargetExpression(Scope* scope,
-                                              AstNodeFactory* factory,
+Expression* ParserTraits::NewTargetExpression(AstNodeFactory* factory,
                                               int pos) {
   static const int kNewTargetStringLength = 10;
-  auto proxy = scope->NewUnresolved(
+  auto proxy = parser_->scope()->NewUnresolved(
       factory, parser_->ast_value_factory()->new_target_string(),
       Variable::NORMAL, pos, pos + kNewTargetStringLength);
   proxy->set_is_new_target();
   return proxy;
 }
 
-
-Expression* ParserTraits::FunctionSentExpression(Scope* scope,
-                                                 AstNodeFactory* factory,
+Expression* ParserTraits::FunctionSentExpression(AstNodeFactory* factory,
                                                  int pos) {
   // We desugar function.sent into %_GeneratorGetInputOrDebugPos(generator).
   Zone* zone = parser_->zone();
   ZoneList<Expression*>* args = new (zone) ZoneList<Expression*>(1, zone);
   VariableProxy* generator = factory->NewVariableProxy(
       parser_->function_state_->generator_object_variable());
   args->Add(generator, zone);
   return factory->NewCallRuntime(Runtime::kInlineGeneratorGetInputOrDebugPos,
                                  args, pos);
 }
@@ skipping 21 matching lines @@
     default:
       DCHECK(false);
   }
   return NULL;
 }
 
 
 Expression* ParserTraits::ExpressionFromIdentifier(const AstRawString* name,
                                                    int start_position,
                                                    int end_position,
-                                                   Scope* scope,
                                                    AstNodeFactory* factory) {
   if (parser_->fni_ != NULL) parser_->fni_->PushVariableName(name);
-  return scope->NewUnresolved(factory, name, Variable::NORMAL, start_position,
-                              end_position);
+  return parser_->scope()->NewUnresolved(factory, name, Variable::NORMAL,
+                                         start_position, end_position);
 }
 
 
 Expression* ParserTraits::ExpressionFromString(int pos, Scanner* scanner,
                                                AstNodeFactory* factory) {
   const AstRawString* symbol = GetSymbol(scanner);
   if (parser_->fni_ != NULL) parser_->fni_->PushLiteralName(symbol);
   return factory->NewStringLiteral(symbol, pos);
 }
 
@@ skipping 502 matching lines @@
       if ((e_stat = stat->AsExpressionStatement()) != NULL &&
           (literal = e_stat->expression()->AsLiteral()) != NULL &&
           literal->raw_value()->IsString()) {
         // Check "use strict" directive (ES5 14.1), "use asm" directive.
         bool use_strict_found =
             literal->raw_value()->AsString() ==
                 ast_value_factory()->use_strict_string() &&
             token_loc.end_pos - token_loc.beg_pos ==
                 ast_value_factory()->use_strict_string()->length() + 2;
         if (use_strict_found) {
-          if (is_sloppy(this->scope()->language_mode())) {
+          if (is_sloppy(language_mode())) {
             RaiseLanguageMode(STRICT);
           }
 
           if (!this->scope()->HasSimpleParameters()) {
             // TC39 deemed "use strict" directives to be an error when occurring
             // in the body of a function with non-simple parameter list, on
             // 29/7/2015. https://goo.gl/ueA7Ln
             const AstRawString* string = literal->raw_value()->AsString();
             ParserTraits::ReportMessageAt(
                 token_loc, MessageTemplate::kIllegalLanguageModeDirective,
@@ skipping 1439 matching lines @@
   Scanner::Location loc = scanner()->location();
 
   Token::Value tok = peek();
   Statement* result;
   Expression* return_value;
   if (scanner()->HasAnyLineTerminatorBeforeNext() ||
       tok == Token::SEMICOLON ||
       tok == Token::RBRACE ||
       tok == Token::EOS) {
     if (IsSubclassConstructor(function_state_->kind())) {
-      return_value = ThisExpression(scope(), factory(), loc.beg_pos);
+      return_value = ThisExpression(factory(), loc.beg_pos);
     } else {
       return_value = GetLiteralUndefined(position());
     }
   } else {
     int pos = peek_position();
 
     if (IsSubclassConstructor(function_state_->kind())) {
       // Because of the return code rewriting that happens in case of a subclass
       // constructor we don't want to accept tail calls, therefore we don't set
       // ReturnExprScope to kInsideValidReturnStatement here.
@@ skipping 27 matching lines @@
       Expression* is_object_conditional = factory()->NewConditional(
           is_spec_object_call, factory()->NewVariableProxy(temp),
           factory()->NewSmiLiteral(1, pos), pos);
 
       // temp === undefined
       Expression* is_undefined = factory()->NewCompareOperation(
           Token::EQ_STRICT, assign,
           factory()->NewUndefinedLiteral(kNoSourcePosition), pos);
 
       // is_undefined ? this : is_object_conditional
-      return_value = factory()->NewConditional(
-          is_undefined, ThisExpression(scope(), factory(), pos),
-          is_object_conditional, pos);
+      return_value = factory()->NewConditional(is_undefined,
+                                               ThisExpression(factory(), pos),
+                                               is_object_conditional, pos);
     } else {
       ReturnExprScope maybe_allow_tail_calls(
           function_state_, ReturnExprContext::kInsideValidReturnStatement);
       return_value = ParseExpression(true, CHECK_OK);
 
       if (allow_tailcalls() && !is_sloppy(language_mode())) {
         // ES6 14.6.1 Static Semantics: IsInTailPosition
         function_state_->AddImplicitTailCallExpression(return_value);
       }
     }
@@ skipping 1812 matching lines @@
     scope()->RecordSuperPropertyUsage();
   }
   if (logger.calls_eval()) {
     scope()->RecordEvalCall();
   }
   if (produce_cached_parse_data()) {
     DCHECK(log_);
     // Position right after terminal '}'.
     int body_end = scanner()->location().end_pos;
     log_->LogFunction(function_block_pos, body_end, *materialized_literal_count,
-                      *expected_property_count, scope()->language_mode(),
+                      *expected_property_count, language_mode(),
                       scope()->uses_super_property(), scope()->calls_eval());
   }
 }
 
 
 Statement* Parser::BuildAssertIsCoercible(Variable* var) {
   // if (var === null || var === undefined)
   //     throw /* type error kNonCoercible) */;
 
   Expression* condition = factory()->NewBinaryOperation(
@@ skipping 154 matching lines @@
   block->statements()->Add(try_catch_statement, zone());
   return block;
 }
 
 Expression* Parser::BuildCreateJSGeneratorObject(int pos, FunctionKind kind) {
   DCHECK_NOT_NULL(function_state_->generator_object_variable());
   ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
   args->Add(factory()->NewThisFunction(pos), zone());
   args->Add(IsArrowFunction(kind)
                 ? GetLiteralUndefined(pos)
-                : ThisExpression(scope(), factory(), kNoSourcePosition),
+                : ThisExpression(factory(), kNoSourcePosition),
             zone());
   return factory()->NewCallRuntime(Runtime::kCreateJSGeneratorObject, args,
                                    pos);
 }
 
 Expression* Parser::BuildPromiseResolve(Expression* value, int pos) {
   ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(1, zone());
   args->Add(value, zone());
   return factory()->NewCallRuntime(Context::PROMISE_CREATE_RESOLVED_INDEX, args,
                                    pos);
@@ skipping 100 matching lines @@
     } else if (IsAsyncFunction(kind)) {
       const bool accept_IN = true;
       DesugarAsyncFunctionBody(function_name, inner_scope, body, nullptr, kind,
                                FunctionBody::Normal, accept_IN, pos, CHECK_OK);
     } else {
       ParseStatementList(body, Token::RBRACE, CHECK_OK);
     }
 
     if (IsSubclassConstructor(kind)) {
       body->Add(factory()->NewReturnStatement(
-                    this->ThisExpression(scope(), factory(), kNoSourcePosition),
+                    this->ThisExpression(factory(), kNoSourcePosition),
                     kNoSourcePosition),
                 zone());
     }
   }
 
   Expect(Token::RBRACE, CHECK_OK);
   scope()->set_end_position(scanner()->location().end_pos);
 
   if (!parameters.is_simple) {
     DCHECK_NOT_NULL(inner_scope);
@@ skipping 797 matching lines @@
     Expression* super_constructor = factory()->NewCallRuntime(
         Runtime::kInlineGetSuperConstructor, tmp, pos);
     args->InsertAt(0, super_constructor, zone());
     args->Add(function->AsSuperCallReference()->new_target_var(), zone());
     return factory()->NewCallRuntime(Context::REFLECT_CONSTRUCT_INDEX, args,
                                      pos);
   } else {
     if (function->IsProperty()) {
       // Method calls
       if (function->AsProperty()->IsSuperAccess()) {
-        Expression* home =
-            ThisExpression(scope(), factory(), kNoSourcePosition);
+        Expression* home = ThisExpression(factory(), kNoSourcePosition);
         args->InsertAt(0, function, zone());
         args->InsertAt(1, home, zone());
       } else {
         Variable* temp =
             scope()->NewTemporary(ast_value_factory()->empty_string());
         VariableProxy* obj = factory()->NewVariableProxy(temp);
         Assignment* assign_obj = factory()->NewAssignment(
             Token::ASSIGN, obj, function->AsProperty()->obj(),
             kNoSourcePosition);
         function = factory()->NewProperty(
@@ skipping 224 matching lines @@
 }
 
 Expression* Parser::RewriteAssignExponentiation(Expression* left,
                                                 Expression* right, int pos) {
   ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
   if (left->IsVariableProxy()) {
     VariableProxy* lhs = left->AsVariableProxy();
 
     Expression* result;
     DCHECK_NOT_NULL(lhs->raw_name());
-    result =
-        this->ExpressionFromIdentifier(lhs->raw_name(), lhs->position(),
-                                       lhs->end_position(), scope(), factory());
+    result = this->ExpressionFromIdentifier(lhs->raw_name(), lhs->position(),
+                                            lhs->end_position(), factory());
     args->Add(left, zone());
     args->Add(right, zone());
     Expression* call =
         factory()->NewCallRuntime(Context::MATH_POW_INDEX, args, pos);
     return factory()->NewAssignment(Token::ASSIGN, result, call, pos);
   } else if (left->IsProperty()) {
     Property* prop = left->AsProperty();
     auto temp_obj = scope()->NewTemporary(ast_value_factory()->empty_string());
     auto temp_key = scope()->NewTemporary(ast_value_factory()->empty_string());
     Expression* assign_obj = factory()->NewAssignment(
@@ skipping 510 matching lines @@
         factory->NewSmiLiteral(JSGeneratorObject::kThrow, nopos);
     Expression* assignment =
         factory->NewAssignment(Token::ASSIGN, mode_proxy, kthrow, nopos);
     set_mode_throw = factory->NewExpressionStatement(assignment, nopos);
   }
 
 
   // input = function.sent;
   Statement* get_input;
   {
-    Expression* function_sent = FunctionSentExpression(scope, factory, nopos);
+    Expression* function_sent = FunctionSentExpression(factory, nopos);
     Expression* input_proxy = factory->NewVariableProxy(var_input);
     Expression* assignment = factory->NewAssignment(
         Token::ASSIGN, input_proxy, function_sent, nopos);
     get_input = factory->NewExpressionStatement(assignment, nopos);
   }
 
 
   // if (mode === kReturn) {
   //   return {value: output.value, done: true};
   // }
@@ skipping 605 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8