[clang][dataflow][NFC] Mark test analysis classes as `final`.

[ymandel]

Summary

Change from marking individual methods as final to marking the whole class.

[xazax.hun]

Thanks!

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

TEST_F(NoreturnDestructorTest, ConditionalOperatorNestedBranchReturns) {
   )";
   runDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
                         "p", HoldsFunctionCallLattice(HasCalledFunctions(
                                  UnorderedElementsAre("baz", "foo"))))));
   // FIXME: Called functions at point `p` should contain only "foo".
 }
 
 // Models an analysis that uses flow conditions.
-//
-// FIXME: Here and below: change class to final and final methods to override,
-// since we're marking them all as final.
-class SpecialBoolAnalysis
+class SpecialBoolAnalysis final
     : public DataflowAnalysis<SpecialBoolAnalysis, NoopLattice> {
 public:
   explicit SpecialBoolAnalysis(ASTContext &Context)
       : DataflowAnalysis<SpecialBoolAnalysis, NoopLattice>(Context) {}
 
   static NoopLattice initialElement() { return {}; }
 
   void transfer(const CFGElement *Elt, NoopLattice &, Environment &Env) {
if (const auto *E = selectFirst<CXXConstructExpr>(
       auto &ConstructorVal = *Env.createValue(Object->getType());
       ConstructorVal.setProperty("is_set", Env.getBoolLiteralValue(true));
       Env.setValue(*ObjectLoc, ConstructorVal);
     }
   }
 
   bool compareEquivalent(QualType Type, const Value &Val1,
                          const Environment &Env1, const Value &Val2,
-                         const Environment &Env2) final {
+                         const Environment &Env2) override {
     const auto *Decl = Type->getAsCXXRecordDecl();
     if (Decl == nullptr || Decl->getIdentifier() == nullptr ||
         Decl->getName() != "SpecialBool")
       return false;
 
     auto *IsSet1 = cast_or_null<BoolValue>(Val1.getProperty("is_set"));
     if (IsSet1 == nullptr)
       return true;
 
     auto *IsSet2 = cast_or_null<BoolValue>(Val2.getProperty("is_set"));
     if (IsSet2 == nullptr)
       return false;
 
     return Env1.flowConditionImplies(*IsSet1) ==
            Env2.flowConditionImplies(*IsSet2);
   }
 
   // Always returns `true` to accept the `MergedVal`.
   bool merge(QualType Type, const Value &Val1, const Environment &Env1,
              const Value &Val2, const Environment &Env2, Value &MergedVal,
-             Environment &MergedEnv) final {
+             Environment &MergedEnv) override {
     const auto *Decl = Type->getAsCXXRecordDecl();
     if (Decl == nullptr || Decl->getIdentifier() == nullptr ||
         Decl->getName() != "SpecialBool")
       return true;
 
     auto *IsSet1 = cast_or_null<BoolValue>(Val1.getProperty("is_set"));
     if (IsSet1 == nullptr)
       return true;
runDataflow(
 
         EXPECT_FALSE(Env1.flowConditionImplies(*GetFooValue(Env1)));
         EXPECT_TRUE(Env2.flowConditionImplies(*GetFooValue(Env2)));
         EXPECT_TRUE(Env3.flowConditionImplies(*GetFooValue(Env3)));
         EXPECT_TRUE(Env4.flowConditionImplies(*GetFooValue(Env3)));
       });
 }
 
-class OptionalIntAnalysis
+class OptionalIntAnalysis final
     : public DataflowAnalysis<OptionalIntAnalysis, NoopLattice> {
 public:
   explicit OptionalIntAnalysis(ASTContext &Context)
       : DataflowAnalysis<OptionalIntAnalysis, NoopLattice>(Context) {}
 
   static NoopLattice initialElement() { return {}; }
 
   void transfer(const CFGElement *Elt, NoopLattice &, Environment &Env) {
if (const auto *E = selectFirst<CXXConstructExpr>(
       auto &ConstructorVal = *Env.createValue(Object->getType());
       ConstructorVal.setProperty("has_value", Env.getBoolLiteralValue(true));
       Env.setValue(*ObjectLoc, ConstructorVal);
     }
   }
 
   bool compareEquivalent(QualType Type, const Value &Val1,
                          const Environment &Env1, const Value &Val2,
-                         const Environment &Env2) final {
+                         const Environment &Env2) override {
     // Nothing to say about a value that does not model an `OptionalInt`.
     if (!Type->isRecordType() ||
         Type->getAsCXXRecordDecl()->getQualifiedNameAsString() != "OptionalInt")
       return false;
 
     auto *Prop1  = Val1.getProperty("has_value");
     auto *Prop2 = Val2.getProperty("has_value");
     return Prop1 == Prop2 ||
            (Prop1 != nullptr && Prop2 != nullptr && isa<TopBoolValue>(Prop1) &&
             isa<TopBoolValue>(Prop2));
   }
 
   bool merge(QualType Type, const Value &Val1, const Environment &Env1,
              const Value &Val2, const Environment &Env2, Value &MergedVal,
-             Environment &MergedEnv) final {
+             Environment &MergedEnv) override {
     // Nothing to say about a value that does not model an `OptionalInt`.
     if (!Type->isRecordType() ||
         Type->getAsCXXRecordDecl()->getQualifiedNameAsString() != "OptionalInt")
       return false;
 
     auto *HasValue1 = cast_or_null<BoolValue>(Val1.getProperty("has_value"));
     if (HasValue1 == nullptr)
       return false;