[tools] Updating PPCallbacks::InclusionDirective calls

[juliehockett]

Summary

[[ https://reviews.llvm.org/D46614 | [D46614] ]] adds SrcMgr::CharacteristicKind to the InclusionDirective callback, this patch updates instances of it in clang-tools-extra.

[aaron.ballman]

Aside from a minor nit, LGTM (no need for more review, you can fix the nit and commit).

clang-move/ClangMove.cpp

135

Put FileType into comments so the parameter is unnamed like the other unused ones.

clang-move/ClangMove.cpp

explicit FindAllIncludes(SourceManager *SM, ClangMoveTool *const MoveTool)
       : SM(*SM), MoveTool(MoveTool) {}
 
   void InclusionDirective(clang::SourceLocation HashLoc,
                           const clang::Token & /*IncludeTok*/,
                           StringRef FileName, bool IsAngled,
                           clang::CharSourceRange FilenameRange,
                           const clang::FileEntry * /*File*/,
                           StringRef SearchPath, StringRef /*RelativePath*/,
-                          const clang::Module * /*Imported*/) override {
+                          const clang::Module * /*Imported*/,
+                          SrcMgr::CharacteristicKind FileType) override {
     if (const auto *FileEntry = SM.getFileEntryForID(SM.getFileID(HashLoc)))
       MoveTool->addIncludes(FileName, IsAngled, SearchPath,
                             FileEntry->getName(), FilenameRange, SM);
   }
 
 private:
   const SourceManager &SM;
   ClangMoveTool *const MoveTool;

clang-tidy/llvm/IncludeOrderCheck.cpp

 public:
   explicit IncludeOrderPPCallbacks(ClangTidyCheck &Check, SourceManager &SM)
       : LookForMainModule(true), Check(Check), SM(SM) {}
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange, const FileEntry *File,
                           StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported) override;
+                          const Module *Imported,
+                          SrcMgr::CharacteristicKind FileType) override;
   void EndOfMainFile() override;
 
 private:
   struct IncludeDirective {
     SourceLocation Loc;    ///< '#' location in the include directive
     CharSourceRange Range; ///< SourceRange for the file name
     std::string Filename;  ///< Filename as a string
     bool IsAngled;         ///< true if this was an include with angle brackets
static int getPriority(StringRef Filename, bool IsAngled, bool IsMainModule) {
 
   // Other headers are inserted between the main module header and LLVM headers.
   return 1;
 }
 
 void IncludeOrderPPCallbacks::InclusionDirective(
     SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
     bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
-    StringRef SearchPath, StringRef RelativePath, const Module *Imported) {
+    StringRef SearchPath, StringRef RelativePath, const Module *Imported,
+    SrcMgr::CharacteristicKind FileType) {
   // We recognize the first include as a special main module header and want
   // to leave it in the top position.
   IncludeDirective ID = {HashLoc, FilenameRange, FileName, IsAngled, false};
   if (LookForMainModule && !IsAngled) {
     ID.IsMainModule = true;
     LookForMainModule = false;
   }
 

clang-tidy/modernize/DeprecatedHeadersCheck.cpp

 public:
   explicit IncludeModernizePPCallbacks(ClangTidyCheck &Check,
                                        LangOptions LangOpts);
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange, const FileEntry *File,
                           StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported) override;
+                          const Module *Imported,
+                          SrcMgr::CharacteristicKind FileType) override;
 
 private:
   ClangTidyCheck &Check;
   LangOptions LangOpts;
   llvm::StringMap<std::string> CStyledHeaderToCxx;
   llvm::StringSet<> DeleteHeaders;
 };
 } // namespace
for (const auto &Key :
        std::vector<std::string>({"stdalign.h", "stdbool.h", "iso646.h"})) {
     DeleteHeaders.insert(Key);
   }
 }
 
 void IncludeModernizePPCallbacks::InclusionDirective(
     SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
     bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
-    StringRef SearchPath, StringRef RelativePath, const Module *Imported) {
+    StringRef SearchPath, StringRef RelativePath, const Module *Imported,
+    SrcMgr::CharacteristicKind FileType) {
   // FIXME: Take care of library symbols from the global namespace.
   //
   // Reasonable options for the check:
   //
   // 1. Insert std prefix for every such symbol occurrence.
   // 2. Insert `using namespace std;` to the beginning of TU.
   // 3. Do nothing and let the user deal with the migration himself.
   if (CStyledHeaderToCxx.count(FileName) != 0) {

clang-tidy/utils/IncludeInserter.cpp

explicit IncludeInserterCallback(IncludeInserter *Inserter)
       : Inserter(Inserter) {}
   // Implements PPCallbacks::InclusionDerective(). Records the names and source
   // locations of the inclusions in the main source file being processed.
   void InclusionDirective(SourceLocation HashLocation,
                           const Token &IncludeToken, StringRef FileNameRef,
                           bool IsAngled, CharSourceRange FileNameRange,
                           const FileEntry * /*IncludedFile*/,
                           StringRef /*SearchPath*/, StringRef /*RelativePath*/,
-                          const Module * /*ImportedModule*/) override {
+                          const Module * /*ImportedModule*/,
+                          SrcMgr::CharacteristicKind FileType) override {
     Inserter->AddInclude(FileNameRef, IsAngled, HashLocation,
                          IncludeToken.getEndLoc());
   }
 
 private:
   IncludeInserter *Inserter;
 };
 

clangd/ClangdUnit.cpp

public:
   InclusionLocationsCollector(SourceManager &SourceMgr,
                               InclusionLocations &IncLocations)
       : SourceMgr(SourceMgr), IncLocations(IncLocations) {}
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange, const FileEntry *File,
                           StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported) override {
+                          const Module *Imported,
+                          SrcMgr::CharacteristicKind FileType) override {
     auto SR = FilenameRange.getAsRange();
     if (SR.isInvalid() || !File || File->tryGetRealPathName().empty())
       return;
 
     if (SourceMgr.isInMainFile(SR.getBegin())) {
       // Only inclusion directives in the main file make sense. The user cannot
       // select directives not in the main file.
       IncLocations.emplace_back(halfOpenToRange(SourceMgr, FilenameRange),

clangd/Headers.cpp

RecordHeaders(llvm::StringSet<> &WrittenHeaders,
       : WrittenHeaders(WrittenHeaders), ResolvedHeaders(ResolvedHeaders) {}
 
   void InclusionDirective(SourceLocation /*HashLoc*/,
                           const Token & /*IncludeTok*/,
                           llvm::StringRef FileName, bool IsAngled,
                           CharSourceRange /*FilenameRange*/,
                           const FileEntry *File, llvm::StringRef /*SearchPath*/,
                           llvm::StringRef /*RelativePath*/,
-                          const Module * /*Imported*/) override {
+                          const Module * /*Imported*/,
+                          SrcMgr::CharacteristicKind FileType) override {
     WrittenHeaders.insert(
         (IsAngled ? "<" + FileName + ">" : "\"" + FileName + "\"").str());
     if (File != nullptr && !File->tryGetRealPathName().empty())
       ResolvedHeaders.insert(File->tryGetRealPathName());
   }
 
 private:
   llvm::StringSet<> &WrittenHeaders;

modularize/CoverageChecker.cpp

public:
   CoverageCheckerCallbacks(CoverageChecker &Checker) : Checker(Checker) {}
   ~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) override {
+                          const Module *Imported,
+                          SrcMgr::CharacteristicKind FileType) override {
     Checker.collectUmbrellaHeaderHeader(File->getName());
   }
 
 private:
   CoverageChecker &Checker;
 };
 
 // Frontend action stuff:

modularize/PreprocessorTracker.cpp

public:
   // 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) override;
+                          const clang::Module *Imported,
+                          SrcMgr::CharacteristicKind FileType) override;
   void FileChanged(clang::SourceLocation Loc,
                    clang::PPCallbacks::FileChangeReason Reason,
                    clang::SrcMgr::CharacteristicKind FileType,
                    clang::FileID PrevFID = clang::FileID()) override;
   void MacroExpands(const clang::Token &MacroNameTok,
                     const clang::MacroDefinition &MD, clang::SourceRange Range,
                     const clang::MacroArgs *Args) override;
   void Defined(const clang::Token &MacroNameTok,

 // Preprocessor callbacks for modularize.
 
 // Handle include directive.
 void PreprocessorCallbacks::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, SrcMgr::CharacteristicKind FileType) {
   int DirectiveLine, DirectiveColumn;
   std::string HeaderPath = getSourceLocationFile(PP, HashLoc);
   getSourceLocationLineAndColumn(PP, HashLoc, DirectiveLine, DirectiveColumn);
   PPTracker.handleIncludeDirective(HeaderPath, DirectiveLine, DirectiveColumn,
                                    FileName);
 }
 
 // Handle file entry/exit.

pp-trace/PPCallbacksTracker.h

bool FileNotFound(llvm::StringRef FileName,
                     llvm::SmallVectorImpl<char> &RecoveryPath) override;
   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) override;
+                          const clang::Module *Imported,
+                          SrcMgr::CharacteristicKind FileType) override;
   void moduleImport(clang::SourceLocation ImportLoc, clang::ModuleIdPath Path,
                     const clang::Module *Imported) override;
   void EndOfMainFile() override;
   void Ident(clang::SourceLocation Loc, llvm::StringRef str) override;
   void PragmaDirective(clang::SourceLocation Loc,
                        clang::PragmaIntroducerKind Introducer) override;
   void PragmaComment(clang::SourceLocation Loc,
                      const clang::IdentifierInfo *Kind,

pp-trace/PPCallbacksTracker.cpp

 // Callback invoked whenever an inclusion directive of
 // any kind (#include, #import, etc.) has been processed, regardless
 // of whether the inclusion will actually result in an inclusion.
 void PPCallbacksTracker::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, SrcMgr::CharacteristicKind FileType) {
   beginCallback("InclusionDirective");
   appendArgument("IncludeTok", IncludeTok);
   appendFilePathArgument("FileName", FileName);
   appendArgument("IsAngled", IsAngled);
   appendArgument("FilenameRange", FilenameRange);
   appendArgument("File", File);
   appendFilePathArgument("SearchPath", SearchPath);
   appendFilePathArgument("RelativePath", RelativePath);
   appendArgument("Imported", Imported);
+  appendArgument("FileType", FileType);
 }
 
 // Callback invoked whenever there was an explicit module-import
 // syntax.
 void PPCallbacksTracker::moduleImport(clang::SourceLocation ImportLoc,
                                       clang::ModuleIdPath Path,
                                       const clang::Module *Imported) {
   beginCallback("moduleImport");