Parser cleanup: less member variables.

src/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/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 248 matching lines @@
   } else {
     DCHECK(info_->cached_data() != NULL);
     if (compile_options() == ScriptCompiler::kConsumeParserCache) {
       cached_parse_data_ = new ParseData(*info_->cached_data());
     }
   }
 }
 
 
 Scope* Parser::NewScope(Scope* parent, ScopeType scope_type) {
-  DCHECK(ast_value_factory_);
+  DCHECK(ast_value_factory());
   Scope* result =
-      new (zone()) Scope(parent, scope_type, ast_value_factory_, zone());
+      new (zone()) Scope(parent, scope_type, ast_value_factory(), zone());
   result->Initialize();
   return result;
 }
 
 
 // ----------------------------------------------------------------------------
 // Target is a support class to facilitate manipulation of the
 // Parser's target_stack_ (the stack of potential 'break' and
 // 'continue' statement targets). Upon construction, a new target is
 // added; it is removed upon destruction.
@@ skipping 72 matching lines @@
     *parser_->ast_node_id_gen_ = saved_ast_node_id_gen_;
   }
 
  private:
   ParserBase<ParserTraits>* parser_;
   AstNode::IdGen saved_ast_node_id_gen_;
 };
 
 
 bool ParserTraits::IsEvalOrArguments(const AstRawString* identifier) const {
-  return identifier == parser_->ast_value_factory_->eval_string() ||
-         identifier == parser_->ast_value_factory_->arguments_string();
+  return identifier == parser_->ast_value_factory()->eval_string() ||
+         identifier == parser_->ast_value_factory()->arguments_string();
 }
 
 
 bool ParserTraits::IsThisProperty(Expression* expression) {
   DCHECK(expression != NULL);
   Property* property = expression->AsProperty();
   return property != NULL &&
       property->obj()->AsVariableProxy() != NULL &&
       property->obj()->AsVariableProxy()->is_this();
 }
 
 
 bool ParserTraits::IsIdentifier(Expression* expression) {
   VariableProxy* operand = expression->AsVariableProxy();
   return operand != NULL && !operand->is_this();
 }
 
 
 void ParserTraits::PushPropertyName(FuncNameInferrer* fni,
                                     Expression* expression) {
   if (expression->IsPropertyName()) {
     fni->PushLiteralName(expression->AsLiteral()->AsRawPropertyName());
   } else {
     fni->PushLiteralName(
-        parser_->ast_value_factory_->anonymous_function_string());
+        parser_->ast_value_factory()->anonymous_function_string());
   }
 }
 
 
 void ParserTraits::CheckAssigningFunctionLiteralToProperty(Expression* left,
                                                            Expression* right) {
   DCHECK(left != NULL);
   if (left->AsProperty() != NULL &&
       right->AsFunctionLiteral() != NULL) {
     right->AsFunctionLiteral()->set_pretenure();
   }
 }
 
 
 void ParserTraits::CheckPossibleEvalCall(Expression* expression,
                                          Scope* scope) {
   VariableProxy* callee = expression->AsVariableProxy();
   if (callee != NULL &&
-      callee->raw_name() == parser_->ast_value_factory_->eval_string()) {
+      callee->raw_name() == parser_->ast_value_factory()->eval_string()) {
     scope->DeclarationScope()->RecordEvalCall();
   }
 }
 
 
 Expression* ParserTraits::MarkExpressionAsAssigned(Expression* expression) {
   VariableProxy* proxy =
       expression != NULL ? expression->AsVariableProxy() : NULL;
   if (proxy != NULL) proxy->set_is_assigned();
   return expression;
@@ skipping 99 matching lines @@
   if (op == Token::BIT_NOT) {
     return factory->NewBinaryOperation(
         Token::BIT_XOR, expression, factory->NewNumberLiteral(~0, pos), pos);
   }
   return factory->NewUnaryOperation(op, expression, pos);
 }
 
 
 Expression* ParserTraits::NewThrowReferenceError(const char* message, int pos) {
   return NewThrowError(
-      parser_->ast_value_factory_->make_reference_error_string(), message, NULL,
-      pos);
+      parser_->ast_value_factory()->make_reference_error_string(), message,
+      NULL, pos);
 }
 
 
 Expression* ParserTraits::NewThrowSyntaxError(
     const char* message, const AstRawString* arg, int pos) {
-  return NewThrowError(parser_->ast_value_factory_->make_syntax_error_string(),
+  return NewThrowError(parser_->ast_value_factory()->make_syntax_error_string(),
                        message, arg, pos);
 }
 
 
 Expression* ParserTraits::NewThrowTypeError(
     const char* message, const AstRawString* arg, int pos) {
-  return NewThrowError(parser_->ast_value_factory_->make_type_error_string(),
+  return NewThrowError(parser_->ast_value_factory()->make_type_error_string(),
                        message, arg, pos);
 }
 
 
 Expression* ParserTraits::NewThrowError(
     const AstRawString* constructor, const char* message,
     const AstRawString* arg, int pos) {
   Zone* zone = parser_->zone();
   int argc = arg != NULL ? 1 : 0;
   const AstRawString* type =
-      parser_->ast_value_factory_->GetOneByteString(message);
+      parser_->ast_value_factory()->GetOneByteString(message);
   ZoneList<const AstRawString*>* array =
       new (zone) ZoneList<const AstRawString*>(argc, zone);
   if (arg != NULL) {
     array->Add(arg, zone);
   }
   ZoneList<Expression*>* args = new (zone) ZoneList<Expression*>(2, zone);
   args->Add(parser_->factory()->NewStringLiteral(type, pos), zone);
   args->Add(parser_->factory()->NewStringListLiteral(array, pos), zone);
   CallRuntime* call_constructor =
       parser_->factory()->NewCallRuntime(constructor, NULL, args, pos);
@@ skipping 50 matching lines @@
   parser_->pending_error_location_ = source_location;
   parser_->pending_error_message_ = message;
   parser_->pending_error_char_arg_ = NULL;
   parser_->pending_error_arg_ = arg;
   parser_->pending_error_is_reference_error_ = is_reference_error;
 }
 
 
 const AstRawString* ParserTraits::GetSymbol(Scanner* scanner) {
   const AstRawString* result =
-      parser_->scanner()->CurrentSymbol(parser_->ast_value_factory_);
+      parser_->scanner()->CurrentSymbol(parser_->ast_value_factory());
   DCHECK(result != NULL);
   return result;
 }
 
 
 const AstRawString* ParserTraits::GetNumberAsSymbol(Scanner* scanner) {
   double double_value = parser_->scanner()->DoubleValue();
   char array[100];
   const char* string =
       DoubleToCString(double_value, Vector<char>(array, arraysize(array)));
   return ast_value_factory()->GetOneByteString(string);
 }
 
 
 const AstRawString* ParserTraits::GetNextSymbol(Scanner* scanner) {
-  return parser_->scanner()->NextSymbol(parser_->ast_value_factory_);
+  return parser_->scanner()->NextSymbol(parser_->ast_value_factory());
 }
 
 
 Expression* ParserTraits::ThisExpression(
     Scope* scope, AstNodeFactory<AstConstructionVisitor>* factory, int pos) {
   return factory->NewVariableProxy(scope->receiver(), pos);
 }
 
 Expression* ParserTraits::SuperReference(
     Scope* scope, AstNodeFactory<AstConstructionVisitor>* factory, int pos) {
@@ skipping 84 matching lines @@
                                        name_is_strict_reserved, is_generator,
                                        function_token_position, type,
                                        arity_restriction, ok);
 }
 
 
 Parser::Parser(CompilationInfo* info, ParseInfo* parse_info)
     : ParserBase<ParserTraits>(&scanner_, parse_info->stack_limit,
                                info->extension(), NULL, info->zone(),
                                info->ast_node_id_gen(), this),
-      isolate_(info->isolate()),
-      script_(info->script()),
       scanner_(parse_info->unicode_cache),
       reusable_preparser_(NULL),
       original_scope_(NULL),
       target_stack_(NULL),
       cached_parse_data_(NULL),
-      ast_value_factory_(info->ast_value_factory()),
       info_(info),
       has_pending_error_(false),
       pending_error_message_(NULL),
       pending_error_arg_(NULL),
       pending_error_char_arg_(NULL),
       total_preparse_skipped_(0),
       pre_parse_timer_(NULL) {
-  DCHECK(!script_.is_null());
+  DCHECK(!script().is_null());
   set_allow_harmony_scoping(!info->is_native() && FLAG_harmony_scoping);
   set_allow_modules(!info->is_native() && FLAG_harmony_modules);
   set_allow_natives_syntax(FLAG_allow_natives_syntax || info->is_native());
   set_allow_lazy(false);  // Must be explicitly enabled.
   set_allow_generators(FLAG_harmony_generators);
   set_allow_arrow_functions(FLAG_harmony_arrow_functions);
   set_allow_harmony_numeric_literals(FLAG_harmony_numeric_literals);
   set_allow_classes(FLAG_harmony_classes);
   for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount;
        ++feature) {
     use_counts_[feature] = 0;
   }
-  if (ast_value_factory_ == NULL) {
-    ast_value_factory_ = new AstValueFactory(zone(), parse_info->hash_seed);
+  if (info->ast_value_factory() == NULL) {
+    // info takes ownership of AstValueFactory.
+    info->SetAstValueFactory(new stValueFactory(zone(), parse_info->hash_seed));
   }
 }
 
 
 FunctionLiteral* Parser::ParseProgram() {
   // TODO(bmeurer): We temporarily need to pass allow_nesting = true here,
   // see comment for HistogramTimerScope class.
 
   // It's OK to use the counters here, since this function is only called in
   // the main thread.
   HistogramTimerScope timer_scope(isolate()->counters()->parse(), true);
-  Handle<String> source(String::cast(script_->source()));
+  Handle<String> source(String::cast(script()->source()));
   isolate()->counters()->total_parse_size()->Increment(source->length());
   base::ElapsedTimer timer;
   if (FLAG_trace_parse) {
     timer.Start();
   }
-  fni_ = new(zone()) FuncNameInferrer(ast_value_factory_, zone());
+  fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
 
   // Initialize parser state.
   CompleteParserRecorder recorder;
 
   if (compile_options() == ScriptCompiler::kProduceParserCache) {
     log_ = &recorder;
   } else if (compile_options() == ScriptCompiler::kConsumeParserCache) {
     cached_parse_data_->Initialize();
   }
 
@@ skipping 42 matching lines @@
 
   FunctionLiteral* result = NULL;
   { Scope* scope = NewScope(scope_, GLOBAL_SCOPE);
     info->SetGlobalScope(scope);
     if (!info->context().is_null() && !info->context()->IsNativeContext()) {
       scope = Scope::DeserializeScopeChain(*info->context(), scope, zone());
       // The Scope is backed up by ScopeInfo (which is in the V8 heap); this
       // means the Parser cannot operate independent of the V8 heap. Tell the
       // string table to internalize strings and values right after they're
       // created.
-      ast_value_factory_->Internalize(isolate());
+      ast_value_factory()->Internalize(isolate());
     }
     original_scope_ = scope;
     if (info->is_eval()) {
       if (!scope->is_global_scope() || info->strict_mode() == STRICT) {
         scope = NewScope(scope, EVAL_SCOPE);
       }
     } else if (info->is_global()) {
       scope = NewScope(scope, GLOBAL_SCOPE);
     }
     scope->set_start_position(0);
     scope->set_end_position(source->length());
 
     // Compute the parsing mode.
     Mode mode = (FLAG_lazy && allow_lazy()) ? PARSE_LAZILY : PARSE_EAGERLY;
     if (allow_natives_syntax() ||
         extension_ != NULL ||
         scope->is_eval_scope()) {
       mode = PARSE_EAGERLY;
     }
     ParsingModeScope parsing_mode(this, mode);
 
     // Enters 'scope'.
     FunctionState function_state(&function_state_, &scope_, scope, zone(),
-                                 ast_value_factory_, info->ast_node_id_gen());
+                                 ast_value_factory(), info->ast_node_id_gen());
 
     scope_->SetStrictMode(info->strict_mode());
     ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16, zone());
     bool ok = true;
     int beg_pos = scanner()->location().beg_pos;
     ParseSourceElements(body, Token::EOS, info->is_eval(), true, &ok);
 
     if (ok && strict_mode() == STRICT) {
       CheckOctalLiteral(beg_pos, scanner()->location().end_pos, &ok);
     }
 
     if (ok && allow_harmony_scoping() && strict_mode() == STRICT) {
       CheckConflictingVarDeclarations(scope_, &ok);
     }
 
     if (ok && info->parse_restriction() == ONLY_SINGLE_FUNCTION_LITERAL) {
       if (body->length() != 1 ||
           !body->at(0)->IsExpressionStatement() ||
           !body->at(0)->AsExpressionStatement()->
               expression()->IsFunctionLiteral()) {
         ReportMessage("single_function_literal");
         ok = false;
       }
     }
 
     if (ok) {
       result = factory()->NewFunctionLiteral(
-          ast_value_factory_->empty_string(), ast_value_factory_, scope_, body,
-          function_state.materialized_literal_count(),
+          ast_value_factory()->empty_string(), ast_value_factory(), scope_,
+          body, function_state.materialized_literal_count(),
           function_state.expected_property_count(),
           function_state.handler_count(), 0,
           FunctionLiteral::kNoDuplicateParameters,
           FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::kGlobalOrEval,
           FunctionLiteral::kNotParenthesized, FunctionLiteral::kNormalFunction,
           0);
       result->set_ast_properties(factory()->visitor()->ast_properties());
       result->set_dont_optimize_reason(
           factory()->visitor()->dont_optimize_reason());
     }
   }
 
   // Make sure the target stack is empty.
   DCHECK(target_stack_ == NULL);
 
   return result;
 }
 
 
 FunctionLiteral* Parser::ParseLazy() {
   // It's OK to use the counters here, since this function is only called in
   // the main thread.
   HistogramTimerScope timer_scope(isolate()->counters()->parse_lazy());
-  Handle<String> source(String::cast(script_->source()));
+  Handle<String> source(String::cast(script()->source()));
   isolate()->counters()->total_parse_size()->Increment(source->length());
   base::ElapsedTimer timer;
   if (FLAG_trace_parse) {
     timer.Start();
   }
   Handle<SharedFunctionInfo> shared_info = info()->shared_info();
 
   // Initialize parser state.
   source = String::Flatten(source);
   FunctionLiteral* result;
@@ skipping 19 matching lines @@
 }
 
 
 FunctionLiteral* Parser::ParseLazy(Utf16CharacterStream* source) {
   Handle<SharedFunctionInfo> shared_info = info()->shared_info();
   scanner_.Initialize(source);
   DCHECK(scope_ == NULL);
   DCHECK(target_stack_ == NULL);
 
   Handle<String> name(String::cast(shared_info->name()));
-  DCHECK(ast_value_factory_);
-  fni_ = new(zone()) FuncNameInferrer(ast_value_factory_, zone());
-  const AstRawString* raw_name = ast_value_factory_->GetString(name);
+  DCHECK(ast_value_factory());
+  fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
+  const AstRawString* raw_name = ast_value_factory()->GetString(name);
   fni_->PushEnclosingName(raw_name);
 
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
 
   // Place holder for the result.
   FunctionLiteral* result = NULL;
 
   {
     // Parse the function literal.
     Scope* scope = NewScope(scope_, GLOBAL_SCOPE);
     info()->SetGlobalScope(scope);
     if (!info()->closure().is_null()) {
       scope = Scope::DeserializeScopeChain(info()->closure()->context(), scope,
                                            zone());
     }
     original_scope_ = scope;
     FunctionState function_state(&function_state_, &scope_, scope, zone(),
-                                 ast_value_factory_, info()->ast_node_id_gen());
+                                 ast_value_factory(),
+                                 info()->ast_node_id_gen());
     DCHECK(scope->strict_mode() == SLOPPY || info()->strict_mode() == STRICT);
     DCHECK(info()->strict_mode() == shared_info->strict_mode());
     scope->SetStrictMode(shared_info->strict_mode());
     FunctionLiteral::FunctionType function_type = shared_info->is_expression()
         ? (shared_info->is_anonymous()
               ? FunctionLiteral::ANONYMOUS_EXPRESSION
               : FunctionLiteral::NAMED_EXPRESSION)
         : FunctionLiteral::DECLARATION;
     bool is_generator = shared_info->is_generator();
     bool ok = true;
@@ skipping 64 matching lines @@
       ExpressionStatement* e_stat;
       Literal* literal;
       // Still processing directive prologue?
       if ((e_stat = stat->AsExpressionStatement()) != NULL &&
           (literal = e_stat->expression()->AsLiteral()) != NULL &&
           literal->raw_value()->IsString()) {
         // Check "use strict" directive (ES5 14.1) and "use asm" directive. Only
         // one can be present.
         if (strict_mode() == SLOPPY &&
             literal->raw_value()->AsString() ==
-                ast_value_factory_->use_strict_string() &&
+                ast_value_factory()->use_strict_string() &&
             token_loc.end_pos - token_loc.beg_pos ==
-                ast_value_factory_->use_strict_string()->length() + 2) {
+                ast_value_factory()->use_strict_string()->length() + 2) {
           // TODO(mstarzinger): Global strict eval calls, need their own scope
           // as specified in ES5 10.4.2(3). The correct fix would be to always
           // add this scope in DoParseProgram(), but that requires adaptations
           // all over the code base, so we go with a quick-fix for now.
           // In the same manner, we have to patch the parsing mode.
           if (is_eval && !scope_->is_eval_scope()) {
             DCHECK(scope_->is_global_scope());
             Scope* scope = NewScope(scope_, EVAL_SCOPE);
             scope->set_start_position(scope_->start_position());
             scope->set_end_position(scope_->end_position());
             scope_ = scope;
             mode_ = PARSE_EAGERLY;
           }
           scope_->SetStrictMode(STRICT);
           // "use strict" is the only directive for now.
           directive_prologue = false;
         } else if (literal->raw_value()->AsString() ==
-                       ast_value_factory_->use_asm_string() &&
+                       ast_value_factory()->use_asm_string() &&
                    token_loc.end_pos - token_loc.beg_pos ==
-                       ast_value_factory_->use_asm_string()->length() + 2) {
+                       ast_value_factory()->use_asm_string()->length() + 2) {
           // Store the usage count; The actual use counter on the isolate is
           // incremented after parsing is done.
           ++use_counts_[v8::Isolate::kUseAsm];
         }
       } else {
         // End of the directive prologue.
         directive_prologue = false;
       }
     }
 
@@ skipping 38 matching lines @@
     default: {
       Statement* stmt = ParseStatement(labels, CHECK_OK);
       // Handle 'module' as a context-sensitive keyword.
       if (FLAG_harmony_modules &&
           peek() == Token::IDENTIFIER &&
           !scanner()->HasAnyLineTerminatorBeforeNext() &&
           stmt != NULL) {
         ExpressionStatement* estmt = stmt->AsExpressionStatement();
         if (estmt != NULL && estmt->expression()->AsVariableProxy() != NULL &&
             estmt->expression()->AsVariableProxy()->raw_name() ==
-                ast_value_factory_->module_string() &&
+                ast_value_factory()->module_string() &&
             !scanner()->literal_contains_escapes()) {
           return ParseModuleDeclaration(NULL, ok);
         }
       }
       return stmt;
     }
   }
 }
 
 
@@ skipping 277 matching lines @@
   Expect(Token::EXPORT, CHECK_OK);
 
   Statement* result = NULL;
   ZoneList<const AstRawString*> names(1, zone());
   switch (peek()) {
     case Token::IDENTIFIER: {
       int pos = position();
       const AstRawString* name =
           ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
       // Handle 'module' as a context-sensitive keyword.
-      if (name != ast_value_factory_->module_string()) {
+      if (name != ast_value_factory()->module_string()) {
         names.Add(name, zone());
         while (peek() == Token::COMMA) {
           Consume(Token::COMMA);
           name = ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
           names.Add(name, zone());
         }
         ExpectSemicolon(CHECK_OK);
         result = factory()->NewEmptyStatement(pos);
       } else {
         result = ParseModuleDeclaration(&names, CHECK_OK);
@@ skipping 756 matching lines @@
 
       if (is_const) {
         arguments->Add(value, zone());
         value = NULL;  // zap the value to avoid the unnecessary assignment
 
         // Construct the call to Runtime_InitializeConstGlobal
         // and add it to the initialization statement block.
         // Note that the function does different things depending on
         // the number of arguments (1 or 2).
         initialize = factory()->NewCallRuntime(
-            ast_value_factory_->initialize_const_global_string(),
-            Runtime::FunctionForId(Runtime::kInitializeConstGlobal),
-            arguments, pos);
+            ast_value_factory()->initialize_const_global_string(),
+            Runtime::FunctionForId(Runtime::kInitializeConstGlobal), arguments,
+            pos);
       } else {
         // Add strict mode.
         // We may want to pass singleton to avoid Literal allocations.
         StrictMode strict_mode = initialization_scope->strict_mode();
         arguments->Add(factory()->NewNumberLiteral(strict_mode, pos), zone());
 
         // Be careful not to assign a value to the global variable if
         // we're in a with. The initialization value should not
         // necessarily be stored in the global object in that case,
         // which is why we need to generate a separate assignment node.
         if (value != NULL && !inside_with()) {
           arguments->Add(value, zone());
           value = NULL;  // zap the value to avoid the unnecessary assignment
           // Construct the call to Runtime_InitializeVarGlobal
           // and add it to the initialization statement block.
           initialize = factory()->NewCallRuntime(
-              ast_value_factory_->initialize_var_global_string(),
+              ast_value_factory()->initialize_var_global_string(),
               Runtime::FunctionForId(Runtime::kInitializeVarGlobal), arguments,
               pos);
         } else {
           initialize = NULL;
         }
       }
 
       if (initialize != NULL) {
         block->AddStatement(factory()->NewExpressionStatement(
                                 initialize, RelocInfo::kNoPosition),
@@ skipping 94 matching lines @@
     // from the top scope. This way, we don't try to resolve it
     // during the scope processing.
     scope_->RemoveUnresolved(var);
     Expect(Token::COLON, CHECK_OK);
     return ParseStatement(labels, ok);
   }
 
   // If we have an extension, we allow a native function declaration.
   // A native function declaration starts with "native function" with
   // no line-terminator between the two words.
-  if (extension_ != NULL &&
-      peek() == Token::FUNCTION &&
-      !scanner()->HasAnyLineTerminatorBeforeNext() &&
-      expr != NULL &&
+  if (extension_ != NULL && peek() == Token::FUNCTION &&
+      !scanner()->HasAnyLineTerminatorBeforeNext() && expr != NULL &&
       expr->AsVariableProxy() != NULL &&
       expr->AsVariableProxy()->raw_name() ==
-          ast_value_factory_->native_string() &&
+          ast_value_factory()->native_string() &&
       !scanner()->literal_contains_escapes()) {
     return ParseNativeDeclaration(ok);
   }
 
   // Parsed expression statement, or the context-sensitive 'module' keyword.
   // Only expect semicolon in the former case.
-  if (!FLAG_harmony_modules ||
-      peek() != Token::IDENTIFIER ||
+  if (!FLAG_harmony_modules || peek() != Token::IDENTIFIER ||
       scanner()->HasAnyLineTerminatorBeforeNext() ||
       expr->AsVariableProxy() == NULL ||
       expr->AsVariableProxy()->raw_name() !=
-          ast_value_factory_->module_string() ||
+          ast_value_factory()->module_string() ||
       scanner()->literal_contains_escapes()) {
     ExpectSemicolon(CHECK_OK);
   }
   return factory()->NewExpressionStatement(expr, pos);
 }
 
 
 IfStatement* Parser::ParseIfStatement(ZoneList<const AstRawString*>* labels,
                                       bool* ok) {
   // IfStatement ::
@@ skipping 401 matching lines @@
 
 
 void Parser::InitializeForEachStatement(ForEachStatement* stmt,
                                         Expression* each,
                                         Expression* subject,
                                         Statement* body) {
   ForOfStatement* for_of = stmt->AsForOfStatement();
 
   if (for_of != NULL) {
     Variable* iterator = scope_->DeclarationScope()->NewTemporary(
-        ast_value_factory_->dot_iterator_string());
+        ast_value_factory()->dot_iterator_string());
     Variable* result = scope_->DeclarationScope()->NewTemporary(
-        ast_value_factory_->dot_result_string());
+        ast_value_factory()->dot_result_string());
 
     Expression* assign_iterator;
     Expression* next_result;
     Expression* result_done;
     Expression* assign_each;
 
     // var iterator = subject[Symbol.iterator]();
     assign_iterator = factory()->NewAssignment(
         Token::ASSIGN, factory()->NewVariableProxy(iterator),
         GetIterator(subject, factory()), RelocInfo::kNoPosition);
 
     // var result = iterator.next();
     {
       Expression* iterator_proxy = factory()->NewVariableProxy(iterator);
       Expression* next_literal = factory()->NewStringLiteral(
-          ast_value_factory_->next_string(), RelocInfo::kNoPosition);
+          ast_value_factory()->next_string(), RelocInfo::kNoPosition);
       Expression* next_property = factory()->NewProperty(
           iterator_proxy, next_literal, RelocInfo::kNoPosition);
       ZoneList<Expression*>* next_arguments =
           new(zone()) ZoneList<Expression*>(0, zone());
       Expression* next_call = factory()->NewCall(
           next_property, next_arguments, RelocInfo::kNoPosition);
       Expression* result_proxy = factory()->NewVariableProxy(result);
       next_result = factory()->NewAssignment(
           Token::ASSIGN, result_proxy, next_call, RelocInfo::kNoPosition);
     }
 
     // result.done
     {
       Expression* done_literal = factory()->NewStringLiteral(
-          ast_value_factory_->done_string(), RelocInfo::kNoPosition);
+          ast_value_factory()->done_string(), RelocInfo::kNoPosition);
       Expression* result_proxy = factory()->NewVariableProxy(result);
       result_done = factory()->NewProperty(
           result_proxy, done_literal, RelocInfo::kNoPosition);
     }
 
     // each = result.value
     {
       Expression* value_literal = factory()->NewStringLiteral(
-          ast_value_factory_->value_string(), RelocInfo::kNoPosition);
+          ast_value_factory()->value_string(), RelocInfo::kNoPosition);
       Expression* result_proxy = factory()->NewVariableProxy(result);
       Expression* result_value = factory()->NewProperty(
           result_proxy, value_literal, RelocInfo::kNoPosition);
       assign_each = factory()->NewAssignment(
           Token::ASSIGN, each, result_value, RelocInfo::kNoPosition);
     }
 
     for_of->Initialize(each, subject, body,
                        assign_iterator,
                        next_result,
@@ skipping 42 matching lines @@
   //  }
 
   DCHECK(names->length() > 0);
   Scope* for_scope = scope_;
   ZoneList<Variable*> temps(names->length(), zone());
 
   Block* outer_block = factory()->NewBlock(NULL, names->length() + 3, false,
                                            RelocInfo::kNoPosition);
   outer_block->AddStatement(init, zone());
 
-  const AstRawString* temp_name = ast_value_factory_->dot_for_string();
+  const AstRawString* temp_name = ast_value_factory()->dot_for_string();
 
   // For each let variable x:
   //   make statement: temp_x = x.
   for (int i = 0; i < names->length(); i++) {
     VariableProxy* proxy =
         NewUnresolved(names->at(i), LET, Interface::NewValue());
     Variable* temp = scope_->DeclarationScope()->NewTemporary(temp_name);
     VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);
     Assignment* assignment = factory()->NewAssignment(
         Token::ASSIGN, temp_proxy, proxy, RelocInfo::kNoPosition);
@@ skipping 177 matching lines @@
         //   <let x' be a temporary variable>
         //   for (x' in e) {
         //     let x;
         //     x = x';
         //     b;
         //   }
 
         // TODO(keuchel): Move the temporary variable to the block scope, after
         // implementing stack allocated block scoped variables.
         Variable* temp = scope_->DeclarationScope()->NewTemporary(
-            ast_value_factory_->dot_for_string());
+            ast_value_factory()->dot_for_string());
         VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);
         ForEachStatement* loop =
             factory()->NewForEachStatement(mode, labels, pos);
         Target target(&this->target_stack_, loop);
 
         // The expression does not see the loop variable.
         scope_ = saved_scope;
         Expression* enumerable = ParseExpression(true, CHECK_OK);
         scope_ = for_scope;
         Expect(Token::RPAREN, CHECK_OK);
@@ skipping 263 matching lines @@
   int pos = function_token_pos == RelocInfo::kNoPosition
       ? peek_position() : function_token_pos;
 
   // Anonymous functions were passed either the empty symbol or a null
   // handle as the function name.  Remember if we were passed a non-empty
   // handle to decide whether to invoke function name inference.
   bool should_infer_name = function_name == NULL;
 
   // We want a non-null handle as the function name.
   if (should_infer_name) {
-    function_name = ast_value_factory_->empty_string();
+    function_name = ast_value_factory()->empty_string();
   }
 
   int num_parameters = 0;
   // Function declarations are function scoped in normal mode, so they are
   // hoisted. In harmony block scoping mode they are block scoped, so they
   // are not hoisted.
   //
   // One tricky case are function declarations in a local sloppy-mode eval:
   // their declaration is hoisted, but they still see the local scope. E.g.,
   //
@@ skipping 33 matching lines @@
   FunctionLiteral::ParameterFlag duplicate_parameters =
       FunctionLiteral::kNoDuplicateParameters;
   FunctionLiteral::IsParenthesizedFlag parenthesized = parenthesized_function_
       ? FunctionLiteral::kIsParenthesized
       : FunctionLiteral::kNotParenthesized;
   AstProperties ast_properties;
   BailoutReason dont_optimize_reason = kNoReason;
   // Parse function body.
   {
     FunctionState function_state(&function_state_, &scope_, scope, zone(),
-                                 ast_value_factory_, info()->ast_node_id_gen());
+                                 ast_value_factory(),
+                                 info()->ast_node_id_gen());
     scope_->SetScopeName(function_name);
 
     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.
       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 = scope_->DeclarationScope()->NewTemporary(
-          ast_value_factory_->dot_generator_object_string());
+          ast_value_factory()->dot_generator_object_string());
       function_state.set_generator_object_variable(temp);
     }
 
     //  FormalParameterList ::
     //    '(' (Identifier)*[','] ')'
     Expect(Token::LPAREN, CHECK_OK);
     scope->set_start_position(scanner()->location().beg_pos);
 
     // We don't yet know if the function will be strict, so we cannot yet
     // produce errors for parameter names or duplicates. However, we remember
@@ skipping 137 matching lines @@
 
     if (allow_harmony_scoping() && strict_mode() == STRICT) {
       CheckConflictingVarDeclarations(scope, CHECK_OK);
     }
   }
 
   FunctionLiteral::KindFlag kind = is_generator
                                        ? FunctionLiteral::kGeneratorFunction
                                        : FunctionLiteral::kNormalFunction;
   FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
-      function_name, ast_value_factory_, scope, body,
+      function_name, ast_value_factory(), scope, body,
       materialized_literal_count, expected_property_count, handler_count,
       num_parameters, duplicate_parameters, function_type,
       FunctionLiteral::kIsFunction, parenthesized, kind, pos);
   function_literal->set_function_token_position(function_token_pos);
   function_literal->set_ast_properties(&ast_properties);
   function_literal->set_dont_optimize_reason(dont_optimize_reason);
 
   if (fni_ != NULL && should_infer_name) fni_->AddFunction(function_literal);
   return function_literal;
 }
@@ skipping 82 matching lines @@
                                  factory()->NewThisFunction(pos),
                                  RelocInfo::kNoPosition),
         RelocInfo::kNoPosition), zone());
   }
 
   // For generators, allocate and yield an iterator on function entry.
   if (is_generator) {
     ZoneList<Expression*>* arguments =
         new(zone()) ZoneList<Expression*>(0, zone());
     CallRuntime* allocation = factory()->NewCallRuntime(
-        ast_value_factory_->empty_string(),
-        Runtime::FunctionForId(Runtime::kCreateJSGeneratorObject),
-        arguments, pos);
+        ast_value_factory()->empty_string(),
+        Runtime::FunctionForId(Runtime::kCreateJSGeneratorObject), arguments,
+        pos);
     VariableProxy* init_proxy = factory()->NewVariableProxy(
         function_state_->generator_object_variable());
     Assignment* assignment = factory()->NewAssignment(
         Token::INIT_VAR, init_proxy, allocation, RelocInfo::kNoPosition);
     VariableProxy* get_proxy = factory()->NewVariableProxy(
         function_state_->generator_object_variable());
     Yield* yield = factory()->NewYield(
         get_proxy, assignment, Yield::kInitial, RelocInfo::kNoPosition);
     body->Add(factory()->NewExpressionStatement(
         yield, RelocInfo::kNoPosition), zone());
@@ skipping 192 matching lines @@
   }
   if (scanner_.source_mapping_url()->length() > 0) {
     Handle<String> source_mapping_url =
         scanner_.source_mapping_url()->Internalize(isolate());
     info_->script()->set_source_mapping_url(*source_mapping_url);
   }
 }
 
 
 void Parser::ThrowPendingError() {
-  DCHECK(ast_value_factory_->IsInternalized());
+  DCHECK(ast_value_factory()->IsInternalized());
   if (has_pending_error_) {
-    MessageLocation location(script_,
-                             pending_error_location_.beg_pos,
+    MessageLocation location(script(), pending_error_location_.beg_pos,
                              pending_error_location_.end_pos);
     Factory* factory = isolate()->factory();
     bool has_arg =
         pending_error_arg_ != NULL || pending_error_char_arg_ != NULL;
     Handle<FixedArray> elements = factory->NewFixedArray(has_arg ? 1 : 0);
     if (pending_error_arg_ != NULL) {
       Handle<String> arg_string = pending_error_arg_->string();
       elements->set(0, *arg_string);
     } else if (pending_error_char_arg_ != NULL) {
       Handle<String> arg_string =
           factory->NewStringFromUtf8(CStrVector(pending_error_char_arg_))
           .ToHandleChecked();
       elements->set(0, *arg_string);
     }
-    isolate()->debug()->OnCompileError(script_);
+    isolate()->debug()->OnCompileError(script());
 
     Handle<JSArray> array = factory->NewJSArrayWithElements(elements);
     Handle<Object> error;
     MaybeHandle<Object> maybe_error =
         pending_error_is_reference_error_
             ? factory->NewReferenceError(pending_error_message_, array)
             : factory->NewSyntaxError(pending_error_message_, array);
     if (maybe_error.ToHandle(&error)) isolate()->Throw(*error, &location);
   }
 }
 
 
 void Parser::Internalize() {
   // Internalize strings.
-  ast_value_factory_->Internalize(isolate());
+  ast_value_factory()->Internalize(isolate());
 
   // Error processing.
   if (info()->function() == NULL) {
     if (stack_overflow()) {
       isolate()->StackOverflow();
     } else {
       ThrowPendingError();
     }
   }
 
@@ skipping 841 matching lines @@
 
 
 bool Parser::Parse() {
   DCHECK(info()->function() == NULL);
   FunctionLiteral* result = NULL;
   pre_parse_timer_ = isolate()->counters()->pre_parse();
   if (allow_natives_syntax() || extension_ != NULL) {
     // If intrinsics are allowed, the Parser cannot operate independent of the
     // V8 heap because of Runtime. Tell the string table to internalize strings
     // and values right after they're created.
-    ast_value_factory_->Internalize(isolate());
+    ast_value_factory()->Internalize(isolate());
   }
 
   if (info()->is_lazy()) {
     DCHECK(!info()->is_eval());
     if (info()->shared_info()->is_function()) {
       result = ParseLazy();
     } else {
       result = ParseProgram();
     }
   } else {
     SetCachedData();
     result = ParseProgram();
   }
   info()->SetFunction(result);
 
   Internalize();
-  DCHECK(ast_value_factory_->IsInternalized());
-  // info takes ownership of ast_value_factory_.
-  if (info()->ast_value_factory() == NULL) {
-    info()->SetAstValueFactory(ast_value_factory_);
-  }
-  ast_value_factory_ = NULL;
+  DCHECK(ast_value_factory()->IsInternalized());
   return (result != NULL);
 }
 
 } }  // namespace v8::internal