Revert of Store SharedFunctionInfos of a Script in a FixedArray indexed by their ID

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 literal_count,
+                                               int parent_index) {
   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(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);
 }
 
 Handle<SharedFunctionInfo> FunctionInfoWrapper::GetSharedFunctionInfo() {
   Handle<Object> element = this->GetField(kSharedFunctionInfoOffset_);
@@ skipping 401 matching lines @@
   shared_info->set_start_position(start_position);
   shared_info->set_end_position(end_position);
 
   LiteralFixer::PatchLiterals(&compile_info_wrapper, shared_info,
                               feedback_metadata_changed, isolate);
 
   DeoptimizeDependentFunctions(*shared_info);
   isolate->compilation_cache()->Remove(shared_info);
 }
 
-void LiveEdit::FunctionSourceUpdated(Handle<JSArray> shared_info_array,
-                                     int new_function_literal_id) {
+
+void LiveEdit::FunctionSourceUpdated(Handle<JSArray> shared_info_array) {
   SharedInfoWrapper shared_info_wrapper(shared_info_array);
   Handle<SharedFunctionInfo> shared_info = shared_info_wrapper.GetInfo();
 
-  shared_info->set_function_literal_id(new_function_literal_id);
   DeoptimizeDependentFunctions(*shared_info);
   shared_info_array->GetIsolate()->compilation_cache()->Remove(shared_info);
 }
 
-void LiveEdit::FixupScript(Handle<Script> script, int max_function_literal_id) {
-  Isolate* isolate = script->GetIsolate();
-  Handle<FixedArray> old_infos(script->shared_function_infos(), isolate);
-  Handle<FixedArray> new_infos(
-      isolate->factory()->NewFixedArray(max_function_literal_id + 1));
-  script->set_shared_function_infos(*new_infos);
-  SharedFunctionInfo::ScriptIterator iterator(isolate, old_infos);
-  while (SharedFunctionInfo* shared = iterator.Next()) {
-    // We can't use SharedFunctionInfo::SetScript(info, undefined_value()) here,
-    // as we severed the link from the Script to the SharedFunctionInfo above.
-    Handle<SharedFunctionInfo> info(shared, isolate);
-    info->set_script(isolate->heap()->undefined_value());
-    Handle<Object> new_noscript_list = WeakFixedArray::Add(
-        isolate->factory()->noscript_shared_function_infos(), info);
-    isolate->heap()->SetRootNoScriptSharedFunctionInfos(*new_noscript_list);
-
-    // Put the SharedFunctionInfo at its new, correct location.
-    SharedFunctionInfo::SetScript(info, script);
-  }
-}
 
 void LiveEdit::SetFunctionScript(Handle<JSValue> function_wrapper,
                                  Handle<Object> script_handle) {
   Handle<SharedFunctionInfo> shared_info =
       UnwrapSharedFunctionInfoFromJSValue(function_wrapper);
   Isolate* isolate = function_wrapper->GetIsolate();
   CHECK(script_handle->IsScript() || script_handle->IsUndefined(isolate));
   SharedFunctionInfo::SetScript(shared_info, script_handle);
   shared_info->DisableOptimization(kLiveEdit);
 
@@ skipping 106 matching lines @@
   Handle<Script> copy = isolate->factory()->NewScript(original_source);
 
   copy->set_name(original->name());
   copy->set_line_offset(original->line_offset());
   copy->set_column_offset(original->column_offset());
   copy->set_type(original->type());
   copy->set_context_data(original->context_data());
   copy->set_eval_from_shared(original->eval_from_shared());
   copy->set_eval_from_position(original->eval_from_position());
 
-  Handle<FixedArray> infos(isolate->factory()->NewFixedArray(
-      original->shared_function_infos()->length()));
-  copy->set_shared_function_infos(*infos);
-
   // Copy all the flags, but clear compilation state.
   copy->set_flags(original->flags());
   copy->set_compilation_state(Script::COMPILATION_STATE_INITIAL);
 
   return copy;
 }
 
+
 Handle<Object> LiveEdit::ChangeScriptSource(Handle<Script> original_script,
                                             Handle<String> new_source,
                                             Handle<Object> old_script_name) {
   Isolate* isolate = original_script->GetIsolate();
   Handle<Object> old_script_object;
   if (old_script_name->IsString()) {
     Handle<Script> old_script = CreateScriptCopy(original_script);
     old_script->set_name(String::cast(*old_script_name));
     old_script_object = old_script;
     isolate->debug()->OnAfterCompile(old_script);
@@ skipping 655 matching lines @@
   script_ = script;
   zone_ = zone;
 }
 
 void LiveEditFunctionTracker::VisitFunctionLiteral(FunctionLiteral* node) {
   // FunctionStarted is called in pre-order.
   FunctionStarted(node);
   // Recurse using the regular traversal.
   AstTraversalVisitor::VisitFunctionLiteral(node);
   // FunctionDone are called in post-order.
+  // TODO(jgruber): If required, replace the (linear cost)
+  // FindSharedFunctionInfo call with a more efficient implementation.
   Handle<SharedFunctionInfo> info =
-      script_->FindSharedFunctionInfo(isolate_, node).ToHandleChecked();
+      script_->FindSharedFunctionInfo(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_);
   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) {
   HandleScope handle_scope(isolate_);
@@ skipping 32 matching lines @@
     scope_info_length++;
 
     current_scope = current_scope->outer_scope();
   }
 
   return scope_info_list;
 }
 
 }  // namespace internal
 }  // namespace v8