[clangd] dump xrefs information in dexp tool.

[sammccall]

clangd/index/dex/dexp/Dexp.cpp

203

filter -> regular expression

222

you're requiring a full match, and matching the URI, which is going to confuse users who try to use a filter of /usr/include/.* or so.

Consider just using the URI path?

246

I'm not sure "by qualified name" is a good idea, at least as the only option:

• if there are overloads, you can't choose the right one (possible fix: make this a named flag like refs --name foo::bar)
• you can't search for refs for std::unique without getting std::unique_ptr (possible fix: postfilter by name)
• it seems inconsistent with Lookup (possible fix: update both)

[hokein]

Address review comments:

• provide query by qualified name (with -name)
• add -name support for Lookup.

[hokein]

clangd/index/dex/dexp/Dexp.cpp

246

Sounds fair enough. I think query the symbol by "qualified_name" would be more convenient and practical when we use the tool. ID is not quite straight-forward.

[hokein]

Minor fix.

[sammccall]

clangd/index/dex/dexp/Dexp.cpp

65

I don't think this is reasonable behavior. I'd suggest either of:

• processing all results (this function would return a vector)
• treat this as an error, the error message should include the ID of each symbol so we can rerun the command in an unambiguous way

173

nit: just "id" with no dash

[hokein]

Address review comments.

[sammccall]

clangd/index/dex/dexp/Dexp.cpp

61

Are you sure you want both foo to mean ::foo only, rather than accept any scope and the user can type ::foo for explicitly global scope?

64

stale comment

185

(nit: why not just initialize in place above?)

192

clang-format

[hokein]

Fix global scope, and clang-format.

[hokein]

clangd/index/dex/dexp/Dexp.cpp

61

Oops, this is not intended. "foo" and "::foo" are different.

185

In fact, Request.IDs and IDs are different types, and DenseSet is missing such constructor :(

[sammccall]

clangd/index/dex/dexp/Dexp.cpp

185

I meant, why does the local variable "IDs" exist at all? Why not just populate Request.IDs directly?

clangd/index/dex/dexp/CMakeLists.txt

+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../..)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../../)
 
 set(LLVM_LINK_COMPONENTS
   LineEditor
   Support
   )
 
 add_clang_executable(dexp
   Dexp.cpp
   )
 
 target_link_libraries(dexp
   PRIVATE
   clangBasic
   clangDaemon
   )

clangd/index/dex/dexp/Dexp.cpp

 //===--- Dexp.cpp - Dex EXPloration tool ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a simple interactive tool which can be used to manually
 // evaluate symbol search quality of Clangd index.
 //
 //===----------------------------------------------------------------------===//
 
-#include "../../Serialization.h"
-#include "../Dex.h"
+#include "Dex.h"
+#include "Serialization.h"
+#include "SourceCode.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/LineEditor/LineEditor.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/Signals.h"
 
 using clang::clangd::FuzzyFindRequest;
 using clang::clangd::loadIndex;
 using clang::clangd::Symbol;
 using clang::clangd::SymbolIndex;
 using namespace llvm;
 
void reportTime(StringRef Name, llvm::function_ref<void()> F) {
   const auto TimerStart = std::chrono::high_resolution_clock::now();
   F();
   const auto TimerStop = std::chrono::high_resolution_clock::now();
   const auto Duration = std::chrono::duration_cast<std::chrono::milliseconds>(
       TimerStop - TimerStart);
   llvm::outs() << llvm::formatv("{0} took {1:ms+n}.\n", Name, Duration);
 }
 
+llvm::Expected<clang::clangd::SymbolID>
+getSymbolIDFromIndex(llvm::StringRef QualifiedName, const SymbolIndex *Index) {
+  FuzzyFindRequest Request;
+  Request.Scopes.emplace_back();
+  std::tie(Request.Scopes.back(), Request.Query) =
+      clang::clangd::splitQualifiedName(QualifiedName);
+  bool Found = false;
+  clang::clangd::SymbolID SymID;
+  // We choose the first one if there are overloaded symbols.
+  Index->fuzzyFind(Request, [&](const Symbol &Sym) {
+    std::string SymQualifiedName = (Sym.Scope + Sym.Name).str();
+    if (!Found && QualifiedName == SymQualifiedName) {
+      SymID = Sym.ID;
+      Found = true;
+    }
+  });
+  return Found ? SymID
+               : llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                         "Symbol not found in index.");
+}
+
 // REPL commands inherit from Command and contain their options as members.
 // Creating a Command populates parser options, parseAndRun() resets them.
 class Command {
   // By resetting the parser options, we lost the standard -help flag.
   cl::opt<bool, false, cl::parser<bool>> Help{
       "help", cl::desc("Display available options"), cl::ValueDisallowed,
       cl::cat(cl::GeneralCategory)};
   virtual void run() = 0;
if (Help.getNumOccurrences() > 0) {
         reportTime(Argv[0], [&] { run(); });
       }
     }
     cl::ResetCommandLineParser(); // must do this before opts are destroyed.
   }
 };
 
 // FIXME(kbobyrev): Ideas for more commands:
-// * find symbol references: print set of reference locations
 // * load/swap/reload index: this would make it possible to get rid of llvm::cl
 //   usages in the tool driver and actually use llvm::cl library in the REPL.
 // * show posting list density histogram (our dump data somewhere so that user
 //   could build one)
 // * show number of tokens of each kind
 // * print out tokens with the most dense posting lists
 // * print out tokens with least dense posting lists
 
void run() override {
     });
   }
 };
 
 class Lookup : public Command {
   cl::opt<std::string> ID{
       "id",
       cl::Positional,
-      cl::Required,
       cl::desc("Symbol ID to look up (hex)"),
   };
+  cl::opt<std::string> Name{
+      "name", cl::desc("Qualified name to look up."),
+  };
 
   void run() override {
-    auto SID = clang::clangd::SymbolID::fromStr(ID);
+    if (ID.getNumOccurrences() == 0 && Name.getNumOccurrences() == 0) {
+      llvm::outs()
+          << "Missing required argument: please provide -id or -name.\n";
+      return;
+    }
+    llvm::Expected<clang::clangd::SymbolID> SID =
+        ID.getNumOccurrences() ? clang::clangd::SymbolID::fromStr(ID)
+                               : getSymbolIDFromIndex(Name, Index);
     if (!SID) {
       llvm::outs() << llvm::toString(SID.takeError()) << "\n";
       return;
     }
 
     clang::clangd::LookupRequest Request;
     Request.IDs = {*SID};
     bool FoundSymbol = false;
     Index->lookup(Request, [&](const Symbol &Sym) {
       FoundSymbol = true;
       llvm::outs() << toYAML(Sym);
     });
     if (!FoundSymbol)
       llvm::outs() << "not found\n";
   }
 };
 
+class Refs : public Command {
+  cl::opt<std::string> ID{
+      "id", cl::Positional,
+      cl::desc("Symbol ID of the symbol being queried (hex)."),
+  };
+  cl::opt<std::string> Name{
+      "name", cl::desc("Qualified name of the symbol being queried."),
+  };
+  cl::opt<std::string> Filter{
+      "filter",
+      cl::init(".*"),
+      cl::desc(
+          "Print all results from files matching this regular expression."),
+  };
+
+  void run() override {
+    if (ID.getNumOccurrences() == 0 && Name.getNumOccurrences() == 0) {
+      llvm::outs()
+          << "Missing required argument: please provide -id or -name.\n";
+      return;
+    }
+    llvm::Expected<clang::clangd::SymbolID> SID =
+        ID.getNumOccurrences() ? clang::clangd::SymbolID::fromStr(ID)
+                               : getSymbolIDFromIndex(Name, Index);
+    if (!SID) {
+      llvm::outs() << llvm::toString(SID.takeError()) << "\n";
+      return;
+    }
+    clang::clangd::RefsRequest RefRequest;
+    RefRequest.IDs.insert(*SID);
+    llvm::Regex RegexFilter(Filter);
+    Index->refs(RefRequest, [&RegexFilter](const clang::clangd::Ref &R) {
+      auto U = clang::clangd::URI::parse(R.Location.FileURI);
+      if (!U) {
+        llvm::outs() << U.takeError();
+        return;
+      }
+      if (RegexFilter.match(U->body()))
+        llvm::outs() << R << "\n";
+    });
+  }
+};
+
 struct {
   const char *Name;
   const char *Description;
   std::function<std::unique_ptr<Command>()> Implementation;
 } CommandInfo[] = {
     {"find", "Search for symbols with fuzzyFind", llvm::make_unique<FuzzyFind>},
-    {"lookup", "Dump symbol details by ID", llvm::make_unique<Lookup>},
+    {"lookup", "Dump symbol details by ID or qualified name",
+     llvm::make_unique<Lookup>},
+    {"refs", "Find references by ID or qualified name",
+     llvm::make_unique<Refs>},
 };
 
 } // namespace
 
 int main(int argc, const char *argv[]) {
   llvm::cl::ParseCommandLineOptions(argc, argv, Overview);
   llvm::cl::ResetCommandLineParser(); // We reuse it for REPL commands.
   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);