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

test/unittests/compiler/node-test-utils.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 "test/unittests/compiler/node-test-utils.h"
 
 #include "src/assembler.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/unique.h"
@@ skipping 23 matching lines @@
     return false;
   }
   return true;
 }
 
 
 class NodeMatcher : public MatcherInterface<Node*> {
  public:
   explicit NodeMatcher(IrOpcode::Value opcode) : opcode_(opcode) {}
 
-  void DescribeTo(std::ostream* os) const OVERRIDE {
+  void DescribeTo(std::ostream* os) const override {
     *os << "is a " << IrOpcode::Mnemonic(opcode_) << " node";
   }
 
   bool MatchAndExplain(Node* node,
-                       MatchResultListener* listener) const OVERRIDE {
+                       MatchResultListener* listener) const override {
     if (node == NULL) {
       *listener << "which is NULL";
       return false;
     }
     if (node->opcode() != opcode_) {
       *listener << "whose opcode is " << IrOpcode::Mnemonic(node->opcode())
                 << " but should have been " << IrOpcode::Mnemonic(opcode_);
       return false;
     }
     return true;
   }
 
  private:
   const IrOpcode::Value opcode_;
 };
 
 
-class IsBranchMatcher FINAL : public NodeMatcher {
+class IsBranchMatcher final : public NodeMatcher {
  public:
   IsBranchMatcher(const Matcher<Node*>& value_matcher,
                   const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kBranch),
         value_matcher_(value_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose value (";
     value_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
                                  "value", value_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> value_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsSwitchMatcher FINAL : public NodeMatcher {
+class IsSwitchMatcher final : public NodeMatcher {
  public:
   IsSwitchMatcher(const Matcher<Node*>& value_matcher,
                   const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kSwitch),
         value_matcher_(value_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose value (";
     value_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
                                  "value", value_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> value_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsIfValueMatcher FINAL : public NodeMatcher {
+class IsIfValueMatcher final : public NodeMatcher {
  public:
   IsIfValueMatcher(const Matcher<int32_t>& value_matcher,
                    const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kIfValue),
         value_matcher_(value_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose value (";
     value_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<int32_t>(node->op()), "value",
                                  value_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<int32_t> value_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsControl1Matcher FINAL : public NodeMatcher {
+class IsControl1Matcher final : public NodeMatcher {
  public:
   IsControl1Matcher(IrOpcode::Value opcode,
                     const Matcher<Node*>& control_matcher)
       : NodeMatcher(opcode), control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsControl2Matcher FINAL : public NodeMatcher {
+class IsControl2Matcher final : public NodeMatcher {
  public:
   IsControl2Matcher(IrOpcode::Value opcode,
                     const Matcher<Node*>& control0_matcher,
                     const Matcher<Node*>& control1_matcher)
       : NodeMatcher(opcode),
         control0_matcher_(control0_matcher),
         control1_matcher_(control1_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose control0 (";
     control0_matcher_.DescribeTo(os);
     *os << ") and control1 (";
     control1_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node, 0),
                                  "control0", control0_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node, 1),
                                  "control1", control1_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> control0_matcher_;
   const Matcher<Node*> control1_matcher_;
 };
 
 
-class IsControl3Matcher FINAL : public NodeMatcher {
+class IsControl3Matcher final : public NodeMatcher {
  public:
   IsControl3Matcher(IrOpcode::Value opcode,
                     const Matcher<Node*>& control0_matcher,
                     const Matcher<Node*>& control1_matcher,
                     const Matcher<Node*>& control2_matcher)
       : NodeMatcher(opcode),
         control0_matcher_(control0_matcher),
         control1_matcher_(control1_matcher),
         control2_matcher_(control2_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose control0 (";
     control0_matcher_.DescribeTo(os);
     *os << ") and control1 (";
     control1_matcher_.DescribeTo(os);
     *os << ") and control2 (";
     control2_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node, 0),
                                  "control0", control0_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node, 1),
                                  "control1", control1_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node, 2),
                                  "control2", control2_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> control0_matcher_;
   const Matcher<Node*> control1_matcher_;
   const Matcher<Node*> control2_matcher_;
 };
 
 
-class IsFinishMatcher FINAL : public NodeMatcher {
+class IsFinishMatcher final : public NodeMatcher {
  public:
   IsFinishMatcher(const Matcher<Node*>& value_matcher,
                   const Matcher<Node*>& effect_matcher)
       : NodeMatcher(IrOpcode::kFinish),
         value_matcher_(value_matcher),
         effect_matcher_(effect_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose value (";
     value_matcher_.DescribeTo(os);
     *os << ") and effect (";
     effect_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
                                  "value", value_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
                                  effect_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> value_matcher_;
   const Matcher<Node*> effect_matcher_;
 };
 
 
-class IsReturnMatcher FINAL : public NodeMatcher {
+class IsReturnMatcher final : public NodeMatcher {
  public:
   IsReturnMatcher(const Matcher<Node*>& value_matcher,
                   const Matcher<Node*>& effect_matcher,
                   const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kReturn),
         value_matcher_(value_matcher),
         effect_matcher_(effect_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose value (";
     value_matcher_.DescribeTo(os);
     *os << ") and effect (";
     effect_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
                                  "value", value_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
                                  effect_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> value_matcher_;
   const Matcher<Node*> effect_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
 template <typename T>
-class IsConstantMatcher FINAL : public NodeMatcher {
+class IsConstantMatcher final : public NodeMatcher {
  public:
   IsConstantMatcher(IrOpcode::Value opcode, const Matcher<T>& value_matcher)
       : NodeMatcher(opcode), value_matcher_(value_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose value (";
     value_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<T>(node), "value", value_matcher_,
                                  listener));
   }
 
  private:
   const Matcher<T> value_matcher_;
 };
 
 
-class IsSelectMatcher FINAL : public NodeMatcher {
+class IsSelectMatcher final : public NodeMatcher {
  public:
   IsSelectMatcher(const Matcher<MachineType>& type_matcher,
                   const Matcher<Node*>& value0_matcher,
                   const Matcher<Node*>& value1_matcher,
                   const Matcher<Node*>& value2_matcher)
       : NodeMatcher(IrOpcode::kSelect),
         type_matcher_(type_matcher),
         value0_matcher_(value0_matcher),
         value1_matcher_(value1_matcher),
         value2_matcher_(value2_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose type (";
     type_matcher_.DescribeTo(os);
     *os << "), value0 (";
     value0_matcher_.DescribeTo(os);
     *os << "), value1 (";
     value1_matcher_.DescribeTo(os);
     *os << ") and value2 (";
     value2_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<MachineType>(node), "type",
                                  type_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
                                  "value0", value0_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
                                  "value1", value1_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
                                  "value2", value2_matcher_, listener));
   }
 
  private:
   const Matcher<MachineType> type_matcher_;
   const Matcher<Node*> value0_matcher_;
   const Matcher<Node*> value1_matcher_;
   const Matcher<Node*> value2_matcher_;
 };
 
 
-class IsPhiMatcher FINAL : public NodeMatcher {
+class IsPhiMatcher final : public NodeMatcher {
  public:
   IsPhiMatcher(const Matcher<MachineType>& type_matcher,
                const Matcher<Node*>& value0_matcher,
                const Matcher<Node*>& value1_matcher,
                const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kPhi),
         type_matcher_(type_matcher),
         value0_matcher_(value0_matcher),
         value1_matcher_(value1_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose type (";
     type_matcher_.DescribeTo(os);
     *os << "), value0 (";
     value0_matcher_.DescribeTo(os);
     *os << "), value1 (";
     value1_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<MachineType>(node), "type",
                                  type_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
                                  "value0", value0_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
                                  "value1", value1_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<MachineType> type_matcher_;
   const Matcher<Node*> value0_matcher_;
   const Matcher<Node*> value1_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsPhi2Matcher FINAL : public NodeMatcher {
+class IsPhi2Matcher final : public NodeMatcher {
  public:
   IsPhi2Matcher(const Matcher<MachineType>& type_matcher,
                 const Matcher<Node*>& value0_matcher,
                 const Matcher<Node*>& value1_matcher,
                 const Matcher<Node*>& value2_matcher,
                 const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kPhi),
         type_matcher_(type_matcher),
         value0_matcher_(value0_matcher),
         value1_matcher_(value1_matcher),
         value2_matcher_(value2_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose type (";
     type_matcher_.DescribeTo(os);
     *os << "), value0 (";
     value0_matcher_.DescribeTo(os);
     *os << "), value1 (";
     value1_matcher_.DescribeTo(os);
     *os << "), value2 (";
     value2_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<MachineType>(node), "type",
                                  type_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
                                  "value0", value0_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
                                  "value1", value1_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
                                  "value2", value2_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<MachineType> type_matcher_;
   const Matcher<Node*> value0_matcher_;
   const Matcher<Node*> value1_matcher_;
   const Matcher<Node*> value2_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsEffectPhiMatcher FINAL : public NodeMatcher {
+class IsEffectPhiMatcher final : public NodeMatcher {
  public:
   IsEffectPhiMatcher(const Matcher<Node*>& effect0_matcher,
                      const Matcher<Node*>& effect1_matcher,
                      const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kEffectPhi),
         effect0_matcher_(effect0_matcher),
         effect1_matcher_(effect1_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << "), effect0 (";
     effect0_matcher_.DescribeTo(os);
     *os << "), effect1 (";
     effect1_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node, 0),
                                  "effect0", effect0_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node, 1),
                                  "effect1", effect1_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> effect0_matcher_;
   const Matcher<Node*> effect1_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsEffectSetMatcher FINAL : public NodeMatcher {
+class IsEffectSetMatcher final : public NodeMatcher {
  public:
   IsEffectSetMatcher(const Matcher<Node*>& effect0_matcher,
                      const Matcher<Node*>& effect1_matcher)
       : NodeMatcher(IrOpcode::kEffectSet),
         effect0_matcher_(effect0_matcher),
         effect1_matcher_(effect1_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << "), effect0 (";
     effect0_matcher_.DescribeTo(os);
     *os << ") and effect1 (";
     effect1_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     if (!NodeMatcher::MatchAndExplain(node, listener)) return false;
 
     Node* effect0 = NodeProperties::GetEffectInput(node, 0);
     Node* effect1 = NodeProperties::GetEffectInput(node, 1);
 
     {
       // Try matching in the reverse order first.
       StringMatchResultListener value_listener;
       if (effect0_matcher_.MatchAndExplain(effect1, &value_listener) &&
           effect1_matcher_.MatchAndExplain(effect0, &value_listener)) {
         return true;
       }
     }
 
     return PrintMatchAndExplain(effect0, "effect0", effect0_matcher_,
                                 listener) &&
            PrintMatchAndExplain(effect1, "effect1", effect1_matcher_, listener);
   }
 
  private:
   const Matcher<Node*> effect0_matcher_;
   const Matcher<Node*> effect1_matcher_;
 };
 
 
-class IsProjectionMatcher FINAL : public NodeMatcher {
+class IsProjectionMatcher final : public NodeMatcher {
  public:
   IsProjectionMatcher(const Matcher<size_t>& index_matcher,
                       const Matcher<Node*>& base_matcher)
       : NodeMatcher(IrOpcode::kProjection),
         index_matcher_(index_matcher),
         base_matcher_(base_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose index (";
     index_matcher_.DescribeTo(os);
     *os << ") and base (";
     base_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<size_t>(node), "index",
                                  index_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
                                  base_matcher_, listener));
   }
 
  private:
   const Matcher<size_t> index_matcher_;
   const Matcher<Node*> base_matcher_;
 };
 
 
-class IsCall2Matcher FINAL : public NodeMatcher {
+class IsCall2Matcher final : public NodeMatcher {
  public:
   IsCall2Matcher(const Matcher<CallDescriptor*>& descriptor_matcher,
                  const Matcher<Node*>& value0_matcher,
                  const Matcher<Node*>& value1_matcher,
                  const Matcher<Node*>& effect_matcher,
                  const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kCall),
         descriptor_matcher_(descriptor_matcher),
         value0_matcher_(value0_matcher),
         value1_matcher_(value1_matcher),
         effect_matcher_(effect_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose value0 (";
     value0_matcher_.DescribeTo(os);
     *os << ") and value1 (";
     value1_matcher_.DescribeTo(os);
     *os << ") and effect (";
     effect_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<CallDescriptor*>(node),
                                  "descriptor", descriptor_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
                                  "value0", value0_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
                                  "value1", value1_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
                                  effect_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<CallDescriptor*> descriptor_matcher_;
   const Matcher<Node*> value0_matcher_;
   const Matcher<Node*> value1_matcher_;
   const Matcher<Node*> effect_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsCall4Matcher FINAL : public NodeMatcher {
+class IsCall4Matcher final : public NodeMatcher {
  public:
   IsCall4Matcher(const Matcher<CallDescriptor*>& descriptor_matcher,
                  const Matcher<Node*>& value0_matcher,
                  const Matcher<Node*>& value1_matcher,
                  const Matcher<Node*>& value2_matcher,
                  const Matcher<Node*>& value3_matcher,
                  const Matcher<Node*>& effect_matcher,
                  const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kCall),
         descriptor_matcher_(descriptor_matcher),
         value0_matcher_(value0_matcher),
         value1_matcher_(value1_matcher),
         value2_matcher_(value2_matcher),
         value3_matcher_(value3_matcher),
         effect_matcher_(effect_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose value0 (";
     value0_matcher_.DescribeTo(os);
     *os << ") and value1 (";
     value1_matcher_.DescribeTo(os);
     *os << ") and value2 (";
     value2_matcher_.DescribeTo(os);
     *os << ") and value3 (";
     value3_matcher_.DescribeTo(os);
     *os << ") and effect (";
     effect_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<CallDescriptor*>(node),
                                  "descriptor", descriptor_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
                                  "value0", value0_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
                                  "value1", value1_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
                                  "value2", value2_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 3),
                                  "value3", value3_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
                                  effect_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<CallDescriptor*> descriptor_matcher_;
   const Matcher<Node*> value0_matcher_;
   const Matcher<Node*> value1_matcher_;
   const Matcher<Node*> value2_matcher_;
   const Matcher<Node*> value3_matcher_;
   const Matcher<Node*> effect_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsLoadFieldMatcher FINAL : public NodeMatcher {
+class IsLoadFieldMatcher final : public NodeMatcher {
  public:
   IsLoadFieldMatcher(const Matcher<FieldAccess>& access_matcher,
                      const Matcher<Node*>& base_matcher,
                      const Matcher<Node*>& effect_matcher,
                      const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kLoadField),
         access_matcher_(access_matcher),
         base_matcher_(base_matcher),
         effect_matcher_(effect_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose access (";
     access_matcher_.DescribeTo(os);
     *os << "), base (";
     base_matcher_.DescribeTo(os);
     *os << "), effect (";
     effect_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<FieldAccess>(node), "access",
                                  access_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
                                  base_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
                                  effect_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<FieldAccess> access_matcher_;
   const Matcher<Node*> base_matcher_;
   const Matcher<Node*> effect_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsStoreFieldMatcher FINAL : public NodeMatcher {
+class IsStoreFieldMatcher final : public NodeMatcher {
  public:
   IsStoreFieldMatcher(const Matcher<FieldAccess>& access_matcher,
                       const Matcher<Node*>& base_matcher,
                       const Matcher<Node*>& value_matcher,
                       const Matcher<Node*>& effect_matcher,
                       const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kStoreField),
         access_matcher_(access_matcher),
         base_matcher_(base_matcher),
         value_matcher_(value_matcher),
         effect_matcher_(effect_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose access (";
     access_matcher_.DescribeTo(os);
     *os << "), base (";
     base_matcher_.DescribeTo(os);
     *os << "), value (";
     value_matcher_.DescribeTo(os);
     *os << "), effect (";
     effect_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<FieldAccess>(node), "access",
                                  access_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
                                  base_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
                                  "value", value_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
                                  effect_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<FieldAccess> access_matcher_;
   const Matcher<Node*> base_matcher_;
   const Matcher<Node*> value_matcher_;
   const Matcher<Node*> effect_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsLoadBufferMatcher FINAL : public NodeMatcher {
+class IsLoadBufferMatcher final : public NodeMatcher {
  public:
   IsLoadBufferMatcher(const Matcher<BufferAccess>& access_matcher,
                       const Matcher<Node*>& buffer_matcher,
                       const Matcher<Node*>& offset_matcher,
                       const Matcher<Node*>& length_matcher,
                       const Matcher<Node*>& effect_matcher,
                       const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kLoadBuffer),
         access_matcher_(access_matcher),
         buffer_matcher_(buffer_matcher),
         offset_matcher_(offset_matcher),
         length_matcher_(length_matcher),
         effect_matcher_(effect_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose access (";
     access_matcher_.DescribeTo(os);
     *os << "), buffer (";
     buffer_matcher_.DescribeTo(os);
     *os << "), offset (";
     offset_matcher_.DescribeTo(os);
     *os << "), length (";
     length_matcher_.DescribeTo(os);
     *os << "), effect (";
     effect_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(BufferAccessOf(node->op()), "access",
                                  access_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
                                  "buffer", buffer_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
                                  "offset", offset_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
                                  "length", length_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
                                  effect_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<BufferAccess> access_matcher_;
   const Matcher<Node*> buffer_matcher_;
   const Matcher<Node*> offset_matcher_;
   const Matcher<Node*> length_matcher_;
   const Matcher<Node*> effect_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsStoreBufferMatcher FINAL : public NodeMatcher {
+class IsStoreBufferMatcher final : public NodeMatcher {
  public:
   IsStoreBufferMatcher(const Matcher<BufferAccess>& access_matcher,
                        const Matcher<Node*>& buffer_matcher,
                        const Matcher<Node*>& offset_matcher,
                        const Matcher<Node*>& length_matcher,
                        const Matcher<Node*>& value_matcher,
                        const Matcher<Node*>& effect_matcher,
                        const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kStoreBuffer),
         access_matcher_(access_matcher),
         buffer_matcher_(buffer_matcher),
         offset_matcher_(offset_matcher),
         length_matcher_(length_matcher),
         value_matcher_(value_matcher),
         effect_matcher_(effect_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose access (";
     access_matcher_.DescribeTo(os);
     *os << "), buffer (";
     buffer_matcher_.DescribeTo(os);
     *os << "), offset (";
     offset_matcher_.DescribeTo(os);
     *os << "), length (";
     length_matcher_.DescribeTo(os);
     *os << "), value (";
     value_matcher_.DescribeTo(os);
     *os << "), effect (";
     effect_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(BufferAccessOf(node->op()), "access",
                                  access_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
                                  "buffer", buffer_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
                                  "offset", offset_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
                                  "length", length_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 3),
                                  "value", value_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
                                  effect_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<BufferAccess> access_matcher_;
   const Matcher<Node*> buffer_matcher_;
   const Matcher<Node*> offset_matcher_;
   const Matcher<Node*> length_matcher_;
   const Matcher<Node*> value_matcher_;
   const Matcher<Node*> effect_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsLoadElementMatcher FINAL : public NodeMatcher {
+class IsLoadElementMatcher final : public NodeMatcher {
  public:
   IsLoadElementMatcher(const Matcher<ElementAccess>& access_matcher,
                        const Matcher<Node*>& base_matcher,
                        const Matcher<Node*>& index_matcher,
                        const Matcher<Node*>& effect_matcher,
                        const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kLoadElement),
         access_matcher_(access_matcher),
         base_matcher_(base_matcher),
         index_matcher_(index_matcher),
         effect_matcher_(effect_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose access (";
     access_matcher_.DescribeTo(os);
     *os << "), base (";
     base_matcher_.DescribeTo(os);
     *os << "), index (";
     index_matcher_.DescribeTo(os);
     *os << "), effect (";
     effect_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<ElementAccess>(node), "access",
                                  access_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
                                  base_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
                                  "index", index_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
                                  effect_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<ElementAccess> access_matcher_;
   const Matcher<Node*> base_matcher_;
   const Matcher<Node*> index_matcher_;
   const Matcher<Node*> effect_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsStoreElementMatcher FINAL : public NodeMatcher {
+class IsStoreElementMatcher final : public NodeMatcher {
  public:
   IsStoreElementMatcher(const Matcher<ElementAccess>& access_matcher,
                         const Matcher<Node*>& base_matcher,
                         const Matcher<Node*>& index_matcher,
                         const Matcher<Node*>& value_matcher,
                         const Matcher<Node*>& effect_matcher,
                         const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kStoreElement),
         access_matcher_(access_matcher),
         base_matcher_(base_matcher),
         index_matcher_(index_matcher),
         value_matcher_(value_matcher),
         effect_matcher_(effect_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose access (";
     access_matcher_.DescribeTo(os);
     *os << "), base (";
     base_matcher_.DescribeTo(os);
     *os << "), index (";
     index_matcher_.DescribeTo(os);
     *os << "), value (";
     value_matcher_.DescribeTo(os);
     *os << "), effect (";
     effect_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<ElementAccess>(node), "access",
                                  access_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
                                  base_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
                                  "index", index_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
                                  "value", value_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
                                  effect_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<ElementAccess> access_matcher_;
   const Matcher<Node*> base_matcher_;
   const Matcher<Node*> index_matcher_;
   const Matcher<Node*> value_matcher_;
   const Matcher<Node*> effect_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsLoadMatcher FINAL : public NodeMatcher {
+class IsLoadMatcher final : public NodeMatcher {
  public:
   IsLoadMatcher(const Matcher<LoadRepresentation>& rep_matcher,
                 const Matcher<Node*>& base_matcher,
                 const Matcher<Node*>& index_matcher,
                 const Matcher<Node*>& effect_matcher,
                 const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kLoad),
         rep_matcher_(rep_matcher),
         base_matcher_(base_matcher),
         index_matcher_(index_matcher),
         effect_matcher_(effect_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose rep (";
     rep_matcher_.DescribeTo(os);
     *os << "), base (";
     base_matcher_.DescribeTo(os);
     *os << "), index (";
     index_matcher_.DescribeTo(os);
     *os << "), effect (";
     effect_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<LoadRepresentation>(node), "rep",
                                  rep_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
                                  base_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
                                  "index", index_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
                                  effect_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<LoadRepresentation> rep_matcher_;
   const Matcher<Node*> base_matcher_;
   const Matcher<Node*> index_matcher_;
   const Matcher<Node*> effect_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsToNumberMatcher FINAL : public NodeMatcher {
+class IsToNumberMatcher final : public NodeMatcher {
  public:
   IsToNumberMatcher(const Matcher<Node*>& base_matcher,
                     const Matcher<Node*>& context_matcher,
                     const Matcher<Node*>& effect_matcher,
                     const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kJSToNumber),
         base_matcher_(base_matcher),
         context_matcher_(context_matcher),
         effect_matcher_(effect_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose base (";
     base_matcher_.DescribeTo(os);
     *os << "), context (";
     context_matcher_.DescribeTo(os);
     *os << "), effect (";
     effect_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
                                  base_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetContextInput(node),
                                  "context", context_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
                                  effect_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> base_matcher_;
   const Matcher<Node*> context_matcher_;
   const Matcher<Node*> effect_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsStoreMatcher FINAL : public NodeMatcher {
+class IsStoreMatcher final : public NodeMatcher {
  public:
   IsStoreMatcher(const Matcher<StoreRepresentation>& rep_matcher,
                  const Matcher<Node*>& base_matcher,
                  const Matcher<Node*>& index_matcher,
                  const Matcher<Node*>& value_matcher,
                  const Matcher<Node*>& effect_matcher,
                  const Matcher<Node*>& control_matcher)
       : NodeMatcher(IrOpcode::kStore),
         rep_matcher_(rep_matcher),
         base_matcher_(base_matcher),
         index_matcher_(index_matcher),
         value_matcher_(value_matcher),
         effect_matcher_(effect_matcher),
         control_matcher_(control_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose rep (";
     rep_matcher_.DescribeTo(os);
     *os << "), base (";
     base_matcher_.DescribeTo(os);
     *os << "), index (";
     index_matcher_.DescribeTo(os);
     *os << "), value (";
     value_matcher_.DescribeTo(os);
     *os << "), effect (";
     effect_matcher_.DescribeTo(os);
     *os << ") and control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(OpParameter<StoreRepresentation>(node), "rep",
                                  rep_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
                                  base_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
                                  "index", index_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
                                  "value", value_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
                                  effect_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<StoreRepresentation> rep_matcher_;
   const Matcher<Node*> base_matcher_;
   const Matcher<Node*> index_matcher_;
   const Matcher<Node*> value_matcher_;
   const Matcher<Node*> effect_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsBinopMatcher FINAL : public NodeMatcher {
+class IsBinopMatcher final : public NodeMatcher {
  public:
   IsBinopMatcher(IrOpcode::Value opcode, const Matcher<Node*>& lhs_matcher,
                  const Matcher<Node*>& rhs_matcher)
       : NodeMatcher(opcode),
         lhs_matcher_(lhs_matcher),
         rhs_matcher_(rhs_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose lhs (";
     lhs_matcher_.DescribeTo(os);
     *os << ") and rhs (";
     rhs_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "lhs",
                                  lhs_matcher_, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1), "rhs",
                                  rhs_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> lhs_matcher_;
   const Matcher<Node*> rhs_matcher_;
 };
 
 
-class IsUnopMatcher FINAL : public NodeMatcher {
+class IsUnopMatcher final : public NodeMatcher {
  public:
   IsUnopMatcher(IrOpcode::Value opcode, const Matcher<Node*>& input_matcher)
       : NodeMatcher(opcode), input_matcher_(input_matcher) {}
 
-  void DescribeTo(std::ostream* os) const FINAL {
+  void DescribeTo(std::ostream* os) const final {
     NodeMatcher::DescribeTo(os);
     *os << " whose input (";
     input_matcher_.DescribeTo(os);
     *os << ")";
   }
 
-  bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
                                  "input", input_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> input_matcher_;
 };
 
 }  // namespace
@@ skipping 378 matching lines @@
 IS_UNOP_MATCHER(NumberToInt32)
 IS_UNOP_MATCHER(NumberToUint32)
 IS_UNOP_MATCHER(ObjectIsSmi)
 IS_UNOP_MATCHER(ObjectIsNonNegativeSmi)
 IS_UNOP_MATCHER(Word32Clz)
 #undef IS_UNOP_MATCHER
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8