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

src/ast.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_AST_H_
 #define V8_AST_H_
 
 #include "src/v8.h"
 
 #include "src/assembler.h"
@@ skipping 122 matching lines @@
 #undef DEF_FORWARD_DECLARATION
 
 
 // Typedef only introduced to avoid unreadable code.
 // Please do appreciate the required space in "> >".
 typedef ZoneList<Handle<String> > ZoneStringList;
 typedef ZoneList<Handle<Object> > ZoneObjectList;
 
 
 #define DECLARE_NODE_TYPE(type)                                          \
-  void Accept(AstVisitor* v) OVERRIDE;                                   \
-  AstNode::NodeType node_type() const FINAL { return AstNode::k##type; } \
+  void Accept(AstVisitor* v) override;                                   \
+  AstNode::NodeType node_type() const final { return AstNode::k##type; } \
   friend class AstNodeFactory;
 
 
 enum AstPropertiesFlag {
   kDontSelfOptimize,
   kDontSoftInline,
   kDontCache
 };
 
 
 class FeedbackVectorRequirements {
  public:
   FeedbackVectorRequirements(int slots, int ic_slots)
       : slots_(slots), ic_slots_(ic_slots) {}
 
   int slots() const { return slots_; }
   int ic_slots() const { return ic_slots_; }
 
  private:
   int slots_;
   int ic_slots_;
 };
 
 
-class VariableICSlotPair FINAL {
+class VariableICSlotPair final {
  public:
   VariableICSlotPair(Variable* variable, FeedbackVectorICSlot slot)
       : variable_(variable), slot_(slot) {}
   VariableICSlotPair()
       : variable_(NULL), slot_(FeedbackVectorICSlot::Invalid()) {}
 
   Variable* variable() const { return variable_; }
   FeedbackVectorICSlot slot() const { return slot_; }
 
  private:
   Variable* variable_;
   FeedbackVectorICSlot slot_;
 };
 
 
 typedef List<VariableICSlotPair> ICSlotCache;
 
 
-class AstProperties FINAL BASE_EMBEDDED {
+class AstProperties final BASE_EMBEDDED {
  public:
   class Flags : public EnumSet<AstPropertiesFlag, int> {};
 
   explicit AstProperties(Zone* zone) : node_count_(0), spec_(zone) {}
 
   Flags* flags() { return &flags_; }
   int node_count() { return node_count_; }
   void add_node_count(int count) { node_count_ += count; }
 
   int slots() const { return spec_.slots(); }
@@ skipping 77 matching lines @@
 
 class Statement : public AstNode {
  public:
   explicit Statement(Zone* zone, int position) : AstNode(position) {}
 
   bool IsEmpty() { return AsEmptyStatement() != NULL; }
   virtual bool IsJump() const { return false; }
 };
 
 
-class SmallMapList FINAL {
+class SmallMapList final {
  public:
   SmallMapList() {}
   SmallMapList(int capacity, Zone* zone) : list_(capacity, zone) {}
 
   void Reserve(int capacity, Zone* zone) { list_.Reserve(capacity, zone); }
   void Clear() { list_.Clear(); }
   void Sort() { list_.Sort(); }
 
   bool is_empty() const { return list_.is_empty(); }
   int length() const { return list_.length(); }
@@ skipping 151 matching lines @@
   enum BreakableType {
     TARGET_FOR_ANONYMOUS,
     TARGET_FOR_NAMED_ONLY
   };
 
   // The labels associated with this statement. May be NULL;
   // if it is != NULL, guaranteed to contain at least one entry.
   ZoneList<const AstRawString*>* labels() const { return labels_; }
 
   // Type testing & conversion.
-  BreakableStatement* AsBreakableStatement() FINAL { return this; }
+  BreakableStatement* AsBreakableStatement() final { return this; }
 
   // Code generation
   Label* break_target() { return &break_target_; }
 
   // Testers.
   bool is_target_for_anonymous() const {
     return breakable_type_ == TARGET_FOR_ANONYMOUS;
   }
 
   void set_base_id(int id) { base_id_ = id; }
@@ skipping 20 matching lines @@
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   ZoneList<const AstRawString*>* labels_;
   BreakableType breakable_type_;
   Label break_target_;
   int base_id_;
 };
 
 
-class Block FINAL : public BreakableStatement {
+class Block final : public BreakableStatement {
  public:
   DECLARE_NODE_TYPE(Block)
 
   void AddStatement(Statement* statement, Zone* zone) {
     statements_.Add(statement, zone);
   }
 
   ZoneList<Statement*>* statements() { return &statements_; }
   bool is_initializer_block() const { return is_initializer_block_; }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId DeclsId() const { return BailoutId(local_id(0)); }
 
-  bool IsJump() const OVERRIDE {
+  bool IsJump() const override {
     return !statements_.is_empty() && statements_.last()->IsJump()
         && labels() == NULL;  // Good enough as an approximation...
   }
 
   Scope* scope() const { return scope_; }
   void set_scope(Scope* scope) { scope_ = scope; }
 
  protected:
   Block(Zone* zone, ZoneList<const AstRawString*>* labels, int capacity,
         bool is_initializer_block, int pos)
@@ skipping 29 matching lines @@
 
  private:
   VariableMode mode_;
   VariableProxy* proxy_;
 
   // Nested scope from which the declaration originated.
   Scope* scope_;
 };
 
 
-class VariableDeclaration FINAL : public Declaration {
+class VariableDeclaration final : public Declaration {
  public:
   DECLARE_NODE_TYPE(VariableDeclaration)
 
-  InitializationFlag initialization() const OVERRIDE {
+  InitializationFlag initialization() const override {
     return mode() == VAR ? kCreatedInitialized : kNeedsInitialization;
   }
 
   bool is_class_declaration() const { return is_class_declaration_; }
 
  protected:
   VariableDeclaration(Zone* zone, VariableProxy* proxy, VariableMode mode,
                       Scope* scope, int pos, bool is_class_declaration = false)
       : Declaration(zone, proxy, mode, scope, pos),
         is_class_declaration_(is_class_declaration) {}
 
   bool is_class_declaration_;
 };
 
 
-class FunctionDeclaration FINAL : public Declaration {
+class FunctionDeclaration final : public Declaration {
  public:
   DECLARE_NODE_TYPE(FunctionDeclaration)
 
   FunctionLiteral* fun() const { return fun_; }
-  InitializationFlag initialization() const OVERRIDE {
+  InitializationFlag initialization() const override {
     return kCreatedInitialized;
   }
-  bool IsInlineable() const OVERRIDE;
+  bool IsInlineable() const override;
 
  protected:
   FunctionDeclaration(Zone* zone,
                       VariableProxy* proxy,
                       VariableMode mode,
                       FunctionLiteral* fun,
                       Scope* scope,
                       int pos)
       : Declaration(zone, proxy, mode, scope, pos),
         fun_(fun) {
     DCHECK(mode == VAR || mode == LET || mode == CONST);
     DCHECK(fun != NULL);
   }
 
  private:
   FunctionLiteral* fun_;
 };
 
 
-class ModuleDeclaration FINAL : public Declaration {
+class ModuleDeclaration final : public Declaration {
  public:
   DECLARE_NODE_TYPE(ModuleDeclaration)
 
   Module* module() const { return module_; }
-  InitializationFlag initialization() const OVERRIDE {
+  InitializationFlag initialization() const override {
     return kCreatedInitialized;
   }
 
  protected:
   ModuleDeclaration(Zone* zone, VariableProxy* proxy, Module* module,
                     Scope* scope, int pos)
       : Declaration(zone, proxy, CONST, scope, pos), module_(module) {}
 
  private:
   Module* module_;
 };
 
 
-class ImportDeclaration FINAL : public Declaration {
+class ImportDeclaration final : public Declaration {
  public:
   DECLARE_NODE_TYPE(ImportDeclaration)
 
   const AstRawString* import_name() const { return import_name_; }
   const AstRawString* module_specifier() const { return module_specifier_; }
   void set_module_specifier(const AstRawString* module_specifier) {
     DCHECK(module_specifier_ == NULL);
     module_specifier_ = module_specifier;
   }
-  InitializationFlag initialization() const OVERRIDE {
+  InitializationFlag initialization() const override {
     return kNeedsInitialization;
   }
 
  protected:
   ImportDeclaration(Zone* zone, VariableProxy* proxy,
                     const AstRawString* import_name,
                     const AstRawString* module_specifier, Scope* scope, int pos)
       : Declaration(zone, proxy, IMPORT, scope, pos),
         import_name_(import_name),
         module_specifier_(module_specifier) {}
 
  private:
   const AstRawString* import_name_;
   const AstRawString* module_specifier_;
 };
 
 
-class ExportDeclaration FINAL : public Declaration {
+class ExportDeclaration final : public Declaration {
  public:
   DECLARE_NODE_TYPE(ExportDeclaration)
 
-  InitializationFlag initialization() const OVERRIDE {
+  InitializationFlag initialization() const override {
     return kCreatedInitialized;
   }
 
  protected:
   ExportDeclaration(Zone* zone, VariableProxy* proxy, Scope* scope, int pos)
       : Declaration(zone, proxy, LET, scope, pos) {}
 };
 
 
 class Module : public AstNode {
  public:
   ModuleDescriptor* descriptor() const { return descriptor_; }
   Block* body() const { return body_; }
 
  protected:
   Module(Zone* zone, int pos)
       : AstNode(pos), descriptor_(ModuleDescriptor::New(zone)), body_(NULL) {}
   Module(Zone* zone, ModuleDescriptor* descriptor, int pos, Block* body = NULL)
       : AstNode(pos), descriptor_(descriptor), body_(body) {}
 
  private:
   ModuleDescriptor* descriptor_;
   Block* body_;
 };
 
 
-class ModuleLiteral FINAL : public Module {
+class ModuleLiteral final : public Module {
  public:
   DECLARE_NODE_TYPE(ModuleLiteral)
 
  protected:
   ModuleLiteral(Zone* zone, Block* body, ModuleDescriptor* descriptor, int pos)
       : Module(zone, descriptor, pos, body) {}
 };
 
 
-class ModulePath FINAL : public Module {
+class ModulePath final : public Module {
  public:
   DECLARE_NODE_TYPE(ModulePath)
 
   Module* module() const { return module_; }
   Handle<String> name() const { return name_->string(); }
 
  protected:
   ModulePath(Zone* zone, Module* module, const AstRawString* name, int pos)
       : Module(zone, pos), module_(module), name_(name) {}
 
  private:
   Module* module_;
   const AstRawString* name_;
 };
 
 
-class ModuleUrl FINAL : public Module {
+class ModuleUrl final : public Module {
  public:
   DECLARE_NODE_TYPE(ModuleUrl)
 
   Handle<String> url() const { return url_; }
 
  protected:
   ModuleUrl(Zone* zone, Handle<String> url, int pos)
       : Module(zone, pos), url_(url) {
   }
 
  private:
   Handle<String> url_;
 };
 
 
-class ModuleStatement FINAL : public Statement {
+class ModuleStatement final : public Statement {
  public:
   DECLARE_NODE_TYPE(ModuleStatement)
 
   Block* body() const { return body_; }
 
  protected:
   ModuleStatement(Zone* zone, Block* body, int pos)
       : Statement(zone, pos), body_(body) {}
 
  private:
   Block* body_;
 };
 
 
 class IterationStatement : public BreakableStatement {
  public:
   // Type testing & conversion.
-  IterationStatement* AsIterationStatement() FINAL { return this; }
+  IterationStatement* AsIterationStatement() final { return this; }
 
   Statement* body() const { return body_; }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId OsrEntryId() const { return BailoutId(local_id(0)); }
   virtual BailoutId ContinueId() const = 0;
   virtual BailoutId StackCheckId() const = 0;
 
   // Code generation
   Label* continue_target()  { return &continue_target_; }
 
  protected:
   IterationStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos),
         body_(NULL) {}
   static int parent_num_ids() { return BreakableStatement::num_ids(); }
   void Initialize(Statement* body) { body_ = body; }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Statement* body_;
   Label continue_target_;
 };
 
 
-class DoWhileStatement FINAL : public IterationStatement {
+class DoWhileStatement final : public IterationStatement {
  public:
   DECLARE_NODE_TYPE(DoWhileStatement)
 
   void Initialize(Expression* cond, Statement* body) {
     IterationStatement::Initialize(body);
     cond_ = cond;
   }
 
   Expression* cond() const { return cond_; }
 
   static int num_ids() { return parent_num_ids() + 2; }
-  BailoutId ContinueId() const OVERRIDE { return BailoutId(local_id(0)); }
-  BailoutId StackCheckId() const OVERRIDE { return BackEdgeId(); }
+  BailoutId ContinueId() const override { return BailoutId(local_id(0)); }
+  BailoutId StackCheckId() const override { return BackEdgeId(); }
   BailoutId BackEdgeId() const { return BailoutId(local_id(1)); }
 
  protected:
   DoWhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : IterationStatement(zone, labels, pos), cond_(NULL) {}
   static int parent_num_ids() { return IterationStatement::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Expression* cond_;
 };
 
 
-class WhileStatement FINAL : public IterationStatement {
+class WhileStatement final : public IterationStatement {
  public:
   DECLARE_NODE_TYPE(WhileStatement)
 
   void Initialize(Expression* cond, Statement* body) {
     IterationStatement::Initialize(body);
     cond_ = cond;
   }
 
   Expression* cond() const { return cond_; }
 
   static int num_ids() { return parent_num_ids() + 1; }
-  BailoutId ContinueId() const OVERRIDE { return EntryId(); }
-  BailoutId StackCheckId() const OVERRIDE { return BodyId(); }
+  BailoutId ContinueId() const override { return EntryId(); }
+  BailoutId StackCheckId() const override { return BodyId(); }
   BailoutId BodyId() const { return BailoutId(local_id(0)); }
 
  protected:
   WhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : IterationStatement(zone, labels, pos), cond_(NULL) {}
   static int parent_num_ids() { return IterationStatement::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Expression* cond_;
 };
 
 
-class ForStatement FINAL : public IterationStatement {
+class ForStatement final : public IterationStatement {
  public:
   DECLARE_NODE_TYPE(ForStatement)
 
   void Initialize(Statement* init,
                   Expression* cond,
                   Statement* next,
                   Statement* body) {
     IterationStatement::Initialize(body);
     init_ = init;
     cond_ = cond;
     next_ = next;
   }
 
   Statement* init() const { return init_; }
   Expression* cond() const { return cond_; }
   Statement* next() const { return next_; }
 
   static int num_ids() { return parent_num_ids() + 2; }
-  BailoutId ContinueId() const OVERRIDE { return BailoutId(local_id(0)); }
-  BailoutId StackCheckId() const OVERRIDE { return BodyId(); }
+  BailoutId ContinueId() const override { return BailoutId(local_id(0)); }
+  BailoutId StackCheckId() const override { return BodyId(); }
   BailoutId BodyId() const { return BailoutId(local_id(1)); }
 
  protected:
   ForStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : IterationStatement(zone, labels, pos),
         init_(NULL),
         cond_(NULL),
         next_(NULL) {}
   static int parent_num_ids() { return IterationStatement::num_ids(); }
 
@@ skipping 25 matching lines @@
  protected:
   ForEachStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : IterationStatement(zone, labels, pos), each_(NULL), subject_(NULL) {}
 
  private:
   Expression* each_;
   Expression* subject_;
 };
 
 
-class ForInStatement FINAL : public ForEachStatement {
+class ForInStatement final : public ForEachStatement {
  public:
   DECLARE_NODE_TYPE(ForInStatement)
 
   Expression* enumerable() const {
     return subject();
   }
 
   // Type feedback information.
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
-      Isolate* isolate, const ICSlotCache* cache) OVERRIDE {
+      Isolate* isolate, const ICSlotCache* cache) override {
     return FeedbackVectorRequirements(1, 0);
   }
-  void SetFirstFeedbackSlot(FeedbackVectorSlot slot) OVERRIDE {
+  void SetFirstFeedbackSlot(FeedbackVectorSlot slot) override {
     for_in_feedback_slot_ = slot;
   }
 
   FeedbackVectorSlot ForInFeedbackSlot() {
     DCHECK(!for_in_feedback_slot_.IsInvalid());
     return for_in_feedback_slot_;
   }
 
   enum ForInType { FAST_FOR_IN, SLOW_FOR_IN };
   ForInType for_in_type() const { return for_in_type_; }
   void set_for_in_type(ForInType type) { for_in_type_ = type; }
 
   static int num_ids() { return parent_num_ids() + 6; }
   BailoutId BodyId() const { return BailoutId(local_id(0)); }
   BailoutId PrepareId() const { return BailoutId(local_id(1)); }
   BailoutId EnumId() const { return BailoutId(local_id(2)); }
   BailoutId ToObjectId() const { return BailoutId(local_id(3)); }
   BailoutId FilterId() const { return BailoutId(local_id(4)); }
   BailoutId AssignmentId() const { return BailoutId(local_id(5)); }
-  BailoutId ContinueId() const OVERRIDE { return EntryId(); }
-  BailoutId StackCheckId() const OVERRIDE { return BodyId(); }
+  BailoutId ContinueId() const override { return EntryId(); }
+  BailoutId StackCheckId() const override { return BodyId(); }
 
  protected:
   ForInStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : ForEachStatement(zone, labels, pos),
         for_in_type_(SLOW_FOR_IN),
         for_in_feedback_slot_(FeedbackVectorSlot::Invalid()) {}
   static int parent_num_ids() { return ForEachStatement::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   ForInType for_in_type_;
   FeedbackVectorSlot for_in_feedback_slot_;
 };
 
 
-class ForOfStatement FINAL : public ForEachStatement {
+class ForOfStatement final : public ForEachStatement {
  public:
   DECLARE_NODE_TYPE(ForOfStatement)
 
   void Initialize(Expression* each,
                   Expression* subject,
                   Statement* body,
                   Expression* assign_iterator,
                   Expression* next_result,
                   Expression* result_done,
                   Expression* assign_each) {
@@ skipping 21 matching lines @@
   // result.done
   Expression* result_done() const {
     return result_done_;
   }
 
   // each = result.value
   Expression* assign_each() const {
     return assign_each_;
   }
 
-  BailoutId ContinueId() const OVERRIDE { return EntryId(); }
-  BailoutId StackCheckId() const OVERRIDE { return BackEdgeId(); }
+  BailoutId ContinueId() const override { return EntryId(); }
+  BailoutId StackCheckId() const override { return BackEdgeId(); }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId BackEdgeId() const { return BailoutId(local_id(0)); }
 
  protected:
   ForOfStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : ForEachStatement(zone, labels, pos),
         assign_iterator_(NULL),
         next_result_(NULL),
         result_done_(NULL),
         assign_each_(NULL) {}
   static int parent_num_ids() { return ForEachStatement::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Expression* assign_iterator_;
   Expression* next_result_;
   Expression* result_done_;
   Expression* assign_each_;
 };
 
 
-class ExpressionStatement FINAL : public Statement {
+class ExpressionStatement final : public Statement {
  public:
   DECLARE_NODE_TYPE(ExpressionStatement)
 
   void set_expression(Expression* e) { expression_ = e; }
   Expression* expression() const { return expression_; }
-  bool IsJump() const OVERRIDE { return expression_->IsThrow(); }
+  bool IsJump() const override { return expression_->IsThrow(); }
 
  protected:
   ExpressionStatement(Zone* zone, Expression* expression, int pos)
       : Statement(zone, pos), expression_(expression) { }
 
  private:
   Expression* expression_;
 };
 
 
 class JumpStatement : public Statement {
  public:
-  bool IsJump() const FINAL { return true; }
+  bool IsJump() const final { return true; }
 
  protected:
   explicit JumpStatement(Zone* zone, int pos) : Statement(zone, pos) {}
 };
 
 
-class ContinueStatement FINAL : public JumpStatement {
+class ContinueStatement final : public JumpStatement {
  public:
   DECLARE_NODE_TYPE(ContinueStatement)
 
   IterationStatement* target() const { return target_; }
 
  protected:
   explicit ContinueStatement(Zone* zone, IterationStatement* target, int pos)
       : JumpStatement(zone, pos), target_(target) { }
 
  private:
   IterationStatement* target_;
 };
 
 
-class BreakStatement FINAL : public JumpStatement {
+class BreakStatement final : public JumpStatement {
  public:
   DECLARE_NODE_TYPE(BreakStatement)
 
   BreakableStatement* target() const { return target_; }
 
  protected:
   explicit BreakStatement(Zone* zone, BreakableStatement* target, int pos)
       : JumpStatement(zone, pos), target_(target) { }
 
  private:
   BreakableStatement* target_;
 };
 
 
-class ReturnStatement FINAL : public JumpStatement {
+class ReturnStatement final : public JumpStatement {
  public:
   DECLARE_NODE_TYPE(ReturnStatement)
 
   Expression* expression() const { return expression_; }
 
  protected:
   explicit ReturnStatement(Zone* zone, Expression* expression, int pos)
       : JumpStatement(zone, pos), expression_(expression) { }
 
  private:
   Expression* expression_;
 };
 
 
-class WithStatement FINAL : public Statement {
+class WithStatement final : public Statement {
  public:
   DECLARE_NODE_TYPE(WithStatement)
 
   Scope* scope() { return scope_; }
   Expression* expression() const { return expression_; }
   Statement* statement() const { return statement_; }
 
   void set_base_id(int id) { base_id_ = id; }
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId EntryId() const { return BailoutId(local_id(0)); }
@@ skipping 16 matching lines @@
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Scope* scope_;
   Expression* expression_;
   Statement* statement_;
   int base_id_;
 };
 
 
-class CaseClause FINAL : public Expression {
+class CaseClause final : public Expression {
  public:
   DECLARE_NODE_TYPE(CaseClause)
 
   bool is_default() const { return label_ == NULL; }
   Expression* label() const {
     CHECK(!is_default());
     return label_;
   }
   Label* body_target() { return &body_target_; }
   ZoneList<Statement*>* statements() const { return statements_; }
@@ skipping 13 matching lines @@
              int pos);
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Expression* label_;
   Label body_target_;
   ZoneList<Statement*>* statements_;
   Type* compare_type_;
 };
 
 
-class SwitchStatement FINAL : public BreakableStatement {
+class SwitchStatement final : public BreakableStatement {
  public:
   DECLARE_NODE_TYPE(SwitchStatement)
 
   void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
     tag_ = tag;
     cases_ = cases;
   }
 
   Expression* tag() const { return tag_; }
   ZoneList<CaseClause*>* cases() const { return cases_; }
 
  protected:
   SwitchStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos),
         tag_(NULL),
         cases_(NULL) {}
 
  private:
   Expression* tag_;
   ZoneList<CaseClause*>* cases_;
 };
 
 
 // If-statements always have non-null references to their then- and
 // else-parts. When parsing if-statements with no explicit else-part,
 // the parser implicitly creates an empty statement. Use the
 // HasThenStatement() and HasElseStatement() functions to check if a
 // given if-statement has a then- or an else-part containing code.
-class IfStatement FINAL : public Statement {
+class IfStatement final : public Statement {
  public:
   DECLARE_NODE_TYPE(IfStatement)
 
   bool HasThenStatement() const { return !then_statement()->IsEmpty(); }
   bool HasElseStatement() const { return !else_statement()->IsEmpty(); }
 
   Expression* condition() const { return condition_; }
   Statement* then_statement() const { return then_statement_; }
   Statement* else_statement() const { return else_statement_; }
 
-  bool IsJump() const OVERRIDE {
+  bool IsJump() const override {
     return HasThenStatement() && then_statement()->IsJump()
         && HasElseStatement() && else_statement()->IsJump();
   }
 
   void set_base_id(int id) { base_id_ = id; }
   static int num_ids() { return parent_num_ids() + 3; }
   BailoutId IfId() const { return BailoutId(local_id(0)); }
   BailoutId ThenId() const { return BailoutId(local_id(1)); }
   BailoutId ElseId() const { return BailoutId(local_id(2)); }
 
@@ skipping 32 matching lines @@
       : Statement(zone, pos), index_(index), try_block_(try_block) {}
 
  private:
   // Unique (per-function) index of this handler.  This is not an AST ID.
   int index_;
 
   Block* try_block_;
 };
 
 
-class TryCatchStatement FINAL : public TryStatement {
+class TryCatchStatement final : public TryStatement {
  public:
   DECLARE_NODE_TYPE(TryCatchStatement)
 
   Scope* scope() { return scope_; }
   Variable* variable() { return variable_; }
   Block* catch_block() const { return catch_block_; }
 
  protected:
   TryCatchStatement(Zone* zone,
                     int index,
                     Block* try_block,
                     Scope* scope,
                     Variable* variable,
                     Block* catch_block,
                     int pos)
       : TryStatement(zone, index, try_block, pos),
         scope_(scope),
         variable_(variable),
         catch_block_(catch_block) {
   }
 
  private:
   Scope* scope_;
   Variable* variable_;
   Block* catch_block_;
 };
 
 
-class TryFinallyStatement FINAL : public TryStatement {
+class TryFinallyStatement final : public TryStatement {
  public:
   DECLARE_NODE_TYPE(TryFinallyStatement)
 
   Block* finally_block() const { return finally_block_; }
 
  protected:
   TryFinallyStatement(
       Zone* zone, int index, Block* try_block, Block* finally_block, int pos)
       : TryStatement(zone, index, try_block, pos),
         finally_block_(finally_block) { }
 
  private:
   Block* finally_block_;
 };
 
 
-class DebuggerStatement FINAL : public Statement {
+class DebuggerStatement final : public Statement {
  public:
   DECLARE_NODE_TYPE(DebuggerStatement)
 
   void set_base_id(int id) { base_id_ = id; }
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId DebugBreakId() const { return BailoutId(local_id(0)); }
 
  protected:
   explicit DebuggerStatement(Zone* zone, int pos)
       : Statement(zone, pos), base_id_(BailoutId::None().ToInt()) {}
   static int parent_num_ids() { return 0; }
 
   int base_id() const {
     DCHECK(!BailoutId(base_id_).IsNone());
     return base_id_;
   }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   int base_id_;
 };
 
 
-class EmptyStatement FINAL : public Statement {
+class EmptyStatement final : public Statement {
  public:
   DECLARE_NODE_TYPE(EmptyStatement)
 
  protected:
   explicit EmptyStatement(Zone* zone, int pos): Statement(zone, pos) {}
 };
 
 
-class Literal FINAL : public Expression {
+class Literal final : public Expression {
  public:
   DECLARE_NODE_TYPE(Literal)
 
-  bool IsPropertyName() const OVERRIDE { return value_->IsPropertyName(); }
+  bool IsPropertyName() const override { return value_->IsPropertyName(); }
 
   Handle<String> AsPropertyName() {
     DCHECK(IsPropertyName());
     return Handle<String>::cast(value());
   }
 
   const AstRawString* AsRawPropertyName() {
     DCHECK(IsPropertyName());
     return value_->AsString();
   }
 
-  bool ToBooleanIsTrue() const OVERRIDE { return value()->BooleanValue(); }
-  bool ToBooleanIsFalse() const OVERRIDE { return !value()->BooleanValue(); }
+  bool ToBooleanIsTrue() const override { return value()->BooleanValue(); }
+  bool ToBooleanIsFalse() const override { return !value()->BooleanValue(); }
 
   Handle<Object> value() const { return value_->value(); }
   const AstValue* raw_value() const { return value_; }
 
   // Support for using Literal as a HashMap key. NOTE: Currently, this works
   // only for string and number literals!
   uint32_t Hash();
   static bool Match(void* literal1, void* literal2);
 
   static int num_ids() { return parent_num_ids() + 1; }
@@ skipping 59 matching lines @@
  private:
   int literal_index_;
   bool is_simple_;
   int depth_;
 };
 
 
 // Property is used for passing information
 // about an object literal's properties from the parser
 // to the code generator.
-class ObjectLiteralProperty FINAL : public ZoneObject {
+class ObjectLiteralProperty final : public ZoneObject {
  public:
   enum Kind {
     CONSTANT,              // Property with constant value (compile time).
     COMPUTED,              // Property with computed value (execution time).
     MATERIALIZED_LITERAL,  // Property value is a materialized literal.
     GETTER, SETTER,        // Property is an accessor function.
     PROTOTYPE              // Property is __proto__.
   };
 
   Expression* key() { return key_; }
@@ skipping 29 matching lines @@
   Kind kind_;
   bool emit_store_;
   bool is_static_;
   bool is_computed_name_;
   Handle<Map> receiver_type_;
 };
 
 
 // An object literal has a boilerplate object that is used
 // for minimizing the work when constructing it at runtime.
-class ObjectLiteral FINAL : public MaterializedLiteral {
+class ObjectLiteral final : public MaterializedLiteral {
  public:
   typedef ObjectLiteralProperty Property;
 
   DECLARE_NODE_TYPE(ObjectLiteral)
 
   Handle<FixedArray> constant_properties() const {
     return constant_properties_;
   }
   int properties_count() const { return constant_properties_->length() / 2; }
   ZoneList<Property*>* properties() const { return properties_; }
@@ skipping 63 matching lines @@
   ZoneList<Property*>* properties_;
   int boilerplate_properties_;
   bool fast_elements_;
   bool has_elements_;
   bool may_store_doubles_;
   bool has_function_;
 };
 
 
 // Node for capturing a regexp literal.
-class RegExpLiteral FINAL : public MaterializedLiteral {
+class RegExpLiteral final : public MaterializedLiteral {
  public:
   DECLARE_NODE_TYPE(RegExpLiteral)
 
   Handle<String> pattern() const { return pattern_->string(); }
   Handle<String> flags() const { return flags_->string(); }
 
  protected:
   RegExpLiteral(Zone* zone, const AstRawString* pattern,
                 const AstRawString* flags, int literal_index, int pos)
       : MaterializedLiteral(zone, literal_index, pos),
         pattern_(pattern),
         flags_(flags) {
     set_depth(1);
   }
 
  private:
   const AstRawString* pattern_;
   const AstRawString* flags_;
 };
 
 
 // An array literal has a literals object that is used
 // for minimizing the work when constructing it at runtime.
-class ArrayLiteral FINAL : public MaterializedLiteral {
+class ArrayLiteral final : public MaterializedLiteral {
  public:
   DECLARE_NODE_TYPE(ArrayLiteral)
 
   Handle<FixedArray> constant_elements() const { return constant_elements_; }
   ElementsKind constant_elements_kind() const {
     DCHECK_EQ(2, constant_elements_->length());
     return static_cast<ElementsKind>(
         Smi::cast(constant_elements_->get(0))->value());
   }
 
@@ skipping 33 matching lines @@
   static int parent_num_ids() { return MaterializedLiteral::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Handle<FixedArray> constant_elements_;
   ZoneList<Expression*>* values_;
 };
 
 
-class VariableProxy FINAL : public Expression {
+class VariableProxy final : public Expression {
  public:
   DECLARE_NODE_TYPE(VariableProxy)
 
-  bool IsValidReferenceExpression() const OVERRIDE { return !is_this(); }
+  bool IsValidReferenceExpression() const override { return !is_this(); }
 
   bool IsArguments() const { return is_resolved() && var()->is_arguments(); }
 
   Handle<String> name() const { return raw_name()->string(); }
   const AstRawString* raw_name() const {
     return is_resolved() ? var_->raw_name() : raw_name_;
   }
 
   Variable* var() const {
     DCHECK(is_resolved());
@@ skipping 20 matching lines @@
   int end_position() const { return end_position_; }
 
   // Bind this proxy to the variable var.
   void BindTo(Variable* var);
 
   bool UsesVariableFeedbackSlot() const {
     return FLAG_vector_ics && (var()->IsUnallocated() || var()->IsLookupSlot());
   }
 
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
-      Isolate* isolate, const ICSlotCache* cache) OVERRIDE;
+      Isolate* isolate, const ICSlotCache* cache) override;
 
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
-                              ICSlotCache* cache) OVERRIDE;
-  Code::Kind FeedbackICSlotKind(int index) OVERRIDE { return Code::LOAD_IC; }
+                              ICSlotCache* cache) override;
+  Code::Kind FeedbackICSlotKind(int index) override { return Code::LOAD_IC; }
   FeedbackVectorICSlot VariableFeedbackSlot() {
     DCHECK(!UsesVariableFeedbackSlot() || !variable_feedback_slot_.IsInvalid());
     return variable_feedback_slot_;
   }
 
  protected:
   VariableProxy(Zone* zone, Variable* var, int start_position,
                 int end_position);
 
   VariableProxy(Zone* zone, const AstRawString* name,
@@ skipping 12 matching lines @@
     const AstRawString* raw_name_;  // if !is_resolved_
     Variable* var_;                 // if is_resolved_
   };
   // Position is stored in the AstNode superclass, but VariableProxy needs to
   // know its end position too (for error messages). It cannot be inferred from
   // the variable name length because it can contain escapes.
   int end_position_;
 };
 
 
-class Property FINAL : public Expression {
+class Property final : public Expression {
  public:
   DECLARE_NODE_TYPE(Property)
 
-  bool IsValidReferenceExpression() const OVERRIDE { return true; }
+  bool IsValidReferenceExpression() const override { return true; }
 
   Expression* obj() const { return obj_; }
   Expression* key() const { return key_; }
 
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId LoadId() const { return BailoutId(local_id(0)); }
   TypeFeedbackId PropertyFeedbackId() { return TypeFeedbackId(local_id(1)); }
 
   bool IsStringAccess() const {
     return IsStringAccessField::decode(bit_field_);
   }
 
   // Type feedback information.
-  bool IsMonomorphic() OVERRIDE { return receiver_types_.length() == 1; }
-  SmallMapList* GetReceiverTypes() OVERRIDE { return &receiver_types_; }
-  KeyedAccessStoreMode GetStoreMode() const OVERRIDE { return STANDARD_STORE; }
-  IcCheckType GetKeyType() const OVERRIDE {
+  bool IsMonomorphic() override { return receiver_types_.length() == 1; }
+  SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
+  KeyedAccessStoreMode GetStoreMode() const override { return STANDARD_STORE; }
+  IcCheckType GetKeyType() const override {
     return KeyTypeField::decode(bit_field_);
   }
   bool IsUninitialized() const {
     return !is_for_call() && HasNoTypeInformation();
   }
   bool HasNoTypeInformation() const {
     return GetInlineCacheState() == UNINITIALIZED;
   }
   InlineCacheState GetInlineCacheState() const {
     return InlineCacheStateField::decode(bit_field_);
@@ skipping 10 matching lines @@
   void mark_for_call() {
     bit_field_ = IsForCallField::update(bit_field_, true);
   }
   bool is_for_call() const { return IsForCallField::decode(bit_field_); }
 
   bool IsSuperAccess() {
     return obj()->IsSuperReference();
   }
 
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
-      Isolate* isolate, const ICSlotCache* cache) OVERRIDE {
+      Isolate* isolate, const ICSlotCache* cache) override {
     return FeedbackVectorRequirements(0, FLAG_vector_ics ? 1 : 0);
   }
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
-                              ICSlotCache* cache) OVERRIDE {
+                              ICSlotCache* cache) override {
     property_feedback_slot_ = slot;
   }
-  Code::Kind FeedbackICSlotKind(int index) OVERRIDE {
+  Code::Kind FeedbackICSlotKind(int index) override {
     return key()->IsPropertyName() ? Code::LOAD_IC : Code::KEYED_LOAD_IC;
   }
 
   FeedbackVectorICSlot PropertyFeedbackSlot() const {
     DCHECK(!FLAG_vector_ics || !property_feedback_slot_.IsInvalid());
     return property_feedback_slot_;
   }
 
  protected:
   Property(Zone* zone, Expression* obj, Expression* key, int pos)
@@ skipping 14 matching lines @@
   class KeyTypeField : public BitField8<IcCheckType, 2, 1> {};
   class InlineCacheStateField : public BitField8<InlineCacheState, 3, 4> {};
   uint8_t bit_field_;
   FeedbackVectorICSlot property_feedback_slot_;
   Expression* obj_;
   Expression* key_;
   SmallMapList receiver_types_;
 };
 
 
-class Call FINAL : public Expression {
+class Call final : public Expression {
  public:
   DECLARE_NODE_TYPE(Call)
 
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
 
   // Type feedback information.
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
-      Isolate* isolate, const ICSlotCache* cache) OVERRIDE;
+      Isolate* isolate, const ICSlotCache* cache) override;
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
-                              ICSlotCache* cache) OVERRIDE {
+                              ICSlotCache* cache) override {
     ic_slot_or_slot_ = slot.ToInt();
   }
-  void SetFirstFeedbackSlot(FeedbackVectorSlot slot) OVERRIDE {
+  void SetFirstFeedbackSlot(FeedbackVectorSlot slot) override {
     ic_slot_or_slot_ = slot.ToInt();
   }
-  Code::Kind FeedbackICSlotKind(int index) OVERRIDE { return Code::CALL_IC; }
+  Code::Kind FeedbackICSlotKind(int index) override { return Code::CALL_IC; }
 
   FeedbackVectorSlot CallFeedbackSlot() const {
     DCHECK(ic_slot_or_slot_ != FeedbackVectorSlot::Invalid().ToInt());
     return FeedbackVectorSlot(ic_slot_or_slot_);
   }
 
   FeedbackVectorICSlot CallFeedbackICSlot() const {
     DCHECK(ic_slot_or_slot_ != FeedbackVectorICSlot::Invalid().ToInt());
     return FeedbackVectorICSlot(ic_slot_or_slot_);
   }
 
-  SmallMapList* GetReceiverTypes() OVERRIDE {
+  SmallMapList* GetReceiverTypes() override {
     if (expression()->IsProperty()) {
       return expression()->AsProperty()->GetReceiverTypes();
     }
     return NULL;
   }
 
-  bool IsMonomorphic() OVERRIDE {
+  bool IsMonomorphic() override {
     if (expression()->IsProperty()) {
       return expression()->AsProperty()->IsMonomorphic();
     }
     return !target_.is_null();
   }
 
   bool global_call() const {
     VariableProxy* proxy = expression_->AsVariableProxy();
     return proxy != NULL && proxy->var()->IsUnallocated();
   }
@@ skipping 67 matching lines @@
   int ic_slot_or_slot_;
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
   Handle<JSFunction> target_;
   Handle<AllocationSite> allocation_site_;
   class IsUninitializedField : public BitField8<bool, 0, 1> {};
   uint8_t bit_field_;
 };
 
 
-class CallNew FINAL : public Expression {
+class CallNew final : public Expression {
  public:
   DECLARE_NODE_TYPE(CallNew)
 
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
 
   // Type feedback information.
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
-      Isolate* isolate, const ICSlotCache* cache) OVERRIDE {
+      Isolate* isolate, const ICSlotCache* cache) override {
     return FeedbackVectorRequirements(FLAG_pretenuring_call_new ? 2 : 1, 0);
   }
-  void SetFirstFeedbackSlot(FeedbackVectorSlot slot) OVERRIDE {
+  void SetFirstFeedbackSlot(FeedbackVectorSlot slot) override {
     callnew_feedback_slot_ = slot;
   }
 
   FeedbackVectorSlot CallNewFeedbackSlot() {
     DCHECK(!callnew_feedback_slot_.IsInvalid());
     return callnew_feedback_slot_;
   }
   FeedbackVectorSlot AllocationSiteFeedbackSlot() {
     DCHECK(FLAG_pretenuring_call_new);
     return CallNewFeedbackSlot().next();
   }
 
-  bool IsMonomorphic() OVERRIDE { return is_monomorphic_; }
+  bool IsMonomorphic() override { return is_monomorphic_; }
   Handle<JSFunction> target() const { return target_; }
   Handle<AllocationSite> allocation_site() const {
     return allocation_site_;
   }
 
   static int num_ids() { return parent_num_ids() + 1; }
   static int feedback_slots() { return 1; }
   BailoutId ReturnId() const { return BailoutId(local_id(0)); }
 
   void set_allocation_site(Handle<AllocationSite> site) {
@@ skipping 26 matching lines @@
   Handle<JSFunction> target_;
   Handle<AllocationSite> allocation_site_;
   FeedbackVectorSlot callnew_feedback_slot_;
 };
 
 
 // The CallRuntime class does not represent any official JavaScript
 // language construct. Instead it is used to call a C or JS function
 // with a set of arguments. This is used from the builtins that are
 // implemented in JavaScript (see "v8natives.js").
-class CallRuntime FINAL : public Expression {
+class CallRuntime final : public Expression {
  public:
   DECLARE_NODE_TYPE(CallRuntime)
 
   Handle<String> name() const { return raw_name_->string(); }
   const AstRawString* raw_name() const { return raw_name_; }
   const Runtime::Function* function() const { return function_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
   bool is_jsruntime() const { return function_ == NULL; }
 
   // Type feedback information.
   bool HasCallRuntimeFeedbackSlot() const {
     return FLAG_vector_ics && is_jsruntime();
   }
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
-      Isolate* isolate, const ICSlotCache* cache) OVERRIDE {
+      Isolate* isolate, const ICSlotCache* cache) override {
     return FeedbackVectorRequirements(0, HasCallRuntimeFeedbackSlot() ? 1 : 0);
   }
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
-                              ICSlotCache* cache) OVERRIDE {
+                              ICSlotCache* cache) override {
     callruntime_feedback_slot_ = slot;
   }
-  Code::Kind FeedbackICSlotKind(int index) OVERRIDE { return Code::LOAD_IC; }
+  Code::Kind FeedbackICSlotKind(int index) override { return Code::LOAD_IC; }
 
   FeedbackVectorICSlot CallRuntimeFeedbackSlot() {
     DCHECK(!HasCallRuntimeFeedbackSlot() ||
            !callruntime_feedback_slot_.IsInvalid());
     return callruntime_feedback_slot_;
   }
 
   static int num_ids() { return parent_num_ids() + 1; }
   TypeFeedbackId CallRuntimeFeedbackId() const {
     return TypeFeedbackId(local_id(0));
@@ skipping 13 matching lines @@
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   const AstRawString* raw_name_;
   const Runtime::Function* function_;
   ZoneList<Expression*>* arguments_;
   FeedbackVectorICSlot callruntime_feedback_slot_;
 };
 
 
-class UnaryOperation FINAL : public Expression {
+class UnaryOperation final : public Expression {
  public:
   DECLARE_NODE_TYPE(UnaryOperation)
 
   Token::Value op() const { return op_; }
   Expression* expression() const { return expression_; }
 
   // For unary not (Token::NOT), the AST ids where true and false will
   // actually be materialized, respectively.
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId MaterializeTrueId() const { return BailoutId(local_id(0)); }
   BailoutId MaterializeFalseId() const { return BailoutId(local_id(1)); }
 
-  virtual void RecordToBooleanTypeFeedback(
-      TypeFeedbackOracle* oracle) OVERRIDE;
+  virtual void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) override;
 
  protected:
   UnaryOperation(Zone* zone, Token::Value op, Expression* expression, int pos)
       : Expression(zone, pos), op_(op), expression_(expression) {
     DCHECK(Token::IsUnaryOp(op));
   }
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Token::Value op_;
   Expression* expression_;
 };
 
 
-class BinaryOperation FINAL : public Expression {
+class BinaryOperation final : public Expression {
  public:
   DECLARE_NODE_TYPE(BinaryOperation)
 
   Token::Value op() const { return static_cast<Token::Value>(op_); }
   Expression* left() const { return left_; }
   Expression* right() const { return right_; }
   Handle<AllocationSite> allocation_site() const { return allocation_site_; }
   void set_allocation_site(Handle<AllocationSite> allocation_site) {
     allocation_site_ = allocation_site;
   }
 
   // The short-circuit logical operations need an AST ID for their
   // right-hand subexpression.
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId RightId() const { return BailoutId(local_id(0)); }
 
   TypeFeedbackId BinaryOperationFeedbackId() const {
     return TypeFeedbackId(local_id(1));
   }
   Maybe<int> fixed_right_arg() const {
     return has_fixed_right_arg_ ? Just(fixed_right_arg_value_) : Nothing<int>();
   }
   void set_fixed_right_arg(Maybe<int> arg) {
     has_fixed_right_arg_ = arg.IsJust();
     if (arg.IsJust()) fixed_right_arg_value_ = arg.FromJust();
   }
 
-  virtual void RecordToBooleanTypeFeedback(
-      TypeFeedbackOracle* oracle) OVERRIDE;
+  virtual void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) override;
 
  protected:
   BinaryOperation(Zone* zone, Token::Value op, Expression* left,
                   Expression* right, int pos)
       : Expression(zone, pos),
         op_(static_cast<byte>(op)),
         has_fixed_right_arg_(false),
         fixed_right_arg_value_(0),
         left_(left),
         right_(right) {
     DCHECK(Token::IsBinaryOp(op));
   }
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   const byte op_;  // actually Token::Value
   // TODO(rossberg): the fixed arg should probably be represented as a Constant
   // type for the RHS. Currenty it's actually a Maybe<int>
   bool has_fixed_right_arg_;
   int fixed_right_arg_value_;
   Expression* left_;
   Expression* right_;
   Handle<AllocationSite> allocation_site_;
 };
 
 
-class CountOperation FINAL : public Expression {
+class CountOperation final : public Expression {
  public:
   DECLARE_NODE_TYPE(CountOperation)
 
   bool is_prefix() const { return IsPrefixField::decode(bit_field_); }
   bool is_postfix() const { return !is_prefix(); }
 
   Token::Value op() const { return TokenField::decode(bit_field_); }
   Token::Value binary_op() {
     return (op() == Token::INC) ? Token::ADD : Token::SUB;
   }
 
   Expression* expression() const { return expression_; }
 
-  bool IsMonomorphic() OVERRIDE { return receiver_types_.length() == 1; }
-  SmallMapList* GetReceiverTypes() OVERRIDE { return &receiver_types_; }
-  IcCheckType GetKeyType() const OVERRIDE {
+  bool IsMonomorphic() override { return receiver_types_.length() == 1; }
+  SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
+  IcCheckType GetKeyType() const override {
     return KeyTypeField::decode(bit_field_);
   }
-  KeyedAccessStoreMode GetStoreMode() const OVERRIDE {
+  KeyedAccessStoreMode GetStoreMode() const override {
     return StoreModeField::decode(bit_field_);
   }
   Type* type() const { return type_; }
   void set_key_type(IcCheckType type) {
     bit_field_ = KeyTypeField::update(bit_field_, type);
   }
   void set_store_mode(KeyedAccessStoreMode mode) {
     bit_field_ = StoreModeField::update(bit_field_, mode);
   }
   void set_type(Type* type) { type_ = type; }
@@ skipping 30 matching lines @@
 
   // Starts with 16-bit field, which should get packed together with
   // Expression's trailing 16-bit field.
   uint16_t bit_field_;
   Type* type_;
   Expression* expression_;
   SmallMapList receiver_types_;
 };
 
 
-class CompareOperation FINAL : public Expression {
+class CompareOperation final : public Expression {
  public:
   DECLARE_NODE_TYPE(CompareOperation)
 
   Token::Value op() const { return op_; }
   Expression* left() const { return left_; }
   Expression* right() const { return right_; }
 
   // Type feedback information.
   static int num_ids() { return parent_num_ids() + 1; }
   TypeFeedbackId CompareOperationFeedbackId() const {
@@ skipping 23 matching lines @@
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Token::Value op_;
   Expression* left_;
   Expression* right_;
 
   Type* combined_type_;
 };
 
 
-class Spread FINAL : public Expression {
+class Spread final : public Expression {
  public:
   DECLARE_NODE_TYPE(Spread)
 
   Expression* expression() const { return expression_; }
 
   static int num_ids() { return parent_num_ids(); }
 
  protected:
   Spread(Zone* zone, Expression* expression, int pos)
       : Expression(zone, pos), expression_(expression) {}
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Expression* expression_;
 };
 
 
-class Conditional FINAL : public Expression {
+class Conditional final : public Expression {
  public:
   DECLARE_NODE_TYPE(Conditional)
 
   Expression* condition() const { return condition_; }
   Expression* then_expression() const { return then_expression_; }
   Expression* else_expression() const { return else_expression_; }
 
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId ThenId() const { return BailoutId(local_id(0)); }
   BailoutId ElseId() const { return BailoutId(local_id(1)); }
 
  protected:
   Conditional(Zone* zone, Expression* condition, Expression* then_expression,
               Expression* else_expression, int position)
       : Expression(zone, position),
         condition_(condition),
         then_expression_(then_expression),
         else_expression_(else_expression) {}
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Expression* condition_;
   Expression* then_expression_;
   Expression* else_expression_;
 };
 
 
-class Assignment FINAL : public Expression {
+class Assignment final : public Expression {
  public:
   DECLARE_NODE_TYPE(Assignment)
 
   Assignment* AsSimpleAssignment() { return !is_compound() ? this : NULL; }
 
   Token::Value binary_op() const;
 
   Token::Value op() const { return TokenField::decode(bit_field_); }
   Expression* target() const { return target_; }
   Expression* value() const { return value_; }
   BinaryOperation* binary_operation() const { return binary_operation_; }
 
   // This check relies on the definition order of token in token.h.
   bool is_compound() const { return op() > Token::ASSIGN; }
 
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId AssignmentId() const { return BailoutId(local_id(0)); }
 
   // Type feedback information.
   TypeFeedbackId AssignmentFeedbackId() { return TypeFeedbackId(local_id(1)); }
-  bool IsMonomorphic() OVERRIDE { return receiver_types_.length() == 1; }
+  bool IsMonomorphic() override { return receiver_types_.length() == 1; }
   bool IsUninitialized() const {
     return IsUninitializedField::decode(bit_field_);
   }
   bool HasNoTypeInformation() {
     return IsUninitializedField::decode(bit_field_);
   }
-  SmallMapList* GetReceiverTypes() OVERRIDE { return &receiver_types_; }
-  IcCheckType GetKeyType() const OVERRIDE {
+  SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
+  IcCheckType GetKeyType() const override {
     return KeyTypeField::decode(bit_field_);
   }
-  KeyedAccessStoreMode GetStoreMode() const OVERRIDE {
+  KeyedAccessStoreMode GetStoreMode() const override {
     return StoreModeField::decode(bit_field_);
   }
   void set_is_uninitialized(bool b) {
     bit_field_ = IsUninitializedField::update(bit_field_, b);
   }
   void set_key_type(IcCheckType key_type) {
     bit_field_ = KeyTypeField::update(bit_field_, key_type);
   }
   void set_store_mode(KeyedAccessStoreMode mode) {
     bit_field_ = StoreModeField::update(bit_field_, mode);
@@ skipping 15 matching lines @@
   // Starts with 16-bit field, which should get packed together with
   // Expression's trailing 16-bit field.
   uint16_t bit_field_;
   Expression* target_;
   Expression* value_;
   BinaryOperation* binary_operation_;
   SmallMapList receiver_types_;
 };
 
 
-class Yield FINAL : public Expression {
+class Yield final : public Expression {
  public:
   DECLARE_NODE_TYPE(Yield)
 
   enum Kind {
     kInitial,  // The initial yield that returns the unboxed generator object.
     kSuspend,  // A normal yield: { value: EXPRESSION, done: false }
     kDelegating,  // A yield*.
     kFinal        // A return: { value: EXPRESSION, done: true }
   };
 
@@ skipping 11 matching lines @@
   void set_index(int index) {
     DCHECK_EQ(kDelegating, yield_kind());
     index_ = index;
   }
 
   // Type feedback information.
   bool HasFeedbackSlots() const {
     return FLAG_vector_ics && (yield_kind() == kDelegating);
   }
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
-      Isolate* isolate, const ICSlotCache* cache) OVERRIDE {
+      Isolate* isolate, const ICSlotCache* cache) override {
     return FeedbackVectorRequirements(0, HasFeedbackSlots() ? 3 : 0);
   }
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
-                              ICSlotCache* cache) OVERRIDE {
+                              ICSlotCache* cache) override {
     yield_first_feedback_slot_ = slot;
   }
-  Code::Kind FeedbackICSlotKind(int index) OVERRIDE {
+  Code::Kind FeedbackICSlotKind(int index) override {
     return index == 0 ? Code::KEYED_LOAD_IC : Code::LOAD_IC;
   }
 
   FeedbackVectorICSlot KeyedLoadFeedbackSlot() {
     DCHECK(!HasFeedbackSlots() || !yield_first_feedback_slot_.IsInvalid());
     return yield_first_feedback_slot_;
   }
 
   FeedbackVectorICSlot DoneFeedbackSlot() {
     return KeyedLoadFeedbackSlot().next();
@@ skipping 13 matching lines @@
 
  private:
   Expression* generator_object_;
   Expression* expression_;
   Kind yield_kind_;
   int index_;
   FeedbackVectorICSlot yield_first_feedback_slot_;
 };
 
 
-class Throw FINAL : public Expression {
+class Throw final : public Expression {
  public:
   DECLARE_NODE_TYPE(Throw)
 
   Expression* exception() const { return exception_; }
 
  protected:
   Throw(Zone* zone, Expression* exception, int pos)
       : Expression(zone, pos), exception_(exception) {}
 
  private:
   Expression* exception_;
 };
 
 
-class FunctionLiteral FINAL : public Expression {
+class FunctionLiteral final : public Expression {
  public:
   enum FunctionType {
     ANONYMOUS_EXPRESSION,
     NAMED_EXPRESSION,
     DECLARATION
   };
 
   enum ParameterFlag {
     kNoDuplicateParameters = 0,
     kHasDuplicateParameters = 1
@@ skipping 173 matching lines @@
   class IsExpression : public BitField<bool, 0, 1> {};
   class IsAnonymous : public BitField<bool, 1, 1> {};
   class Pretenure : public BitField<bool, 2, 1> {};
   class HasDuplicateParameters : public BitField<ParameterFlag, 3, 1> {};
   class IsFunction : public BitField<IsFunctionFlag, 4, 1> {};
   class IsParenthesized : public BitField<IsParenthesizedFlag, 5, 1> {};
   class FunctionKindBits : public BitField<FunctionKind, 6, 8> {};
 };
 
 
-class ClassLiteral FINAL : public Expression {
+class ClassLiteral final : public Expression {
  public:
   typedef ObjectLiteralProperty Property;
 
   DECLARE_NODE_TYPE(ClassLiteral)
 
   Handle<String> name() const { return raw_name_->string(); }
   const AstRawString* raw_name() const { return raw_name_; }
   Scope* scope() const { return scope_; }
   VariableProxy* class_variable_proxy() const { return class_variable_proxy_; }
   Expression* extends() const { return extends_; }
@@ skipping 34 matching lines @@
   const AstRawString* raw_name_;
   Scope* scope_;
   VariableProxy* class_variable_proxy_;
   Expression* extends_;
   FunctionLiteral* constructor_;
   ZoneList<Property*>* properties_;
   int end_position_;
 };
 
 
-class NativeFunctionLiteral FINAL : public Expression {
+class NativeFunctionLiteral final : public Expression {
  public:
   DECLARE_NODE_TYPE(NativeFunctionLiteral)
 
   Handle<String> name() const { return name_->string(); }
   v8::Extension* extension() const { return extension_; }
 
  protected:
   NativeFunctionLiteral(Zone* zone, const AstRawString* name,
                         v8::Extension* extension, int pos)
       : Expression(zone, pos), name_(name), extension_(extension) {}
 
  private:
   const AstRawString* name_;
   v8::Extension* extension_;
 };
 
 
-class ThisFunction FINAL : public Expression {
+class ThisFunction final : public Expression {
  public:
   DECLARE_NODE_TYPE(ThisFunction)
 
  protected:
   ThisFunction(Zone* zone, int pos) : Expression(zone, pos) {}
 };
 
 
-class SuperReference FINAL : public Expression {
+class SuperReference final : public Expression {
  public:
   DECLARE_NODE_TYPE(SuperReference)
 
   VariableProxy* this_var() const { return this_var_; }
 
   static int num_ids() { return parent_num_ids() + 1; }
   TypeFeedbackId HomeObjectFeedbackId() { return TypeFeedbackId(local_id(0)); }
 
   // Type feedback information.
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
-      Isolate* isolate, const ICSlotCache* cache) OVERRIDE {
+      Isolate* isolate, const ICSlotCache* cache) override {
     return FeedbackVectorRequirements(0, FLAG_vector_ics ? 1 : 0);
   }
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
-                              ICSlotCache* cache) OVERRIDE {
+                              ICSlotCache* cache) override {
     homeobject_feedback_slot_ = slot;
   }
-  Code::Kind FeedbackICSlotKind(int index) OVERRIDE { return Code::LOAD_IC; }
+  Code::Kind FeedbackICSlotKind(int index) override { return Code::LOAD_IC; }
 
   FeedbackVectorICSlot HomeObjectFeedbackSlot() {
     DCHECK(!FLAG_vector_ics || !homeobject_feedback_slot_.IsInvalid());
     return homeobject_feedback_slot_;
   }
 
  protected:
   SuperReference(Zone* zone, VariableProxy* this_var, int pos)
       : Expression(zone, pos),
         this_var_(this_var),
@@ skipping 45 matching lines @@
   virtual void AppendToText(RegExpText* text, Zone* zone);
   std::ostream& Print(std::ostream& os, Zone* zone);  // NOLINT
 #define MAKE_ASTYPE(Name)                                                  \
   virtual RegExp##Name* As##Name();                                        \
   virtual bool Is##Name();
   FOR_EACH_REG_EXP_TREE_TYPE(MAKE_ASTYPE)
 #undef MAKE_ASTYPE
 };
 
 
-class RegExpDisjunction FINAL : public RegExpTree {
+class RegExpDisjunction final : public RegExpTree {
  public:
   explicit RegExpDisjunction(ZoneList<RegExpTree*>* alternatives);
-  void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+  void* Accept(RegExpVisitor* visitor, void* data) override;
   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
-                             RegExpNode* on_success) OVERRIDE;
-  RegExpDisjunction* AsDisjunction() OVERRIDE;
-  Interval CaptureRegisters() OVERRIDE;
-  bool IsDisjunction() OVERRIDE;
-  bool IsAnchoredAtStart() OVERRIDE;
-  bool IsAnchoredAtEnd() OVERRIDE;
-  int min_match() OVERRIDE { return min_match_; }
-  int max_match() OVERRIDE { return max_match_; }
+                             RegExpNode* on_success) override;
+  RegExpDisjunction* AsDisjunction() override;
+  Interval CaptureRegisters() override;
+  bool IsDisjunction() override;
+  bool IsAnchoredAtStart() override;
+  bool IsAnchoredAtEnd() override;
+  int min_match() override { return min_match_; }
+  int max_match() override { return max_match_; }
   ZoneList<RegExpTree*>* alternatives() { return alternatives_; }
  private:
   ZoneList<RegExpTree*>* alternatives_;
   int min_match_;
   int max_match_;
 };
 
 
-class RegExpAlternative FINAL : public RegExpTree {
+class RegExpAlternative final : public RegExpTree {
  public:
   explicit RegExpAlternative(ZoneList<RegExpTree*>* nodes);
-  void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+  void* Accept(RegExpVisitor* visitor, void* data) override;
   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
-                             RegExpNode* on_success) OVERRIDE;
-  RegExpAlternative* AsAlternative() OVERRIDE;
-  Interval CaptureRegisters() OVERRIDE;
-  bool IsAlternative() OVERRIDE;
-  bool IsAnchoredAtStart() OVERRIDE;
-  bool IsAnchoredAtEnd() OVERRIDE;
-  int min_match() OVERRIDE { return min_match_; }
-  int max_match() OVERRIDE { return max_match_; }
+                             RegExpNode* on_success) override;
+  RegExpAlternative* AsAlternative() override;
+  Interval CaptureRegisters() override;
+  bool IsAlternative() override;
+  bool IsAnchoredAtStart() override;
+  bool IsAnchoredAtEnd() override;
+  int min_match() override { return min_match_; }
+  int max_match() override { return max_match_; }
   ZoneList<RegExpTree*>* nodes() { return nodes_; }
  private:
   ZoneList<RegExpTree*>* nodes_;
   int min_match_;
   int max_match_;
 };
 
 
-class RegExpAssertion FINAL : public RegExpTree {
+class RegExpAssertion final : public RegExpTree {
  public:
   enum AssertionType {
     START_OF_LINE,
     START_OF_INPUT,
     END_OF_LINE,
     END_OF_INPUT,
     BOUNDARY,
     NON_BOUNDARY
   };
   explicit RegExpAssertion(AssertionType type) : assertion_type_(type) { }
-  void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+  void* Accept(RegExpVisitor* visitor, void* data) override;
   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
-                             RegExpNode* on_success) OVERRIDE;
-  RegExpAssertion* AsAssertion() OVERRIDE;
-  bool IsAssertion() OVERRIDE;
-  bool IsAnchoredAtStart() OVERRIDE;
-  bool IsAnchoredAtEnd() OVERRIDE;
-  int min_match() OVERRIDE { return 0; }
-  int max_match() OVERRIDE { return 0; }
+                             RegExpNode* on_success) override;
+  RegExpAssertion* AsAssertion() override;
+  bool IsAssertion() override;
+  bool IsAnchoredAtStart() override;
+  bool IsAnchoredAtEnd() override;
+  int min_match() override { return 0; }
+  int max_match() override { return 0; }
   AssertionType assertion_type() { return assertion_type_; }
  private:
   AssertionType assertion_type_;
 };
 
 
-class CharacterSet FINAL BASE_EMBEDDED {
+class CharacterSet final BASE_EMBEDDED {
  public:
   explicit CharacterSet(uc16 standard_set_type)
       : ranges_(NULL),
         standard_set_type_(standard_set_type) {}
   explicit CharacterSet(ZoneList<CharacterRange>* ranges)
       : ranges_(ranges),
         standard_set_type_(0) {}
   ZoneList<CharacterRange>* ranges(Zone* zone);
   uc16 standard_set_type() { return standard_set_type_; }
   void set_standard_set_type(uc16 special_set_type) {
     standard_set_type_ = special_set_type;
   }
   bool is_standard() { return standard_set_type_ != 0; }
   void Canonicalize();
  private:
   ZoneList<CharacterRange>* ranges_;
   // If non-zero, the value represents a standard set (e.g., all whitespace
   // characters) without having to expand the ranges.
   uc16 standard_set_type_;
 };
 
 
-class RegExpCharacterClass FINAL : public RegExpTree {
+class RegExpCharacterClass final : public RegExpTree {
  public:
   RegExpCharacterClass(ZoneList<CharacterRange>* ranges, bool is_negated)
       : set_(ranges),
         is_negated_(is_negated) { }
   explicit RegExpCharacterClass(uc16 type)
       : set_(type),
         is_negated_(false) { }
-  void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+  void* Accept(RegExpVisitor* visitor, void* data) override;
   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
-                             RegExpNode* on_success) OVERRIDE;
-  RegExpCharacterClass* AsCharacterClass() OVERRIDE;
-  bool IsCharacterClass() OVERRIDE;
-  bool IsTextElement() OVERRIDE { return true; }
-  int min_match() OVERRIDE { return 1; }
-  int max_match() OVERRIDE { return 1; }
-  void AppendToText(RegExpText* text, Zone* zone) OVERRIDE;
+                             RegExpNode* on_success) override;
+  RegExpCharacterClass* AsCharacterClass() override;
+  bool IsCharacterClass() override;
+  bool IsTextElement() override { return true; }
+  int min_match() override { return 1; }
+  int max_match() override { return 1; }
+  void AppendToText(RegExpText* text, Zone* zone) override;
   CharacterSet character_set() { return set_; }
   // TODO(lrn): Remove need for complex version if is_standard that
   // recognizes a mangled standard set and just do { return set_.is_special(); }
   bool is_standard(Zone* zone);
   // Returns a value representing the standard character set if is_standard()
   // returns true.
   // Currently used values are:
   // s : unicode whitespace
   // S : unicode non-whitespace
   // w : ASCII word character (digit, letter, underscore)
   // W : non-ASCII word character
   // d : ASCII digit
   // D : non-ASCII digit
   // . : non-unicode non-newline
   // * : All characters
   uc16 standard_type() { return set_.standard_set_type(); }
   ZoneList<CharacterRange>* ranges(Zone* zone) { return set_.ranges(zone); }
   bool is_negated() { return is_negated_; }
 
  private:
   CharacterSet set_;
   bool is_negated_;
 };
 
 
-class RegExpAtom FINAL : public RegExpTree {
+class RegExpAtom final : public RegExpTree {
  public:
   explicit RegExpAtom(Vector<const uc16> data) : data_(data) { }
-  void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+  void* Accept(RegExpVisitor* visitor, void* data) override;
   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
-                             RegExpNode* on_success) OVERRIDE;
-  RegExpAtom* AsAtom() OVERRIDE;
-  bool IsAtom() OVERRIDE;
-  bool IsTextElement() OVERRIDE { return true; }
-  int min_match() OVERRIDE { return data_.length(); }
-  int max_match() OVERRIDE { return data_.length(); }
-  void AppendToText(RegExpText* text, Zone* zone) OVERRIDE;
+                             RegExpNode* on_success) override;
+  RegExpAtom* AsAtom() override;
+  bool IsAtom() override;
+  bool IsTextElement() override { return true; }
+  int min_match() override { return data_.length(); }
+  int max_match() override { return data_.length(); }
+  void AppendToText(RegExpText* text, Zone* zone) override;
   Vector<const uc16> data() { return data_; }
   int length() { return data_.length(); }
  private:
   Vector<const uc16> data_;
 };
 
 
-class RegExpText FINAL : public RegExpTree {
+class RegExpText final : public RegExpTree {
  public:
   explicit RegExpText(Zone* zone) : elements_(2, zone), length_(0) {}
-  void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+  void* Accept(RegExpVisitor* visitor, void* data) override;
   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
-                             RegExpNode* on_success) OVERRIDE;
-  RegExpText* AsText() OVERRIDE;
-  bool IsText() OVERRIDE;
-  bool IsTextElement() OVERRIDE { return true; }
-  int min_match() OVERRIDE { return length_; }
-  int max_match() OVERRIDE { return length_; }
-  void AppendToText(RegExpText* text, Zone* zone) OVERRIDE;
+                             RegExpNode* on_success) override;
+  RegExpText* AsText() override;
+  bool IsText() override;
+  bool IsTextElement() override { return true; }
+  int min_match() override { return length_; }
+  int max_match() override { return length_; }
+  void AppendToText(RegExpText* text, Zone* zone) override;
   void AddElement(TextElement elm, Zone* zone)  {
     elements_.Add(elm, zone);
     length_ += elm.length();
   }
   ZoneList<TextElement>* elements() { return &elements_; }
  private:
   ZoneList<TextElement> elements_;
   int length_;
 };
 
 
-class RegExpQuantifier FINAL : public RegExpTree {
+class RegExpQuantifier final : public RegExpTree {
  public:
   enum QuantifierType { GREEDY, NON_GREEDY, POSSESSIVE };
   RegExpQuantifier(int min, int max, QuantifierType type, RegExpTree* body)
       : body_(body),
         min_(min),
         max_(max),
         min_match_(min * body->min_match()),
         quantifier_type_(type) {
     if (max > 0 && body->max_match() > kInfinity / max) {
       max_match_ = kInfinity;
     } else {
       max_match_ = max * body->max_match();
     }
   }
-  void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+  void* Accept(RegExpVisitor* visitor, void* data) override;
   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
-                             RegExpNode* on_success) OVERRIDE;
+                             RegExpNode* on_success) override;
   static RegExpNode* ToNode(int min,
                             int max,
                             bool is_greedy,
                             RegExpTree* body,
                             RegExpCompiler* compiler,
                             RegExpNode* on_success,
                             bool not_at_start = false);
-  RegExpQuantifier* AsQuantifier() OVERRIDE;
-  Interval CaptureRegisters() OVERRIDE;
-  bool IsQuantifier() OVERRIDE;
-  int min_match() OVERRIDE { return min_match_; }
-  int max_match() OVERRIDE { return max_match_; }
+  RegExpQuantifier* AsQuantifier() override;
+  Interval CaptureRegisters() override;
+  bool IsQuantifier() override;
+  int min_match() override { return min_match_; }
+  int max_match() override { return max_match_; }
   int min() { return min_; }
   int max() { return max_; }
   bool is_possessive() { return quantifier_type_ == POSSESSIVE; }
   bool is_non_greedy() { return quantifier_type_ == NON_GREEDY; }
   bool is_greedy() { return quantifier_type_ == GREEDY; }
   RegExpTree* body() { return body_; }
 
  private:
   RegExpTree* body_;
   int min_;
   int max_;
   int min_match_;
   int max_match_;
   QuantifierType quantifier_type_;
 };
 
 
-class RegExpCapture FINAL : public RegExpTree {
+class RegExpCapture final : public RegExpTree {
  public:
   explicit RegExpCapture(RegExpTree* body, int index)
       : body_(body), index_(index) { }
-  void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+  void* Accept(RegExpVisitor* visitor, void* data) override;
   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
-                             RegExpNode* on_success) OVERRIDE;
+                             RegExpNode* on_success) override;
   static RegExpNode* ToNode(RegExpTree* body,
                             int index,
                             RegExpCompiler* compiler,
                             RegExpNode* on_success);
-  RegExpCapture* AsCapture() OVERRIDE;
-  bool IsAnchoredAtStart() OVERRIDE;
-  bool IsAnchoredAtEnd() OVERRIDE;
-  Interval CaptureRegisters() OVERRIDE;
-  bool IsCapture() OVERRIDE;
-  int min_match() OVERRIDE { return body_->min_match(); }
-  int max_match() OVERRIDE { return body_->max_match(); }
+  RegExpCapture* AsCapture() override;
+  bool IsAnchoredAtStart() override;
+  bool IsAnchoredAtEnd() override;
+  Interval CaptureRegisters() override;
+  bool IsCapture() override;
+  int min_match() override { return body_->min_match(); }
+  int max_match() override { return body_->max_match(); }
   RegExpTree* body() { return body_; }
   int index() { return index_; }
   static int StartRegister(int index) { return index * 2; }
   static int EndRegister(int index) { return index * 2 + 1; }
 
  private:
   RegExpTree* body_;
   int index_;
 };
 
 
-class RegExpLookahead FINAL : public RegExpTree {
+class RegExpLookahead final : public RegExpTree {
  public:
   RegExpLookahead(RegExpTree* body,
                   bool is_positive,
                   int capture_count,
                   int capture_from)
       : body_(body),
         is_positive_(is_positive),
         capture_count_(capture_count),
         capture_from_(capture_from) { }
 
-  void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+  void* Accept(RegExpVisitor* visitor, void* data) override;
   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
-                             RegExpNode* on_success) OVERRIDE;
-  RegExpLookahead* AsLookahead() OVERRIDE;
-  Interval CaptureRegisters() OVERRIDE;
-  bool IsLookahead() OVERRIDE;
-  bool IsAnchoredAtStart() OVERRIDE;
-  int min_match() OVERRIDE { return 0; }
-  int max_match() OVERRIDE { return 0; }
+                             RegExpNode* on_success) override;
+  RegExpLookahead* AsLookahead() override;
+  Interval CaptureRegisters() override;
+  bool IsLookahead() override;
+  bool IsAnchoredAtStart() override;
+  int min_match() override { return 0; }
+  int max_match() override { return 0; }
   RegExpTree* body() { return body_; }
   bool is_positive() { return is_positive_; }
   int capture_count() { return capture_count_; }
   int capture_from() { return capture_from_; }
 
  private:
   RegExpTree* body_;
   bool is_positive_;
   int capture_count_;
   int capture_from_;
 };
 
 
-class RegExpBackReference FINAL : public RegExpTree {
+class RegExpBackReference final : public RegExpTree {
  public:
   explicit RegExpBackReference(RegExpCapture* capture)
       : capture_(capture) { }
-  void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+  void* Accept(RegExpVisitor* visitor, void* data) override;
   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
-                             RegExpNode* on_success) OVERRIDE;
-  RegExpBackReference* AsBackReference() OVERRIDE;
-  bool IsBackReference() OVERRIDE;
-  int min_match() OVERRIDE { return 0; }
-  int max_match() OVERRIDE { return capture_->max_match(); }
+                             RegExpNode* on_success) override;
+  RegExpBackReference* AsBackReference() override;
+  bool IsBackReference() override;
+  int min_match() override { return 0; }
+  int max_match() override { return capture_->max_match(); }
   int index() { return capture_->index(); }
   RegExpCapture* capture() { return capture_; }
  private:
   RegExpCapture* capture_;
 };
 
 
-class RegExpEmpty FINAL : public RegExpTree {
+class RegExpEmpty final : public RegExpTree {
  public:
   RegExpEmpty() { }
-  void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+  void* Accept(RegExpVisitor* visitor, void* data) override;
   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
-                             RegExpNode* on_success) OVERRIDE;
-  RegExpEmpty* AsEmpty() OVERRIDE;
-  bool IsEmpty() OVERRIDE;
-  int min_match() OVERRIDE { return 0; }
-  int max_match() OVERRIDE { return 0; }
+                             RegExpNode* on_success) override;
+  RegExpEmpty* AsEmpty() override;
+  bool IsEmpty() override;
+  int min_match() override { return 0; }
+  int max_match() override { return 0; }
 };
 
 
 // ----------------------------------------------------------------------------
 // Basic visitor
 // - leaf node visitors are abstract.
 
 class AstVisitor BASE_EMBEDDED {
  public:
   AstVisitor() {}
@@ skipping 10 matching lines @@
   // Individual AST nodes.
 #define DEF_VISIT(type)                         \
   virtual void Visit##type(type* node) = 0;
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 };
 
 
 #define DEFINE_AST_VISITOR_SUBCLASS_MEMBERS()               \
  public:                                                    \
-  void Visit(AstNode* node) FINAL {                         \
+  void Visit(AstNode* node) final {                         \
     if (!CheckStackOverflow()) node->Accept(this);          \
   }                                                         \
                                                             \
   void SetStackOverflow() { stack_overflow_ = true; }       \
   void ClearStackOverflow() { stack_overflow_ = false; }    \
   bool HasStackOverflow() const { return stack_overflow_; } \
                                                             \
   bool CheckStackOverflow() {                               \
     if (stack_overflow_) return true;                       \
     StackLimitCheck check(isolate_);                        \
@@ skipping 12 matching lines @@
   Isolate* isolate() { return isolate_; }                   \
                                                             \
   Isolate* isolate_;                                        \
   Zone* zone_;                                              \
   bool stack_overflow_
 
 
 // ----------------------------------------------------------------------------
 // AstNode factory
 
-class AstNodeFactory FINAL BASE_EMBEDDED {
+class AstNodeFactory final BASE_EMBEDDED {
  public:
   explicit AstNodeFactory(AstValueFactory* ast_value_factory)
       : zone_(ast_value_factory->zone()),
         ast_value_factory_(ast_value_factory) {}
 
   VariableDeclaration* NewVariableDeclaration(
       VariableProxy* proxy, VariableMode mode, Scope* scope, int pos,
       bool is_class_declaration = false) {
     return new (zone_) VariableDeclaration(zone_, proxy, mode, scope, pos,
                                            is_class_declaration);
@@ skipping 358 matching lines @@
 
  private:
   Zone* zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_