Use 'override/final' instead of 'virtual' for overridden methods

[alexfh]

Summary

The patch is generated using clang-tidy misc-use-override check.

This command was used:

tools/clang/tools/extra/clang-tidy/tool/run-clang-tidy.py \
    -checks='-*,misc-use-override' -header-filter='llvm|clang' -j=32 -fix

svn diff | clang-format-diff -i

[alexfh]

Recreated the patch using:

tools/clang/tools/extra/clang-tidy/tool/run-clang-tidy.py -checks='-*,misc-use-override' -header-filter='llvm|clang' -j=32 -fix -format

Fewer formatting changes.

[dblaikie]

Looks great - thanks a bunch!

clang-modernize/AddOverride/AddOverrideActions.h

 class AddOverrideFixer : public clang::ast_matchers::MatchFinder::MatchCallback {
 public:
   AddOverrideFixer(unsigned &AcceptedChanges, bool DetectMacros,
                    Transform &Owner)
       : AcceptedChanges(AcceptedChanges), DetectMacros(DetectMacros),
         Owner(Owner) {}
 
   /// \brief Entry point to the callback called when matches are made.
-  virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result);
+  void
+  run(const clang::ast_matchers::MatchFinder::MatchResult &Result) override;
 
   void setPreprocessor(clang::Preprocessor &PP) { this->PP = &PP; }
 
 private:
   clang::Preprocessor *PP;
   unsigned &AcceptedChanges;
   bool DetectMacros;
   Transform &Owner;
 };
 
 #endif // CLANG_MODERNIZE_ADD_OVERRIDE_ACTIONS_H

clang-modernize/Core/IncludeDirectives.cpp

struct GuardDetection {
     bool isPotentialHeaderGuard() const {
       return Count == CountAtEndif && DefineLoc.isValid();
     }
   };
 
 public:
   IncludeDirectivesPPCallback(IncludeDirectives *Self)
       : Self(Self), Guard(nullptr) {}
-  virtual ~IncludeDirectivesPPCallback() {}
+  ~IncludeDirectivesPPCallback() override {}
 
 private:
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange, const FileEntry *File,
                           StringRef SearchPath, StringRef RelativePath,
                           const Module *Imported) override {
     SourceManager &SM = Self->Sources;
     const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(HashLoc));
     assert(FE && "Valid file expected.");
 
     IncludeDirectives::Entry E(HashLoc, File, IsAngled);
     Self->FileToEntries[FE].push_back(E);
     Self->IncludeAsWrittenToLocationsMap[FileName].push_back(HashLoc);
   }
 
   // Keep track of the current file in the stack
-  virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
-                           SrcMgr::CharacteristicKind FileType,
-                           FileID PrevFID) override {
+  void FileChanged(SourceLocation Loc, FileChangeReason Reason,
     SourceManager &SM = Self->Sources;
     switch (Reason) {
     case EnterFile:
       Files.push(GuardDetection(SM.getFileID(Loc)));
       Guard = &Files.top();
       break;
 
     case ExitFile:
void handlePotentialHeaderGuard(const GuardDetection &Guard) {
     // else than comments or whitespaces.
     if (Tok.isNot(tok::eof))
       return;
 
     // Add to the location of the define to the IncludeDirectives for this file.
     Self->HeaderToGuard[File] = Guard.DefineLoc;
   }
 
-  virtual void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
-                      const MacroDirective *MD) override {
+  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
     Guard->Count++;
 
     // If this #ifndef is the top-most directive and the symbol isn't defined
     // store those information in the guard detection, the next step will be to
     // check for the define.
     if (Guard->Count == 1 && MD == nullptr) {
       IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
 
       if (MII->hasMacroDefinition())
         return;
       Guard->IfndefLoc = Loc;
       Guard->TheMacro = MII;
     }
   }
 
-  virtual void MacroDefined(const Token &MacroNameTok,
-                            const MacroDirective *MD) override {
+  void MacroDefined(const Token &MacroNameTok,
     Guard->Count++;
 
     // If this #define is the second directive of the file and the symbol
     // defined is the same as the one checked in the #ifndef then store the
     // information about this define.
     if (Guard->Count == 2 && Guard->TheMacro != nullptr) {
       IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
 
if (Guard->DefineLoc.isInvalid())
       return;
 
     // Then save the information about this #endif. Once the file is exited we
     // will check if it was the final preprocessor directive.
     Guard->CountAtEndif = Guard->Count;
     Guard->EndifLoc = Loc;
   }
 
-  virtual void MacroExpands(const Token &, const MacroDirective *, SourceRange,
-                            const MacroArgs *) override {
+  void MacroExpands(const Token &, const MacroDirective *, SourceRange,
     Guard->Count++;
   }
-  virtual void MacroUndefined(const Token &,
-                              const MacroDirective *) override {
+  void MacroUndefined(const Token &, const MacroDirective *) override {
     Guard->Count++;
   }
-  virtual void Defined(const Token &, const MacroDirective *,
-                       SourceRange) override {
+  void Defined(const Token &, const MacroDirective *, SourceRange) override {
     Guard->Count++;
   }
-  virtual void If(SourceLocation, SourceRange,
-                  ConditionValueKind) override {
+  void If(SourceLocation, SourceRange, ConditionValueKind) override {
     Guard->Count++;
   }
-  virtual void Elif(SourceLocation, SourceRange, ConditionValueKind,
-                    SourceLocation) override {
+  void Elif(SourceLocation, SourceRange, ConditionValueKind,
     Guard->Count++;
   }
-  virtual void Ifdef(SourceLocation, const Token &,
-                     const MacroDirective *) override {
+  void Ifdef(SourceLocation, const Token &, const MacroDirective *) override {
     Guard->Count++;
   }
   void Else(SourceLocation, SourceLocation) override {
     Guard->Count++;
   }
 
   IncludeDirectives *Self;
   // keep track of the guard info through the include stack

clang-modernize/Core/Transform.cpp

public:
     FactoryAdaptor(MatchFinder &Finder, Transform &Owner)
         : Finder(Finder), Owner(Owner) {}
 
     std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
                                                    StringRef) override {
       return Finder.newASTConsumer();
     }
 
-    virtual bool BeginSourceFileAction(CompilerInstance &CI,
-                                       StringRef Filename) override {
+    bool BeginSourceFileAction(CompilerInstance &CI,
       if (!ASTFrontendAction::BeginSourceFileAction(CI, Filename))
         return false;
 
       return Owner.handleBeginSource(CI, Filename);
     }
 
     void EndSourceFileAction() override {
       Owner.handleEndSource();

clang-modernize/LoopConvert/LoopActions.h

 public:
   LoopFixer(TUTrackingInfo &TUInfo, unsigned *AcceptedChanges,
             unsigned *DeferredChanges, unsigned *RejectedChanges,
             RiskLevel MaxRisk, LoopFixerKind FixerKind, Transform &Owner)
       : TUInfo(TUInfo), AcceptedChanges(AcceptedChanges),
         DeferredChanges(DeferredChanges), RejectedChanges(RejectedChanges),
         MaxRisk(MaxRisk), FixerKind(FixerKind), Owner(Owner) {}
 
-  virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result);
+  void
+  run(const clang::ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   TUTrackingInfo &TUInfo;
   unsigned *AcceptedChanges;
   unsigned *DeferredChanges;
   unsigned *RejectedChanges;
   RiskLevel MaxRisk;
   LoopFixerKind FixerKind;

clang-modernize/UseNullptr/NullptrActions.h

 /// \brief The callback to be used for nullptr migration matchers.
 ///
 class NullptrFixer : public clang::ast_matchers::MatchFinder::MatchCallback {
 public:
   NullptrFixer(unsigned &AcceptedChanges,
                llvm::ArrayRef<llvm::StringRef> UserMacros, Transform &Owner);
 
   /// \brief Entry point to the callback called when matches are made.
-  virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result);
+  void
+  run(const clang::ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   unsigned &AcceptedChanges;
   UserMacroNames UserNullMacros;
   Transform &Owner;
 };
 
 #endif // CLANG_MODERNIZE_NULLPTR_ACTIONS_H

clang-query/Query.cpp

bool HelpQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
   return true;
 }
 
 namespace {
 
 struct CollectBoundNodes : MatchFinder::MatchCallback {
   std::vector<BoundNodes> &Bindings;
   CollectBoundNodes(std::vector<BoundNodes> &Bindings) : Bindings(Bindings) {}
-  void run(const MatchFinder::MatchResult &Result) {
+  void run(const MatchFinder::MatchResult &Result) override {
     Bindings.push_back(Result.Nodes);
   }
 };
 
 }  // namespace
 
 bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
   unsigned MatchCount = 0;

modularize/CoverageChecker.cpp

 namespace cl = llvm::cl;
 namespace sys = llvm::sys;
 
 // Preprocessor callbacks.
 // We basically just collect include files.
 class CoverageCheckerCallbacks : public PPCallbacks {
 public:
   CoverageCheckerCallbacks(CoverageChecker &Checker) : Checker(Checker) {}
-  ~CoverageCheckerCallbacks() {}
+  ~CoverageCheckerCallbacks() override {}
 
   // Include directive callback.
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange, const FileEntry *File,
                           StringRef SearchPath, StringRef RelativePath,
-    const Module *Imported) {
+                          const Module *Imported) override {
     Checker.collectUmbrellaHeaderHeader(File->getName());
   }
 
 private:
   CoverageChecker &Checker;
 };
 
 // Frontend action stuff:
private:
   CoverageChecker &Checker;
 };
 
 class CoverageCheckerFrontendActionFactory : public FrontendActionFactory {
 public:
   CoverageCheckerFrontendActionFactory(CoverageChecker &Checker)
     : Checker(Checker) {}
 
-  virtual CoverageCheckerAction *create() {
+  CoverageCheckerAction *create() override {
     return new CoverageCheckerAction(Checker);
   }
 
 private:
   CoverageChecker &Checker;
 };
 
 // CoverageChecker class implementation.

modularize/Modularize.cpp

public:
   CollectEntitiesConsumer(EntityMap &Entities,
                           PreprocessorTracker &preprocessorTracker,
                           Preprocessor &PP, StringRef InFile, int &HadErrors)
       : Entities(Entities), PPTracker(preprocessorTracker), PP(PP),
         HadErrors(HadErrors) {
     PPTracker.handlePreprocessorEntry(PP, InFile);
   }
 
-  ~CollectEntitiesConsumer() { PPTracker.handlePreprocessorExit(); }
+  ~CollectEntitiesConsumer() override { PPTracker.handlePreprocessorExit(); }
 
-  virtual void HandleTranslationUnit(ASTContext &Ctx) {
+  void HandleTranslationUnit(ASTContext &Ctx) override {
     SourceManager &SM = Ctx.getSourceManager();
 
     // Collect declared entities.
     CollectEntitiesVisitor(SM, Entities, PP, PPTracker, HadErrors)
         .TraverseDecl(Ctx.getTranslationUnitDecl());
 
     // Collect macro definitions.
     for (Preprocessor::macro_iterator M = PP.macro_begin(),

 class ModularizeFrontendActionFactory : public FrontendActionFactory {
 public:
   ModularizeFrontendActionFactory(EntityMap &Entities,
                                   PreprocessorTracker &preprocessorTracker,
                                   int &HadErrors)
       : Entities(Entities), PPTracker(preprocessorTracker),
         HadErrors(HadErrors) {}
 
-  virtual CollectEntitiesAction *create() {
+  CollectEntitiesAction *create() override {
     return new CollectEntitiesAction(Entities, PPTracker, HadErrors);
   }
 
 private:
   EntityMap &Entities;
   PreprocessorTracker &PPTracker;
   int &HadErrors;
 };

modularize/PreprocessorTracker.cpp

 // actions, such as changing files and handling preprocessor directives and
 // macro expansions.  It has to figure out when a new header file is entered
 // and left, as the provided handler is not particularly clear about it.
 class PreprocessorCallbacks : public clang::PPCallbacks {
 public:
   PreprocessorCallbacks(PreprocessorTrackerImpl &ppTracker,
                         clang::Preprocessor &PP, llvm::StringRef rootHeaderFile)
       : PPTracker(ppTracker), PP(PP), RootHeaderFile(rootHeaderFile) {}
-  ~PreprocessorCallbacks() {}
+  ~PreprocessorCallbacks() override {}
 
   // Overridden handlers.
   void InclusionDirective(clang::SourceLocation HashLoc,
                           const clang::Token &IncludeTok,
                           llvm::StringRef FileName, bool IsAngled,
                           clang::CharSourceRange FilenameRange,
                           const clang::FileEntry *File,
                           llvm::StringRef SearchPath,
                           llvm::StringRef RelativePath,
-                          const clang::Module *Imported);
+                          const clang::Module *Imported) override;
   void FileChanged(clang::SourceLocation Loc,
                    clang::PPCallbacks::FileChangeReason Reason,
                    clang::SrcMgr::CharacteristicKind FileType,
-                   clang::FileID PrevFID = clang::FileID());
+                   clang::FileID PrevFID = clang::FileID()) override;
   void MacroExpands(const clang::Token &MacroNameTok,
                     const clang::MacroDirective *MD, clang::SourceRange Range,
-                    const clang::MacroArgs *Args);
+                    const clang::MacroArgs *Args) override;
   void Defined(const clang::Token &MacroNameTok,
-               const clang::MacroDirective *MD, clang::SourceRange Range);
+               const clang::MacroDirective *MD,
+               clang::SourceRange Range) override;
   void If(clang::SourceLocation Loc, clang::SourceRange ConditionRange,
-          clang::PPCallbacks::ConditionValueKind ConditionResult);
+          clang::PPCallbacks::ConditionValueKind ConditionResult) override;
   void Elif(clang::SourceLocation Loc, clang::SourceRange ConditionRange,
-            clang::PPCallbacks::ConditionValueKind ConditionResult, clang::SourceLocation IfLoc);
+            clang::PPCallbacks::ConditionValueKind ConditionResult,
+            clang::SourceLocation IfLoc) override;
   void Ifdef(clang::SourceLocation Loc, const clang::Token &MacroNameTok,
-             const clang::MacroDirective *MD);
+             const clang::MacroDirective *MD) override;
   void Ifndef(clang::SourceLocation Loc, const clang::Token &MacroNameTok,
-              const clang::MacroDirective *MD);
+              const clang::MacroDirective *MD) override;
 
 private:
   PreprocessorTrackerImpl &PPTracker;
   clang::Preprocessor &PP;
   std::string RootHeaderFile;
 };
 
 // Preprocessor macro expansion item map types.
PreprocessorTrackerImpl(llvm::SmallVector<std::string, 32> &Headers,
     // Use canonical header path representation.
     for (llvm::ArrayRef<std::string>::iterator I = Headers.begin(),
       E = Headers.end();
       I != E; ++I) {
       HeaderList.push_back(getCanonicalPath(*I));
     }
   }
 
-  ~PreprocessorTrackerImpl() {}
+  ~PreprocessorTrackerImpl() override {}
 
   // Handle entering a preprocessing session.
   void handlePreprocessorEntry(clang::Preprocessor &PP,
-                               llvm::StringRef rootHeaderFile) {
+                               llvm::StringRef rootHeaderFile) override {
     HeadersInThisCompile.clear();
     assert((HeaderStack.size() == 0) && "Header stack should be empty.");
     pushHeaderHandle(addHeader(rootHeaderFile));
     PP.addPPCallbacks(llvm::make_unique<PreprocessorCallbacks>(*this, PP,
                                                                rootHeaderFile));
   }
   // Handle exiting a preprocessing session.
-  void handlePreprocessorExit() { HeaderStack.clear(); }
+  void handlePreprocessorExit() override { HeaderStack.clear(); }
 
   // Handle include directive.
   // This function is called every time an include directive is seen by the
   // preprocessor, for the purpose of later checking for 'extern "" {}' or
   // "namespace {}" blocks containing #include directives.
   void handleIncludeDirective(llvm::StringRef DirectivePath, int DirectiveLine,
-                              int DirectiveColumn, llvm::StringRef TargetPath) {
+                              int DirectiveColumn,
+                              llvm::StringRef TargetPath) override {
     // If it's not a header in the header list, ignore it with respect to
     // the check.
     if (BlockCheckHeaderListOnly && !isHeaderListHeader(TargetPath))
       return;
     HeaderHandle CurrentHeaderHandle = findHeaderHandle(DirectivePath);
     StringHandle IncludeHeaderHandle = addString(TargetPath);
     for (std::vector<PPItemKey>::const_iterator I = IncludeDirectives.begin(),
                                                 E = IncludeDirectives.end();
          I != E; ++I) {
       // If we already have an entry for this directive, return now.
       if ((I->File == CurrentHeaderHandle) && (I->Line == DirectiveLine))
         return;
     }
     PPItemKey IncludeDirectiveItem(IncludeHeaderHandle, CurrentHeaderHandle,
                                    DirectiveLine, DirectiveColumn);
     IncludeDirectives.push_back(IncludeDirectiveItem);
   }
 
   // Check for include directives within the given source line range.
   // Report errors if any found.  Returns true if no include directives
   // found in block.
   bool checkForIncludesInBlock(clang::Preprocessor &PP,
                                clang::SourceRange BlockSourceRange,
                                const char *BlockIdentifierMessage,
-                               llvm::raw_ostream &OS) {
+                               llvm::raw_ostream &OS) override {
     clang::SourceLocation BlockStartLoc = BlockSourceRange.getBegin();
     clang::SourceLocation BlockEndLoc = BlockSourceRange.getEnd();
     // Use block location to get FileID of both the include directive
     // and block statement.
     clang::FileID FileID = PP.getSourceManager().getFileID(BlockStartLoc);
     std::string SourcePath = getSourceLocationFile(PP, BlockStartLoc);
     SourcePath = ModularizeUtilities::getCanonicalPath(SourcePath);
     HeaderHandle SourceHandle = findHeaderHandle(SourcePath);
if (I == ConditionalExpansions.end()) {
         CondTracker.addConditionalExpansionInstance(ConditionValue,
                                                     InclusionPathHandle);
       }
     }
   }
 
   // Report on inconsistent macro instances.
   // Returns true if any mismatches.
-  bool reportInconsistentMacros(llvm::raw_ostream &OS) {
+  bool reportInconsistentMacros(llvm::raw_ostream &OS) override {
     bool ReturnValue = false;
     // Walk all the macro expansion trackers in the map.
     for (MacroExpansionMapIter I = MacroExpansions.begin(),
                                E = MacroExpansions.end();
          I != E; ++I) {
       const PPItemKey &ItemKey = I->first;
       MacroExpansionTracker &MacroExpTracker = I->second;
       // If no mismatch (only one instance value) continue.
for (MacroExpansionMapIter I = MacroExpansions.begin(),
              << "\n";
       }
     }
     return ReturnValue;
   }
 
   // Report on inconsistent conditional instances.
   // Returns true if any mismatches.
-  bool reportInconsistentConditionals(llvm::raw_ostream &OS) {
+  bool reportInconsistentConditionals(llvm::raw_ostream &OS) override {
     bool ReturnValue = false;
     // Walk all the conditional trackers in the map.
     for (ConditionalExpansionMapIter I = ConditionalExpansions.begin(),
                                      E = ConditionalExpansions.end();
          I != E; ++I) {
       const PPItemKey &ItemKey = I->first;
       ConditionalTracker &CondTracker = I->second;
       if (!CondTracker.hasMismatch())

pp-trace/PPCallbacksTracker.h

public:
   /// by the caller.
   /// \param Ignore - Set of names of callbacks to ignore.
   /// \param CallbackCalls - Trace buffer.
   /// \param PP - The preprocessor.  Needed for getting some argument strings.
   PPCallbacksTracker(llvm::SmallSet<std::string, 4> &Ignore,
                      std::vector<CallbackCall> &CallbackCalls,
                      clang::Preprocessor &PP);
 
-  virtual ~PPCallbacksTracker();
+  ~PPCallbacksTracker() override;
 
   // Overidden callback functions.
 
   void FileChanged(clang::SourceLocation Loc,
                    clang::PPCallbacks::FileChangeReason Reason,
                    clang::SrcMgr::CharacteristicKind FileType,
                    clang::FileID PrevFID = clang::FileID()) override;
   void FileSkipped(const clang::FileEntry &ParentFile,

pp-trace/PPTrace.cpp

 };
 
 class PPTraceFrontendActionFactory : public FrontendActionFactory {
 public:
   PPTraceFrontendActionFactory(SmallSet<std::string, 4> &Ignore,
                                std::vector<CallbackCall> &CallbackCalls)
       : Ignore(Ignore), CallbackCalls(CallbackCalls) {}
 
-  virtual PPTraceAction *create() {
+  PPTraceAction *create() override {
     return new PPTraceAction(Ignore, CallbackCalls);
   }
 
 private:
   SmallSet<std::string, 4> &Ignore;
   std::vector<CallbackCall> &CallbackCalls;
 };
 } // namespace

unittests/clang-modernize/IncludeDirectivesTest.cpp

public:
   /// \brief Map additional header files.
   ///
   /// \sa makeHeaderFileName()
   void mapVirtualHeader(StringRef FileName, StringRef Content) {
     VFHelper.mapFile(makeHeaderFileName(FileName), Content);
   }
 
 private:
-  virtual bool BeginSourceFileAction(CompilerInstance &CI,
-                                     StringRef FileName) override {
+  bool BeginSourceFileAction(CompilerInstance &CI,
     if (!PreprocessOnlyAction::BeginSourceFileAction(CI, FileName))
       return false;
     VFHelper.mapVirtualFiles(CI.getSourceManager());
 
     FileToModify =
         HeaderToModify ? makeHeaderFileName(HeaderToModify) : FileName.str();
 
     FileIncludes.reset(new IncludeDirectives(CI));
     return true;
   }
 
-  virtual void EndSourceFileAction() override {
+  void EndSourceFileAction() override {
     const tooling::Replacement &Replace =
         FileIncludes->addAngledInclude(FileToModify, Include);
     if (Replace.isApplicable())
       Replaces.insert(Replace);
   }
 
   StringRef Include;
   VirtualFileHelper VFHelper;

unittests/clang-modernize/PerfSupportTest.cpp

 using namespace llvm;
 using namespace clang;
 
 class TransformA : public Transform {
 public:
   TransformA(const TransformOptions &Options)
       : Transform("TransformA", Options) {}
 
-  virtual int apply(const tooling::CompilationDatabase &,
-                    const std::vector<std::string> &) {
+  int apply(const tooling::CompilationDatabase &,
+            const std::vector<std::string> &) override {
     return 0;
   }
 
   void addTiming(StringRef Label, TimeRecord Duration) {
     Transform::addTiming(Label, Duration);
   }
 };
 
 class TransformB : public Transform {
 public:
   TransformB(const TransformOptions &Options)
       : Transform("TransformB", Options) {}
 
-  virtual int apply(const tooling::CompilationDatabase &,
-                    const std::vector<std::string> &) {
+  int apply(const tooling::CompilationDatabase &,
+            const std::vector<std::string> &) override {
     return 0;
   }
 
   void addTiming(StringRef Label, TimeRecord Duration) {
     Transform::addTiming(Label, Duration);
   }
 };
 

unittests/clang-modernize/TransformTest.cpp

 using namespace clang;
 using namespace ast_matchers;
 
 class DummyTransform : public Transform {
 public:
   DummyTransform(llvm::StringRef Name, const TransformOptions &Options)
       : Transform(Name, Options) {}
 
-  virtual int apply(const tooling::CompilationDatabase &,
-                    const std::vector<std::string> &) { return 0; }
+  int apply(const tooling::CompilationDatabase &,
+            const std::vector<std::string> &) override {
+    return 0;
+  }
 
   void setAcceptedChanges(unsigned Changes) {
     Transform::setAcceptedChanges(Changes);
   }
   void setRejectedChanges(unsigned Changes) {
     Transform::setRejectedChanges(Changes);
   }
   void setDeferredChanges(unsigned Changes) {
TEST(Transform, Interface) {
   T.setRejectedChanges(1);
   ASSERT_TRUE(T.getChangesNotMade());
 }
 
 class TimePassingASTConsumer : public ASTConsumer {
 public:
   TimePassingASTConsumer(bool *Called) : Called(Called) {}
 
-  virtual bool HandleTopLevelDecl(DeclGroupRef DeclGroup) {
+  bool HandleTopLevelDecl(DeclGroupRef DeclGroup) override {
     llvm::sys::TimeValue UserStart;
     llvm::sys::TimeValue SystemStart;
     llvm::sys::TimeValue UserNow;
     llvm::sys::TimeValue SystemNow;
     llvm::sys::TimeValue Wall;
 
     // Busy-wait until the user/system time combined is more than 1ms
     llvm::sys::TimeValue OneMS(0, 1000000);
std::unique_ptr<ASTConsumer> newASTConsumer() {
     return llvm::make_unique<TimePassingASTConsumer>(&Called);
   }
   bool Called;
 };
 
 struct CallbackForwarder : public clang::tooling::SourceFileCallbacks {
   CallbackForwarder(Transform &Callee) : Callee(Callee) {}
 
-  virtual bool handleBeginSource(CompilerInstance &CI, StringRef Filename) {
+  bool handleBeginSource(CompilerInstance &CI, StringRef Filename) override {
     return Callee.handleBeginSource(CI, Filename);
   }
 
-  virtual void handleEndSource() {
-    Callee.handleEndSource();
-  }
+  void handleEndSource() override { Callee.handleEndSource(); }
 
   Transform &Callee;
 };
 
 TEST(Transform, Timings) {
   TransformOptions Options;
   Options.EnableTiming = true;
   DummyTransform T("timing_transform", Options);

 }
 
 class ModifiableCallback
     : public clang::ast_matchers::MatchFinder::MatchCallback {
 public:
   ModifiableCallback(const Transform &Owner)
       : Owner(Owner) {}
 
-  virtual void
-  run(const clang::ast_matchers::MatchFinder::MatchResult &Result) {
+  void
+  run(const clang::ast_matchers::MatchFinder::MatchResult &Result) override {
     const VarDecl *Decl = Result.Nodes.getNodeAs<VarDecl>("decl");
     ASSERT_TRUE(Decl != nullptr);
 
     const SourceManager &SM = *Result.SourceManager;
 
     // Decl 'a' comes from the main source file. This test should always pass.
     if (Decl->getName().equals("a"))
       EXPECT_TRUE(Owner.isFileModifiable(SM, Decl->getLocStart()));