Apply modernize-use-default to clang-tools-extra.

[angelgarcia]

Summary

Replace empty bodies of default constructors and destructors with '= default'.

[klimek]

LG

clang-modernize/Core/IncludeDirectives.cpp

struct GuardDetection {
     bool isPotentialHeaderGuard() const {
       return Count == CountAtEndif && DefineLoc.isValid();
     }
   };
 
 public:
   IncludeDirectivesPPCallback(IncludeDirectives *Self)
       : Self(Self), Guard(nullptr) {}
-  ~IncludeDirectivesPPCallback() override {}
+  ~IncludeDirectivesPPCallback() override = default;
 
 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;

clang-modernize/Core/Transform.cpp

 };
 } // namespace
 
 Transform::Transform(llvm::StringRef Name, const TransformOptions &Options)
     : Name(Name), GlobalOptions(Options) {
   Reset();
 }
 
-Transform::~Transform() {}
+Transform::~Transform() = default;
 
 bool Transform::isFileModifiable(const SourceManager &SM,
                                  SourceLocation Loc) const {
   if (SM.isWrittenInMainFile(Loc))
     return true;
 
   const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(Loc));
   if (!FE)
if (!MinorStr.empty()) {
     if (MinorStr.getAsInteger(10, V.Minor))
       return Version();
   }
   if (MajorStr.getAsInteger(10, V.Major))
     return Version();
   return V;
 }
 
-TransformFactory::~TransformFactory() {}
+TransformFactory::~TransformFactory() = default;
 
 namespace {
 bool versionSupported(Version Required, Version AvailableSince) {
   // null version, means no requirements, means supported
   if (Required.isNull())
     return true;
   return Required >= AvailableSince;
 }
 } // end anonymous namespace
 
 bool TransformFactory::supportsCompilers(CompilerVersions Required) const {
   return versionSupported(Required.Clang, Since.Clang) &&
          versionSupported(Required.Gcc, Since.Gcc) &&
          versionSupported(Required.Icc, Since.Icc) &&
          versionSupported(Required.Msvc, Since.Msvc);
 }

clang-query/Query.cpp

 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang::ast_matchers;
 using namespace clang::ast_matchers::dynamic;
 
 namespace clang {
 namespace query {
 
-Query::~Query() {}
+Query::~Query() = default;
 
 bool InvalidQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
   OS << ErrStr << "\n";
   return false;
 }
 
 bool NoOpQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
   return true;

clang-tidy/ClangTidyModule.h

 private:
   FactoryMap Factories;
 };
 
 /// \brief A clang-tidy module groups a number of \c ClangTidyChecks and gives
 /// them a prefixed name.
 class ClangTidyModule {
 public:
-  virtual ~ClangTidyModule() {}
+  virtual ~ClangTidyModule() = default;
 
   /// \brief Implement this function in order to register all \c CheckFactories
   /// belonging to this module.
   virtual void addCheckFactories(ClangTidyCheckFactories &CheckFactories) = 0;
 
   /// \brief Gets default options for checks defined in this module.
   virtual ClangTidyOptions getModuleOptions();
 };
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULE_H

clang-tidy/ClangTidyOptions.h

struct ClangTidyOptions {
 
   /// \brief Key-value mapping used to store check-specific options.
   OptionMap CheckOptions;
 };
 
 /// \brief Abstract interface for retrieving various ClangTidy options.
 class ClangTidyOptionsProvider {
 public:
-  virtual ~ClangTidyOptionsProvider() {}
+  virtual ~ClangTidyOptionsProvider() = default;
 
   /// \brief Returns global options, which are independent of the file.
   virtual const ClangTidyGlobalOptions &getGlobalOptions() = 0;
 
   /// \brief Returns options applying to a specific translation unit with the
   /// specified \p FileName.
   virtual ClangTidyOptions getOptions(llvm::StringRef FileName) = 0;
 };

clang-tidy/utils/IncludeInserter.cpp

private:
   IncludeInserter *Inserter;
 };
 
 IncludeInserter::IncludeInserter(const SourceManager &SourceMgr,
                                  const LangOptions &LangOpts,
                                  IncludeSorter::IncludeStyle Style)
     : SourceMgr(SourceMgr), LangOpts(LangOpts), Style(Style) {}
 
-IncludeInserter::~IncludeInserter() {}
+IncludeInserter::~IncludeInserter() = default;
 
 std::unique_ptr<PPCallbacks> IncludeInserter::CreatePPCallbacks() {
   return llvm::make_unique<IncludeInserterCallback>(this);
 }
 
 llvm::Optional<FixItHint>
 IncludeInserter::CreateIncludeInsertion(FileID FileID, StringRef Header,
                                         bool IsAngled) {

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() override {}
+  ~CoverageCheckerCallbacks() override = default;
 
   // 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) override {
     Checker.collectUmbrellaHeaderHeader(File->getName());

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() override {}
+  ~PreprocessorCallbacks() override = default;
 
   // 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,
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() override {}
+  ~PreprocessorTrackerImpl() override = default;
 
   // Handle entering a preprocessing session.
   void handlePreprocessorEntry(clang::Preprocessor &PP,
                                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,
private:
   bool InNestedHeader;
 };
 
 } // namespace
 
 // PreprocessorTracker functions.
 
 // PreprocessorTracker desctructor.
-PreprocessorTracker::~PreprocessorTracker() {}
+PreprocessorTracker::~PreprocessorTracker() = default;
 
 // Create instance of PreprocessorTracker.
 PreprocessorTracker *PreprocessorTracker::create(
     llvm::SmallVector<std::string, 32> &Headers,
     bool DoBlockCheckHeaderListOnly) {
   return new PreprocessorTrackerImpl(Headers, DoBlockCheckHeaderListOnly);
 }
 

pp-trace/PPCallbacksTracker.cpp

 
 // PPCallbacksTracker functions.
 
 PPCallbacksTracker::PPCallbacksTracker(llvm::SmallSet<std::string, 4> &Ignore,
                                        std::vector<CallbackCall> &CallbackCalls,
                                        clang::Preprocessor &PP)
     : CallbackCalls(CallbackCalls), Ignore(Ignore), PP(PP) {}
 
-PPCallbacksTracker::~PPCallbacksTracker() {}
+PPCallbacksTracker::~PPCallbacksTracker() = default;
 
 // Callback functions.
 
 // Callback invoked whenever a source file is entered or exited.
 void PPCallbacksTracker::FileChanged(
     clang::SourceLocation Loc, clang::PPCallbacks::FileChangeReason Reason,
     clang::SrcMgr::CharacteristicKind FileType, clang::FileID PrevFID) {
   beginCallback("FileChanged");

unittests/clang-tidy/IncludeInserterTest.cpp

public:
   }
   bool IsAngledInclude() const override { return true; }
 };
 
 class CXXSystemIncludeInserterCheck : public IncludeInserterCheckBase {
 public:
   CXXSystemIncludeInserterCheck(StringRef CheckName, ClangTidyContext *Context)
       : IncludeInserterCheckBase(CheckName, Context) {}
-  virtual ~CXXSystemIncludeInserterCheck() {}
+  virtual ~CXXSystemIncludeInserterCheck() = default;
 
   std::vector<StringRef> HeadersToInclude() const override { return {"set"}; }
   bool IsAngledInclude() const override { return true; }
 };
 
 template <typename Check>
 std::string runCheckOnCode(StringRef Code, StringRef Filename) {
   std::vector<ClangTidyError> Errors;