Deprecate ability to generate stubs via Compiler class.

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/ast.h"
 #include "src/bailout-reason.h"
@@ skipping 296 matching lines @@
   bool IsStub() const { return mode_ == STUB; }
   void SetOptimizing(BailoutId osr_ast_id, Handle<Code> unoptimized) {
     DCHECK(has_shared_info());
     SetMode(OPTIMIZE);
     osr_ast_id_ = osr_ast_id;
     unoptimized_code_ = unoptimized;
     optimization_id_ = isolate()->NextOptimizationId();
     set_output_code_kind(Code::OPTIMIZED_FUNCTION);
   }
 
-  void SetFunctionType(Type::FunctionType* function_type) {
-    function_type_ = function_type;
-  }
-  Type::FunctionType* function_type() const { return function_type_; }
-
-  void SetStub(CodeStub* code_stub);
-
   // Deoptimization support.
   bool HasDeoptimizationSupport() const {
     return GetFlag(kDeoptimizationSupport);
   }
   void EnableDeoptimizationSupport() {
     DCHECK_EQ(BASE, mode_);
     SetFlag(kDeoptimizationSupport);
   }
   bool ShouldEnsureSpaceForLazyDeopt() { return !IsStub(); }
 
@@ skipping 184 matching lines @@
   // Number of parameters used for compilation of stubs that require arguments.
   int parameter_count_;
 
   int optimization_id_;
 
   int osr_expr_stack_height_;
 
   // The current OSR frame for specialization or {nullptr}.
   JavaScriptFrame* osr_frame_ = nullptr;
 
-  Type::FunctionType* function_type_;
-
   const char* debug_name_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilationInfo);
 };
 
 
 // A wrapper around a CompilationInfo that detaches the Handles from
 // the underlying DeferredHandleScope and stores them in info_ on
 // destruction.
 class CompilationHandleScope BASE_EMBEDDED {
@@ skipping 104 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);
@@ skipping 61 matching lines @@
   size_t info_zone_start_allocation_size_;
   base::ElapsedTimer timer_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilationPhase);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_H_