Replace OVERRIDE->override and FINAL->final since we now require C++11.

src/hydrogen.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_HYDROGEN_H_
 #define V8_HYDROGEN_H_
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 14 matching lines @@
 class HEnvironment;
 class HGraph;
 class HLoopInformation;
 class HOsrBuilder;
 class HTracer;
 class LAllocator;
 class LChunk;
 class LiveRange;
 
 
-class HBasicBlock FINAL : public ZoneObject {
+class HBasicBlock final : public ZoneObject {
  public:
   explicit HBasicBlock(HGraph* graph);
   ~HBasicBlock() { }
 
   // Simple accessors.
   int block_id() const { return block_id_; }
   void set_block_id(int id) { block_id_ = id; }
   HGraph* graph() const { return graph_; }
   Isolate* isolate() const;
   const ZoneList<HPhi*>* phis() const { return &phis_; }
@@ skipping 161 matching lines @@
   bool is_reachable_ : 1;
   bool dominates_loop_successors_ : 1;
   bool is_osr_entry_ : 1;
   bool is_ordered_ : 1;
 };
 
 
 std::ostream& operator<<(std::ostream& os, const HBasicBlock& b);
 
 
-class HPredecessorIterator FINAL BASE_EMBEDDED {
+class HPredecessorIterator final BASE_EMBEDDED {
  public:
   explicit HPredecessorIterator(HBasicBlock* block)
       : predecessor_list_(block->predecessors()), current_(0) { }
 
   bool Done() { return current_ >= predecessor_list_->length(); }
   HBasicBlock* Current() { return predecessor_list_->at(current_); }
   void Advance() { current_++; }
 
  private:
   const ZoneList<HBasicBlock*>* predecessor_list_;
   int current_;
 };
 
 
-class HInstructionIterator FINAL BASE_EMBEDDED {
+class HInstructionIterator final BASE_EMBEDDED {
  public:
   explicit HInstructionIterator(HBasicBlock* block)
       : instr_(block->first()) {
     next_ = Done() ? NULL : instr_->next();
   }
 
   inline bool Done() const { return instr_ == NULL; }
   inline HInstruction* Current() { return instr_; }
   inline void Advance() {
     instr_ = next_;
     next_ = Done() ? NULL : instr_->next();
   }
 
  private:
   HInstruction* instr_;
   HInstruction* next_;
 };
 
 
-class HLoopInformation FINAL : public ZoneObject {
+class HLoopInformation final : public ZoneObject {
  public:
   HLoopInformation(HBasicBlock* loop_header, Zone* zone)
       : back_edges_(4, zone),
         loop_header_(loop_header),
         blocks_(8, zone),
         stack_check_(NULL) {
     blocks_.Add(loop_header, zone);
   }
   ~HLoopInformation() {}
 
@@ skipping 27 matching lines @@
 
   ZoneList<HBasicBlock*> back_edges_;
   HBasicBlock* loop_header_;
   ZoneList<HBasicBlock*> blocks_;
   HStackCheck* stack_check_;
 };
 
 
 class BoundsCheckTable;
 class InductionVariableBlocksTable;
-class HGraph FINAL : public ZoneObject {
+class HGraph final : public ZoneObject {
  public:
   explicit HGraph(CompilationInfo* info);
 
   Isolate* isolate() const { return isolate_; }
   Zone* zone() const { return zone_; }
   CompilationInfo* info() const { return info_; }
 
   const ZoneList<HBasicBlock*>* blocks() const { return &blocks_; }
   const ZoneList<HPhi*>* phi_list() const { return phi_list_; }
   HBasicBlock* entry_block() const { return entry_block_; }
@@ skipping 205 matching lines @@
 enum FrameType {
   JS_FUNCTION,
   JS_CONSTRUCT,
   JS_GETTER,
   JS_SETTER,
   ARGUMENTS_ADAPTOR,
   STUB
 };
 
 
-class HEnvironment FINAL : public ZoneObject {
+class HEnvironment final : public ZoneObject {
  public:
   HEnvironment(HEnvironment* outer,
                Scope* scope,
                Handle<JSFunction> closure,
                Zone* zone);
 
   HEnvironment(Zone* zone, int parameter_count);
 
   HEnvironment* arguments_environment() {
     return outer()->frame_type() == ARGUMENTS_ADAPTOR ? outer() : this;
@@ skipping 246 matching lines @@
 #endif
 
  private:
   HOptimizedGraphBuilder* owner_;
   Expression::Context kind_;
   AstContext* outer_;
   bool for_typeof_;
 };
 
 
-class EffectContext FINAL : public AstContext {
+class EffectContext final : public AstContext {
  public:
   explicit EffectContext(HOptimizedGraphBuilder* owner)
       : AstContext(owner, Expression::kEffect) {
   }
   virtual ~EffectContext();
 
-  void ReturnValue(HValue* value) OVERRIDE;
+  void ReturnValue(HValue* value) override;
   virtual void ReturnInstruction(HInstruction* instr,
-                                 BailoutId ast_id) OVERRIDE;
+                                 BailoutId ast_id) override;
   virtual void ReturnControl(HControlInstruction* instr,
-                             BailoutId ast_id) OVERRIDE;
+                             BailoutId ast_id) override;
   virtual void ReturnContinuation(HIfContinuation* continuation,
-                                  BailoutId ast_id) OVERRIDE;
+                                  BailoutId ast_id) override;
 };
 
 
-class ValueContext FINAL : public AstContext {
+class ValueContext final : public AstContext {
  public:
   ValueContext(HOptimizedGraphBuilder* owner, ArgumentsAllowedFlag flag)
       : AstContext(owner, Expression::kValue), flag_(flag) {
   }
   virtual ~ValueContext();
 
-  void ReturnValue(HValue* value) OVERRIDE;
+  void ReturnValue(HValue* value) override;
   virtual void ReturnInstruction(HInstruction* instr,
-                                 BailoutId ast_id) OVERRIDE;
+                                 BailoutId ast_id) override;
   virtual void ReturnControl(HControlInstruction* instr,
-                             BailoutId ast_id) OVERRIDE;
+                             BailoutId ast_id) override;
   virtual void ReturnContinuation(HIfContinuation* continuation,
-                                  BailoutId ast_id) OVERRIDE;
+                                  BailoutId ast_id) override;
 
   bool arguments_allowed() { return flag_ == ARGUMENTS_ALLOWED; }
 
  private:
   ArgumentsAllowedFlag flag_;
 };
 
 
-class TestContext FINAL : public AstContext {
+class TestContext final : public AstContext {
  public:
   TestContext(HOptimizedGraphBuilder* owner,
               Expression* condition,
               HBasicBlock* if_true,
               HBasicBlock* if_false)
       : AstContext(owner, Expression::kTest),
         condition_(condition),
         if_true_(if_true),
         if_false_(if_false) {
   }
 
-  void ReturnValue(HValue* value) OVERRIDE;
+  void ReturnValue(HValue* value) override;
   virtual void ReturnInstruction(HInstruction* instr,
-                                 BailoutId ast_id) OVERRIDE;
+                                 BailoutId ast_id) override;
   virtual void ReturnControl(HControlInstruction* instr,
-                             BailoutId ast_id) OVERRIDE;
+                             BailoutId ast_id) override;
   virtual void ReturnContinuation(HIfContinuation* continuation,
-                                  BailoutId ast_id) OVERRIDE;
+                                  BailoutId ast_id) override;
 
   static TestContext* cast(AstContext* context) {
     DCHECK(context->IsTest());
     return reinterpret_cast<TestContext*>(context);
   }
 
   Expression* condition() const { return condition_; }
   HBasicBlock* if_true() const { return if_true_; }
   HBasicBlock* if_false() const { return if_false_; }
 
  private:
   // Build the shared core part of the translation unpacking a value into
   // control flow.
   void BuildBranch(HValue* value);
 
   Expression* condition_;
   HBasicBlock* if_true_;
   HBasicBlock* if_false_;
 };
 
 
-class FunctionState FINAL {
+class FunctionState final {
  public:
   FunctionState(HOptimizedGraphBuilder* owner,
                 CompilationInfo* info,
                 InliningKind inlining_kind,
                 int inlining_id);
   ~FunctionState();
 
   CompilationInfo* compilation_info() { return compilation_info_; }
   AstContext* call_context() { return call_context_; }
   InliningKind inlining_kind() const { return inlining_kind_; }
@@ skipping 52 matching lines @@
   HArgumentsObject* arguments_object_;
   HArgumentsElements* arguments_elements_;
 
   int inlining_id_;
   SourcePosition outer_source_position_;
 
   FunctionState* outer_;
 };
 
 
-class HIfContinuation FINAL {
+class HIfContinuation final {
  public:
   HIfContinuation()
     : continuation_captured_(false),
       true_branch_(NULL),
       false_branch_(NULL) {}
   HIfContinuation(HBasicBlock* true_branch,
                   HBasicBlock* false_branch)
       : continuation_captured_(true), true_branch_(true_branch),
         false_branch_(false_branch) {}
   ~HIfContinuation() { DCHECK(!continuation_captured_); }
@@ skipping 23 matching lines @@
   HBasicBlock* true_branch() const { return true_branch_; }
   HBasicBlock* false_branch() const { return false_branch_; }
 
  private:
   bool continuation_captured_;
   HBasicBlock* true_branch_;
   HBasicBlock* false_branch_;
 };
 
 
-class HAllocationMode FINAL BASE_EMBEDDED {
+class HAllocationMode final BASE_EMBEDDED {
  public:
   explicit HAllocationMode(Handle<AllocationSite> feedback_site)
       : current_site_(NULL), feedback_site_(feedback_site),
         pretenure_flag_(NOT_TENURED) {}
   explicit HAllocationMode(HValue* current_site)
       : current_site_(current_site), pretenure_flag_(NOT_TENURED) {}
   explicit HAllocationMode(PretenureFlag pretenure_flag)
       : current_site_(NULL), pretenure_flag_(pretenure_flag) {}
   HAllocationMode()
       : current_site_(NULL), pretenure_flag_(NOT_TENURED) {}
@@ skipping 451 matching lines @@
 
   HValue* AddLoadJSBuiltin(Builtins::JavaScript builtin);
 
   HValue* EnforceNumberType(HValue* number, Type* expected);
   HValue* TruncateToNumber(HValue* value, Type** expected);
 
   void FinishExitWithHardDeoptimization(Deoptimizer::DeoptReason reason);
 
   void AddIncrementCounter(StatsCounter* counter);
 
-  class IfBuilder FINAL {
+  class IfBuilder final {
    public:
     // If using this constructor, Initialize() must be called explicitly!
     IfBuilder();
 
     explicit IfBuilder(HGraphBuilder* builder);
     IfBuilder(HGraphBuilder* builder,
               HIfContinuation* continuation);
 
     ~IfBuilder() {
       if (!finished_) End();
@@ skipping 182 matching lines @@
     bool needs_compare_ : 1;
     bool pending_merge_block_ : 1;
     HBasicBlock* first_true_block_;
     HBasicBlock* first_false_block_;
     HBasicBlock* split_edge_merge_block_;
     MergeAtJoinBlock* merge_at_join_blocks_;
     int normal_merge_at_join_block_count_;
     int deopt_merge_at_join_block_count_;
   };
 
-  class LoopBuilder FINAL {
+  class LoopBuilder final {
    public:
     enum Direction {
       kPreIncrement,
       kPostIncrement,
       kPreDecrement,
       kPostDecrement,
       kWhileTrue
     };
 
     explicit LoopBuilder(HGraphBuilder* builder);  // while (true) {...}
@@ skipping 33 matching lines @@
     HBasicBlock* header_block_;
     HBasicBlock* body_block_;
     HBasicBlock* exit_block_;
     HBasicBlock* exit_trampoline_block_;
     Direction direction_;
     bool finished_;
   };
 
   HValue* BuildNewElementsCapacity(HValue* old_capacity);
 
-  class JSArrayBuilder FINAL {
+  class JSArrayBuilder final {
    public:
     JSArrayBuilder(HGraphBuilder* builder,
                    ElementsKind kind,
                    HValue* allocation_site_payload,
                    HValue* constructor_function,
                    AllocationSiteOverrideMode override_mode);
 
     JSArrayBuilder(HGraphBuilder* builder,
                    ElementsKind kind,
                    HValue* constructor_function = NULL);
@@ skipping 300 matching lines @@
 template<>
 inline HInstruction* HGraphBuilder::NewUncasted<HContext>() {
   return New<HContext>();
 }
 
 class HOptimizedGraphBuilder : public HGraphBuilder, public AstVisitor {
  public:
   // A class encapsulating (lazily-allocated) break and continue blocks for
   // a breakable statement.  Separated from BreakAndContinueScope so that it
   // can have a separate lifetime.
-  class BreakAndContinueInfo FINAL BASE_EMBEDDED {
+  class BreakAndContinueInfo final BASE_EMBEDDED {
    public:
     explicit BreakAndContinueInfo(BreakableStatement* target,
                                   Scope* scope,
                                   int drop_extra = 0)
         : target_(target),
           break_block_(NULL),
           continue_block_(NULL),
           scope_(scope),
           drop_extra_(drop_extra) {
     }
 
     BreakableStatement* target() { return target_; }
     HBasicBlock* break_block() { return break_block_; }
     void set_break_block(HBasicBlock* block) { break_block_ = block; }
     HBasicBlock* continue_block() { return continue_block_; }
     void set_continue_block(HBasicBlock* block) { continue_block_ = block; }
     Scope* scope() { return scope_; }
     int drop_extra() { return drop_extra_; }
 
    private:
     BreakableStatement* target_;
     HBasicBlock* break_block_;
     HBasicBlock* continue_block_;
     Scope* scope_;
     int drop_extra_;
   };
 
   // A helper class to maintain a stack of current BreakAndContinueInfo
   // structures mirroring BreakableStatement nesting.
-  class BreakAndContinueScope FINAL BASE_EMBEDDED {
+  class BreakAndContinueScope final BASE_EMBEDDED {
    public:
     BreakAndContinueScope(BreakAndContinueInfo* info,
                           HOptimizedGraphBuilder* owner)
         : info_(info), owner_(owner), next_(owner->break_scope()) {
       owner->set_break_scope(this);
     }
 
     ~BreakAndContinueScope() { owner_->set_break_scope(next_); }
 
     BreakAndContinueInfo* info() { return info_; }
     HOptimizedGraphBuilder* owner() { return owner_; }
     BreakAndContinueScope* next() { return next_; }
 
     // Search the break stack for a break or continue target.
     enum BreakType { BREAK, CONTINUE };
     HBasicBlock* Get(BreakableStatement* stmt, BreakType type,
                      Scope** scope, int* drop_extra);
 
    private:
     BreakAndContinueInfo* info_;
     HOptimizedGraphBuilder* owner_;
     BreakAndContinueScope* next_;
   };
 
   explicit HOptimizedGraphBuilder(CompilationInfo* info);
 
-  bool BuildGraph() OVERRIDE;
+  bool BuildGraph() override;
 
   // Simple accessors.
   BreakAndContinueScope* break_scope() const { return break_scope_; }
   void set_break_scope(BreakAndContinueScope* head) { break_scope_ = head; }
 
-  HValue* context() OVERRIDE { return environment()->context(); }
+  HValue* context() override { return environment()->context(); }
 
   HOsrBuilder* osr() const { return osr_; }
 
   void Bailout(BailoutReason reason);
 
   HBasicBlock* CreateJoin(HBasicBlock* first,
                           HBasicBlock* second,
                           BailoutId join_id);
 
   FunctionState* function_state() const { return function_state_; }
 
-  void VisitDeclarations(ZoneList<Declaration*>* declarations) OVERRIDE;
+  void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
 
   void* operator new(size_t size, Zone* zone) { return zone->New(size); }
   void operator delete(void* pointer, Zone* zone) { }
   void operator delete(void* pointer) { }
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
 
  protected:
   // Forward declarations for inner scope classes.
   class SubgraphScope;
@@ skipping 209 matching lines @@
   // test contexts.)
   void VisitForValue(Expression* expr,
                      ArgumentsAllowedFlag flag = ARGUMENTS_NOT_ALLOWED);
   void VisitForTypeOf(Expression* expr);
   void VisitForEffect(Expression* expr);
   void VisitForControl(Expression* expr,
                        HBasicBlock* true_block,
                        HBasicBlock* false_block);
 
   // Visit a list of expressions from left to right, each in a value context.
-  void VisitExpressions(ZoneList<Expression*>* exprs) OVERRIDE;
+  void VisitExpressions(ZoneList<Expression*>* exprs) override;
   void VisitExpressions(ZoneList<Expression*>* exprs,
                         ArgumentsAllowedFlag flag);
 
   // Remove the arguments from the bailout environment and emit instructions
   // to push them as outgoing parameters.
   template <class Instruction> HInstruction* PreProcessCall(Instruction* call);
   void PushArgumentsFromEnvironment(int count);
 
   void SetUpScope(Scope* scope);
-  void VisitStatements(ZoneList<Statement*>* statements) OVERRIDE;
+  void VisitStatements(ZoneList<Statement*>* statements) override;
 
-#define DECLARE_VISIT(type) virtual void Visit##type(type* node) OVERRIDE;
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node) override;
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
  private:
   // Helpers for flow graph construction.
   enum GlobalPropertyAccess {
     kUseCell,
     kUseGeneric
   };
   GlobalPropertyAccess LookupGlobalProperty(Variable* var, LookupIterator* it,
@@ skipping 506 matching lines @@
   friend class KeyedLoadFastElementStub;
   friend class HOsrBuilder;
 
   DISALLOW_COPY_AND_ASSIGN(HOptimizedGraphBuilder);
 };
 
 
 Zone* AstContext::zone() const { return owner_->zone(); }
 
 
-class HStatistics FINAL: public Malloced {
+class HStatistics final : public Malloced {
  public:
   HStatistics()
       : times_(5),
         names_(5),
         sizes_(5),
         total_size_(0),
         source_size_(0) { }
 
   void Initialize(CompilationInfo* info);
   void Print();
@@ skipping 42 matching lines @@
  protected:
   HGraph* graph() const { return graph_; }
 
  private:
   HGraph* graph_;
 
   DISALLOW_COPY_AND_ASSIGN(HPhase);
 };
 
 
-class HTracer FINAL : public Malloced {
+class HTracer final : public Malloced {
  public:
   explicit HTracer(int isolate_id)
       : trace_(&string_allocator_), indent_(0) {
     if (FLAG_trace_hydrogen_file == NULL) {
       SNPrintF(filename_,
                "hydrogen-%d-%d.cfg",
                base::OS::GetCurrentProcessId(),
                isolate_id);
     } else {
       StrNCpy(filename_, FLAG_trace_hydrogen_file, filename_.length());
     }
     WriteChars(filename_.start(), "", 0, false);
   }
 
   void TraceCompilation(CompilationInfo* info);
   void TraceHydrogen(const char* name, HGraph* graph);
   void TraceLithium(const char* name, LChunk* chunk);
   void TraceLiveRanges(const char* name, LAllocator* allocator);
 
  private:
-  class Tag FINAL BASE_EMBEDDED {
+  class Tag final BASE_EMBEDDED {
    public:
     Tag(HTracer* tracer, const char* name) {
       name_ = name;
       tracer_ = tracer;
       tracer->PrintIndent();
       tracer->trace_.Add("begin_%s\n", name);
       tracer->indent_++;
     }
 
     ~Tag() {
@@ skipping 44 matching lines @@
     }
   }
 
   EmbeddedVector<char, 64> filename_;
   HeapStringAllocator string_allocator_;
   StringStream trace_;
   int indent_;
 };
 
 
-class NoObservableSideEffectsScope FINAL {
+class NoObservableSideEffectsScope final {
  public:
   explicit NoObservableSideEffectsScope(HGraphBuilder* builder) :
       builder_(builder) {
     builder_->graph()->IncrementInNoSideEffectsScope();
   }
   ~NoObservableSideEffectsScope() {
     builder_->graph()->DecrementInNoSideEffectsScope();
   }
 
  private:
   HGraphBuilder* builder_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_H_