[debugger] Refactor LiveEdit function info collection

src/compiler.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/compiler.h"
 
 #include <algorithm>
 
 #include "src/ast/ast-numbering.h"
 #include "src/ast/prettyprinter.h"
@@ skipping 1014 matching lines @@
         parse_info->set_compile_options(ScriptCompiler::kNoCompileOptions);
       }
       if (!Parser::ParseStatic(parse_info)) {
         return Handle<SharedFunctionInfo>::null();
       }
     }
 
     DCHECK(!info->is_debug() || !parse_info->allow_lazy_parsing());
 
     FunctionLiteral* lit = parse_info->literal();
-    LiveEditFunctionTracker live_edit_tracker(isolate, lit);
 
     // Measure how long it takes to do the compilation; only take the
     // rest of the function into account to avoid overlap with the
     // parsing statistics.
     HistogramTimer* rate = parse_info->is_eval()
                                ? info->isolate()->counters()->compile_eval()
                                : info->isolate()->counters()->compile();
     HistogramTimerScope timer(rate);
     TRACE_EVENT0("v8", parse_info->is_eval() ? "V8.CompileEval" : "V8.Compile");
 
@@ skipping 25 matching lines @@
     Logger::LogEventsAndTags log_tag =
         parse_info->is_eval()
             ? Logger::EVAL_TAG
             : Logger::ToNativeByScript(Logger::SCRIPT_TAG, *script);
 
     PROFILE(isolate, CodeCreateEvent(log_tag, result->abstract_code(), *result,
                                      *script_name));
 
     if (!script.is_null())
       script->set_compilation_state(Script::COMPILATION_STATE_COMPILED);
-
-    live_edit_tracker.RecordFunctionInfo(result, lit, info->zone());
   }
 
   return result;
 }
 
 }  // namespace
 
 // ----------------------------------------------------------------------------
 // Implementation of Compiler
 
@@ skipping 156 matching lines @@
   Zone zone(isolate->allocator());
   ParseInfo parse_info(&zone, script);
   CompilationInfo info(&parse_info, Handle<JSFunction>::null());
   parse_info.set_global();
   info.MarkAsDebug();
   // TODO(635): support extensions.
   if (CompileToplevel(&info).is_null()) {
     return false;
   }
 
+  LiveEditFunctionTracker::Collect(script, &parse_info, isolate);

[Yang, 2016/05/11 07:29:09]

The caller of CompileForLiveEdit (LiveEdit::GatherCompileInfo) sets the
FunctionInfoListener onto the isolate for LiveEditFunctionTracker to call into.
This should not be necessary. Instead, let's fold the functionality of
LiveEditFunctionTracker and FunctionInfoListener into LiveEditFunctionVisitor.
LiveEdit::GatherCompileInfo should just pass in an instance of
LiveEditFunctionVisitor into here.

LiveEditFunctionVisitor would have a Collect method, and hide all the visit
methods as private.

[jgruber1, 2016/05/12 12:30:25]

Done.
We can't hide visit methods since they're used by node::Accept().

+
   // Check postconditions on success.
   DCHECK(!isolate->has_pending_exception());
   return true;
 }
 
 // TODO(turbofan): In the future, unoptimized code with deopt support could
 // be generated lazily once deopt is triggered.
 bool Compiler::EnsureDeoptimizationSupport(CompilationInfo* info) {
   DCHECK_NOT_NULL(info->literal());
   DCHECK_NOT_NULL(info->scope());
@@ skipping 310 matching lines @@
   Zone zone(isolate->allocator());
   ParseInfo parse_info(&zone, script);
   CompilationInfo info(&parse_info, Handle<JSFunction>::null());
   parse_info.set_literal(literal);
   parse_info.set_shared_info(result);
   parse_info.set_scope(literal->scope());
   parse_info.set_language_mode(literal->scope()->language_mode());
   if (outer_info->will_serialize()) info.PrepareForSerializing();
   if (outer_info->is_debug()) info.MarkAsDebug();
 
-  LiveEditFunctionTracker live_edit_tracker(isolate, literal);
   // Determine if the function can be lazily compiled. This is necessary to
   // allow some of our builtin JS files to be lazily compiled. These
   // builtins cannot be handled lazily by the parser, since we have to know
   // if a function uses the special natives syntax, which is something the
   // parser records.
   // If the debugger requests compilation for break points, we cannot be
   // aggressive about lazy compilation, because it might trigger compilation
   // of functions without an outer context when setting a breakpoint through
   // Debug::FindSharedFunctionInfoInScript.
   bool allow_lazy_without_ctx = literal->AllowsLazyCompilationWithoutContext();
@@ skipping 28 matching lines @@
     // Update the shared function info with the scope info.
     InstallSharedScopeInfo(&info, result);
     // Install compilation result on the shared function info.
     InstallSharedCompilationResult(&info, result);
   } else {
     return Handle<SharedFunctionInfo>::null();
   }
 
   if (maybe_existing.is_null()) {
     RecordFunctionCompilation(Logger::FUNCTION_TAG, &info);
-    live_edit_tracker.RecordFunctionInfo(result, literal, info.zone());
   }
 
   return result;
 }
 
 Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForNative(
     v8::Extension* extension, Handle<String> name) {
   Isolate* isolate = name->GetIsolate();
   v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
 
@@ skipping 114 matching lines @@
     MaybeHandle<Code> code;
     if (cached.code != nullptr) code = handle(cached.code);
     Handle<Context> native_context(function->context()->native_context());
     SharedFunctionInfo::AddToOptimizedCodeMap(shared, native_context, code,
                                               literals, BailoutId::None());
   }
 }
 
 }  // namespace internal
 }  // namespace v8