[Index] Marked a bunch of classes 'final'

[gribozavr]

Summary

This file defines multiple inheritance hierarchies and 'final' helps
with readability.

[ilya-biryukov]

LGTM

[gribozavr]

Committed as r370321.

clang/lib/Index/IndexingAction.cpp

 #include "llvm/ADT/STLExtras.h"
 #include <memory>
 
 using namespace clang;
 using namespace clang::index;
 
 namespace {
 
-class IndexASTConsumer : public ASTConsumer {
+class IndexASTConsumer final : public ASTConsumer {
   std::shared_ptr<Preprocessor> PP;
   std::shared_ptr<IndexingContext> IndexCtx;
 
 public:
   IndexASTConsumer(std::shared_ptr<Preprocessor> PP,
                    std::shared_ptr<IndexingContext> IndexCtx)
       : PP(std::move(PP)), IndexCtx(std::move(IndexCtx)) {}
 
protected:
   void HandleTopLevelDeclInObjCContainer(DeclGroupRef DG) override {
     IndexCtx->indexDeclGroupRef(DG);
   }
 
   void HandleTranslationUnit(ASTContext &Ctx) override {
   }
 };
 
-class IndexPPCallbacks : public PPCallbacks {
+class IndexPPCallbacks final : public PPCallbacks {
   std::shared_ptr<IndexingContext> IndexCtx;
 
 public:
   IndexPPCallbacks(std::shared_ptr<IndexingContext> IndexCtx)
       : IndexCtx(std::move(IndexCtx)) {}
 
   void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *Args) override {
std::unique_ptr<PPCallbacks> createIndexPPCallbacks() {
     return std::make_unique<IndexPPCallbacks>(IndexCtx);
   }
 
   void finish() {
     DataConsumer->finish();
   }
 };
 
-class IndexAction : public ASTFrontendAction, IndexActionBase {
+class IndexAction final : public ASTFrontendAction, IndexActionBase {
 public:
   IndexAction(std::shared_ptr<IndexDataConsumer> DataConsumer,
               IndexingOptions Opts)
     : IndexActionBase(std::move(DataConsumer), Opts) {}
 
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override {
     return createIndexASTConsumer(CI);
   }
 
   bool BeginSourceFileAction(clang::CompilerInstance &CI) override {
     CI.getPreprocessor().addPPCallbacks(createIndexPPCallbacks());
     return true;
   }
 
   void EndSourceFileAction() override {
     FrontendAction::EndSourceFileAction();
     finish();
   }
 };
 
-class WrappingIndexAction : public WrapperFrontendAction, IndexActionBase {
+class WrappingIndexAction final : public WrapperFrontendAction, IndexActionBase {
   bool IndexActionFailed = false;
 
 public:
   WrappingIndexAction(std::unique_ptr<FrontendAction> WrappedAction,
                       std::shared_ptr<IndexDataConsumer> DataConsumer,
                       IndexingOptions Opts)
     : WrapperFrontendAction(std::move(WrappedAction)),
       IndexActionBase(std::move(DataConsumer), Opts) {}