Fix: AstValueFactory must be internalized before ThrowPendingError.

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/bootstrapper.h"
 #include "src/char-predicates-inl.h"
@@ skipping 893 matching lines @@
     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;
       }
     }
 
+    ast_value_factory_->Internalize(isolate());
     if (ok) {
       result = factory()->NewFunctionLiteral(
           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,
@@ skipping 100 matching lines @@
                                   function_type,
                                   FunctionLiteral::NORMAL_ARITY,
                                   &ok);
     // Make sure the results agree.
     ASSERT(ok == (result != NULL));
   }
 
   // Make sure the target stack is empty.
   ASSERT(target_stack_ == NULL);
 
+  ast_value_factory_->Internalize(isolate());
   if (result == NULL) {
     if (stack_overflow()) {
       isolate()->StackOverflow();
     } else {
       ThrowPendingError();
     }
   } else {
     Handle<String> inferred_name(shared_info->inferred_name());
     result->set_inferred_name(inferred_name);
   }
@@ skipping 2833 matching lines @@
   // target stack has been used from the top of the target stack. Add
   // the break target to any TargetCollectors passed on the stack.
   for (Target* t = target_stack_; t != stop; t = t->previous()) {
     TargetCollector* collector = t->node()->AsTargetCollector();
     if (collector != NULL) collector->AddTarget(target, zone());
   }
 }
 
 
 void Parser::ThrowPendingError() {
+  ASSERT(ast_value_factory_->IsInternalized());
   if (has_pending_error_) {
     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();
@@ skipping 940 matching lines @@
       ParserTraits::ReportMessageAt(loc, message, arg,
                                     cached_data->IsReferenceError());
       DeleteArray(message);
       DeleteArray(arg);
       ASSERT(info()->isolate()->has_pending_exception());
     } else {
       result = ParseProgram();
     }
   }
   info()->SetFunction(result);
-  ast_value_factory_->Internalize(isolate());
+  ASSERT(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;
   return (result != NULL);
 }
 
 } }  // namespace v8::internal