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

src/compiler/typer.cc

 // Copyright 2014 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.
 
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
@@ skipping 24 matching lines @@
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
   k##Type, k##Type##Array, k##Type##ArrayFunc,
   TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
       kNumLazyCachedTypes
 };
 
 
 // Constructs and caches types lazily.
 // TODO(turbofan): these types could be globally cached or cached per isolate.
-class LazyTypeCache FINAL : public ZoneObject {
+class LazyTypeCache final : public ZoneObject {
  public:
   explicit LazyTypeCache(Isolate* isolate, Zone* zone)
       : isolate_(isolate), zone_(zone) {
     memset(cache_, 0, sizeof(cache_));
   }
 
   inline Type* Get(LazyCachedType type) {
     int index = static_cast<int>(type);
     DCHECK(index < kNumLazyCachedTypes);
     if (cache_[index] == NULL) cache_[index] = Create(type);
@@ skipping 78 matching lines @@
   Factory* factory() const { return isolate()->factory(); }
   Isolate* isolate() const { return isolate_; }
   Zone* zone() const { return zone_; }
 
   Type* cache_[kNumLazyCachedTypes];
   Isolate* isolate_;
   Zone* zone_;
 };
 
 
-class Typer::Decorator FINAL : public GraphDecorator {
+class Typer::Decorator final : public GraphDecorator {
  public:
   explicit Decorator(Typer* typer) : typer_(typer) {}
-  void Decorate(Node* node, bool incomplete) FINAL;
+  void Decorate(Node* node, bool incomplete) final;
 
  private:
   Typer* typer_;
 };
 
 
 Typer::Typer(Isolate* isolate, Graph* graph, MaybeHandle<Context> context)
     : isolate_(isolate),
       graph_(graph),
       context_(context),
@@ skipping 50 matching lines @@
 Typer::~Typer() {
   graph_->RemoveDecorator(decorator_);
 }
 
 
 class Typer::Visitor : public Reducer {
  public:
   explicit Visitor(Typer* typer)
       : typer_(typer), weakened_nodes_(typer->zone()) {}
 
-  Reduction Reduce(Node* node) OVERRIDE {
+  Reduction Reduce(Node* node) override {
     if (node->op()->ValueOutputCount() == 0) return NoChange();
     switch (node->opcode()) {
 #define DECLARE_CASE(x) \
   case IrOpcode::k##x:  \
     return UpdateBounds(node, TypeBinaryOp(node, x##Typer));
       JS_SIMPLE_BINOP_LIST(DECLARE_CASE)
 #undef DECLARE_CASE
 
 #define DECLARE_CASE(x) \
   case IrOpcode::k##x:  \
@@ skipping 2117 matching lines @@
       TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
     }
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8