Teach Scopes whether they will end up being lazily compiled or not

src/compilation-info.h

 // Copyright 2016 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_COMPILATION_INFO_H_
 #define V8_COMPILATION_INFO_H_
 
 #include <memory>
 
 #include "src/compilation-dependencies.h"
@@ skipping 21 matching lines @@
  public:
   // Various configuration flags for a compilation, as well as some properties
   // of the compiled code produced by a compilation.
   enum Flag {
     kDeferredCalling = 1 << 0,
     kNonDeferredCalling = 1 << 1,
     kSavesCallerDoubles = 1 << 2,
     kRequiresFrame = 1 << 3,
     kMustNotHaveEagerFrame = 1 << 4,
     kDeoptimizationSupport = 1 << 5,
-    kDebug = 1 << 6,
-    kSerializing = 1 << 7,
+    kAccessorInliningEnabled = 1 << 6,
+    kTypeFeedbackEnabled = 1 << 7,
     kFunctionContextSpecializing = 1 << 8,
     kFrameSpecializing = 1 << 9,
     kNativeContextSpecializing = 1 << 10,
     kInliningEnabled = 1 << 11,
     kDisableFutureOptimization = 1 << 12,
     kSplittingEnabled = 1 << 13,
     kDeoptimizationEnabled = 1 << 14,
     kSourcePositionsEnabled = 1 << 15,
     kBailoutOnUninitialized = 1 << 16,
     kOptimizeFromBytecode = 1 << 17,
-    kTypeFeedbackEnabled = 1 << 18,
-    kAccessorInliningEnabled = 1 << 19,
   };
 
   CompilationInfo(ParseInfo* parse_info, Handle<JSFunction> closure);
   CompilationInfo(Vector<const char> debug_name, Isolate* isolate, Zone* zone,
                   Code::Flags code_flags);
   ~CompilationInfo();
 
   ParseInfo* parse_info() const { return parse_info_; }
 
   // -----------------------------------------------------------
@@ skipping 49 matching lines @@
   void MarkMustNotHaveEagerFrame() { SetFlag(kMustNotHaveEagerFrame); }
 
   bool GetMustNotHaveEagerFrame() const {
     return GetFlag(kMustNotHaveEagerFrame);
   }
 
   // Compiles marked as debug produce unoptimized code with debug break slots.
   // Inner functions that cannot be compiled w/o context are compiled eagerly.
   // Always include deoptimization support to avoid having to recompile again.
   void MarkAsDebug() {
-    SetFlag(kDebug);
+    set_is_debug();
     SetFlag(kDeoptimizationSupport);
   }
 
-  bool is_debug() const { return GetFlag(kDebug); }
+  bool is_debug() const;
 
-  void PrepareForSerializing() { SetFlag(kSerializing); }
+  void PrepareForSerializing() { set_will_serialize(); }
 
-  bool will_serialize() const { return GetFlag(kSerializing); }
+  bool will_serialize() const;
 
   void MarkAsFunctionContextSpecializing() {
     SetFlag(kFunctionContextSpecializing);
   }
 
   bool is_function_context_specializing() const {
     return GetFlag(kFunctionContextSpecializing);
   }
 
   void MarkAsFrameSpecializing() { SetFlag(kFrameSpecializing); }
@@ skipping 195 matching lines @@
   void SetMode(Mode mode) { mode_ = mode; }
 
   void SetFlag(Flag flag) { flags_ |= flag; }
 
   void SetFlag(Flag flag, bool value) {
     flags_ = value ? flags_ | flag : flags_ & ~flag;
   }
 
   bool GetFlag(Flag flag) const { return (flags_ & flag) != 0; }
 
+  void set_is_debug();
+  void set_will_serialize();
+
   unsigned flags_;
 
   Code::Flags code_flags_;
 
   Handle<JSFunction> closure_;
 
   // The compiled code.
   Handle<Code> code_;
 
   // Compilation mode flag and whether deoptimization is allowed.
@@ skipping 32 matching lines @@
 
   Vector<const char> debug_name_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilationInfo);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILATION_INFO_H_