Remove funky 2-stage initialization of ParserInfo and an adventurous memset.

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/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 17 matching lines @@
   if (!IsAligned(reinterpret_cast<intptr_t>(data), kPointerAlignment)) {
     byte* copy = NewArray<byte>(length);
     DCHECK(IsAligned(reinterpret_cast<intptr_t>(copy), kPointerAlignment));
     CopyBytes(copy, data, length);
     data_ = copy;
     AcquireDataOwnership();
   }
 }
 
 
-ParseInfo* ParseInfo::InitializeFromJSFunction(Handle<JSFunction> function) {
-  Handle<SharedFunctionInfo> shared(function->shared());
-  InitializeFromSharedFunctionInfo(shared);
+ParseInfo::ParseInfo(Zone* zone)
+    : zone_(zone),
+      flags_(0),
+      source_stream_(nullptr),
+      source_stream_encoding_(ScriptCompiler::StreamedSource::ONE_BYTE),
+      extension_(nullptr),
+      compile_options_(ScriptCompiler::kNoCompileOptions),
+      script_scope_(nullptr),
+      unicode_cache_(nullptr),
+      stack_limit_(0),
+      hash_seed_(0),
+      cached_data_(nullptr),
+      ast_value_factory_(nullptr),
+      literal_(nullptr),
+      scope_(nullptr) {}
+
+
+ParseInfo::ParseInfo(Zone* zone, Handle<JSFunction> function)
+    : ParseInfo(zone, Handle<SharedFunctionInfo>(function->shared())) {
   set_closure(function);
   set_context(Handle<Context>(function->context()));
-  return this;
 }
 
 
-ParseInfo* ParseInfo::InitializeFromSharedFunctionInfo(
-    Handle<SharedFunctionInfo> shared) {
+ParseInfo::ParseInfo(Zone* zone, Handle<SharedFunctionInfo> shared)
+    : ParseInfo(zone) {
   isolate_ = shared->GetIsolate();
 
   set_lazy();
   set_this_has_uses();
   set_hash_seed(isolate_->heap()->HashSeed());
   set_stack_limit(isolate_->stack_guard()->real_climit());
   set_unicode_cache(isolate_->unicode_cache());
   set_language_mode(shared->language_mode());
   set_shared_info(shared);
 
   Handle<Script> script(Script::cast(shared->script()));
   set_script(script);
   if (!script.is_null() && script->type()->value() == Script::TYPE_NATIVE) {
     set_native();
   }
-  return this;
 }
 
 
-ParseInfo* ParseInfo::InitializeFromScript(Handle<Script> script) {
+ParseInfo::ParseInfo(Zone* zone, Handle<Script> script) : ParseInfo(zone) {
   isolate_ = script->GetIsolate();
 
   set_this_has_uses();
   set_hash_seed(isolate_->heap()->HashSeed());
   set_stack_limit(isolate_->stack_guard()->real_climit());
   set_unicode_cache(isolate_->unicode_cache());
   set_script(script);
 
   if (script->type()->value() == Script::TYPE_NATIVE) {
     set_native();
   }
-  return this;
 }
 
 
 RegExpBuilder::RegExpBuilder(Zone* zone)
     : zone_(zone),
       pending_empty_(false),
       characters_(NULL),
       terms_(),
       alternatives_()
 #ifdef DEBUG
@@ skipping 5420 matching lines @@
     } else {
       const uc16* data = reinterpret_cast<const uc16*>(raw_string->raw_data());
       running_hash = StringHasher::ComputeRunningHash(running_hash, data,
                                                       raw_string->length());
     }
   }
 
   return running_hash;
 }
 } }  // namespace v8::internal