[parser] Refactor parser and preparser traits

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 371 matching lines @@
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 // ----------------------------------------------------------------------------
 // Implementation of Parser
 
 bool ParserTraits::IsEval(const AstRawString* identifier) const {
   return identifier == parser_->ast_value_factory()->eval_string();
 }
 
-
 bool ParserTraits::IsArguments(const AstRawString* identifier) const {
   return identifier == parser_->ast_value_factory()->arguments_string();
 }
 
-
 bool ParserTraits::IsEvalOrArguments(const AstRawString* identifier) const {
   return IsEval(identifier) || IsArguments(identifier);
 }
 
 bool ParserTraits::IsUndefined(const AstRawString* identifier) const {
   return identifier == parser_->ast_value_factory()->undefined_string();
 }
 
 bool ParserTraits::IsAwait(const AstRawString* identifier) const {
   return identifier == parser_->ast_value_factory()->await_string();
@@ skipping 176 matching lines @@
   auto args = new (zone) ZoneList<Expression*>(2, zone);
   args->Add(value, zone);
   args->Add(factory->NewBooleanLiteral(done, pos), zone);
 
   return factory->NewCallRuntime(Runtime::kInlineCreateIterResultObject, args,
                                  pos);
 }
 
 Expression* ParserTraits::NewThrowReferenceError(
     MessageTemplate::Template message, int pos) {
-  return NewThrowError(Runtime::kNewReferenceError, message,
-                       parser_->ast_value_factory()->empty_string(), pos);
+  return parser_->NewThrowError(Runtime::kNewReferenceError, message,
+                                parser_->ast_value_factory()->empty_string(),
+                                pos);
 }
 
 
 Expression* ParserTraits::NewThrowSyntaxError(MessageTemplate::Template message,
                                               const AstRawString* arg,
                                               int pos) {
-  return NewThrowError(Runtime::kNewSyntaxError, message, arg, pos);
+  return parser_->NewThrowError(Runtime::kNewSyntaxError, message, arg, pos);
 }
 
 
 Expression* ParserTraits::NewThrowTypeError(MessageTemplate::Template message,
                                             const AstRawString* arg, int pos) {
-  return NewThrowError(Runtime::kNewTypeError, message, arg, pos);
+  return parser_->NewThrowError(Runtime::kNewTypeError, message, arg, pos);
+}
+
+Expression* Parser::NewThrowError(Runtime::FunctionId id,
+                                  MessageTemplate::Template message,
+                                  const AstRawString* arg, int pos) {
+  ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
+  args->Add(factory()->NewSmiLiteral(message, pos), zone());
+  args->Add(factory()->NewStringLiteral(arg, pos), zone());
+  CallRuntime* call_constructor = factory()->NewCallRuntime(id, args, pos);
+  return factory()->NewThrow(call_constructor, pos);
 }
 
 
-Expression* ParserTraits::NewThrowError(Runtime::FunctionId id,
-                                        MessageTemplate::Template message,
-                                        const AstRawString* arg, int pos) {
-  Zone* zone = parser_->zone();
-  ZoneList<Expression*>* args = new (zone) ZoneList<Expression*>(2, zone);
-  args->Add(parser_->factory()->NewSmiLiteral(message, pos), zone);
-  args->Add(parser_->factory()->NewStringLiteral(arg, pos), zone);
-  CallRuntime* call_constructor =
-      parser_->factory()->NewCallRuntime(id, args, pos);
-  return parser_->factory()->NewThrow(call_constructor, pos);
-}
-
-
 void ParserTraits::ReportMessageAt(Scanner::Location source_location,
                                    MessageTemplate::Template message,
                                    const char* arg, ParseErrorType error_type) {
   if (parser_->stack_overflow()) {
     // Suppress the error message (syntax error or such) in the presence of a
     // stack overflow. The isolate allows only one pending exception at at time
     // and we want to report the stack overflow later.
     return;
   }
   parser_->pending_error_handler_.ReportMessageAt(source_location.beg_pos,
                                                   source_location.end_pos,
                                                   message, arg, error_type);
 }
 
 
-void ParserTraits::ReportMessage(MessageTemplate::Template message,
-                                 const char* arg, ParseErrorType error_type) {
-  Scanner::Location source_location = parser_->scanner()->location();
-  ReportMessageAt(source_location, message, arg, error_type);
-}
-
-
-void ParserTraits::ReportMessage(MessageTemplate::Template message,
-                                 const AstRawString* arg,
-                                 ParseErrorType error_type) {
-  Scanner::Location source_location = parser_->scanner()->location();
-  ReportMessageAt(source_location, message, arg, error_type);
-}
-
-
 void ParserTraits::ReportMessageAt(Scanner::Location source_location,
                                    MessageTemplate::Template message,
                                    const AstRawString* arg,
                                    ParseErrorType error_type) {
   if (parser_->stack_overflow()) {
     // Suppress the error message (syntax error or such) in the presence of a
     // stack overflow. The isolate allows only one pending exception at at time
     // and we want to report the stack overflow later.
     return;
   }
@@ skipping 645 matching lines @@
         if (use_strict_found) {
           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,
-                string);
+            ReportMessageAt(token_loc,
+                            MessageTemplate::kIllegalLanguageModeDirective,
+                            string);
             *ok = false;
             return;
           }
           // Because declarations in strict eval code don't leak into the scope
           // of the eval call, it is likely that functions declared in strict
           // eval code will be used within the eval code, so lazy parsing is
           // probably not a win.
           if (this->scope()->is_eval_scope()) mode_ = PARSE_EAGERLY;
         } else if (literal->raw_value()->AsString() ==
                        ast_value_factory()->use_asm_string() &&
@@ skipping 729 matching lines @@
         // check also covers the special case
         //
         // function () { let x; { var x; } }
         //
         // because the var declaration is hoisted to the function scope where
         // 'x' is already bound.
         DCHECK(IsDeclaredVariableMode(var->mode()));
         // In harmony we treat re-declarations as early errors. See
         // ES5 16 for a definition of early errors.
         if (declaration_kind == DeclarationDescriptor::NORMAL) {
-          ParserTraits::ReportMessage(MessageTemplate::kVarRedeclaration, name);
+          ReportMessage(MessageTemplate::kVarRedeclaration, name);
         } else {
-          ParserTraits::ReportMessage(MessageTemplate::kParamDupe);
+          ReportMessage(MessageTemplate::kParamDupe);
         }
         *ok = false;
         return nullptr;
       }
     } else if (mode == VAR) {
       var->set_maybe_assigned();
     }
   }
   DCHECK_NOT_NULL(var);
 
@@ skipping 372 matching lines @@
 
       // End position of the initializer is after the assignment expression.
       initializer_position = scanner()->location().end_pos;
     } else {
       // Initializers may be either required or implied unless this is a
       // for-in/of iteration variable.
       if (var_context != kForStatement || !PeekInOrOf()) {
         // ES6 'const' and binding patterns require initializers.
         if (parsing_result->descriptor.mode == CONST ||
             !pattern->IsVariableProxy()) {
-          ParserTraits::ReportMessageAt(
+          ReportMessageAt(
               Scanner::Location(decl_pos, scanner()->location().end_pos),
               MessageTemplate::kDeclarationMissingInitializer,
               !pattern->IsVariableProxy() ? "destructuring" : "const");
           *ok = false;
           return nullptr;
         }
 
         // 'let x' initializes 'x' to undefined.
         if (parsing_result->descriptor.mode == LET) {
           value = GetLiteralUndefined(position());
@@ skipping 42 matching lines @@
   return false;
 }
 
 Statement* Parser::ParseFunctionDeclaration(bool* ok) {
   Consume(Token::FUNCTION);
   int pos = position();
   ParseFunctionFlags flags = ParseFunctionFlags::kIsNormal;
   if (Check(Token::MUL)) {
     flags |= ParseFunctionFlags::kIsGenerator;
     if (allow_harmony_restrictive_declarations()) {
-      ParserTraits::ReportMessageAt(scanner()->location(),
-                                    MessageTemplate::kGeneratorInLegacyContext);
+      ReportMessageAt(scanner()->location(),
+                      MessageTemplate::kGeneratorInLegacyContext);
       *ok = false;
       return nullptr;
     }
   }
 
   return ParseHoistableDeclaration(pos, flags, nullptr, false, CHECK_OK);
 }
 
 Statement* Parser::ParseExpressionOrLabelledStatement(
     ZoneList<const AstRawString*>* labels,
@@ skipping 27 matching lines @@
     // Expression is a single identifier, and not, e.g., a parenthesized
     // identifier.
     VariableProxy* var = expr->AsVariableProxy();
     const AstRawString* label = var->raw_name();
     // TODO(1240780): We don't check for redeclaration of labels
     // during preparsing since keeping track of the set of active
     // labels requires nontrivial changes to the way scopes are
     // structured.  However, these are probably changes we want to
     // make later anyway so we should go back and fix this then.
     if (ContainsLabel(labels, label) || TargetStackContainsLabel(label)) {
-      ParserTraits::ReportMessage(MessageTemplate::kLabelRedeclaration, label);
+      ReportMessage(MessageTemplate::kLabelRedeclaration, label);
       *ok = false;
       return NULL;
     }
     if (labels == NULL) {
       labels = new(zone()) ZoneList<const AstRawString*>(4, zone());
     }
     labels->Add(label, zone());
     // Remove the "ghost" variable that turned out to be a label
     // from the top scope. This way, we don't try to resolve it
     // during the scope processing.
@@ skipping 64 matching lines @@
     // ECMA allows "eval" or "arguments" as labels even in strict mode.
     label = ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK);
   }
   IterationStatement* target = LookupContinueTarget(label, CHECK_OK);
   if (target == NULL) {
     // Illegal continue statement.
     MessageTemplate::Template message = MessageTemplate::kIllegalContinue;
     if (label != NULL) {
       message = MessageTemplate::kUnknownLabel;
     }
-    ParserTraits::ReportMessage(message, label);
+    ReportMessage(message, label);
     *ok = false;
     return NULL;
   }
   ExpectSemicolon(CHECK_OK);
   return factory()->NewContinueStatement(target, pos);
 }
 
 
 Statement* Parser::ParseBreakStatement(ZoneList<const AstRawString*>* labels,
                                        bool* ok) {
@@ skipping 16 matching lines @@
     return factory()->NewEmptyStatement(pos);
   }
   BreakableStatement* target = NULL;
   target = LookupBreakTarget(label, CHECK_OK);
   if (target == NULL) {
     // Illegal break statement.
     MessageTemplate::Template message = MessageTemplate::kIllegalBreak;
     if (label != NULL) {
       message = MessageTemplate::kUnknownLabel;
     }
-    ParserTraits::ReportMessage(message, label);
+    ReportMessage(message, label);
     *ok = false;
     return NULL;
   }
   ExpectSemicolon(CHECK_OK);
   return factory()->NewBreakStatement(target, pos);
 }
 
 
 Statement* Parser::ParseReturnStatement(bool* ok) {
   // ReturnStatement ::
@@ skipping 362 matching lines @@
           Declaration* decl =
               inner_block_scope->CheckLexDeclarationsConflictingWith(
                   bound_names);
           if (decl != nullptr) {
             const AstRawString* name = decl->proxy()->raw_name();
             int position = decl->proxy()->position();
             Scanner::Location location =
                 position == kNoSourcePosition
                     ? Scanner::Location::invalid()
                     : Scanner::Location(position, position + 1);
-            ParserTraits::ReportMessageAt(
-                location, MessageTemplate::kVarRedeclaration, name);
+            ReportMessageAt(location, MessageTemplate::kVarRedeclaration, name);
             *ok = false;
             return nullptr;
           }
         }
         block_state.set_end_position(scanner()->location().end_pos);
         catch_block->set_scope(block_state.FinalizedBlockScope());
       }
     }
 
     catch_scope->set_end_position(scanner()->location().end_pos);
@@ skipping 289 matching lines @@
   // Statement* body (gets overwritten)
   if (finalize) {
     Block* block = factory()->NewBlock(nullptr, 2, false, nopos);
     block->statements()->Add(body, zone());
     block->statements()->Add(set_completion_normal, zone());
     body = block;
   }
 
   for_of->Initialize(body, iterator, assign_iterator, next_result, result_done,
                      assign_each);
-  return finalize
-             ? ParserTraits::FinalizeForOfStatement(for_of, completion, nopos)
-             : for_of;
+  return finalize ? FinalizeForOfStatement(for_of, completion, nopos) : for_of;
 }
 
 Statement* Parser::DesugarLexicalBindingsInForStatement(
     Scope* inner_scope, VariableMode mode, ZoneList<const AstRawString*>* names,
     ForStatement* loop, Statement* init, Expression* cond, Statement* next,
     Statement* body, bool* ok) {
   // ES6 13.7.4.8 specifies that on each loop iteration the let variables are
   // copied into a new environment.  Moreover, the "next" statement must be
   // evaluated not in the environment of the just completed iteration but in
   // that of the upcoming one.  We achieve this with the following desugaring.
@@ skipping 271 matching lines @@
       ParseVariableDeclarations(kForStatement, &parsing_result, nullptr,
                                 CHECK_OK);
 
       ForEachStatement::VisitMode mode = ForEachStatement::ENUMERATE;
       int each_beg_pos = scanner()->location().beg_pos;
       int each_end_pos = scanner()->location().end_pos;
 
       if (CheckInOrOf(&mode, ok)) {
         if (!*ok) return nullptr;
         if (parsing_result.declarations.length() != 1) {
-          ParserTraits::ReportMessageAt(
-              parsing_result.bindings_loc,
-              MessageTemplate::kForInOfLoopMultiBindings,
-              ForEachStatement::VisitModeString(mode));
+          ReportMessageAt(parsing_result.bindings_loc,
+                          MessageTemplate::kForInOfLoopMultiBindings,
+                          ForEachStatement::VisitModeString(mode));
           *ok = false;
           return nullptr;
         }
         DeclarationParsingResult::Declaration& decl =
             parsing_result.declarations[0];
         if (parsing_result.first_initializer_loc.IsValid() &&
             (is_strict(language_mode()) || mode == ForEachStatement::ITERATE ||
              IsLexicalVariableMode(parsing_result.descriptor.mode) ||
              !decl.pattern->IsVariableProxy() || allow_harmony_for_in())) {
           // Only increment the use count if we would have let this through
           // without the flag.
           if (allow_harmony_for_in()) {
             ++use_counts_[v8::Isolate::kForInInitializer];
           }
-          ParserTraits::ReportMessageAt(
-              parsing_result.first_initializer_loc,
-              MessageTemplate::kForInOfLoopInitializer,
-              ForEachStatement::VisitModeString(mode));
+          ReportMessageAt(parsing_result.first_initializer_loc,
+                          MessageTemplate::kForInOfLoopInitializer,
+                          ForEachStatement::VisitModeString(mode));
           *ok = false;
           return nullptr;
         }
 
         Block* init_block = nullptr;
         bound_names_are_lexical =
             IsLexicalVariableMode(parsing_result.descriptor.mode);
 
         // special case for legacy for (var ... = ... in ...)
         if (!bound_names_are_lexical && decl.pattern->IsVariableProxy() &&
@@ skipping 88 matching lines @@
             if (is_for_var_of) {
               Scope* catch_scope = scope();
               while (catch_scope != nullptr &&
                      !catch_scope->is_declaration_scope()) {
                 if (catch_scope->is_catch_scope()) {
                   auto name = catch_scope->catch_variable_name();
                   if (name !=
                       ast_value_factory()
                           ->dot_catch_string()) {  // i.e. is a simple binding
                     if (bound_names.Contains(name)) {
-                      ParserTraits::ReportMessageAt(
-                          parsing_result.bindings_loc,
-                          MessageTemplate::kVarRedeclaration, name);
+                      ReportMessageAt(parsing_result.bindings_loc,
+                                      MessageTemplate::kVarRedeclaration, name);
                       *ok = false;
                       return nullptr;
                     }
                   }
                 }
                 catch_scope = catch_scope->outer_scope();
               }
             }
           }
 
@@ skipping 227 matching lines @@
     Handle<FixedArray> value) {
   Smi* literal_type = Smi::cast(value->get(kLiteralTypeSlot));
   return static_cast<LiteralType>(literal_type->value());
 }
 
 
 Handle<FixedArray> CompileTimeValue::GetElements(Handle<FixedArray> value) {
   return Handle<FixedArray>(FixedArray::cast(value->get(kElementsSlot)));
 }
 
-void ParserTraits::ParseArrowFunctionFormalParameters(
+void Parser::ParseArrowFunctionFormalParameters(
     ParserFormalParameters* parameters, Expression* expr, int end_pos,
     bool* ok) {
   // ArrowFunctionFormals ::
   //    Binary(Token::COMMA, NonTailArrowFunctionFormals, Tail)
   //    Tail
   // NonTailArrowFunctionFormals ::
   //    Binary(Token::COMMA, NonTailArrowFunctionFormals, VariableProxy)
   //    VariableProxy
   // Tail ::
   //    VariableProxy
@@ skipping 111 matching lines @@
   }
   return expr;
 }
 
 void ParserTraits::ParseArrowFunctionFormalParameterList(
     ParserFormalParameters* parameters, Expression* expr,
     const Scanner::Location& params_loc, Scanner::Location* duplicate_loc,
     const Scope::Snapshot& scope_snapshot, bool* ok) {
   if (expr->IsEmptyParentheses()) return;
 
-  ParseArrowFunctionFormalParameters(parameters, expr, params_loc.end_pos,
-                                     CHECK_OK_VOID);
+  parser_->ParseArrowFunctionFormalParameters(
+      parameters, expr, params_loc.end_pos, CHECK_OK_VOID);
 
   scope_snapshot.Reparent(parameters->scope);
 
   if (parameters->Arity() > Code::kMaxArguments) {
     ReportMessageAt(params_loc, MessageTemplate::kMalformedArrowFunParamList);
     *ok = false;
     return;
   }
 
   Type::ExpressionClassifier classifier(parser_);
@@ skipping 353 matching lines @@
   if (bookmark && bookmark->HasBeenReset()) {
     return;  // Return immediately if pre-parser devided to abort parsing.
   }
   if (result == PreParser::kPreParseStackOverflow) {
     // Propagate stack overflow.
     set_stack_overflow();
     *ok = false;
     return;
   }
   if (logger.has_error()) {
-    ParserTraits::ReportMessageAt(
-        Scanner::Location(logger.start(), logger.end()), logger.message(),
-        logger.argument_opt(), logger.error_type());
+    ReportMessageAt(Scanner::Location(logger.start(), logger.end()),
+                    logger.message(), logger.argument_opt(),
+                    logger.error_type());
     *ok = false;
     return;
   }
   scope()->set_end_position(logger.end());
   Expect(Token::RBRACE, CHECK_OK_VOID);
   total_preparse_skipped_ += scope()->end_position() - function_block_pos;
   *materialized_literal_count = logger.literals();
   *expected_property_count = logger.properties();
   SetLanguageMode(scope(), logger.language_mode());
   if (logger.uses_super_property()) {
@@ skipping 573 matching lines @@
       return NULL;
     }
 
     return factory()->NewCallRuntime(function, args, pos);
   }
 
   int context_index = Context::IntrinsicIndexForName(name->string());
 
   // Check that the function is defined.
   if (context_index == Context::kNotFound) {
-    ParserTraits::ReportMessage(MessageTemplate::kNotDefined, name);
+    ReportMessage(MessageTemplate::kNotDefined, name);
     *ok = false;
     return NULL;
   }
 
   return factory()->NewCallRuntime(context_index, args, pos);
 }
 
 
 Literal* Parser::GetLiteralUndefined(int position) {
   return factory()->NewUndefinedLiteral(position);
 }
 
 
 void Parser::CheckConflictingVarDeclarations(Scope* scope, bool* ok) {
   Declaration* decl = scope->CheckConflictingVarDeclarations();
   if (decl != NULL) {
     // In ES6, conflicting variable bindings are early errors.
     const AstRawString* name = decl->proxy()->raw_name();
     int position = decl->proxy()->position();
     Scanner::Location location =
         position == kNoSourcePosition
             ? Scanner::Location::invalid()
             : Scanner::Location(position, position + 1);
-    ParserTraits::ReportMessageAt(location, MessageTemplate::kVarRedeclaration,
-                                  name);
+    ReportMessageAt(location, MessageTemplate::kVarRedeclaration, name);
     *ok = false;
   }
 }
 
 
 void Parser::InsertShadowingVarBindingInitializers(Block* inner_block) {
   // For each var-binding that shadows a parameter, insert an assignment
   // initializing the variable with the parameter.
   Scope* inner_scope = inner_block->scope();
   DCHECK(inner_scope->is_declaration_scope());
@@ skipping 878 matching lines @@
       return;
     }
   }
 
   // Ignore "__proto__" as a name when it's being used to set the [[Prototype]]
   // of an object literal.
   if (property->kind() == ObjectLiteralProperty::PROTOTYPE) return;
 
   DCHECK(!value->IsAnonymousFunctionDefinition() ||
          property->kind() == ObjectLiteralProperty::COMPUTED);
-  SetFunctionName(value, name);
+  parser_->SetFunctionName(value, name);
 }
 
 
 void ParserTraits::SetFunctionNameFromIdentifierRef(Expression* value,
                                                     Expression* identifier) {
   if (!identifier->IsVariableProxy()) return;
-  SetFunctionName(value, identifier->AsVariableProxy()->raw_name());
+  parser_->SetFunctionName(value, identifier->AsVariableProxy()->raw_name());
 }
 
-
-void ParserTraits::SetFunctionName(Expression* value,
-                                   const AstRawString* name) {
+void Parser::SetFunctionName(Expression* value, const AstRawString* name) {
   DCHECK_NOT_NULL(name);
   if (!value->IsAnonymousFunctionDefinition()) return;
   auto function = value->AsFunctionLiteral();
   if (function != nullptr) {
     function->set_raw_name(name);
   } else {
     DCHECK(value->IsDoExpression());
     value->AsDoExpression()->represented_function()->set_raw_name(name);
   }
 }
@@ skipping 72 matching lines @@
 //     if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
 //   }
 //
 // IteratorClose(iterator, input, output) expands to the following:
 //
 //   let iteratorReturn = iterator.return;
 //   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) {
+Expression* Parser::RewriteYieldStar(Expression* generator,
+                                     Expression* iterable, int pos) {
   const int nopos = kNoSourcePosition;
 
-  auto factory = parser_->factory();
-  auto avfactory = parser_->ast_value_factory();
-  auto zone = parser_->zone();
-
-
   // Forward definition for break/continue statements.
-  WhileStatement* loop = factory->NewWhileStatement(nullptr, nopos);
-
+  WhileStatement* loop = factory()->NewWhileStatement(nullptr, nopos);
 
   // let input = undefined;
-  Variable* var_input = parser_->NewTemporary(avfactory->empty_string());
+  Variable* var_input = NewTemporary(ast_value_factory()->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);
-  }
-
+    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 = parser_->NewTemporary(avfactory->empty_string());
+  Variable* var_mode = NewTemporary(ast_value_factory()->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);
-  }
-
+    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 = parser_->NewTemporary(avfactory->empty_string());
+  Variable* var_output = NewTemporary(ast_value_factory()->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);
-  }
-
+    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 = parser_->NewTemporary(avfactory->empty_string());
+  Variable* var_iterator = NewTemporary(ast_value_factory()->empty_string());
   Statement* get_iterator;
   {
-    Expression* iterator = GetIterator(iterable, factory, nopos);
-    Expression* iterator_proxy = factory->NewVariableProxy(var_iterator);
-    Expression* assignment = factory->NewAssignment(
+    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);
-  }
-
+    get_iterator = factory()->NewExpressionStatement(assignment, nopos);
+  }
 
   // if (!IS_RECEIVER(iterator)) throw MakeTypeError(kSymbolIteratorInvalid);
   Statement* validate_iterator;
   {
     Expression* is_receiver_call;
     {
-      auto args = new (zone) ZoneList<Expression*>(1, zone);
-      args->Add(factory->NewVariableProxy(var_iterator), zone);
+      auto args = new (zone()) ZoneList<Expression*>(1, zone());
+      args->Add(factory()->NewVariableProxy(var_iterator), zone());
       is_receiver_call =
-          factory->NewCallRuntime(Runtime::kInlineIsJSReceiver, args, nopos);
+          factory()->NewCallRuntime(Runtime::kInlineIsJSReceiver, args, nopos);
     }
 
     Statement* throw_call;
     {
-      Expression* call = NewThrowTypeError(
-          MessageTemplate::kSymbolIteratorInvalid, avfactory->empty_string(),
-          nopos);
-      throw_call = factory->NewExpressionStatement(call, nopos);
-    }
-
-    validate_iterator = factory->NewIfStatement(
-        is_receiver_call, factory->NewEmptyStatement(nopos), throw_call, nopos);
-  }
-
+      Expression* call =
+          NewThrowTypeError(MessageTemplate::kSymbolIteratorInvalid,
+                            ast_value_factory()->empty_string(), nopos);
+      throw_call = factory()->NewExpressionStatement(call, nopos);
+    }
+
+    validate_iterator = factory()->NewIfStatement(
+        is_receiver_call, factory()->NewEmptyStatement(nopos), throw_call,
+        nopos);
+  }
 
   // output = iterator.next(input);
   Statement* call_next;
   {
-    Expression* iterator_proxy = factory->NewVariableProxy(var_iterator);
+    Expression* iterator_proxy = factory()->NewVariableProxy(var_iterator);
     Expression* literal =
-        factory->NewStringLiteral(avfactory->next_string(), nopos);
+        factory()->NewStringLiteral(ast_value_factory()->next_string(), nopos);
     Expression* next_property =
-        factory->NewProperty(iterator_proxy, literal, nopos);
-    Expression* input_proxy = factory->NewVariableProxy(var_input);
-    auto args = new (zone) ZoneList<Expression*>(1, zone);
-    args->Add(input_proxy, zone);
-    Expression* call = factory->NewCall(next_property, args, nopos);
-    Expression* output_proxy = factory->NewVariableProxy(var_output);
-    Expression* assignment =
-        factory->NewAssignment(Token::ASSIGN, output_proxy, call, nopos);
-    call_next = factory->NewExpressionStatement(assignment, nopos);
-  }
-
+        factory()->NewProperty(iterator_proxy, literal, nopos);
+    Expression* input_proxy = factory()->NewVariableProxy(var_input);
+    auto args = new (zone()) ZoneList<Expression*>(1, zone());
+    args->Add(input_proxy, zone());
+    Expression* call = factory()->NewCall(next_property, args, nopos);
+    Expression* output_proxy = factory()->NewVariableProxy(var_output);
+    Expression* assignment =
+        factory()->NewAssignment(Token::ASSIGN, output_proxy, call, nopos);
+    call_next = factory()->NewExpressionStatement(assignment, nopos);
+  }
 
   // if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
   Statement* validate_next_output;
   {
     Expression* is_receiver_call;
     {
-      auto args = new (zone) ZoneList<Expression*>(1, zone);
-      args->Add(factory->NewVariableProxy(var_output), zone);
+      auto args = new (zone()) ZoneList<Expression*>(1, zone());
+      args->Add(factory()->NewVariableProxy(var_output), zone());
       is_receiver_call =
-          factory->NewCallRuntime(Runtime::kInlineIsJSReceiver, args, nopos);
+          factory()->NewCallRuntime(Runtime::kInlineIsJSReceiver, args, nopos);
     }
 
     Statement* throw_call;
     {
-      auto args = new (zone) ZoneList<Expression*>(1, zone);
-      args->Add(factory->NewVariableProxy(var_output), zone);
-      Expression* call = factory->NewCallRuntime(
+      auto args = new (zone()) ZoneList<Expression*>(1, zone());
+      args->Add(factory()->NewVariableProxy(var_output), zone());
+      Expression* call = factory()->NewCallRuntime(
           Runtime::kThrowIteratorResultNotAnObject, args, nopos);
-      throw_call = factory->NewExpressionStatement(call, nopos);
-    }
-
-    validate_next_output = factory->NewIfStatement(
-        is_receiver_call, factory->NewEmptyStatement(nopos), throw_call, 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 = parser_->NewTemporary(avfactory->empty_string());
+  Variable* var_throw = NewTemporary(ast_value_factory()->empty_string());
   Statement* get_throw;
   {
-    Expression* iterator_proxy = factory->NewVariableProxy(var_iterator);
+    Expression* iterator_proxy = factory()->NewVariableProxy(var_iterator);
     Expression* literal =
-        factory->NewStringLiteral(avfactory->throw_string(), nopos);
+        factory()->NewStringLiteral(ast_value_factory()->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);
-    get_throw = factory->NewExpressionStatement(assignment, nopos);
-  }
-
+        factory()->NewProperty(iterator_proxy, literal, nopos);
+    Expression* throw_proxy = factory()->NewVariableProxy(var_throw);
+    Expression* assignment =
+        factory()->NewAssignment(Token::ASSIGN, throw_proxy, property, nopos);
+    get_throw = factory()->NewExpressionStatement(assignment, nopos);
+  }
 
   // if (IS_NULL_OR_UNDEFINED(iteratorThrow) {
   //   IteratorClose(iterator);
   //   throw MakeTypeError(kThrowMethodMissing);
   // }
   Statement* check_throw;
   {
-    Expression* condition = factory->NewCompareOperation(
-        Token::EQ, factory->NewVariableProxy(var_throw),
-        factory->NewNullLiteral(nopos), nopos);
-
-    Expression* call = NewThrowTypeError(
-        MessageTemplate::kThrowMethodMissing,
-        avfactory->empty_string(), nopos);
-    Statement* throw_call = factory->NewExpressionStatement(call, nopos);
-
-    Block* then = factory->NewBlock(nullptr, 4+1, false, nopos);
-    parser_->BuildIteratorCloseForCompletion(
+    Expression* condition = factory()->NewCompareOperation(
+        Token::EQ, factory()->NewVariableProxy(var_throw),
+        factory()->NewNullLiteral(nopos), nopos);
+    Expression* call =
+        NewThrowTypeError(MessageTemplate::kThrowMethodMissing,
+                          ast_value_factory()->empty_string(), nopos);
+    Statement* throw_call = factory()->NewExpressionStatement(call, nopos);
+
+    Block* then = factory()->NewBlock(nullptr, 4 + 1, false, nopos);
+    BuildIteratorCloseForCompletion(
         then->statements(), var_iterator,
-        factory->NewSmiLiteral(Parser::kNormalCompletion, nopos));
-    then->statements()->Add(throw_call, zone);
-    check_throw = factory->NewIfStatement(
-        condition, then, factory->NewEmptyStatement(nopos), nopos);
-  }
-
+        factory()->NewSmiLiteral(Parser::kNormalCompletion, nopos));
+    then->statements()->Add(throw_call, zone());
+    check_throw = factory()->NewIfStatement(
+        condition, then, factory()->NewEmptyStatement(nopos), nopos);
+  }
 
   // output = %_Call(iteratorThrow, iterator, input);
   Statement* call_throw;
   {
-    auto args = new (zone) ZoneList<Expression*>(3, zone);
-    args->Add(factory->NewVariableProxy(var_throw), zone);
-    args->Add(factory->NewVariableProxy(var_iterator), zone);
-    args->Add(factory->NewVariableProxy(var_input), zone);
+    auto args = new (zone()) ZoneList<Expression*>(3, zone());
+    args->Add(factory()->NewVariableProxy(var_throw), zone());
+    args->Add(factory()->NewVariableProxy(var_iterator), zone());
+    args->Add(factory()->NewVariableProxy(var_input), zone());
     Expression* call =
-        factory->NewCallRuntime(Runtime::kInlineCall, args, nopos);
-    Expression* assignment = factory->NewAssignment(
-        Token::ASSIGN, factory->NewVariableProxy(var_output), call, nopos);
-    call_throw = factory->NewExpressionStatement(assignment, nopos);
-  }
-
+        factory()->NewCallRuntime(Runtime::kInlineCall, args, nopos);
+    Expression* assignment = factory()->NewAssignment(
+        Token::ASSIGN, factory()->NewVariableProxy(var_output), call, nopos);
+    call_throw = factory()->NewExpressionStatement(assignment, nopos);
+  }
 
   // if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
   Statement* validate_throw_output;
   {
     Expression* is_receiver_call;
     {
-      auto args = new (zone) ZoneList<Expression*>(1, zone);
-      args->Add(factory->NewVariableProxy(var_output), zone);
+      auto args = new (zone()) ZoneList<Expression*>(1, zone());
+      args->Add(factory()->NewVariableProxy(var_output), zone());
       is_receiver_call =
-          factory->NewCallRuntime(Runtime::kInlineIsJSReceiver, args, nopos);
+          factory()->NewCallRuntime(Runtime::kInlineIsJSReceiver, args, nopos);
     }
 
     Statement* throw_call;
     {
-      auto args = new (zone) ZoneList<Expression*>(1, zone);
-      args->Add(factory->NewVariableProxy(var_output), zone);
-      Expression* call = factory->NewCallRuntime(
+      auto args = new (zone()) ZoneList<Expression*>(1, zone());
+      args->Add(factory()->NewVariableProxy(var_output), zone());
+      Expression* call = factory()->NewCallRuntime(
           Runtime::kThrowIteratorResultNotAnObject, args, nopos);
-      throw_call = factory->NewExpressionStatement(call, nopos);
-    }
-
-    validate_throw_output = factory->NewIfStatement(
-        is_receiver_call, factory->NewEmptyStatement(nopos), throw_call, nopos);
-  }
-
+      throw_call = factory()->NewExpressionStatement(call, nopos);
+    }
+
+    validate_throw_output = factory()->NewIfStatement(
+        is_receiver_call, factory()->NewEmptyStatement(nopos), throw_call,
+        nopos);
+  }
 
   // if (output.done) break;
   Statement* if_done;
   {
-    Expression* output_proxy = factory->NewVariableProxy(var_output);
+    Expression* output_proxy = factory()->NewVariableProxy(var_output);
     Expression* literal =
-        factory->NewStringLiteral(avfactory->done_string(), nopos);
-    Expression* property = factory->NewProperty(output_proxy, literal, nopos);
-    BreakStatement* break_loop = factory->NewBreakStatement(loop, nopos);
-    if_done = factory->NewIfStatement(
-        property, break_loop, factory->NewEmptyStatement(nopos), nopos);
+        factory()->NewStringLiteral(ast_value_factory()->done_string(), nopos);
+    Expression* property = factory()->NewProperty(output_proxy, literal, nopos);
+    BreakStatement* break_loop = factory()->NewBreakStatement(loop, nopos);
+    if_done = factory()->NewIfStatement(
+        property, break_loop, factory()->NewEmptyStatement(nopos), nopos);
   }
 
 
   // mode = kReturn;
   Statement* set_mode_return;
   {
-    Expression* mode_proxy = factory->NewVariableProxy(var_mode);
+    Expression* mode_proxy = factory()->NewVariableProxy(var_mode);
     Expression* kreturn =
-        factory->NewSmiLiteral(JSGeneratorObject::kReturn, nopos);
-    Expression* assignment =
-        factory->NewAssignment(Token::ASSIGN, mode_proxy, kreturn, nopos);
-    set_mode_return = factory->NewExpressionStatement(assignment, nopos);
+        factory()->NewSmiLiteral(JSGeneratorObject::kReturn, nopos);
+    Expression* assignment =
+        factory()->NewAssignment(Token::ASSIGN, mode_proxy, kreturn, nopos);
+    set_mode_return = factory()->NewExpressionStatement(assignment, nopos);
   }
 
   // Yield(output);
   Statement* yield_output;
   {
-    Expression* output_proxy = factory->NewVariableProxy(var_output);
-    Yield* yield = factory->NewYield(generator, output_proxy, nopos,
-                                     Yield::kOnExceptionThrow);
-    yield_output = factory->NewExpressionStatement(yield, nopos);
-  }
-
+    Expression* output_proxy = factory()->NewVariableProxy(var_output);
+    Yield* yield = factory()->NewYield(generator, output_proxy, nopos,
+                                       Yield::kOnExceptionThrow);
+    yield_output = factory()->NewExpressionStatement(yield, nopos);
+  }
 
   // mode = kNext;
   Statement* set_mode_next;
   {
-    Expression* mode_proxy = factory->NewVariableProxy(var_mode);
-    Expression* knext = factory->NewSmiLiteral(JSGeneratorObject::kNext, nopos);
-    Expression* assignment =
-        factory->NewAssignment(Token::ASSIGN, mode_proxy, knext, nopos);
-    set_mode_next = factory->NewExpressionStatement(assignment, nopos);
-  }
-
+    Expression* mode_proxy = factory()->NewVariableProxy(var_mode);
+    Expression* knext =
+        factory()->NewSmiLiteral(JSGeneratorObject::kNext, nopos);
+    Expression* assignment =
+        factory()->NewAssignment(Token::ASSIGN, mode_proxy, knext, nopos);
+    set_mode_next = factory()->NewExpressionStatement(assignment, nopos);
+  }
 
   // mode = kThrow;
   Statement* set_mode_throw;
   {
-    Expression* mode_proxy = factory->NewVariableProxy(var_mode);
+    Expression* mode_proxy = factory()->NewVariableProxy(var_mode);
     Expression* kthrow =
-        factory->NewSmiLiteral(JSGeneratorObject::kThrow, nopos);
-    Expression* assignment =
-        factory->NewAssignment(Token::ASSIGN, mode_proxy, kthrow, nopos);
-    set_mode_throw = factory->NewExpressionStatement(assignment, nopos);
-  }
-
+        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(factory, nopos);
-    Expression* input_proxy = factory->NewVariableProxy(var_input);
-    Expression* assignment = factory->NewAssignment(
+    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);
-  }
-
+    get_input = factory()->NewExpressionStatement(assignment, nopos);
+  }
 
   // if (mode === kReturn) {
   //   return {value: output.value, done: true};
   // }
   Statement* maybe_return_value;
   {
-    Expression* mode_proxy = factory->NewVariableProxy(var_mode);
+    Expression* mode_proxy = factory()->NewVariableProxy(var_mode);
     Expression* kreturn =
-        factory->NewSmiLiteral(JSGeneratorObject::kReturn, nopos);
-    Expression* condition = factory->NewCompareOperation(
+        factory()->NewSmiLiteral(JSGeneratorObject::kReturn, nopos);
+    Expression* condition = factory()->NewCompareOperation(
         Token::EQ_STRICT, mode_proxy, kreturn, nopos);
 
-    Expression* output_proxy = factory->NewVariableProxy(var_output);
+    Expression* output_proxy = factory()->NewVariableProxy(var_output);
     Expression* literal =
-        factory->NewStringLiteral(avfactory->value_string(), nopos);
-    Expression* property = factory->NewProperty(output_proxy, literal, nopos);
-    Statement* return_value =
-        factory->NewReturnStatement(BuildIteratorResult(property, true), nopos);
-
-    maybe_return_value = factory->NewIfStatement(
-        condition, return_value, factory->NewEmptyStatement(nopos), nopos);
-  }
-
+        factory()->NewStringLiteral(ast_value_factory()->value_string(), nopos);
+    Expression* property = factory()->NewProperty(output_proxy, literal, nopos);
+    Statement* return_value = factory()->NewReturnStatement(
+        BuildIteratorResult(property, true), nopos);
+
+    maybe_return_value = factory()->NewIfStatement(
+        condition, return_value, factory()->NewEmptyStatement(nopos), nopos);
+  }
 
   // output.value
   Statement* get_value;
   {
-    Expression* output_proxy = factory->NewVariableProxy(var_output);
+    Expression* output_proxy = factory()->NewVariableProxy(var_output);
     Expression* literal =
-        factory->NewStringLiteral(avfactory->value_string(), nopos);
-    Expression* property = factory->NewProperty(output_proxy, literal, nopos);
-    get_value = factory->NewExpressionStatement(property, nopos);
-  }
-
+        factory()->NewStringLiteral(ast_value_factory()->value_string(), nopos);
+    Expression* property = factory()->NewProperty(output_proxy, literal, nopos);
+    get_value = factory()->NewExpressionStatement(property, nopos);
+  }
 
   // Now put things together.
 
-
   // 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);
+    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 = NewScope(CATCH_SCOPE);
     catch_scope->set_is_hidden();
-    const AstRawString* name = avfactory->dot_catch_string();
+    const AstRawString* name = ast_value_factory()->dot_catch_string();
     Variable* catch_variable =
         catch_scope->DeclareLocal(name, VAR, kCreatedInitialized,
                                                Variable::NORMAL);
 
-    try_catch = factory->NewTryCatchStatementForDesugaring(
+    try_catch = factory()->NewTryCatchStatementForDesugaring(
         try_block, catch_scope, catch_variable, catch_block, nopos);
   }
 
-
   // try { ... } finally { ... }
   Statement* try_finally;
   {
-    Block* try_block = factory->NewBlock(nullptr, 1, false, nopos);
-    try_block->statements()->Add(try_catch, zone);
-
-    Block* finally = factory->NewBlock(nullptr, 2, false, nopos);
-    finally->statements()->Add(get_input, zone);
-    finally->statements()->Add(
-        factory->NewContinueStatement(loop, nopos), zone);
-
-    try_finally = factory->NewTryFinallyStatement(try_block, finally, nopos);
-  }
-
+    Block* try_block = factory()->NewBlock(nullptr, 1, false, nopos);
+    try_block->statements()->Add(try_catch, zone());
+
+    Block* finally = factory()->NewBlock(nullptr, 2, false, nopos);
+    finally->statements()->Add(get_input, zone());
+    finally->statements()->Add(factory()->NewContinueStatement(loop, nopos),
+                               zone());
+
+    try_finally = factory()->NewTryFinallyStatement(try_block, finally, nopos);
+  }
 
   // switch (mode) { ... }
-  SwitchStatement* switch_mode = factory->NewSwitchStatement(nullptr, nopos);
-  {
-    auto case_next = new (zone) ZoneList<Statement*>(3, zone);
-    case_next->Add(call_next, zone);
-    case_next->Add(validate_next_output, zone);
-    case_next->Add(factory->NewBreakStatement(switch_mode, nopos), zone);
-
-    auto case_return = new (zone) ZoneList<Statement*>(5, zone);
+  SwitchStatement* switch_mode = factory()->NewSwitchStatement(nullptr, nopos);
+  {
+    auto case_next = new (zone()) ZoneList<Statement*>(3, zone());
+    case_next->Add(call_next, zone());
+    case_next->Add(validate_next_output, zone());
+    case_next->Add(factory()->NewBreakStatement(switch_mode, nopos), zone());
+
+    auto case_return = new (zone()) ZoneList<Statement*>(5, zone());
     BuildIteratorClose(case_return, var_iterator, var_input, var_output);
-    case_return->Add(factory->NewBreakStatement(switch_mode, nopos), zone);
-
-    auto case_throw = new (zone) ZoneList<Statement*>(5, zone);
-    case_throw->Add(get_throw, zone);
-    case_throw->Add(check_throw, zone);
-    case_throw->Add(call_throw, zone);
-    case_throw->Add(validate_throw_output, zone);
-    case_throw->Add(factory->NewBreakStatement(switch_mode, nopos), zone);
-
-    auto cases = new (zone) ZoneList<CaseClause*>(3, zone);
-    Expression* knext = factory->NewSmiLiteral(JSGeneratorObject::kNext, nopos);
+    case_return->Add(factory()->NewBreakStatement(switch_mode, nopos), zone());
+
+    auto case_throw = new (zone()) ZoneList<Statement*>(5, zone());
+    case_throw->Add(get_throw, zone());
+    case_throw->Add(check_throw, zone());
+    case_throw->Add(call_throw, zone());
+    case_throw->Add(validate_throw_output, zone());
+    case_throw->Add(factory()->NewBreakStatement(switch_mode, nopos), zone());
+
+    auto cases = new (zone()) ZoneList<CaseClause*>(3, zone());
+    Expression* knext =
+        factory()->NewSmiLiteral(JSGeneratorObject::kNext, nopos);
     Expression* kreturn =
-        factory->NewSmiLiteral(JSGeneratorObject::kReturn, nopos);
+        factory()->NewSmiLiteral(JSGeneratorObject::kReturn, nopos);
     Expression* kthrow =
-        factory->NewSmiLiteral(JSGeneratorObject::kThrow, nopos);
-    cases->Add(factory->NewCaseClause(knext, case_next, nopos), zone);
-    cases->Add(factory->NewCaseClause(kreturn, case_return, nopos), zone);
-    cases->Add(factory->NewCaseClause(kthrow, case_throw, nopos), zone);
-
-    switch_mode->Initialize(factory->NewVariableProxy(var_mode), cases);
-  }
-
+        factory()->NewSmiLiteral(JSGeneratorObject::kThrow, nopos);
+    cases->Add(factory()->NewCaseClause(knext, case_next, nopos), zone());
+    cases->Add(factory()->NewCaseClause(kreturn, case_return, nopos), zone());
+    cases->Add(factory()->NewCaseClause(kthrow, case_throw, nopos), zone());
+
+    switch_mode->Initialize(factory()->NewVariableProxy(var_mode), cases);
+  }
 
   // while (true) { ... }
   // Already defined earlier: WhileStatement* loop = ...
   {
-    Block* loop_body = factory->NewBlock(nullptr, 4, false, nopos);
-    loop_body->statements()->Add(switch_mode, zone);
-    loop_body->statements()->Add(if_done, zone);
-    loop_body->statements()->Add(set_mode_return, zone);
-    loop_body->statements()->Add(try_finally, zone);
-
-    loop->Initialize(factory->NewBooleanLiteral(true, nopos), loop_body);
-  }
-
+    Block* loop_body = factory()->NewBlock(nullptr, 4, false, nopos);
+    loop_body->statements()->Add(switch_mode, zone());
+    loop_body->statements()->Add(if_done, zone());
+    loop_body->statements()->Add(set_mode_return, zone());
+    loop_body->statements()->Add(try_finally, zone());
+
+    loop->Initialize(factory()->NewBooleanLiteral(true, nopos), loop_body);
+  }
 
   // do { ... }
   DoExpression* yield_star;
   {
     // The rewriter needs to process the get_value statement only, hence we
     // put the preceding statements into an init block.
 
-    Block* do_block_ = factory->NewBlock(nullptr, 7, true, nopos);
-    do_block_->statements()->Add(initialize_input, zone);
-    do_block_->statements()->Add(initialize_mode, zone);
-    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);
+    Block* do_block_ = factory()->NewBlock(nullptr, 7, true, nopos);
+    do_block_->statements()->Add(initialize_input, zone());
+    do_block_->statements()->Add(initialize_mode, zone());
+    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 =
-        parser_->NewTemporary(avfactory->dot_result_string());
-    yield_star = factory->NewDoExpression(do_block, dot_result, nopos);
-    Rewriter::Rewrite(parser_, parser_->GetClosureScope(), yield_star,
-                      avfactory);
+        NewTemporary(ast_value_factory()->dot_result_string());
+    yield_star = factory()->NewDoExpression(do_block, dot_result, nopos);
+    Rewriter::Rewrite(this, GetClosureScope(), yield_star, ast_value_factory());
   }
 
   return yield_star;
 }
 
-Statement* ParserTraits::CheckCallable(Variable* var, Expression* error,
-                                       int pos) {
-  auto factory = parser_->factory();
-  auto avfactory = parser_->ast_value_factory();
+Statement* Parser::CheckCallable(Variable* var, Expression* error, int pos) {
   const int nopos = kNoSourcePosition;
   Statement* validate_var;
   {
-    Expression* type_of = factory->NewUnaryOperation(
-        Token::TYPEOF, factory->NewVariableProxy(var), nopos);
-    Expression* function_literal =
-        factory->NewStringLiteral(avfactory->function_string(), nopos);
-    Expression* condition = factory->NewCompareOperation(
+    Expression* type_of = factory()->NewUnaryOperation(
+        Token::TYPEOF, factory()->NewVariableProxy(var), nopos);
+    Expression* function_literal = factory()->NewStringLiteral(
+        ast_value_factory()->function_string(), nopos);
+    Expression* condition = factory()->NewCompareOperation(
         Token::EQ_STRICT, type_of, function_literal, nopos);
 
-    Statement* throw_call = factory->NewExpressionStatement(error, pos);
-
-    validate_var = factory->NewIfStatement(
-        condition, factory->NewEmptyStatement(nopos), throw_call, nopos);
+    Statement* throw_call = factory()->NewExpressionStatement(error, pos);
+
+    validate_var = factory()->NewIfStatement(
+        condition, factory()->NewEmptyStatement(nopos), throw_call, nopos);
   }
   return validate_var;
 }
 
-void ParserTraits::BuildIteratorClose(ZoneList<Statement*>* statements,
-                                      Variable* iterator, Variable* input,
-                                      Variable* var_output) {
+void Parser::BuildIteratorClose(ZoneList<Statement*>* statements,
+                                Variable* iterator, Variable* input,
+                                Variable* var_output) {
   //
   // This function adds four statements to [statements], corresponding to the
   // following code:
   //
   //   let iteratorReturn = iterator.return;
   //   if (IS_NULL_OR_UNDEFINED(iteratorReturn) {
   //     return {value: input, done: true};
   //   }
   //   output = %_Call(iteratorReturn, iterator, input);
   //   if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
   //
 
   const int nopos = kNoSourcePosition;
-  auto factory = parser_->factory();
-  auto avfactory = parser_->ast_value_factory();
-  auto zone = parser_->zone();
 
   // let iteratorReturn = iterator.return;
   Variable* var_return = var_output;  // Reusing the output variable.
   Statement* get_return;
   {
-    Expression* iterator_proxy = factory->NewVariableProxy(iterator);
-    Expression* literal =
-        factory->NewStringLiteral(avfactory->return_string(), nopos);
+    Expression* iterator_proxy = factory()->NewVariableProxy(iterator);
+    Expression* literal = factory()->NewStringLiteral(
+        ast_value_factory()->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);
-    get_return = factory->NewExpressionStatement(assignment, nopos);
+        factory()->NewProperty(iterator_proxy, literal, nopos);
+    Expression* return_proxy = factory()->NewVariableProxy(var_return);
+    Expression* assignment =
+        factory()->NewAssignment(Token::ASSIGN, return_proxy, property, nopos);
+    get_return = factory()->NewExpressionStatement(assignment, nopos);
   }
 
   // if (IS_NULL_OR_UNDEFINED(iteratorReturn) {
   //   return {value: input, done: true};
   // }
   Statement* check_return;
   {
-    Expression* condition = factory->NewCompareOperation(
-        Token::EQ, factory->NewVariableProxy(var_return),
-        factory->NewNullLiteral(nopos), nopos);
+    Expression* condition = factory()->NewCompareOperation(
+        Token::EQ, factory()->NewVariableProxy(var_return),
+        factory()->NewNullLiteral(nopos), nopos);
 
-    Expression* value = factory->NewVariableProxy(input);
+    Expression* value = factory()->NewVariableProxy(input);
 
     Statement* return_input =
-        factory->NewReturnStatement(BuildIteratorResult(value, true), nopos);
+        factory()->NewReturnStatement(BuildIteratorResult(value, true), nopos);
 
-    check_return = factory->NewIfStatement(
-        condition, return_input, factory->NewEmptyStatement(nopos), nopos);
+    check_return = factory()->NewIfStatement(
+        condition, return_input, factory()->NewEmptyStatement(nopos), nopos);
   }
 
   // output = %_Call(iteratorReturn, iterator, input);
   Statement* call_return;
   {
-    auto args = new (zone) ZoneList<Expression*>(3, zone);
-    args->Add(factory->NewVariableProxy(var_return), zone);
-    args->Add(factory->NewVariableProxy(iterator), zone);
-    args->Add(factory->NewVariableProxy(input), zone);
+    auto args = new (zone()) ZoneList<Expression*>(3, zone());
+    args->Add(factory()->NewVariableProxy(var_return), zone());
+    args->Add(factory()->NewVariableProxy(iterator), zone());
+    args->Add(factory()->NewVariableProxy(input), zone());
 
     Expression* call =
-        factory->NewCallRuntime(Runtime::kInlineCall, args, nopos);
-    Expression* output_proxy = factory->NewVariableProxy(var_output);
-    Expression* assignment = factory->NewAssignment(
-        Token::ASSIGN, output_proxy, call, nopos);
-    call_return = factory->NewExpressionStatement(assignment, nopos);
+        factory()->NewCallRuntime(Runtime::kInlineCall, args, nopos);
+    Expression* output_proxy = factory()->NewVariableProxy(var_output);
+    Expression* assignment =
+        factory()->NewAssignment(Token::ASSIGN, output_proxy, call, nopos);
+    call_return = factory()->NewExpressionStatement(assignment, nopos);
   }
 
   // if (!IS_RECEIVER(output)) %ThrowIteratorResultNotAnObject(output);
   Statement* validate_output;
   {
     Expression* is_receiver_call;
     {
-      auto args = new (zone) ZoneList<Expression*>(1, zone);
-      args->Add(factory->NewVariableProxy(var_output), zone);
+      auto args = new (zone()) ZoneList<Expression*>(1, zone());
+      args->Add(factory()->NewVariableProxy(var_output), zone());
       is_receiver_call =
-          factory->NewCallRuntime(Runtime::kInlineIsJSReceiver, args, nopos);
+          factory()->NewCallRuntime(Runtime::kInlineIsJSReceiver, args, nopos);
     }
 
     Statement* throw_call;
     {
-      auto args = new (zone) ZoneList<Expression*>(1, zone);
-      args->Add(factory->NewVariableProxy(var_output), zone);
-      Expression* call = factory->NewCallRuntime(
+      auto args = new (zone()) ZoneList<Expression*>(1, zone());
+      args->Add(factory()->NewVariableProxy(var_output), zone());
+      Expression* call = factory()->NewCallRuntime(
           Runtime::kThrowIteratorResultNotAnObject, args, nopos);
-      throw_call = factory->NewExpressionStatement(call, nopos);
+      throw_call = factory()->NewExpressionStatement(call, nopos);
     }
 
-    validate_output = factory->NewIfStatement(
-        is_receiver_call, factory->NewEmptyStatement(nopos), throw_call, nopos);
+    validate_output = factory()->NewIfStatement(
+        is_receiver_call, factory()->NewEmptyStatement(nopos), throw_call,
+        nopos);
   }
 
-  statements->Add(get_return, zone);
-  statements->Add(check_return, zone);
-  statements->Add(call_return, zone);
-  statements->Add(validate_output, zone);
+  statements->Add(get_return, zone());
+  statements->Add(check_return, zone());
+  statements->Add(call_return, zone());
+  statements->Add(validate_output, zone());
 }
 
-void ParserTraits::FinalizeIteratorUse(Variable* completion,
-                                       Expression* condition, Variable* iter,
-                                       Block* iterator_use, Block* target) {
+void Parser::FinalizeIteratorUse(Variable* completion, Expression* condition,
+                                 Variable* iter, Block* iterator_use,
+                                 Block* target) {
   //
   // This function adds two statements to [target], corresponding to the
   // following code:
   //
   //   completion = kNormalCompletion;
   //   try {
   //     try {
   //       iterator_use
   //     } catch(e) {
   //       if (completion === kAbruptCompletion) completion = kThrowCompletion;
   //       %ReThrow(e);
   //     }
   //   } finally {
   //     if (condition) {
   //       #BuildIteratorCloseForCompletion(iter, completion)
   //     }
   //   }
   //
 
   const int nopos = kNoSourcePosition;
-  auto factory = parser_->factory();
-  auto avfactory = parser_->ast_value_factory();
-  auto scope = parser_->scope();
-  auto zone = parser_->zone();
 
   // completion = kNormalCompletion;
   Statement* initialize_completion;
   {
-    Expression* proxy = factory->NewVariableProxy(completion);
-    Expression* assignment = factory->NewAssignment(
+    Expression* proxy = factory()->NewVariableProxy(completion);
+    Expression* assignment = factory()->NewAssignment(
         Token::ASSIGN, proxy,
-        factory->NewSmiLiteral(Parser::kNormalCompletion, nopos), nopos);
-    initialize_completion = factory->NewExpressionStatement(assignment, nopos);
+        factory()->NewSmiLiteral(Parser::kNormalCompletion, nopos), nopos);
+    initialize_completion =
+        factory()->NewExpressionStatement(assignment, nopos);
   }
 
   // if (completion === kAbruptCompletion) completion = kThrowCompletion;
   Statement* set_completion_throw;
   {
-    Expression* condition = factory->NewCompareOperation(
-        Token::EQ_STRICT, factory->NewVariableProxy(completion),
-        factory->NewSmiLiteral(Parser::kAbruptCompletion, nopos), nopos);
+    Expression* condition = factory()->NewCompareOperation(
+        Token::EQ_STRICT, factory()->NewVariableProxy(completion),
+        factory()->NewSmiLiteral(Parser::kAbruptCompletion, nopos), nopos);
 
-    Expression* proxy = factory->NewVariableProxy(completion);
-    Expression* assignment = factory->NewAssignment(
+    Expression* proxy = factory()->NewVariableProxy(completion);
+    Expression* assignment = factory()->NewAssignment(
         Token::ASSIGN, proxy,
-        factory->NewSmiLiteral(Parser::kThrowCompletion, nopos), nopos);
-    Statement* statement = factory->NewExpressionStatement(assignment, nopos);
-    set_completion_throw = factory->NewIfStatement(
-        condition, statement, factory->NewEmptyStatement(nopos), nopos);
+        factory()->NewSmiLiteral(Parser::kThrowCompletion, nopos), nopos);
+    Statement* statement = factory()->NewExpressionStatement(assignment, nopos);
+    set_completion_throw = factory()->NewIfStatement(
+        condition, statement, factory()->NewEmptyStatement(nopos), nopos);
   }
 
   // if (condition) {
   //   #BuildIteratorCloseForCompletion(iter, completion)
   // }
   Block* maybe_close;
   {
-    Block* block = factory->NewBlock(nullptr, 2, true, nopos);
-    Expression* proxy = factory->NewVariableProxy(completion);
-    parser_->BuildIteratorCloseForCompletion(block->statements(), iter, proxy);
+    Block* block = factory()->NewBlock(nullptr, 2, true, nopos);
+    Expression* proxy = factory()->NewVariableProxy(completion);
+    BuildIteratorCloseForCompletion(block->statements(), iter, proxy);
     DCHECK(block->statements()->length() == 2);
 
-    maybe_close = factory->NewBlock(nullptr, 1, true, nopos);
+    maybe_close = factory()->NewBlock(nullptr, 1, true, nopos);
     maybe_close->statements()->Add(
-        factory->NewIfStatement(condition, block,
-                                factory->NewEmptyStatement(nopos), nopos),
-        zone);
+        factory()->NewIfStatement(condition, block,
+                                  factory()->NewEmptyStatement(nopos), nopos),
+        zone());
   }
 
   // try { #try_block }
   // catch(e) {
   //   #set_completion_throw;
   //   %ReThrow(e);
   // }
   Statement* try_catch;
   {
-    Scope* catch_scope = parser_->NewScopeWithParent(scope, CATCH_SCOPE);
+    Scope* catch_scope = NewScopeWithParent(scope(), CATCH_SCOPE);
     Variable* catch_variable =
-        catch_scope->DeclareLocal(avfactory->dot_catch_string(), VAR,
+        catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(), VAR,
                                   kCreatedInitialized, Variable::NORMAL);
     catch_scope->set_is_hidden();
 
     Statement* rethrow;
     // We use %ReThrow rather than the ordinary throw because we want to
     // preserve the original exception message.  This is also why we create a
     // TryCatchStatementForReThrow below (which does not clear the pending
     // message), rather than a TryCatchStatement.
     {
-      auto args = new (zone) ZoneList<Expression*>(1, zone);
-      args->Add(factory->NewVariableProxy(catch_variable), zone);
-      rethrow = factory->NewExpressionStatement(
-          factory->NewCallRuntime(Runtime::kReThrow, args, nopos), nopos);
+      auto args = new (zone()) ZoneList<Expression*>(1, zone());
+      args->Add(factory()->NewVariableProxy(catch_variable), zone());
+      rethrow = factory()->NewExpressionStatement(
+          factory()->NewCallRuntime(Runtime::kReThrow, args, nopos), nopos);
     }
 
-    Block* catch_block = factory->NewBlock(nullptr, 2, false, nopos);
-    catch_block->statements()->Add(set_completion_throw, zone);
-    catch_block->statements()->Add(rethrow, zone);
+    Block* catch_block = factory()->NewBlock(nullptr, 2, false, nopos);
+    catch_block->statements()->Add(set_completion_throw, zone());
+    catch_block->statements()->Add(rethrow, zone());
 
-    try_catch = factory->NewTryCatchStatementForReThrow(
+    try_catch = factory()->NewTryCatchStatementForReThrow(
         iterator_use, catch_scope, catch_variable, catch_block, nopos);
   }
 
   // try { #try_catch } finally { #maybe_close }
   Statement* try_finally;
   {
-    Block* try_block = factory->NewBlock(nullptr, 1, false, nopos);
-    try_block->statements()->Add(try_catch, zone);
+    Block* try_block = factory()->NewBlock(nullptr, 1, false, nopos);
+    try_block->statements()->Add(try_catch, zone());
 
     try_finally =
-        factory->NewTryFinallyStatement(try_block, maybe_close, nopos);
+        factory()->NewTryFinallyStatement(try_block, maybe_close, nopos);
   }
 
-  target->statements()->Add(initialize_completion, zone);
-  target->statements()->Add(try_finally, zone);
+  target->statements()->Add(initialize_completion, zone());
+  target->statements()->Add(try_finally, zone());
 }
 
-void ParserTraits::BuildIteratorCloseForCompletion(
-    ZoneList<Statement*>* statements, Variable* iterator,
-    Expression* completion) {
+void Parser::BuildIteratorCloseForCompletion(ZoneList<Statement*>* statements,
+                                             Variable* iterator,
+                                             Expression* completion) {
   //
   // This function adds two statements to [statements], corresponding to the
   // following code:
   //
   //   let iteratorReturn = iterator.return;
   //   if (!IS_NULL_OR_UNDEFINED(iteratorReturn)) {
   //     if (completion === kThrowCompletion) {
   //       if (!IS_CALLABLE(iteratorReturn)) {
   //         throw MakeTypeError(kReturnMethodNotCallable);
   //       }
   //       try { %_Call(iteratorReturn, iterator) } catch (_) { }
   //     } else {
   //       let output = %_Call(iteratorReturn, iterator);
   //       if (!IS_RECEIVER(output)) {
   //         %ThrowIterResultNotAnObject(output);
   //       }
   //     }
   //   }
   //
 
   const int nopos = kNoSourcePosition;
-  auto factory = parser_->factory();
-  auto avfactory = parser_->ast_value_factory();
-  auto zone = parser_->zone();
-
-
   // let iteratorReturn = iterator.return;
-  Variable* var_return = parser_->NewTemporary(avfactory->empty_string());
+  Variable* var_return = NewTemporary(ast_value_factory()->empty_string());
   Statement* get_return;
   {
-    Expression* iterator_proxy = factory->NewVariableProxy(iterator);
-    Expression* literal =
-        factory->NewStringLiteral(avfactory->return_string(), nopos);
+    Expression* iterator_proxy = factory()->NewVariableProxy(iterator);
+    Expression* literal = factory()->NewStringLiteral(
+        ast_value_factory()->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);
-    get_return = factory->NewExpressionStatement(assignment, nopos);
+        factory()->NewProperty(iterator_proxy, literal, nopos);
+    Expression* return_proxy = factory()->NewVariableProxy(var_return);
+    Expression* assignment =
+        factory()->NewAssignment(Token::ASSIGN, return_proxy, property, nopos);
+    get_return = factory()->NewExpressionStatement(assignment, nopos);
   }
 
   // if (!IS_CALLABLE(iteratorReturn)) {
   //   throw MakeTypeError(kReturnMethodNotCallable);
   // }
   Statement* check_return_callable;
   {
-    Expression* throw_expr = NewThrowTypeError(
-        MessageTemplate::kReturnMethodNotCallable,
-        avfactory->empty_string(), nopos);
+    Expression* throw_expr =
+        NewThrowTypeError(MessageTemplate::kReturnMethodNotCallable,
+                          ast_value_factory()->empty_string(), nopos);
     check_return_callable = CheckCallable(var_return, throw_expr, nopos);
   }
 
   // try { %_Call(iteratorReturn, iterator) } catch (_) { }
   Statement* try_call_return;
   {
-    auto args = new (zone) ZoneList<Expression*>(2, zone);
-    args->Add(factory->NewVariableProxy(var_return), zone);
-    args->Add(factory->NewVariableProxy(iterator), zone);
+    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);
+        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* 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);
+    Block* catch_block = factory()->NewBlock(nullptr, 0, false, nopos);
 
     Scope* catch_scope = NewScope(CATCH_SCOPE);
-    Variable* catch_variable = catch_scope->DeclareLocal(
-        avfactory->dot_catch_string(), VAR, kCreatedInitialized,
-        Variable::NORMAL);
+    Variable* catch_variable =
+        catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(), VAR,
+                                  kCreatedInitialized, Variable::NORMAL);
     catch_scope->set_is_hidden();
 
-    try_call_return = factory->NewTryCatchStatement(
+    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 = parser_->NewTemporary(avfactory->empty_string());
+    Variable* var_output = NewTemporary(ast_value_factory()->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);
+      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);
+          factory()->NewCallRuntime(Runtime::kInlineCall, args, nopos);
 
-      Expression* output_proxy = factory->NewVariableProxy(var_output);
+      Expression* output_proxy = factory()->NewVariableProxy(var_output);
       Expression* assignment =
-          factory->NewAssignment(Token::ASSIGN, output_proxy, call, nopos);
-      call_return = factory->NewExpressionStatement(assignment, nopos);
+          factory()->NewAssignment(Token::ASSIGN, output_proxy, call, nopos);
+      call_return = factory()->NewExpressionStatement(assignment, nopos);
     }
 
     Expression* is_receiver_call;
     {
-      auto args = new (zone) ZoneList<Expression*>(1, zone);
-      args->Add(factory->NewVariableProxy(var_output), zone);
+      auto args = new (zone()) ZoneList<Expression*>(1, zone());
+      args->Add(factory()->NewVariableProxy(var_output), zone());
       is_receiver_call =
-          factory->NewCallRuntime(Runtime::kInlineIsJSReceiver, args, nopos);
+          factory()->NewCallRuntime(Runtime::kInlineIsJSReceiver, args, nopos);
     }
 
     Statement* throw_call;
     {
-      auto args = new (zone) ZoneList<Expression*>(1, zone);
-      args->Add(factory->NewVariableProxy(var_output), zone);
-      Expression* call = factory->NewCallRuntime(
+      auto args = new (zone()) ZoneList<Expression*>(1, zone());
+      args->Add(factory()->NewVariableProxy(var_output), zone());
+      Expression* call = factory()->NewCallRuntime(
           Runtime::kThrowIteratorResultNotAnObject, args, nopos);
-      throw_call = factory->NewExpressionStatement(call, nopos);
+      throw_call = factory()->NewExpressionStatement(call, nopos);
     }
 
-    Statement* check_return = factory->NewIfStatement(
-        is_receiver_call, factory->NewEmptyStatement(nopos), throw_call, nopos);
+    Statement* check_return = factory()->NewIfStatement(
+        is_receiver_call, factory()->NewEmptyStatement(nopos), throw_call,
+        nopos);
 
-    validate_return = factory->NewBlock(nullptr, 2, false, nopos);
-    validate_return->statements()->Add(call_return, zone);
-    validate_return->statements()->Add(check_return, zone);
+    validate_return = factory()->NewBlock(nullptr, 2, false, nopos);
+    validate_return->statements()->Add(call_return, zone());
+    validate_return->statements()->Add(check_return, zone());
   }
 
   // if (completion === kThrowCompletion) {
   //   #check_return_callable;
   //   #try_call_return;
   // } else {
   //   #validate_return;
   // }
   Statement* call_return_carefully;
   {
-    Expression* condition = factory->NewCompareOperation(
+    Expression* condition = factory()->NewCompareOperation(
         Token::EQ_STRICT, completion,
-        factory->NewSmiLiteral(Parser::kThrowCompletion, nopos), nopos);
+        factory()->NewSmiLiteral(Parser::kThrowCompletion, nopos), nopos);
 
-    Block* then_block = factory->NewBlock(nullptr, 2, false, nopos);
-    then_block->statements()->Add(check_return_callable, zone);
-    then_block->statements()->Add(try_call_return, zone);
+    Block* then_block = factory()->NewBlock(nullptr, 2, false, nopos);
+    then_block->statements()->Add(check_return_callable, zone());
+    then_block->statements()->Add(try_call_return, zone());
 
-    call_return_carefully =
-        factory->NewIfStatement(condition, then_block, validate_return, nopos);
+    call_return_carefully = factory()->NewIfStatement(condition, then_block,
+                                                      validate_return, nopos);
   }
 
   // if (!IS_NULL_OR_UNDEFINED(iteratorReturn)) { ... }
   Statement* maybe_call_return;
   {
-    Expression* condition = factory->NewCompareOperation(
-        Token::EQ, factory->NewVariableProxy(var_return),
-        factory->NewNullLiteral(nopos), nopos);
+    Expression* condition = factory()->NewCompareOperation(
+        Token::EQ, factory()->NewVariableProxy(var_return),
+        factory()->NewNullLiteral(nopos), nopos);
 
-    maybe_call_return =
-        factory->NewIfStatement(condition, factory->NewEmptyStatement(nopos),
-                                call_return_carefully, nopos);
+    maybe_call_return = factory()->NewIfStatement(
+        condition, factory()->NewEmptyStatement(nopos), call_return_carefully,
+        nopos);
   }
 
-
-  statements->Add(get_return, zone);
-  statements->Add(maybe_call_return, zone);
+  statements->Add(get_return, zone());
+  statements->Add(maybe_call_return, zone());
 }
 
-Statement* ParserTraits::FinalizeForOfStatement(ForOfStatement* loop,
-                                                Variable* var_completion,
-                                                int pos) {
+Statement* Parser::FinalizeForOfStatement(ForOfStatement* loop,
+                                          Variable* var_completion, int pos) {
   //
   // This function replaces the loop with the following wrapping:
   //
   //   completion = kNormalCompletion;
   //   try {
   //     try {
   //       #loop;
   //     } catch(e) {
   //       if (completion === kAbruptCompletion) completion = kThrowCompletion;
   //       %ReThrow(e);
   //     }
   //   } finally {
   //     if (!(completion === kNormalCompletion || IS_UNDEFINED(#iterator))) {
   //       #BuildIteratorCloseForCompletion(#iterator, completion)
   //     }
   //   }
   //
   // Note that the loop's body and its assign_each already contain appropriate
   // assignments to completion (see InitializeForOfStatement).
   //
 
   const int nopos = kNoSourcePosition;
-  auto factory = parser_->factory();
-  auto zone = parser_->zone();
 
   // !(completion === kNormalCompletion || IS_UNDEFINED(#iterator))
   Expression* closing_condition;
   {
-    Expression* lhs = factory->NewCompareOperation(
-        Token::EQ_STRICT, factory->NewVariableProxy(var_completion),
-        factory->NewSmiLiteral(Parser::kNormalCompletion, nopos), nopos);
-    Expression* rhs = factory->NewCompareOperation(
-        Token::EQ_STRICT, factory->NewVariableProxy(loop->iterator()),
-        factory->NewUndefinedLiteral(nopos), nopos);
-    closing_condition = factory->NewUnaryOperation(
-        Token::NOT, factory->NewBinaryOperation(Token::OR, lhs, rhs, nopos),
+    Expression* lhs = factory()->NewCompareOperation(
+        Token::EQ_STRICT, factory()->NewVariableProxy(var_completion),
+        factory()->NewSmiLiteral(Parser::kNormalCompletion, nopos), nopos);
+    Expression* rhs = factory()->NewCompareOperation(
+        Token::EQ_STRICT, factory()->NewVariableProxy(loop->iterator()),
+        factory()->NewUndefinedLiteral(nopos), nopos);
+    closing_condition = factory()->NewUnaryOperation(
+        Token::NOT, factory()->NewBinaryOperation(Token::OR, lhs, rhs, nopos),
         nopos);
   }
 
-  Block* final_loop = factory->NewBlock(nullptr, 2, false, nopos);
+  Block* final_loop = factory()->NewBlock(nullptr, 2, false, nopos);
   {
-    Block* try_block = factory->NewBlock(nullptr, 1, false, nopos);
-    try_block->statements()->Add(loop, zone);
+    Block* try_block = factory()->NewBlock(nullptr, 1, false, nopos);
+    try_block->statements()->Add(loop, zone());
 
     FinalizeIteratorUse(var_completion, closing_condition, loop->iterator(),
                         try_block, final_loop);
   }
 
   return final_loop;
 }
 
 #ifdef DEBUG
 void Parser::Print(AstNode* node) {
   ast_value_factory()->Internalize(Isolate::Current());
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8