No need to collect literal counts.

src/debug/liveedit.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/debug/liveedit.h"
 
 #include "src/ast/scopes.h"
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
 #include "src/compiler.h"
@@ skipping 586 matching lines @@
   return Handle<SharedFunctionInfo>(SharedFunctionInfo::cast(shared));
 }
 
 
 static int GetArrayLength(Handle<JSArray> array) {
   Object* length = array->length();
   CHECK(length->IsSmi());
   return Smi::cast(length)->value();
 }
 
-void FunctionInfoWrapper::SetInitialProperties(
-    Handle<String> name, int start_position, int end_position, int param_num,
-    int literal_count, int parent_index, int function_literal_id) {
+void FunctionInfoWrapper::SetInitialProperties(Handle<String> name,
+                                               int start_position,
+                                               int end_position, int param_num,
+                                               int parent_index,
+                                               int function_literal_id) {
   HandleScope scope(isolate());
   this->SetField(kFunctionNameOffset_, name);
   this->SetSmiValueField(kStartPositionOffset_, start_position);
   this->SetSmiValueField(kEndPositionOffset_, end_position);
   this->SetSmiValueField(kParamNumOffset_, param_num);
-  this->SetSmiValueField(kLiteralNumOffset_, literal_count);
+  this->SetSmiValueField(kLiteralNumOffset, 0);
   this->SetSmiValueField(kParentIndexOffset_, parent_index);
   this->SetSmiValueField(kFunctionLiteralIdOffset_, function_literal_id);
 }
 
 void FunctionInfoWrapper::SetSharedFunctionInfo(
     Handle<SharedFunctionInfo> info) {
   Handle<JSValue> info_holder = WrapInJSValue(info);
   this->SetField(kSharedFunctionInfoOffset_, info_holder);
 }
 
@@ skipping 118 matching lines @@
 
 // Patch function feedback vector.
 // The feedback vector is a cache for complex object boilerplates and for a
 // native context. We must clean cached values, or if the structure of the
 // vector itself changes we need to allocate a new one.
 class FeedbackVectorFixer {
  public:
   static void PatchFeedbackVector(FunctionInfoWrapper* compile_info_wrapper,
                                   Handle<SharedFunctionInfo> shared_info,
                                   Isolate* isolate) {
-    int new_literal_count = compile_info_wrapper->GetLiteralCount();
-
     // When feedback metadata changes, we have to create new array instances.
     // Since we cannot create instances when iterating heap, we should first
     // collect all functions and fix their literal arrays.
     Handle<FixedArray> function_instances =
         CollectJSFunctions(shared_info, isolate);
 
     for (int i = 0; i < function_instances->length(); i++) {
       Handle<JSFunction> fun(JSFunction::cast(function_instances->get(i)));
       Handle<Cell> new_cell = isolate->factory()->NewManyClosuresCell(
           isolate->factory()->undefined_value());
       fun->set_feedback_vector_cell(*new_cell);
       // Only create feedback vectors if we already have the metadata.
       if (shared_info->is_compiled()) JSFunction::EnsureLiterals(fun);
     }
-
-    shared_info->set_num_literals(new_literal_count);
   }
 
  private:
   // Iterates all function instances in the HEAP that refers to the
   // provided shared_info.
   template<typename Visitor>
   static void IterateJSFunctions(Handle<SharedFunctionInfo> shared_info,
                                  Visitor* visitor) {
     HeapIterator iterator(shared_info->GetHeap());
     for (HeapObject* obj = iterator.next(); obj != NULL;
@@ skipping 812 matching lines @@
   Handle<SharedFunctionInfo> info =
       script_->FindSharedFunctionInfo(isolate_, node).ToHandleChecked();
   FunctionDone(info, node->scope());
 }
 
 void LiveEditFunctionTracker::FunctionStarted(FunctionLiteral* fun) {
   HandleScope handle_scope(isolate_);
   FunctionInfoWrapper info = FunctionInfoWrapper::Create(isolate_);
   info.SetInitialProperties(fun->name(), fun->start_position(),
                             fun->end_position(), fun->parameter_count(),
-                            fun->materialized_literal_count(),
                             current_parent_index_, fun->function_literal_id());
   current_parent_index_ = len_;
   SetElementSloppy(result_, len_, info.GetJSArray());
   len_++;
 }
 
 // Saves full information about a function: its code, its scope info
 // and a SharedFunctionInfo object.
 void LiveEditFunctionTracker::FunctionDone(Handle<SharedFunctionInfo> shared,
                                            Scope* scope) {
@@ skipping 33 matching lines @@
     scope_info_length++;
 
     current_scope = current_scope->outer_scope();
   }
 
   return scope_info_list;
 }
 
 }  // namespace internal
 }  // namespace v8