[presubmit] Enabling readability/inheritance linter checking.

src/full-codegen/full-codegen.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_FULL_CODEGEN_FULL_CODEGEN_H_
 #define V8_FULL_CODEGEN_FULL_CODEGEN_H_
 
 #include "src/allocation.h"
 #include "src/assert-scope.h"
 #include "src/ast.h"
@@ skipping 135 matching lines @@
    private:
     DISALLOW_COPY_AND_ASSIGN(NestedStatement);
   };
 
   // A breakable statement such as a block.
   class Breakable : public NestedStatement {
    public:
     Breakable(FullCodeGenerator* codegen, BreakableStatement* statement)
         : NestedStatement(codegen), statement_(statement) {
     }
-    virtual ~Breakable() {}
 
-    virtual Breakable* AsBreakable() { return this; }
-    virtual bool IsBreakTarget(Statement* target) {
+    Breakable* AsBreakable() override { return this; }
+    bool IsBreakTarget(Statement* target) override {
       return statement() == target;
     }
 
     BreakableStatement* statement() { return statement_; }
     Label* break_label() { return &break_label_; }
 
    private:
     BreakableStatement* statement_;
     Label break_label_;
   };
 
   // An iteration statement such as a while, for, or do loop.
   class Iteration : public Breakable {
    public:
     Iteration(FullCodeGenerator* codegen, IterationStatement* statement)
         : Breakable(codegen, statement) {
     }
-    virtual ~Iteration() {}
 
-    virtual Iteration* AsIteration() { return this; }
-    virtual bool IsContinueTarget(Statement* target) {
+    Iteration* AsIteration() override { return this; }
+    bool IsContinueTarget(Statement* target) override {
       return statement() == target;
     }
 
     Label* continue_label() { return &continue_label_; }
 
    private:
     Label continue_label_;
   };
 
   // A nested block statement.
   class NestedBlock : public Breakable {
    public:
     NestedBlock(FullCodeGenerator* codegen, Block* block)
         : Breakable(codegen, block) {
     }
-    virtual ~NestedBlock() {}
 
-    virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
+    NestedStatement* Exit(int* stack_depth, int* context_length) override {
       auto block_scope = statement()->AsBlock()->scope();
       if (block_scope != nullptr) {
         if (block_scope->ContextLocalCount() > 0) ++(*context_length);
       }
       return previous_;
     }
   };
 
   // The try block of a try/catch statement.
   class TryCatch : public NestedStatement {
    public:
     static const int kElementCount = TryBlockConstant::kElementCount;
 
     explicit TryCatch(FullCodeGenerator* codegen) : NestedStatement(codegen) {}
-    virtual ~TryCatch() {}
 
-    virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
+    NestedStatement* Exit(int* stack_depth, int* context_length) override {
       *stack_depth += kElementCount;
       return previous_;
     }
-    virtual NestedStatement* AccumulateDepth(int* stack_depth) {
+    NestedStatement* AccumulateDepth(int* stack_depth) override {
       *stack_depth += kElementCount;
       return previous_;
     }
   };
 
   // The try block of a try/finally statement.
   class TryFinally : public NestedStatement {
    public:
     static const int kElementCount = TryBlockConstant::kElementCount;
 
     TryFinally(FullCodeGenerator* codegen, Label* finally_entry)
         : NestedStatement(codegen), finally_entry_(finally_entry) {
     }
-    virtual ~TryFinally() {}
 
-    virtual NestedStatement* Exit(int* stack_depth, int* context_length);
-    virtual NestedStatement* AccumulateDepth(int* stack_depth) {
+    NestedStatement* Exit(int* stack_depth, int* context_length) override;
+    NestedStatement* AccumulateDepth(int* stack_depth) override {
       *stack_depth += kElementCount;
       return previous_;
     }
 
    private:
     Label* finally_entry_;
   };
 
   // The finally block of a try/finally statement.
   class Finally : public NestedStatement {
    public:
     static const int kElementCount = 3;
 
     explicit Finally(FullCodeGenerator* codegen) : NestedStatement(codegen) {}
-    virtual ~Finally() {}
 
-    virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
+    NestedStatement* Exit(int* stack_depth, int* context_length) override {
       *stack_depth += kElementCount;
       return previous_;
     }
-    virtual NestedStatement* AccumulateDepth(int* stack_depth) {
+    NestedStatement* AccumulateDepth(int* stack_depth) override {
       *stack_depth += kElementCount;
       return previous_;
     }
   };
 
   // The body of a for/in loop.
   class ForIn : public Iteration {
    public:
     static const int kElementCount = 5;
 
     ForIn(FullCodeGenerator* codegen, ForInStatement* statement)
         : Iteration(codegen, statement) {
     }
-    virtual ~ForIn() {}
 
-    virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
+    NestedStatement* Exit(int* stack_depth, int* context_length) override {
       *stack_depth += kElementCount;
       return previous_;
     }
-    virtual NestedStatement* AccumulateDepth(int* stack_depth) {
+    NestedStatement* AccumulateDepth(int* stack_depth) override {
       *stack_depth += kElementCount;
       return previous_;
     }
   };
 
 
   // The body of a with or catch.
   class WithOrCatch : public NestedStatement {
    public:
     explicit WithOrCatch(FullCodeGenerator* codegen)
         : NestedStatement(codegen) {
     }
-    virtual ~WithOrCatch() {}
 
-    virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
+    NestedStatement* Exit(int* stack_depth, int* context_length) override {
       ++(*context_length);
       return previous_;
     }
   };
 
   // A platform-specific utility to overwrite the accumulator register
   // with a GC-safe value.
   void ClearAccumulator();
 
   // Determine whether or not to inline the smi case for the given
@@ skipping 413 matching lines @@
   // in v8::internal::Context.
   void LoadContextField(Register dst, int context_index);
 
   // Push the function argument for the runtime functions PushWithContext
   // and PushCatchContext.
   void PushFunctionArgumentForContextAllocation();
 
   void PushCalleeAndWithBaseObject(Call* expr);
 
   // AST node visit functions.
-#define DECLARE_VISIT(type) virtual void Visit##type(type* node) override;
+#define DECLARE_VISIT(type) void Visit##type(type* node) override;
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
   void VisitComma(BinaryOperation* expr);
   void VisitLogicalExpression(BinaryOperation* expr);
   void VisitArithmeticExpression(BinaryOperation* expr);
 
   void VisitForTypeofValue(Expression* expr);
 
   void Generate();
@@ skipping 93 matching lines @@
    private:
     const ExpressionContext* old_;
     FullCodeGenerator* codegen_;
   };
 
   class AccumulatorValueContext : public ExpressionContext {
    public:
     explicit AccumulatorValueContext(FullCodeGenerator* codegen)
         : ExpressionContext(codegen) { }
 
-    virtual void Plug(bool flag) const;
-    virtual void Plug(Register reg) const;
-    virtual void Plug(Label* materialize_true, Label* materialize_false) const;
-    virtual void Plug(Variable* var) const;
-    virtual void Plug(Handle<Object> lit) const;
-    virtual void Plug(Heap::RootListIndex) const;
-    virtual void PlugTOS() const;
-    virtual void DropAndPlug(int count, Register reg) const;
-    virtual void PrepareTest(Label* materialize_true,
-                             Label* materialize_false,
-                             Label** if_true,
-                             Label** if_false,
-                             Label** fall_through) const;
-    virtual bool IsAccumulatorValue() const { return true; }
+    void Plug(bool flag) const override;
+    void Plug(Register reg) const override;
+    void Plug(Label* materialize_true, Label* materialize_false) const override;
+    void Plug(Variable* var) const override;
+    void Plug(Handle<Object> lit) const override;
+    void Plug(Heap::RootListIndex) const override;
+    void PlugTOS() const override;
+    void DropAndPlug(int count, Register reg) const override;
+    void PrepareTest(Label* materialize_true, Label* materialize_false,
+                     Label** if_true, Label** if_false,
+                     Label** fall_through) const override;
+    bool IsAccumulatorValue() const override { return true; }
   };
 
   class StackValueContext : public ExpressionContext {
    public:
     explicit StackValueContext(FullCodeGenerator* codegen)
         : ExpressionContext(codegen) { }
 
-    virtual void Plug(bool flag) const;
-    virtual void Plug(Register reg) const;
-    virtual void Plug(Label* materialize_true, Label* materialize_false) const;
-    virtual void Plug(Variable* var) const;
-    virtual void Plug(Handle<Object> lit) const;
-    virtual void Plug(Heap::RootListIndex) const;
-    virtual void PlugTOS() const;
-    virtual void DropAndPlug(int count, Register reg) const;
-    virtual void PrepareTest(Label* materialize_true,
-                             Label* materialize_false,
-                             Label** if_true,
-                             Label** if_false,
-                             Label** fall_through) const;
-    virtual bool IsStackValue() const { return true; }
+    void Plug(bool flag) const override;
+    void Plug(Register reg) const override;
+    void Plug(Label* materialize_true, Label* materialize_false) const override;
+    void Plug(Variable* var) const override;
+    void Plug(Handle<Object> lit) const override;
+    void Plug(Heap::RootListIndex) const override;
+    void PlugTOS() const override;
+    void DropAndPlug(int count, Register reg) const override;
+    void PrepareTest(Label* materialize_true, Label* materialize_false,
+                     Label** if_true, Label** if_false,
+                     Label** fall_through) const override;
+    bool IsStackValue() const override { return true; }
   };
 
   class TestContext : public ExpressionContext {
    public:
     TestContext(FullCodeGenerator* codegen,
                 Expression* condition,
                 Label* true_label,
                 Label* false_label,
                 Label* fall_through)
         : ExpressionContext(codegen),
           condition_(condition),
           true_label_(true_label),
           false_label_(false_label),
           fall_through_(fall_through) { }
 
     static const TestContext* cast(const ExpressionContext* context) {
       DCHECK(context->IsTest());
       return reinterpret_cast<const TestContext*>(context);
     }
 
     Expression* condition() const { return condition_; }
     Label* true_label() const { return true_label_; }
     Label* false_label() const { return false_label_; }
     Label* fall_through() const { return fall_through_; }
 
-    virtual void Plug(bool flag) const;
-    virtual void Plug(Register reg) const;
-    virtual void Plug(Label* materialize_true, Label* materialize_false) const;
-    virtual void Plug(Variable* var) const;
-    virtual void Plug(Handle<Object> lit) const;
-    virtual void Plug(Heap::RootListIndex) const;
-    virtual void PlugTOS() const;
-    virtual void DropAndPlug(int count, Register reg) const;
-    virtual void PrepareTest(Label* materialize_true,
-                             Label* materialize_false,
-                             Label** if_true,
-                             Label** if_false,
-                             Label** fall_through) const;
-    virtual bool IsTest() const { return true; }
+    void Plug(bool flag) const override;
+    void Plug(Register reg) const override;
+    void Plug(Label* materialize_true, Label* materialize_false) const override;
+    void Plug(Variable* var) const override;
+    void Plug(Handle<Object> lit) const override;
+    void Plug(Heap::RootListIndex) const override;
+    void PlugTOS() const override;
+    void DropAndPlug(int count, Register reg) const override;
+    void PrepareTest(Label* materialize_true, Label* materialize_false,
+                     Label** if_true, Label** if_false,
+                     Label** fall_through) const override;
+    bool IsTest() const override { return true; }
 
    private:
     Expression* condition_;
     Label* true_label_;
     Label* false_label_;
     Label* fall_through_;
   };
 
   class EffectContext : public ExpressionContext {
    public:
     explicit EffectContext(FullCodeGenerator* codegen)
         : ExpressionContext(codegen) { }
 
-    virtual void Plug(bool flag) const;
-    virtual void Plug(Register reg) const;
-    virtual void Plug(Label* materialize_true, Label* materialize_false) const;
-    virtual void Plug(Variable* var) const;
-    virtual void Plug(Handle<Object> lit) const;
-    virtual void Plug(Heap::RootListIndex) const;
-    virtual void PlugTOS() const;
-    virtual void DropAndPlug(int count, Register reg) const;
-    virtual void PrepareTest(Label* materialize_true,
-                             Label* materialize_false,
-                             Label** if_true,
-                             Label** if_false,
-                             Label** fall_through) const;
-    virtual bool IsEffect() const { return true; }
+    void Plug(bool flag) const override;
+    void Plug(Register reg) const override;
+    void Plug(Label* materialize_true, Label* materialize_false) const override;
+    void Plug(Variable* var) const override;
+    void Plug(Handle<Object> lit) const override;
+    void Plug(Heap::RootListIndex) const override;
+    void PlugTOS() const override;
+    void DropAndPlug(int count, Register reg) const override;
+    void PrepareTest(Label* materialize_true, Label* materialize_false,
+                     Label** if_true, Label** if_false,
+                     Label** fall_through) const override;
+    bool IsEffect() const override { return true; }
   };
 
   class EnterBlockScopeIfNeeded {
    public:
     EnterBlockScopeIfNeeded(FullCodeGenerator* codegen, Scope* scope,
                             BailoutId entry_id, BailoutId declarations_id,
                             BailoutId exit_id);
     ~EnterBlockScopeIfNeeded();
 
    private:
@@ skipping 112 matching lines @@
   Address start_;
   Address instruction_start_;
   uint32_t length_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_FULL_CODEGEN_FULL_CODEGEN_H_