Redirect Scope::NewTemporary over parser

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 2723 matching lines @@
       // for a non object.
       //
       //   return expr;
       //
       // Is rewritten as:
       //
       //   return (temp = expr) === undefined ? this :
       //       %_IsJSReceiver(temp) ? temp : 1;
 
       // temp = expr
-      Variable* temp =
-          scope()->NewTemporary(ast_value_factory()->empty_string());
+      Variable* temp = NewTemporary(ast_value_factory()->empty_string());
       Assignment* assign = factory()->NewAssignment(
           Token::ASSIGN, factory()->NewVariableProxy(temp), return_value, pos);
 
       // %_IsJSReceiver(temp)
       ZoneList<Expression*>* is_spec_object_args =
           new (zone()) ZoneList<Expression*>(1, zone());
       is_spec_object_args->Add(factory()->NewVariableProxy(temp), zone());
       Expression* is_spec_object_call = factory()->NewCallRuntime(
           Runtime::kInlineIsJSReceiver, is_spec_object_args, pos);
 
@@ skipping 121 matching lines @@
 
   Block* switch_block = factory()->NewBlock(NULL, 2, false, kNoSourcePosition);
   int switch_pos = peek_position();
 
   Expect(Token::SWITCH, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   Expression* tag = ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
 
   Variable* tag_variable =
-      scope()->NewTemporary(ast_value_factory()->dot_switch_tag_string());
+      NewTemporary(ast_value_factory()->dot_switch_tag_string());
   Assignment* tag_assign = factory()->NewAssignment(
       Token::ASSIGN, factory()->NewVariableProxy(tag_variable), tag,
       tag->position());
   Statement* tag_statement =
       factory()->NewExpressionStatement(tag_assign, kNoSourcePosition);
   switch_block->statements()->Add(tag_statement, zone());
 
   // make statement: undefined;
   // This is needed so the tag isn't returned as the value, in case the switch
   // statements don't have a value.
@@ skipping 340 matching lines @@
                                               Expression* subject,
                                               Statement* body,
                                               int each_keyword_pos) {
   ForOfStatement* for_of = stmt->AsForOfStatement();
   if (for_of != NULL) {
     const bool finalize = true;
     return InitializeForOfStatement(for_of, each, subject, body, finalize,
                                     each_keyword_pos);
   } else {
     if (each->IsArrayLiteral() || each->IsObjectLiteral()) {
-      Variable* temp =
-          scope()->NewTemporary(ast_value_factory()->empty_string());
+      Variable* temp = NewTemporary(ast_value_factory()->empty_string());
       VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);
       Expression* assign_each = PatternRewriter::RewriteDestructuringAssignment(
           this, factory()->NewAssignment(Token::ASSIGN, each, temp_proxy,
                                          kNoSourcePosition),
           scope());
       auto block = factory()->NewBlock(nullptr, 2, false, kNoSourcePosition);
       block->statements()->Add(
           factory()->NewExpressionStatement(assign_each, kNoSourcePosition),
           zone());
       block->statements()->Add(body, zone());
@@ skipping 12 matching lines @@
                                             int next_result_pos) {
   // Create the auxiliary expressions needed for iterating over the iterable,
   // and initialize the given ForOfStatement with them.
   // If finalize is true, also instrument the loop with code that performs the
   // proper ES6 iterator finalization.  In that case, the result is not
   // immediately a ForOfStatement.
 
   const int nopos = kNoSourcePosition;
   auto avfactory = ast_value_factory();
 
-  Variable* iterator =
-      scope()->NewTemporary(ast_value_factory()->dot_iterator_string());
-  Variable* result =
-      scope()->NewTemporary(ast_value_factory()->dot_result_string());
-  Variable* completion = scope()->NewTemporary(avfactory->empty_string());
+  Variable* iterator = NewTemporary(ast_value_factory()->dot_iterator_string());
+  Variable* result = NewTemporary(ast_value_factory()->dot_result_string());
+  Variable* completion = NewTemporary(avfactory->empty_string());
 
   // iterator = iterable[Symbol.iterator]()
   Expression* assign_iterator;
   {
     assign_iterator = factory()->NewAssignment(
         Token::ASSIGN, factory()->NewVariableProxy(iterator),
         GetIterator(iterable, factory(), iterable->position()),
         iterable->position());
   }
 
@@ skipping 35 matching lines @@
 
     Block* block = factory()->NewBlock(nullptr, 1, true, nopos);
     block->statements()->Add(
         factory()->NewExpressionStatement(assignment, nopos), zone());
     set_completion_abrupt = block;
   }
 
   // do { let tmp = #result_value; #set_completion_abrupt; tmp }
   // Expression* result_value (gets overwritten)
   if (finalize) {
-    Variable* var_tmp = scope()->NewTemporary(avfactory->empty_string());
+    Variable* var_tmp = NewTemporary(avfactory->empty_string());
     Expression* tmp = factory()->NewVariableProxy(var_tmp);
     Expression* assignment =
         factory()->NewAssignment(Token::ASSIGN, tmp, result_value, nopos);
 
     Block* block = factory()->NewBlock(nullptr, 2, false, nopos);
     block->statements()->Add(
         factory()->NewExpressionStatement(assignment, nopos), zone());
     block->statements()->Add(set_completion_abrupt, zone());
 
     result_value = factory()->NewDoExpression(block, var_tmp, nopos);
@@ skipping 89 matching lines @@
 
   // Add statement: let/const x = i.
   outer_block->statements()->Add(init, zone());
 
   const AstRawString* temp_name = ast_value_factory()->dot_for_string();
 
   // For each lexical variable x:
   //   make statement: temp_x = x.
   for (int i = 0; i < names->length(); i++) {
     VariableProxy* proxy = NewUnresolved(names->at(i), LET);
-    Variable* temp = scope()->NewTemporary(temp_name);
+    Variable* temp = NewTemporary(temp_name);
     VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);
     Assignment* assignment = factory()->NewAssignment(Token::ASSIGN, temp_proxy,
                                                       proxy, kNoSourcePosition);
     Statement* assignment_statement =
         factory()->NewExpressionStatement(assignment, kNoSourcePosition);
     outer_block->statements()->Add(assignment_statement, zone());
     temps.Add(temp, zone());
   }
 
   Variable* first = NULL;
   // Make statement: first = 1.
   if (next) {
-    first = scope()->NewTemporary(temp_name);
+    first = NewTemporary(temp_name);
     VariableProxy* first_proxy = factory()->NewVariableProxy(first);
     Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
     Assignment* assignment = factory()->NewAssignment(
         Token::ASSIGN, first_proxy, const1, kNoSourcePosition);
     Statement* assignment_statement =
         factory()->NewExpressionStatement(assignment, kNoSourcePosition);
     outer_block->statements()->Add(assignment_statement, zone());
   }
 
   // make statement: undefined;
@@ skipping 54 matching lines @@
         Assignment* assignment = factory()->NewAssignment(
             Token::ASSIGN, first_proxy, const0, kNoSourcePosition);
         clear_first =
             factory()->NewExpressionStatement(assignment, kNoSourcePosition);
       }
       Statement* clear_first_or_next = factory()->NewIfStatement(
           compare, clear_first, next, kNoSourcePosition);
       ignore_completion_block->statements()->Add(clear_first_or_next, zone());
     }
 
-    Variable* flag = scope()->NewTemporary(temp_name);
+    Variable* flag = NewTemporary(temp_name);
     // Make statement: flag = 1.
     {
       VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
       Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
       Assignment* assignment = factory()->NewAssignment(
           Token::ASSIGN, flag_proxy, const1, kNoSourcePosition);
       Statement* assignment_statement =
           factory()->NewExpressionStatement(assignment, kNoSourcePosition);
       ignore_completion_block->statements()->Add(assignment_statement, zone());
     }
@@ skipping 188 matching lines @@
         //   {
         //     <let x' be a temporary variable>
         //     for (x' in/of e) {
         //       let/const/var x;
         //       x = x';
         //       b;
         //     }
         //     let x;  // for TDZ
         //   }
 
-        Variable* temp =
-            scope()->NewTemporary(ast_value_factory()->dot_for_string());
+        Variable* temp = NewTemporary(ast_value_factory()->dot_for_string());
         ForEachStatement* loop =
             factory()->NewForEachStatement(mode, labels, stmt_pos);
         Target target(&this->target_stack_, loop);
 
         int each_keyword_position = scanner()->location().beg_pos;
 
         Expression* enumerable;
         if (mode == ForEachStatement::ITERATE) {
           ExpressionClassifier classifier(this);
           enumerable = ParseAssignmentExpression(true, &classifier, CHECK_OK);
@@ skipping 371 matching lines @@
                                       bool accept_IN, int pos, bool* ok) {
   // function async_function() {
   //   try {
   //     .generator_object = %CreateGeneratorObject();
   //     ... function body ...
   //   } catch (e) {
   //     return Promise.reject(e);
   //   }
   // }
   scope->ForceContextAllocation();
-  Variable* temp = this->scope()->NewTemporary(
-      ast_value_factory()->dot_generator_object_string());
+  Variable* temp =
+      NewTemporary(ast_value_factory()->dot_generator_object_string());
   function_state_->set_generator_object_variable(temp);
 
   Expression* init_generator_variable = factory()->NewAssignment(
       Token::INIT, factory()->NewVariableProxy(temp),
       BuildCreateJSGeneratorObject(pos, kind), kNoSourcePosition);
   body->Add(factory()->NewExpressionStatement(init_generator_variable,
                                               kNoSourcePosition),
             zone());
 
   Block* try_block = factory()->NewBlock(NULL, 8, true, kNoSourcePosition);
@@ skipping 17 matching lines @@
   body->Add(BuildRejectPromiseOnException(try_block), zone());
   scope->set_end_position(scanner()->location().end_pos);
 }
 
 DoExpression* Parser::ParseDoExpression(bool* ok) {
   // AssignmentExpression ::
   //     do '{' StatementList '}'
   int pos = peek_position();
 
   Expect(Token::DO, CHECK_OK);
-  Variable* result =
-      scope()->NewTemporary(ast_value_factory()->dot_result_string());
+  Variable* result = NewTemporary(ast_value_factory()->dot_result_string());
   Block* block = ParseBlock(nullptr, CHECK_OK);
   DoExpression* expr = factory()->NewDoExpression(block, result, pos);
   if (!Rewriter::Rewrite(this, GetClosureScope(), expr, ast_value_factory())) {
     *ok = false;
     return nullptr;
   }
   return expr;
 }
 
 void ParserTraits::ParseArrowFunctionFormalParameterList(
@@ skipping 182 matching lines @@
     if (is_generator) {
       // For generators, allocating variables in contexts is currently a win
       // because it minimizes the work needed to suspend and resume an
       // activation.  The machine code produced for generators (by full-codegen)
       // relies on this forced context allocation, but not in an essential way.
       this->scope()->ForceContextAllocation();
 
       // Calling a generator returns a generator object.  That object is stored
       // in a temporary variable, a definition that is used by "yield"
       // expressions. This also marks the FunctionState as a generator.
-      Variable* temp = this->scope()->NewTemporary(
-          ast_value_factory()->dot_generator_object_string());
+      Variable* temp =
+          NewTemporary(ast_value_factory()->dot_generator_object_string());
       function_state.set_generator_object_variable(temp);
     }
 
     Expect(Token::LPAREN, CHECK_OK);
     int start_position = scanner()->location().beg_pos;
     this->scope()->set_start_position(start_position);
     ParserFormalParameters formals(scope);
     ParseFormalParameterList(&formals, &formals_classifier, CHECK_OK);
     arity = formals.Arity();
     Expect(Token::RPAREN, CHECK_OK);
@@ skipping 701 matching lines @@
   // Note that we do not finalize this block scope because it is
   // used as a sentinel value indicating an anonymous class.
   block_state.set_end_position(end_pos);
 
   if (name != nullptr) {
     DCHECK_NOT_NULL(proxy);
     proxy->var()->set_initializer_position(end_pos);
   }
 
   Block* do_block = factory()->NewBlock(nullptr, 1, false, pos);
-  Variable* result_var =
-      scope()->NewTemporary(ast_value_factory()->empty_string());
+  Variable* result_var = NewTemporary(ast_value_factory()->empty_string());
   do_block->set_scope(block_state.FinalizedBlockScope());
   DoExpression* do_expr = factory()->NewDoExpression(do_block, result_var, pos);
 
   ClassLiteral* class_literal = factory()->NewClassLiteral(
       proxy, extends, constructor, properties, pos, end_pos);
 
   do_block->statements()->Add(
       factory()->NewExpressionStatement(class_literal, pos), zone());
   do_expr->set_represented_function(constructor);
   Rewriter::Rewrite(this, GetClosureScope(), do_expr, ast_value_factory());
@@ skipping 584 matching lines @@
     return factory()->NewCallRuntime(Context::REFLECT_CONSTRUCT_INDEX, args,
                                      pos);
   } else {
     if (function->IsProperty()) {
       // Method calls
       if (function->AsProperty()->IsSuperAccess()) {
         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());
+        Variable* temp = 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(
             assign_obj, function->AsProperty()->key(), kNoSourcePosition);
         args->InsertAt(0, function, zone());
         obj = factory()->NewVariableProxy(temp);
         args->InsertAt(1, obj, zone());
       }
@@ skipping 84 matching lines @@
   // yield %AsyncFunctionAwait(.generator_object, <operand>)
   Variable* generator_object_variable =
       parser_->function_state_->generator_object_variable();
 
   // If generator_object_variable is null,
   if (!generator_object_variable) return value;
 
   auto factory = parser_->factory();
   const int nopos = kNoSourcePosition;
 
-  Variable* temp_var = parser_->scope()->NewTemporary(
-      parser_->ast_value_factory()->empty_string());
+  Variable* temp_var =
+      parser_->NewTemporary(parser_->ast_value_factory()->empty_string());
   VariableProxy* temp_proxy = factory->NewVariableProxy(temp_var);
   Block* do_block = factory->NewBlock(nullptr, 2, false, nopos);
 
   // Wrap value evaluation to provide a break location.
   Expression* value_assignment =
       factory->NewAssignment(Token::ASSIGN, temp_proxy, value, nopos);
   do_block->statements()->Add(
       factory->NewExpressionStatement(value_assignment, value->position()),
       zone());
 
@@ skipping 122 matching lines @@
     DCHECK_NOT_NULL(lhs->raw_name());
     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());
+    auto temp_obj = NewTemporary(ast_value_factory()->empty_string());
+    auto temp_key = NewTemporary(ast_value_factory()->empty_string());
     Expression* assign_obj = factory()->NewAssignment(
         Token::ASSIGN, factory()->NewVariableProxy(temp_obj), prop->obj(),
         kNoSourcePosition);
     Expression* assign_key = factory()->NewAssignment(
         Token::ASSIGN, factory()->NewVariableProxy(temp_key), prop->key(),
         kNoSourcePosition);
     args->Add(factory()->NewProperty(factory()->NewVariableProxy(temp_obj),
                                      factory()->NewVariableProxy(temp_key),
                                      left->position()),
               zone());
@@ skipping 22 matching lines @@
   //      $R = [1, 2, 3];
   //      for ($i of x) %AppendElement($R, $i);
   //      %AppendElement($R, 4);
   //      for ($j of y) %AppendElement($R, $j);
   //      %AppendElement($R, 5);
   //      $R
   //    }
   // where $R, $i and $j are fresh temporary variables.
   ZoneList<Expression*>::iterator s = lit->FirstSpread();
   if (s == lit->EndValue()) return nullptr;  // no spread, no rewriting...
-  Variable* result =
-      scope()->NewTemporary(ast_value_factory()->dot_result_string());
+  Variable* result = NewTemporary(ast_value_factory()->dot_result_string());
   // NOTE: The value assigned to R is the whole original array literal,
   // spreads included. This will be fixed before the rewritten AST is returned.
   // $R = lit
   Expression* init_result = factory()->NewAssignment(
       Token::INIT, factory()->NewVariableProxy(result), lit, kNoSourcePosition);
   Block* do_block = factory()->NewBlock(nullptr, 16, false, kNoSourcePosition);
   do_block->statements()->Add(
       factory()->NewExpressionStatement(init_result, kNoSourcePosition),
       zone());
   // Traverse the array literal starting from the first spread.
   while (s != lit->EndValue()) {
     Expression* value = *s++;
     Spread* spread = value->AsSpread();
     if (spread == nullptr) {
       // If the element is not a spread, we're adding a single:
       // %AppendElement($R, value)
       ZoneList<Expression*>* append_element_args = NewExpressionList(2, zone());
       append_element_args->Add(factory()->NewVariableProxy(result), zone());
       append_element_args->Add(value, zone());
       do_block->statements()->Add(
           factory()->NewExpressionStatement(
               factory()->NewCallRuntime(Runtime::kAppendElement,
                                         append_element_args, kNoSourcePosition),
               kNoSourcePosition),
           zone());
     } else {
       // If it's a spread, we're adding a for/of loop iterating through it.
-      Variable* each =
-          scope()->NewTemporary(ast_value_factory()->dot_for_string());
+      Variable* each = NewTemporary(ast_value_factory()->dot_for_string());
       Expression* subject = spread->expression();
       // %AppendElement($R, each)
       Statement* append_body;
       {
         ZoneList<Expression*>* append_element_args =
             NewExpressionList(2, zone());
         append_element_args->Add(factory()->NewVariableProxy(result), zone());
         append_element_args->Add(factory()->NewVariableProxy(each), zone());
         append_body = factory()->NewExpressionStatement(
             factory()->NewCallRuntime(Runtime::kAppendElement,
@@ skipping 164 matching lines @@
 //   if (IS_NULL_OR_UNDEFINED(iteratorReturn)) return input;
 //   output = %_Call(iteratorReturn, iterator, input);
 //   if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
 
 Expression* ParserTraits::RewriteYieldStar(
     Expression* generator, Expression* iterable, int pos) {
   const int nopos = kNoSourcePosition;
 
   auto factory = parser_->factory();
   auto avfactory = parser_->ast_value_factory();
-  auto scope = parser_->scope();
   auto zone = parser_->zone();
 
 
   // Forward definition for break/continue statements.
   WhileStatement* loop = factory->NewWhileStatement(nullptr, nopos);
 
 
   // let input = undefined;
-  Variable* var_input = scope->NewTemporary(avfactory->empty_string());
+  Variable* var_input = parser_->NewTemporary(avfactory->empty_string());
   Statement* initialize_input;
   {
     Expression* input_proxy = factory->NewVariableProxy(var_input);
     Expression* assignment = factory->NewAssignment(
         Token::ASSIGN, input_proxy, factory->NewUndefinedLiteral(nopos), nopos);
     initialize_input = factory->NewExpressionStatement(assignment, nopos);
   }
 
 
   // let mode = kNext;
-  Variable* var_mode = scope->NewTemporary(avfactory->empty_string());
+  Variable* var_mode = parser_->NewTemporary(avfactory->empty_string());
   Statement* initialize_mode;
   {
     Expression* mode_proxy = factory->NewVariableProxy(var_mode);
     Expression* knext = factory->NewSmiLiteral(JSGeneratorObject::kNext, nopos);
     Expression* assignment =
         factory->NewAssignment(Token::ASSIGN, mode_proxy, knext, nopos);
     initialize_mode = factory->NewExpressionStatement(assignment, nopos);
   }
 
 
   // let output = undefined;
-  Variable* var_output = scope->NewTemporary(avfactory->empty_string());
+  Variable* var_output = parser_->NewTemporary(avfactory->empty_string());
   Statement* initialize_output;
   {
     Expression* output_proxy = factory->NewVariableProxy(var_output);
     Expression* assignment = factory->NewAssignment(
         Token::ASSIGN, output_proxy, factory->NewUndefinedLiteral(nopos),
         nopos);
     initialize_output = factory->NewExpressionStatement(assignment, nopos);
   }
 
 
   // let iterator = iterable[Symbol.iterator];
-  Variable* var_iterator = scope->NewTemporary(avfactory->empty_string());
+  Variable* var_iterator = parser_->NewTemporary(avfactory->empty_string());
   Statement* get_iterator;
   {
     Expression* iterator = GetIterator(iterable, factory, nopos);
     Expression* iterator_proxy = factory->NewVariableProxy(var_iterator);
     Expression* assignment = factory->NewAssignment(
         Token::ASSIGN, iterator_proxy, iterator, nopos);
     get_iterator = factory->NewExpressionStatement(assignment, nopos);
   }
 
 
@@ skipping 59 matching lines @@
           Runtime::kThrowIteratorResultNotAnObject, args, nopos);
       throw_call = factory->NewExpressionStatement(call, nopos);
     }
 
     validate_next_output = factory->NewIfStatement(
         is_receiver_call, factory->NewEmptyStatement(nopos), throw_call, nopos);
   }
 
 
   // let iteratorThrow = iterator.throw;
-  Variable* var_throw = scope->NewTemporary(avfactory->empty_string());
+  Variable* var_throw = parser_->NewTemporary(avfactory->empty_string());
   Statement* get_throw;
   {
     Expression* iterator_proxy = factory->NewVariableProxy(var_iterator);
     Expression* literal =
         factory->NewStringLiteral(avfactory->throw_string(), nopos);
     Expression* property =
         factory->NewProperty(iterator_proxy, literal, nopos);
     Expression* throw_proxy = factory->NewVariableProxy(var_throw);
     Expression* assignment = factory->NewAssignment(
         Token::ASSIGN, throw_proxy, property, nopos);
@@ skipping 174 matching lines @@
   // try { ... } catch(e) { ... }
   Statement* try_catch;
   {
     Block* try_block = factory->NewBlock(nullptr, 2, false, nopos);
     try_block->statements()->Add(yield_output, zone);
     try_block->statements()->Add(set_mode_next, zone);
 
     Block* catch_block = factory->NewBlock(nullptr, 1, false, nopos);
     catch_block->statements()->Add(set_mode_throw, zone);
 
-    Scope* catch_scope = NewScopeWithParent(scope, CATCH_SCOPE);
+    Scope* catch_scope = NewScope(CATCH_SCOPE);
     catch_scope->set_is_hidden();
     const AstRawString* name = avfactory->dot_catch_string();
     Variable* catch_variable =
         catch_scope->DeclareLocal(name, VAR, kCreatedInitialized,
                                                Variable::NORMAL);
 
     try_catch = factory->NewTryCatchStatementForDesugaring(
         try_block, catch_scope, catch_variable, catch_block, nopos);
   }
 
@@ skipping 71 matching lines @@
     do_block_->statements()->Add(initialize_output, zone);
     do_block_->statements()->Add(get_iterator, zone);
     do_block_->statements()->Add(validate_iterator, zone);
     do_block_->statements()->Add(loop, zone);
     do_block_->statements()->Add(maybe_return_value, zone);
 
     Block* do_block = factory->NewBlock(nullptr, 2, false, nopos);
     do_block->statements()->Add(do_block_, zone);
     do_block->statements()->Add(get_value, zone);
 
-    Variable* dot_result = scope->NewTemporary(avfactory->dot_result_string());
+    Variable* dot_result =
+        parser_->NewTemporary(avfactory->dot_result_string());
     yield_star = factory->NewDoExpression(do_block, dot_result, nopos);
-    Rewriter::Rewrite(parser_, scope->GetClosureScope(), yield_star, avfactory);
+    Rewriter::Rewrite(parser_, parser_->GetClosureScope(), yield_star,
+                      avfactory);
   }
 
   return yield_star;
 }
 
 Statement* ParserTraits::CheckCallable(Variable* var, Expression* error,
                                        int pos) {
   auto factory = parser_->factory();
   auto avfactory = parser_->ast_value_factory();
   const int nopos = kNoSourcePosition;
@@ skipping 250 matching lines @@
   //       if (!IS_RECEIVER(output)) {
   //         %ThrowIterResultNotAnObject(output);
   //       }
   //     }
   //   }
   //
 
   const int nopos = kNoSourcePosition;
   auto factory = parser_->factory();
   auto avfactory = parser_->ast_value_factory();
-  auto scope = parser_->scope();
   auto zone = parser_->zone();
 
 
   // let iteratorReturn = iterator.return;
-  Variable* var_return = scope->NewTemporary(avfactory->empty_string());
+  Variable* var_return = parser_->NewTemporary(avfactory->empty_string());
   Statement* get_return;
   {
     Expression* iterator_proxy = factory->NewVariableProxy(iterator);
     Expression* literal =
         factory->NewStringLiteral(avfactory->return_string(), nopos);
     Expression* property =
         factory->NewProperty(iterator_proxy, literal, nopos);
     Expression* return_proxy = factory->NewVariableProxy(var_return);
     Expression* assignment = factory->NewAssignment(
         Token::ASSIGN, return_proxy, property, nopos);
@@ skipping 20 matching lines @@
 
     Expression* call =
         factory->NewCallRuntime(Runtime::kInlineCall, args, nopos);
 
     Block* try_block = factory->NewBlock(nullptr, 1, false, nopos);
     try_block->statements()->Add(factory->NewExpressionStatement(call, nopos),
                                  zone);
 
     Block* catch_block = factory->NewBlock(nullptr, 0, false, nopos);
 
-    Scope* catch_scope = NewScopeWithParent(scope, CATCH_SCOPE);
+    Scope* catch_scope = NewScope(CATCH_SCOPE);
     Variable* catch_variable = catch_scope->DeclareLocal(
         avfactory->dot_catch_string(), VAR, kCreatedInitialized,
         Variable::NORMAL);
     catch_scope->set_is_hidden();
 
     try_call_return = factory->NewTryCatchStatement(
         try_block, catch_scope, catch_variable, catch_block, nopos);
   }
 
   // let output = %_Call(iteratorReturn, iterator);
   // if (!IS_RECEIVER(output)) {
   //   %ThrowIteratorResultNotAnObject(output);
   // }
   Block* validate_return;
   {
-    Variable* var_output = scope->NewTemporary(avfactory->empty_string());
+    Variable* var_output = parser_->NewTemporary(avfactory->empty_string());
     Statement* call_return;
     {
       auto args = new (zone) ZoneList<Expression*>(2, zone);
       args->Add(factory->NewVariableProxy(var_return), zone);
       args->Add(factory->NewVariableProxy(iterator), zone);
       Expression* call =
           factory->NewCallRuntime(Runtime::kInlineCall, args, nopos);
 
       Expression* output_proxy = factory->NewVariableProxy(var_output);
       Expression* assignment =
@@ skipping 123 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8