[clangd] Limit the index-returned results in dexp.

[hokein]

Summary

When the limit of FuzzyFindRequest is not specified, MemIndex and
DexIndex will set it MAX_UINT, which doesn't make sense in the active tool dexp
(we might get lots results). This patch restricts it to a small number.

[ioeric]

clangd/index/dex/dexp/Dexp.cpp

129

I think we should make it configurable like what we do here.

[hokein]

Address review comment.

[hokein]

clangd/index/dex/dexp/Dexp.cpp

129

Made it configurable for Lookup. Limit option is used to restrict the number for final results, it is reasonable for FuzzyFind, and Lookup

But for Refs, it means the number of different symbols, not the number of final results, I still hard-code it.

[hokein]

Update based on the offline discussion.

[ioeric]

clangd/index/dex/dexp/Dexp.cpp

166

Maybe The max number of symbols with the same name but different IDs to display. Only applies when -name is set.? I think it's worth calling out that there can be different IDs for the same name.

227

I think you would want to set limit to >1. Currently, the error condition will never be triggered?

clangd/index/dex/dexp/Dexp.cpp

void reportTime(StringRef Name, function_ref<void()> F) {
   F();
   const auto TimerStop = std::chrono::high_resolution_clock::now();
   const auto Duration = std::chrono::duration_cast<std::chrono::milliseconds>(
       TimerStop - TimerStart);
   outs() << formatv("{0} took {1:ms+n}.\n", Name, Duration);
 }
 
 std::vector<SymbolID> getSymbolIDsFromIndex(StringRef QualifiedName,
-                                            const SymbolIndex *Index) {
+                                            const SymbolIndex *Index,
+                                            unsigned Limit) {
   FuzzyFindRequest Request;
+  Request.Limit = Limit;
   // Remove leading "::" qualifier as FuzzyFind doesn't need leading "::"
   // qualifier for global scope.
   bool IsGlobalScope = QualifiedName.consume_front("::");
   auto Names = splitQualifiedName(QualifiedName);
   if (IsGlobalScope || !Names.first.empty())
     Request.Scopes = {Names.first};
 
   Request.Query = Names.second;
cl::opt<std::string> Query{
       cl::Positional,
       cl::Required,
       cl::desc("Query string to be fuzzy-matched"),
   };
   cl::opt<std::string> Scopes{
       "scopes",
       cl::desc("Allowed symbol scopes (comma-separated list)"),
   };
   cl::opt<unsigned> Limit{
       "limit",
       cl::init(10),
       cl::desc("Max results to display"),
   };
 
   void run() override {
     FuzzyFindRequest Request;
     Request.Limit = Limit;
class Lookup : public Command {
   cl::opt<std::string> ID{
       "id",
       cl::Positional,
       cl::desc("Symbol ID to look up (hex)"),
   };
   cl::opt<std::string> Name{
       "name", cl::desc("Qualified name to look up."),
   };
+  cl::opt<unsigned> Limit{
+      "limit",
+      cl::init(10),
+      cl::desc("Max results to display. This flag is only meaningful when -name"
+               " is set."),
+  };
 
   void run() override {
     if (ID.getNumOccurrences() == 0 && Name.getNumOccurrences() == 0) {
       outs() << "Missing required argument: please provide id or -name.\n";
       return;
     }
     std::vector<SymbolID> IDs;
     if (ID.getNumOccurrences()) {
       auto SID = SymbolID::fromStr(ID);
       if (!SID) {
         outs() << toString(SID.takeError()) << "\n";
         return;
       }
       IDs.push_back(*SID);
     } else {
-      IDs = getSymbolIDsFromIndex(Name, Index);
+      IDs = getSymbolIDsFromIndex(Name, Index, Limit);
     }
 
     LookupRequest Request;
     Request.IDs.insert(IDs.begin(), IDs.end());
     bool FoundSymbol = false;
     Index->lookup(Request, [&](const Symbol &Sym) {
       FoundSymbol = true;
       outs() << toYAML(Sym);
void run() override {
     if (ID.getNumOccurrences()) {
       auto SID = SymbolID::fromStr(ID);
       if (!SID) {
         outs() << toString(SID.takeError()) << "\n";
         return;
       }
       IDs.push_back(*SID);
     } else {
-      IDs = getSymbolIDsFromIndex(Name, Index);
+      IDs = getSymbolIDsFromIndex(Name, Index, /*Limit=*/1);
+      if (IDs.size() != 1) {
+        outs() << formatv("The name {0} is ambiguous, found {1} different "
+                          "symbols. Please use id flag to disambiguate.\n",
+                          Name, IDs.size());
+        return;
+      }
     }
     RefsRequest RefRequest;
     RefRequest.IDs.insert(IDs.begin(), IDs.end());
     Regex RegexFilter(Filter);
     Index->refs(RefRequest, [&RegexFilter](const Ref &R) {
       auto U = URI::parse(R.Location.FileURI);
       if (!U) {
         outs() << U.takeError();