Refactor allocation policies.

src/parser.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 97 matching lines @@
 
 
 void RegExpBuilder::FlushText() {
   FlushCharacters();
   int num_text = text_.length();
   if (num_text == 0) {
     return;
   } else if (num_text == 1) {
     terms_.Add(text_.last());
   } else {
-    RegExpText* text = new(zone()) RegExpText();
+    RegExpText* text = new(zone()) RegExpText(zone());
     for (int i = 0; i < num_text; i++)
       text_.Get(i)->AppendToText(text);
     terms_.Add(text);
   }
   text_.Clear();
 }
 
 
 void RegExpBuilder::AddCharacter(uc16 c) {
   pending_empty_ = false;
   if (characters_ == NULL) {
-    characters_ = new(zone()) ZoneList<uc16>(4);
+    characters_ = ZoneList<uc16>::New(zone(), 4);
   }
   characters_->Add(c);
   LAST(ADD_CHAR);
 }
 
 
 void RegExpBuilder::AddEmpty() {
   pending_empty_ = true;
 }
 
@@ skipping 424 matching lines @@
 #undef DUMMY
 
 // ----------------------------------------------------------------------------
 // Implementation of Parser
 
 Parser::Parser(Handle<Script> script,
                bool allow_natives_syntax,
                v8::Extension* extension,
                ScriptDataImpl* pre_data)
     : isolate_(script->GetIsolate()),
-      symbol_cache_(pre_data ? pre_data->symbol_count() : 0),
+      symbol_cache_(isolate_->zone(), pre_data ? pre_data->symbol_count() : 0),
       script_(script),
       scanner_(isolate_->unicode_cache()),
       top_scope_(NULL),
       with_nesting_level_(0),
       lexical_scope_(NULL),
       target_stack_(NULL),
       allow_natives_syntax_(allow_natives_syntax),
       extension_(extension),
       pre_data_(pre_data),
       fni_(NULL),
@@ skipping 46 matching lines @@
       ? Scope::GLOBAL_SCOPE
       : Scope::EVAL_SCOPE;
   Handle<String> no_name = isolate()->factory()->empty_symbol();
 
   FunctionLiteral* result = NULL;
   { Scope* scope = NewScope(top_scope_, type, inside_with());
     LexicalScope lexical_scope(this, scope, isolate());
     if (strict_mode == kStrictMode) {
       top_scope_->EnableStrictMode();
     }
-    ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16);
+    ZoneList<Statement*>* body = ZoneList<Statement*>::New(zone(), 16);
     bool ok = true;
     int beg_loc = scanner().location().beg_pos;
     ParseSourceElements(body, Token::EOS, &ok);
     if (ok && top_scope_->is_strict_mode()) {
       CheckOctalLiteral(beg_loc, scanner().location().end_pos, &ok);
     }
     if (ok) {
       result = new(zone()) FunctionLiteral(
           no_name,
           top_scope_,
@@ skipping 410 matching lines @@
   void AssignmentFromSomethingElse() {
     // The this assignment is not a simple one.
     only_simple_this_property_assignments_ = false;
   }
 
   void EnsureAllocation() {
     if (names_ == NULL) {
       ASSERT(assigned_arguments_ == NULL);
       ASSERT(assigned_constants_ == NULL);
       Zone* zone = isolate_->zone();
-      names_ = new(zone) ZoneStringList(4);
-      assigned_arguments_ = new(zone) ZoneList<int>(4);
-      assigned_constants_ = new(zone) ZoneObjectList(4);
+      names_ = ZoneStringList::New(zone, 4);
+      assigned_arguments_ = ZoneList<int>::New(zone, 4);
+      assigned_constants_ = ZoneObjectList::New(zone, 4);
     }
   }
 
   Isolate* isolate_;
   bool only_simple_this_property_assignments_;
   ZoneStringList* names_;
   ZoneList<int>* assigned_arguments_;
   ZoneObjectList* assigned_constants_;
 };
 
@@ skipping 169 matching lines @@
     case Token::THROW:
       stmt = ParseThrowStatement(ok);
       break;
 
     case Token::TRY: {
       // NOTE: It is somewhat complicated to have labels on
       // try-statements. When breaking out of a try-finally statement,
       // one must take great care not to treat it as a
       // fall-through. It is much easier just to wrap the entire
       // try-statement in a statement block and put the labels there
-      Block* result = new(zone()) Block(labels, 1, false);
+      Block* result = new(zone()) Block(zone(), labels, 1, false);
       Target target(&this->target_stack_, result);
       TryStatement* statement = ParseTryStatement(CHECK_OK);
       if (statement) {
         statement->set_statement_pos(statement_pos);
       }
       if (result) result->AddStatement(statement);
       return result;
     }
 
     case Token::FUNCTION: {
@@ skipping 206 matching lines @@
 
 
 Block* Parser::ParseBlock(ZoneStringList* labels, bool* ok) {
   // Block ::
   //   '{' Statement* '}'
 
   // Note that a Block does not introduce a new execution scope!
   // (ECMA-262, 3rd, 12.2)
   //
   // Construct block expecting 16 statements.
-  Block* result = new(zone()) Block(labels, 16, false);
+  Block* result = new(zone()) Block(zone(), labels, 16, false);
   Target target(&this->target_stack_, result);
   Expect(Token::LBRACE, CHECK_OK);
   InitializationBlockFinder block_finder(top_scope_, target_stack_);
   while (peek() != Token::RBRACE) {
     Statement* stat = ParseStatement(NULL, CHECK_OK);
     if (stat && !stat->IsEmpty()) {
       result->AddStatement(stat);
       block_finder.Update(stat);
     }
   }
@@ skipping 54 matching lines @@
   // Scope declaration, and rewrite the source-level initialization into an
   // assignment statement. We use a block to collect multiple assignments.
   //
   // We mark the block as initializer block because we don't want the
   // rewriter to add a '.result' assignment to such a block (to get compliant
   // behavior for code such as print(eval('var x = 7')), and for cosmetic
   // reasons when pretty-printing. Also, unless an assignment (initialization)
   // is inside an initializer block, it is ignored.
   //
   // Create new block with one expected declaration.
-  Block* block = new(zone()) Block(NULL, 1, true);
+  Block* block = new(zone()) Block(zone(), NULL, 1, true);
   int nvars = 0;  // the number of variables declared
   Handle<String> name;
   do {
     if (fni_ != NULL) fni_->Enter();
 
     // Parse variable name.
     if (nvars > 0) Consume(Token::COMMA);
     name = ParseIdentifier(CHECK_OK);
     if (fni_ != NULL) fni_->PushVariableName(name);
 
@@ skipping 89 matching lines @@
     // guarantee to give the global object a "local" variable; a
     // variable defined in the global object and not in any
     // prototype. This way, global variable declarations can shadow
     // properties in the prototype chain, but only after the variable
     // declaration statement has been executed. This is important in
     // browsers where the global object (window) has lots of
     // properties defined in prototype objects.
 
     if (initialization_scope->is_global_scope()) {
       // Compute the arguments for the runtime call.
-      ZoneList<Expression*>* arguments = new(zone()) ZoneList<Expression*>(3);
+      ZoneList<Expression*>* arguments = ZoneList<Expression*>::New(zone(), 3);
       // We have at least 1 parameter.
       arguments->Add(new(zone()) Literal(name));
       CallRuntime* initialize;
 
       if (is_const) {
         arguments->Add(value);
         value = NULL;  // zap the value to avoid the unnecessary assignment
 
         // Construct the call to Runtime_InitializeConstGlobal
         // and add it to the initialization statement block.
@@ skipping 101 matching lines @@
     // 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)) {
       SmartPointer<char> c_string = label->ToCString(DISALLOW_NULLS);
       const char* elms[2] = { "Label", *c_string };
       Vector<const char*> args(elms, 2);
       ReportMessage("redeclaration", args);
       *ok = false;
       return NULL;
     }
-    if (labels == NULL) labels = new(zone()) ZoneStringList(4);
+    if (labels == NULL) labels = ZoneStringList::New(zone(), 4);
     labels->Add(label);
     // 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.
     top_scope_->RemoveUnresolved(var);
     Expect(Token::COLON, CHECK_OK);
     return ParseStatement(labels, ok);
   }
 
   // If we have an extension, we allow a native function declaration.
@@ skipping 133 matching lines @@
   }
 
   Expression* expr = ParseExpression(true, CHECK_OK);
   ExpectSemicolon(CHECK_OK);
   return new(zone()) ReturnStatement(expr);
 }
 
 
 Block* Parser::WithHelper(Expression* obj, ZoneStringList* labels, bool* ok) {
   // Parse the statement and collect escaping labels.
-  TargetCollector collector;
+  TargetCollector collector(zone());
   Statement* stat;
   { Target target(&this->target_stack_, &collector);
     with_nesting_level_++;
     top_scope_->DeclarationScope()->RecordWithStatement();
     stat = ParseStatement(labels, CHECK_OK);
     with_nesting_level_--;
   }
   // Create resulting block with two statements.
   // 1: Evaluate the with expression.
   // 2: The try-finally block evaluating the body.
-  Block* result = new(zone()) Block(NULL, 2, false);
+  Block* result = new(zone()) Block(zone(), NULL, 2, false);
 
   if (result != NULL) {
     result->AddStatement(new(zone()) EnterWithContextStatement(obj));
 
     // Create body block.
-    Block* body = new(zone()) Block(NULL, 1, false);
+    Block* body = new(zone()) Block(zone(), NULL, 1, false);
     body->AddStatement(stat);
 
     // Create exit block.
-    Block* exit = new(zone()) Block(NULL, 1, false);
+    Block* exit = new(zone()) Block(zone(), NULL, 1, false);
     exit->AddStatement(new(zone()) ExitContextStatement());
 
     // Return a try-finally statement.
     TryFinallyStatement* wrapper = new(zone()) TryFinallyStatement(body, exit);
     wrapper->set_escaping_targets(collector.targets());
     result->AddStatement(wrapper);
   }
   return result;
 }
 
@@ skipping 32 matching lines @@
     if (*default_seen_ptr) {
       ReportMessage("multiple_defaults_in_switch",
                     Vector<const char*>::empty());
       *ok = false;
       return NULL;
     }
     *default_seen_ptr = true;
   }
   Expect(Token::COLON, CHECK_OK);
   int pos = scanner().location().beg_pos;
-  ZoneList<Statement*>* statements = new(zone()) ZoneList<Statement*>(5);
+  ZoneList<Statement*>* statements = ZoneList<Statement*>::New(zone(), 5);
   while (peek() != Token::CASE &&
          peek() != Token::DEFAULT &&
          peek() != Token::RBRACE) {
     Statement* stat = ParseStatement(NULL, CHECK_OK);
     statements->Add(stat);
   }
 
   return new(zone()) CaseClause(label, statements, pos);
 }
 
 
 SwitchStatement* Parser::ParseSwitchStatement(ZoneStringList* labels,
                                               bool* ok) {
   // SwitchStatement ::
   //   'switch' '(' Expression ')' '{' CaseClause* '}'
 
   SwitchStatement* statement = new(zone()) SwitchStatement(labels);
   Target target(&this->target_stack_, statement);
 
   Expect(Token::SWITCH, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   Expression* tag = ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
 
   bool default_seen = false;
-  ZoneList<CaseClause*>* cases = new(zone()) ZoneList<CaseClause*>(4);
+  ZoneList<CaseClause*>* cases = ZoneList<CaseClause*>::New(zone(), 4);
   Expect(Token::LBRACE, CHECK_OK);
   while (peek() != Token::RBRACE) {
     CaseClause* clause = ParseCaseClause(&default_seen, CHECK_OK);
     cases->Add(clause);
   }
   Expect(Token::RBRACE, CHECK_OK);
 
   if (statement) statement->Initialize(tag, cases);
   return statement;
 }
@@ skipping 24 matching lines @@
   //   'try' Block Catch Finally
   //
   // Catch ::
   //   'catch' '(' Identifier ')' Block
   //
   // Finally ::
   //   'finally' Block
 
   Expect(Token::TRY, CHECK_OK);
 
-  TargetCollector try_collector;
+  TargetCollector try_collector(zone());
   Block* try_block;
 
   { Target target(&this->target_stack_, &try_collector);
     try_block = ParseBlock(NULL, CHECK_OK);
   }
 
   Token::Value tok = peek();
   if (tok != Token::CATCH && tok != Token::FINALLY) {
     ReportMessage("no_catch_or_finally", Vector<const char*>::empty());
     *ok = false;
     return NULL;
   }
 
   // If we can break out from the catch block and there is a finally block,
   // then we will need to collect escaping targets from the catch
   // block. Since we don't know yet if there will be a finally block, we
   // always collect the targets.
-  TargetCollector catch_collector;
+  TargetCollector catch_collector(zone());
   Scope* catch_scope = NULL;
   Variable* catch_variable = NULL;
   Block* catch_block = NULL;
   Handle<String> name;
   if (tok == Token::CATCH) {
     Consume(Token::CATCH);
 
     Expect(Token::LPAREN, CHECK_OK);
     name = ParseIdentifier(CHECK_OK);
 
     if (top_scope_->is_strict_mode() && IsEvalOrArguments(name)) {
       ReportMessage("strict_catch_variable", Vector<const char*>::empty());
       *ok = false;
       return NULL;
     }
 
     Expect(Token::RPAREN, CHECK_OK);
 
     if (peek() == Token::LBRACE) {
       // Rewrite the catch body B to a single statement block
       // { try B finally { PopContext }}.
       Block* inner_body;
       // We need to collect escapes from the body for both the inner
       // try/finally used to pop the catch context and any possible outer
       // try/finally.
-      TargetCollector inner_collector;
+      TargetCollector inner_collector(zone());
       { Target target(&this->target_stack_, &catch_collector);
         { Target target(&this->target_stack_, &inner_collector);
           catch_scope = NewScope(top_scope_, Scope::CATCH_SCOPE, inside_with());
           if (top_scope_->is_strict_mode()) {
             catch_scope->EnableStrictMode();
           }
           catch_variable = catch_scope->DeclareLocal(name, Variable::VAR);
 
           Scope* saved_scope = top_scope_;
           top_scope_ = catch_scope;
           inner_body = ParseBlock(NULL, CHECK_OK);
           top_scope_ = saved_scope;
         }
       }
 
       // Create exit block.
-      Block* inner_finally = new(zone()) Block(NULL, 1, false);
+      Block* inner_finally = new(zone()) Block(zone(), NULL, 1, false);
       inner_finally->AddStatement(new(zone()) ExitContextStatement());
 
       // Create a try/finally statement.
       TryFinallyStatement* inner_try_finally =
           new(zone()) TryFinallyStatement(inner_body, inner_finally);
       inner_try_finally->set_escaping_targets(inner_collector.targets());
 
-      catch_block = new(zone()) Block(NULL, 1, false);
+      catch_block = new(zone()) Block(zone(), NULL, 1, false);
       catch_block->AddStatement(inner_try_finally);
     } else {
       Expect(Token::LBRACE, CHECK_OK);
     }
 
     tok = peek();
   }
 
   Block* finally_block = NULL;
   if (tok == Token::FINALLY || catch_block == NULL) {
     Consume(Token::FINALLY);
     finally_block = ParseBlock(NULL, CHECK_OK);
   }
 
   // Simplify the AST nodes by converting:
   //   'try B0 catch B1 finally B2'
   // to:
   //   'try { try B0 catch B1 } finally B2'
 
   if (catch_block != NULL && finally_block != NULL) {
     // If we have both, create an inner try/catch.
     ASSERT(catch_scope != NULL && catch_variable != NULL);
     TryCatchStatement* statement =
         new(zone()) TryCatchStatement(try_block,
                                       catch_scope,
                                       catch_variable,
                                       catch_block);
     statement->set_escaping_targets(try_collector.targets());
-    try_block = new(zone()) Block(NULL, 1, false);
+    try_block = new(zone()) Block(zone(), NULL, 1, false);
     try_block->AddStatement(statement);
     catch_block = NULL;  // Clear to indicate it's been handled.
   }
 
   TryStatement* result = NULL;
   if (catch_block != NULL) {
     ASSERT(finally_block == NULL);
     ASSERT(catch_scope != NULL && catch_variable != NULL);
     result =
         new(zone()) TryCatchStatement(try_block,
@@ skipping 80 matching lines @@
         VariableProxy* each = top_scope_->NewUnresolved(name, inside_with());
         ForInStatement* loop = new(zone()) ForInStatement(labels);
         Target target(&this->target_stack_, loop);
 
         Expect(Token::IN, CHECK_OK);
         Expression* enumerable = ParseExpression(true, CHECK_OK);
         Expect(Token::RPAREN, CHECK_OK);
 
         Statement* body = ParseStatement(NULL, CHECK_OK);
         loop->Initialize(each, enumerable, body);
-        Block* result = new(zone()) Block(NULL, 2, false);
+        Block* result = new(zone()) Block(zone(), NULL, 2, false);
         result->AddStatement(variable_statement);
         result->AddStatement(loop);
         // Parsed for-in loop w/ variable/const declaration.
         return result;
       } else {
         init = variable_statement;
       }
 
     } else {
       Expression* expression = ParseExpression(false, CHECK_OK);
@@ skipping 481 matching lines @@
   Expression* result;
   if (peek() == Token::NEW) {
     result = ParseNewPrefix(stack, CHECK_OK);
   } else {
     result = ParseMemberWithNewPrefixesExpression(stack, CHECK_OK);
   }
 
   if (!stack->is_empty()) {
     int last = stack->pop();
     result = new(zone()) CallNew(result,
-                                 new(zone()) ZoneList<Expression*>(0),
+                                 ZoneList<Expression*>::New(zone(), 0),
                                  last);
   }
   return result;
 }
 
 
 Expression* Parser::ParseNewExpression(bool* ok) {
   PositionStack stack(ok);
   return ParseNewPrefix(&stack, ok);
 }
@@ skipping 258 matching lines @@
 
   *is_simple = is_simple_acc;
   *depth = depth_acc;
 }
 
 
 Expression* Parser::ParseArrayLiteral(bool* ok) {
   // ArrayLiteral ::
   //   '[' Expression? (',' Expression?)* ']'
 
-  ZoneList<Expression*>* values = new(zone()) ZoneList<Expression*>(4);
+  ZoneList<Expression*>* values = ZoneList<Expression*>::New(zone(), 4);
   Expect(Token::LBRACK, CHECK_OK);
   while (peek() != Token::RBRACK) {
     Expression* elem;
     if (peek() == Token::COMMA) {
       elem = GetLiteralTheHole();
     } else {
       elem = ParseAssignmentExpression(true, CHECK_OK);
     }
     values->Add(elem);
     if (peek() != Token::RBRACK) {
@@ skipping 322 matching lines @@
 
 
 Expression* Parser::ParseObjectLiteral(bool* ok) {
   // ObjectLiteral ::
   //   '{' (
   //       ((IdentifierName | String | Number) ':' AssignmentExpression)
   //     | (('get' | 'set') (IdentifierName | String | Number) FunctionLiteral)
   //    )*[','] '}'
 
   ZoneList<ObjectLiteral::Property*>* properties =
-      new(zone()) ZoneList<ObjectLiteral::Property*>(4);
+      ZoneList<ObjectLiteral::Property*>::New(zone(), 4);
   int number_of_boilerplate_properties = 0;
   bool has_function = false;
 
   ObjectLiteralPropertyChecker checker(this, top_scope_->is_strict_mode());
 
   Expect(Token::LBRACE, CHECK_OK);
   Scanner::Location loc = scanner().location();
 
   while (peek() != Token::RBRACE) {
     if (fni_ != NULL) fni_->Enter();
@@ skipping 142 matching lines @@
   Next();
 
   return new(zone()) RegExpLiteral(js_pattern, js_flags, literal_index);
 }
 
 
 ZoneList<Expression*>* Parser::ParseArguments(bool* ok) {
   // Arguments ::
   //   '(' (AssignmentExpression)*[','] ')'
 
-  ZoneList<Expression*>* result = new(zone()) ZoneList<Expression*>(4);
+  ZoneList<Expression*>* result = ZoneList<Expression*>::New(zone(), 4);
   Expect(Token::LPAREN, CHECK_OK);
   bool done = (peek() == Token::RPAREN);
   while (!done) {
     Expression* argument = ParseAssignmentExpression(true, CHECK_OK);
     result->Add(argument);
     if (result->length() > kMaxNumFunctionParameters) {
       ReportMessageAt(scanner().location(), "too_many_arguments",
                       Vector<const char*>::empty());
       *ok = false;
       return NULL;
@@ skipping 22 matching lines @@
   Handle<String> name =
       is_named ? var_name : isolate()->factory()->empty_symbol();
   // The function name, if any.
   Handle<String> function_name = isolate()->factory()->empty_symbol();
   if (is_named && (type == EXPRESSION || type == NESTED)) {
     function_name = name;
   }
 
   int num_parameters = 0;
   Scope* scope = NewScope(top_scope_, Scope::FUNCTION_SCOPE, inside_with());
-  ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(8);
+  ZoneList<Statement*>* body = ZoneList<Statement*>::New(zone(), 8);
   int materialized_literal_count;
   int expected_property_count;
   int start_pos;
   int end_pos;
   bool only_simple_this_property_assignments;
   Handle<FixedArray> this_property_assignments;
   bool has_duplicate_parameters = false;
   // Parse function body.
   { LexicalScope lexical_scope(this, scope, isolate());
     top_scope_->SetScopeName(name);
@@ skipping 461 matching lines @@
                                                                     TENURED);
   for (int i = 0; i < argc; i++) {
     Handle<Object> element = arguments[i];
     if (!element.is_null()) {
       elements->set(i, *element);
     }
   }
   Handle<JSArray> array = isolate()->factory()->NewJSArrayWithElements(elements,
                                                                        TENURED);
 
-  ZoneList<Expression*>* args = new(zone()) ZoneList<Expression*>(2);
+  ZoneList<Expression*>* args = ZoneList<Expression*>::New(zone(), 2);
   args->Add(new(zone()) Literal(type));
   args->Add(new(zone()) Literal(array));
   return new(zone()) Throw(new(zone()) CallRuntime(constructor, NULL, args),
                    scanner().location().beg_pos);
 }
 
 // ----------------------------------------------------------------------------
 // Regular expressions
 
 
@@ skipping 174 matching lines @@
       RegExpAssertion::Type type =
           multiline_ ? RegExpAssertion::END_OF_LINE :
                        RegExpAssertion::END_OF_INPUT;
       builder->AddAssertion(new(zone()) RegExpAssertion(type));
       continue;
     }
     case '.': {
       Advance();
       // everything except \x0a, \x0d, \u2028 and \u2029
       ZoneList<CharacterRange>* ranges =
-          new(zone()) ZoneList<CharacterRange>(2);
+          ZoneList<CharacterRange>::New(zone(), 2);
       CharacterRange::AddClassEscape('.', ranges);
       RegExpTree* atom = new(zone()) RegExpCharacterClass(ranges, false);
       builder->AddAtom(atom);
       break;
     }
     case '(': {
       SubexpressionType type = CAPTURE;
       Advance();
       if (current() == '?') {
         switch (Next()) {
           case ':':
             type = GROUPING;
             break;
           case '=':
             type = POSITIVE_LOOKAHEAD;
             break;
           case '!':
             type = NEGATIVE_LOOKAHEAD;
             break;
           default:
             ReportError(CStrVector("Invalid group") CHECK_FAILED);
             break;
         }
         Advance(2);
       } else {
         if (captures_ == NULL) {
-          captures_ = new(zone()) ZoneList<RegExpCapture*>(2);
+          captures_ = ZoneList<RegExpCapture*>::New(zone(), 2);
         }
         if (captures_started() >= kMaxCaptures) {
           ReportError(CStrVector("Too many captures") CHECK_FAILED);
         }
         captures_->Add(NULL);
       }
       // Store current state and begin new disjunction parsing.
       stored_state = new(zone()) RegExpParserState(stored_state,
                                            type,
                                            captures_started());
@@ skipping 23 matching lines @@
         continue;
       // AtomEscape ::
       //   CharacterClassEscape
       //
       // CharacterClassEscape :: one of
       //   d D s S w W
       case 'd': case 'D': case 's': case 'S': case 'w': case 'W': {
         uc32 c = Next();
         Advance(2);
         ZoneList<CharacterRange>* ranges =
-            new(zone()) ZoneList<CharacterRange>(2);
+            ZoneList<CharacterRange>::New(zone(), 2);
         CharacterRange::AddClassEscape(c, ranges);
         RegExpTree* atom = new(zone()) RegExpCharacterClass(ranges, false);
         builder->AddAtom(atom);
         break;
       }
       case '1': case '2': case '3': case '4': case '5': case '6':
       case '7': case '8': case '9': {
         int index = 0;
         if (ParseBackReferenceIndex(&index)) {
           RegExpCapture* capture = NULL;
@@ skipping 475 matching lines @@
   static const char* kUnterminated = "Unterminated character class";
   static const char* kRangeOutOfOrder = "Range out of order in character class";
 
   ASSERT_EQ(current(), '[');
   Advance();
   bool is_negated = false;
   if (current() == '^') {
     is_negated = true;
     Advance();
   }
-  ZoneList<CharacterRange>* ranges = new(zone()) ZoneList<CharacterRange>(2);
+  ZoneList<CharacterRange>* ranges = ZoneList<CharacterRange>::New(zone(), 2);
   while (has_more() && current() != ']') {
     uc16 char_class = kNoCharClass;
     CharacterRange first = ParseClassAtom(&char_class CHECK_FAILED);
     if (current() == '-') {
       Advance();
       if (current() == kEndMarker) {
         // If we reach the end we break out of the loop and let the
         // following code report an error.
         break;
       } else if (current() == ']') {
@@ skipping 203 matching lines @@
                                    info->is_global(),
                                    info->StrictMode());
     }
   }
 
   info->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal