[include-fixer] use includer of .inc header to be the file path of a symbol from .inc header.

[ioeric]

Summary

added PathConfig.cpp and use includer of .inc header to be the file path of a symbol from .inc header.

[bkramer]

include-fixer/find-all-symbols/PathConfig.cpp

21

Maybe add a comment that we walk up the include stack for .inc files?

34

Not your fault here, but I'd really prefer

if (Collector)
  FilePath = Collector->getMappedHeader(FilePath);

[ioeric]

• Addressed reviewer's comments.

include-fixer/find-all-symbols/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_library(findAllSymbols
   FindAllSymbols.cpp
   FindAllSymbolsAction.cpp
   FindAllMacros.cpp
   HeaderMapCollector.cpp
+  PathConfig.cpp
   PragmaCommentHandler.cpp
   STLPostfixHeaderMap.cpp
   SymbolInfo.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangFrontend
   clangLex
   clangTooling
   )
 
 add_subdirectory(tool)

include-fixer/find-all-symbols/FindAllMacros.cpp

 //===-- FindAllMacros.cpp - find all macros ---------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "FindAllMacros.h"
 #include "HeaderMapCollector.h"
+#include "PathConfig.h"
 #include "SymbolInfo.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Token.h"
 #include "llvm/Support/Path.h"
 
 namespace clang {
 namespace find_all_symbols {
 
 void FindAllMacros::MacroDefined(const Token &MacroNameTok,
                                  const MacroDirective *MD) {
   SourceLocation Loc = SM->getExpansionLoc(MacroNameTok.getLocation());
-  if (Loc.isInvalid() || SM->isInMainFile(Loc))
-    return;
-
-  llvm::StringRef FilePath = SM->getFilename(Loc);
-  if (FilePath.empty())
-    return;
-
-  // If Collector is not nullptr, check pragma remapping header.
-  FilePath = Collector ? Collector->getMappedHeader(FilePath) : FilePath;
-
-  SmallString<256> CleanedFilePath = FilePath;
-  llvm::sys::path::remove_dots(CleanedFilePath, /*remove_dot_dot=*/true);
+  std::string FilePath = getIncludePath(*SM, Loc, Collector);
+  if (FilePath.empty()) return;
 
   SymbolInfo Symbol(MacroNameTok.getIdentifierInfo()->getName(),
-                    SymbolInfo::SymbolKind::Macro, CleanedFilePath,
+                    SymbolInfo::SymbolKind::Macro, FilePath,
                     SM->getSpellingLineNumber(Loc), {});
 
   Reporter->reportSymbol(SM->getFileEntryForID(SM->getMainFileID())->getName(),
                          Symbol);
 }
 
 } // namespace find_all_symbols
 } // namespace clang

include-fixer/find-all-symbols/FindAllSymbols.cpp

 //===-- FindAllSymbols.cpp - find all symbols--------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "FindAllSymbols.h"
 #include "HeaderMapCollector.h"
+#include "PathConfig.h"
 #include "SymbolInfo.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Type.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/Optional.h"
CreateSymbolInfo(const NamedDecl *ND, const SourceManager &SM,
 
   SourceLocation Loc = SM.getExpansionLoc(ND->getLocation());
   if (!Loc.isValid()) {
     llvm::errs() << "Declaration " << ND->getNameAsString() << "("
                  << ND->getDeclKindName()
                  << ") has invalid declaration location.";
     return llvm::None;
   }
-  llvm::StringRef FilePath = SM.getFilename(Loc);
-  if (FilePath.empty())
-    return llvm::None;
-
-  // If Collector is not nullptr, check pragma remapping header.
-  FilePath = Collector ? Collector->getMappedHeader(FilePath) : FilePath;
 
-  SmallString<256> CleanedFilePath = FilePath;
-  llvm::sys::path::remove_dots(CleanedFilePath, /*remove_dot_dot=*/true);
+  std::string FilePath = getIncludePath(SM, Loc, Collector);
+  if (FilePath.empty()) return llvm::None;
 
-  return SymbolInfo(ND->getNameAsString(), Type, CleanedFilePath,
+  return SymbolInfo(ND->getNameAsString(), Type, FilePath,
                     SM.getExpansionLineNumber(Loc), GetContexts(ND));
 }
 
 } // namespace
 
 void FindAllSymbols::registerMatchers(MatchFinder *MatchFinder) {
   // FIXME: Handle specialization.
   auto IsInSpecialization = hasAncestor(

include-fixer/find-all-symbols/PathConfig.h

+//===-- PathConfig.h - Process paths of symbols -----------------*- C++ -*-===//
+//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_PATH_CONFIG_H
+#define LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_PATH_CONFIG_H
+
+#include "HeaderMapCollector.h"
+#include "clang/Basic/SourceManager.h"
+#include <string>
+
+namespace clang {
+namespace find_all_symbols {
+
+/// \brief This calculates the include path for \p Loc.
+///
+/// \param SM SourceManager.
+/// \param Loc A SourceLocation.
+/// \param Collector An optional header mapping collector.
+///
+/// \return The file path (or mapped file path if Collector is provided) of the
+/// header that includes \p Loc. If \p Loc comes from .inc header file, \p Loc
+/// is set to the location from which the .inc header file is included. If \p
+/// Loc is invalid or comes from a main file, this returns an empty string.
+std::string getIncludePath(const SourceManager &SM, SourceLocation Loc,
+                           const HeaderMapCollector *Collector = nullptr);
+
+} // namespace find_all_symbols
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_PATH_CONFIG_H

include-fixer/find-all-symbols/PathConfig.cpp

+//===-- PathConfig.cpp - Process paths of symbols ---------------*- C++ -*-===//
+//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "PathConfig.h"
+#include "llvm/Support/Path.h"
+
+namespace clang {
+namespace find_all_symbols {
+
+std::string getIncludePath(const SourceManager &SM, SourceLocation Loc,
+                           const HeaderMapCollector *Collector) {
+  llvm::StringRef FilePath;
+  // Walk up the include stack to skip .inc files.
+  while (true) {
+    if (!Loc.isValid() || SM.isInMainFile(Loc))
+      return "";
+    FilePath = SM.getFilename(Loc);
+    if (FilePath.empty())
+      return "";
+    if (!FilePath.endswith(".inc"))
+      break;
+    FileID ID = SM.getFileID(Loc);
+    Loc = SM.getIncludeLoc(ID);
+  }
+
+  if (Collector)
+    FilePath = Collector->getMappedHeader(FilePath);
+  SmallString<256> CleanedFilePath = FilePath;
+  llvm::sys::path::remove_dots(CleanedFilePath, /*remove_dot_dot=*/true);
+
+  return CleanedFilePath.str();
+}
+
+} // namespace find_all_symbols
+} // namespace clang

unittests/include-fixer/find-all-symbols/FindAllSymbolsTests.cpp

llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
         new vfs::InMemoryFileSystem);
     llvm::IntrusiveRefCntPtr<FileManager> Files(
         new FileManager(FileSystemOptions(), InMemoryFileSystem));
 
     std::string FileName = "symbol.cc";
 
     const std::string InternalHeader = "internal/internal.h";
     const std::string TopHeader = "<top>";
+    // Test .inc header path. The header for `IncHeaderClass` should be
+    // internal.h, which will eventually be mapped to <top>.
+    std::string IncHeader = "internal/private.inc";
+    std::string IncHeaderCode = "class IncHeaderClass {};";
+
     HeaderMapCollector::HeaderMap PostfixMap = {
         {"internal.h", TopHeader},
     };
 
-    std::string InternalCode = "class Internal {};";
+    std::string InternalCode =
+        "#include \"private.inc\"\nclass Internal {};";
     SymbolInfo InternalSymbol("Internal", SymbolInfo::SymbolKind::Class,
-                              TopHeader, 1, {});
+                              TopHeader, 2, {});
+    SymbolInfo IncSymbol("IncHeaderClass", SymbolInfo::SymbolKind::Class,
+    InMemoryFileSystem->addFile(
+        IncHeader, 0, llvm::MemoryBuffer::getMemBuffer(IncHeaderCode));
     InMemoryFileSystem->addFile(InternalHeader, 0,
                                 llvm::MemoryBuffer::getMemBuffer(InternalCode));
 
     std::unique_ptr<clang::tooling::FrontendActionFactory> Factory(
         new FindAllSymbolsActionFactory(&Reporter, &PostfixMap));
 
     tooling::ToolInvocation Invocation(
         {std::string("find_all_symbols"), std::string("-fsyntax-only"),
SymbolInfo DirtyMacro("INTERNAL", SymbolInfo::SymbolKind::Macro,
                           CleanHeader, 1, {});
     SymbolInfo DirtySymbol("ExtraInternal", SymbolInfo::SymbolKind::Class,
                            CleanHeader, 2, {});
 #endif // _MSC_VER && __MINGW32__
     InMemoryFileSystem->addFile(FileName, 0,
                                 llvm::MemoryBuffer::getMemBuffer(Content));
     Invocation.run();
     EXPECT_TRUE(hasSymbol(InternalSymbol));
+    EXPECT_TRUE(hasSymbol(IncSymbol));
 #if !defined(_MSC_VER) && !defined(__MINGW32__)
     EXPECT_TRUE(hasSymbol(DirtySymbol));
     EXPECT_TRUE(hasSymbol(DirtyMacro));
 #endif  // _MSC_VER && __MINGW32__
     return true;
   }
 
 protected: