Get rid of CompilationInfo::GenerateCodeStub method.

src/compiler.h

 // 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.
 
 #ifndef V8_COMPILER_H_
 #define V8_COMPILER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
@@ skipping 384 matching lines @@
   }
   JavaScriptFrame* osr_frame() const { return osr_frame_; }
   void set_osr_frame(JavaScriptFrame* osr_frame) { osr_frame_ = osr_frame; }
 
 #if DEBUG
   void PrintAstForTesting();
 #endif
 
   bool has_simple_parameters();
 
-  Handle<Code> GenerateCodeStub();

[Michael Starzinger, 2015/08/21 16:24:30]

Pretty please, with a cherry on top, let's not put logic methods on plain
data-holding classes like CompilationInfo. The logic should live in the Compiler
class.

-
   typedef std::vector<Handle<SharedFunctionInfo>> InlinedFunctionList;
   InlinedFunctionList const& inlined_functions() const {
     return inlined_functions_;
   }
   void AddInlinedFunction(Handle<SharedFunctionInfo> inlined_function) {
     inlined_functions_.push_back(inlined_function);
   }
 
  protected:
   ParseInfo* parse_info_;
@@ skipping 199 matching lines @@
 // Please note this interface returns shared function infos.  This means you
 // need to call Factory::NewFunctionFromSharedFunctionInfo before you have a
 // real function with a context.
 
 class Compiler : public AllStatic {
  public:
   MUST_USE_RESULT static MaybeHandle<Code> GetUnoptimizedCode(
       Handle<JSFunction> function);
   MUST_USE_RESULT static MaybeHandle<Code> GetLazyCode(
       Handle<JSFunction> function);
+  MUST_USE_RESULT static MaybeHandle<Code> GetStubCode(
+      Handle<JSFunction> function, CodeStub* stub);
 
+  static bool Compile(Handle<JSFunction> function, ClearExceptionFlag flag);
   static bool CompileDebugCode(Handle<JSFunction> function);
   static bool CompileDebugCode(Handle<SharedFunctionInfo> shared);
+  static void CompileForLiveEdit(Handle<Script> script);
 
   // Parser::Parse, then Compiler::Analyze.
   static bool ParseAndAnalyze(ParseInfo* info);
   // Rewrite, analyze scopes, and renumber.
   static bool Analyze(ParseInfo* info);
   // Adds deoptimization support, requires ParseAndAnalyze.
   static bool EnsureDeoptimizationSupport(CompilationInfo* info);
 
-  static bool EnsureCompiled(Handle<JSFunction> function,
-                             ClearExceptionFlag flag);
-
-  static void CompileForLiveEdit(Handle<Script> script);
-
   // Compile a String source within a context for eval.
   MUST_USE_RESULT static MaybeHandle<JSFunction> GetFunctionFromEval(
       Handle<String> source, Handle<SharedFunctionInfo> outer_info,
       Handle<Context> context, LanguageMode language_mode,
       ParseRestriction restriction, int line_offset, int column_offset = 0,
       Handle<Object> script_name = Handle<Object>(),
       ScriptOriginOptions options = ScriptOriginOptions());
 
   // Compile a String source within a context.
   static Handle<SharedFunctionInfo> CompileScript(
@@ skipping 47 matching lines @@
   Zone zone_;
   size_t info_zone_start_allocation_size_;
   base::ElapsedTimer timer_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilationPhase);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_COMPILER_H_