[clangd] Fix incorrect file path for symbols defined by the compile command-line option.

[hokein]

Summary



[ioeric]

lg

clangd/index/SymbolCollector.cpp

132 ↗

(On Diff #132842)

nit: s/<commandline>/<command line>?

[hokein]

Fix a typo

clang-tools-extra/trunk/clangd/index/SymbolCollector.cpp

 //   * use spelling location, otherwise.
 SymbolLocation GetSymbolLocation(const NamedDecl *D, SourceManager &SM,
                                  StringRef FallbackDir,
                                  std::string &FilePathStorage) {
   SymbolLocation Location;
 
   SourceLocation Loc = SM.getSpellingLoc(D->getLocation());
   if (D->getLocation().isMacroID()) {
-    // The symbol is formed via macro concatenation, the spelling location will
-    // be "<scratch space>", which is not interesting to us, use the expansion
-    // location instead.
-    if (llvm::StringRef(Loc.printToString(SM)).startswith("<scratch")) {
+    // We use the expansion location for the following symbols, as spelling
+    // locations of these symbols are not interesting to us:
+    //   * symbols formed via macro concatenation, the spelling location will
+    //     be "<scratch space>"
+    //   * symbols controlled and defined by a compile command-line option
+    //     `-DName=foo`, the spelling location will be "<command line>".
+    std::string PrintLoc = Loc.printToString(SM);
+    if (llvm::StringRef(PrintLoc).startswith("<scratch") ||
+        llvm::StringRef(PrintLoc).startswith("<command line>")) {
       FilePathStorage = makeAbsolutePath(
           SM, SM.getFilename(SM.getExpansionLoc(D->getLocation())),
           FallbackDir);
       return {FilePathStorage,
               SM.getFileOffset(SM.getExpansionRange(D->getLocStart()).first),
               SM.getFileOffset(SM.getExpansionRange(D->getLocEnd()).second)};
     }
   }

clang-tools-extra/trunk/unittests/clangd/SymbolCollectorTests.cpp

public:
   }
 
   std::shared_ptr<SymbolCollector> Collector;
   SymbolCollector::Options COpts;
 };
 
 class SymbolCollectorTest : public ::testing::Test {
 public:
-  bool runSymbolCollector(StringRef HeaderCode, StringRef MainCode) {
+  bool runSymbolCollector(StringRef HeaderCode, StringRef MainCode,
+                          const std::vector<std::string> &ExtraArgs = {}) {
     llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
         new vfs::InMemoryFileSystem);
     llvm::IntrusiveRefCntPtr<FileManager> Files(
         new FileManager(FileSystemOptions(), InMemoryFileSystem));
 
     auto Factory = llvm::make_unique<SymbolIndexActionFactory>(CollectorOpts);
 
+    std::vector<std::string> Args = {"symbol_collector", "-fsyntax-only",
+                                     "-std=c++11", TestFileName};
+    Args.insert(Args.end(), ExtraArgs.begin(), ExtraArgs.end());
     tooling::ToolInvocation Invocation(
-        {"symbol_collector", "-fsyntax-only", "-std=c++11", TestFileName},
+        Args,
         Factory->create(), Files.get(),
         std::make_shared<PCHContainerOperations>());
 
     InMemoryFileSystem->addFile(TestHeaderName, 0,
                                 llvm::MemoryBuffer::getMemBuffer(HeaderCode));
 
     std::string Content = MainCode;
     if (!HeaderCode.empty())
EXPECT_THAT(Symbols,
                   AllOf(QName("abc_Test"),
                         LocationOffsets(Main.offsetRange("expansion")),
                         CPath(TestFileName)),
                   AllOf(QName("Test"),
                         LocationOffsets(Main.offsetRange("spelling")),
                         CPath(TestFileName))));
 }
 
+TEST_F(SymbolCollectorTest, SymbolFormedByCLI) {
+  CollectorOpts.IndexMainFiles = false;
+
+  Annotations Header(R"(
+    #ifdef NAME
+    $expansion[[class NAME {}]];
+    #endif
+  )");
+
+  runSymbolCollector(Header.code(), /*Main=*/"",
+                     /*ExtraArgs=*/{"-DNAME=name"});
+  EXPECT_THAT(Symbols,
+              UnorderedElementsAre(
+                  AllOf(QName("name"),
+                        LocationOffsets(Header.offsetRange("expansion")),
+                        CPath(TestHeaderName))));
+}
+
 TEST_F(SymbolCollectorTest, IgnoreSymbolsInMainFile) {
   CollectorOpts.IndexMainFiles = false;
   const std::string Header = R"(
     class Foo {};
     void f1();
     inline void f2() {}
   )";
   const std::string Main = R"(