[clangd] Pull installed gRPC and introduce clangd-remote-(server|client)

[kbobyrev]

Summary

This patch allows using installed gRPC to build two simple tools which
currently provide the functionality of looking up the symbol by name.
remote-index-client is a simplified version of dexp which connects to
remote-index-server passes lookup requests.

I also significantly reduced the scope of this patch to prevent large changelist
and more bugs. The next steps would be:

• Extending Protocol for deep copies of Symbol and inherit RemoteIndex from Index to unify the interfaces
• Make remote-index-server more generic and merge the remote index client with dexp
• Modify Clangd to allow using remote index instead of the local one for all global index requests

[kbobyrev]

Rebase on top of the correct revision

[kbobyrev]

Discard Dexp.cpp formatting

[kbobyrev]

Rebase on top of the correct revision again

[sammccall]

Naming throughout - sorry to be a pain. I think "shared index" is less precise than it could be. WDYT about "Remote index"?

clang-tools-extra/clangd/CMakeLists.txt

164 ↗

(On Diff #256267)

Can we give these slightly less weird names :-)

169 ↗

(On Diff #256267)

CLANGD_SHARED_INDEX unused?

clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp

270

(unrelated formatting changes to this file)

clang-tools-extra/clangd/index/shared/CMakeLists.txt

4 ↗

(On Diff #256267)

generate a library wrapping those instead, for dependents to link against?

5 ↗

(On Diff #256267)

used once, inline? (and grpc_hdrs)

8 ↗

(On Diff #256267)

can we wrap this in a function?

13 ↗

(On Diff #256267)

Needed? it doesn't import anything

clang-tools-extra/clangd/index/shared/SharedIndex.proto

1

Please drop "Shared" from the various filenames, we're already in a directory called Shared.

nit: header has the wrong name

10

missing package (namespace)

15

nit: LookupRequest, no Proto suffix. (If we need namespacing, we should use a namespace)

17

symbol_yaml.
This is the style the codegen expects, and fighting it yields ugly results.

llvm/cmake/modules/LLVMProcessSources.cmake

112–113

we can't do this :-)

need to move each tool to its own directory instead, which is annoying.

[sammccall]

clang-tools-extra/clangd/CMakeLists.txt

156 ↗

(On Diff #256267)

We'll eventually want to move all this out of clangd I guess? Maybe add FIXMEs for that?

[sammccall]

Oops, hit enter too soon.

Well done getting this to work, will patch it and try out locally.

clang-tools-extra/clangd/index/shared/SharedIndexServer.cpp

43

For a prototype, I wouldn't bother doing anything fancy at all.
Either just do a fuzzyfind, or just do a lookup.

[sammccall]

clang-tools-extra/clangd/CMakeLists.txt

135 ↗

(On Diff #256267)

can you somewhere (shared/README.md?) write down how to get the build working on at least one platform?

e.g.

1. install libgrpc++-dev libprotobuf-dev protobuf-compiler protobuf-compiler-grpc debian packages
2. set -DGRPC_INSTALL_PATH=/usr/include (seems like at least in that case we shouldn't need to set it explicitly!)

But looking at the find_package line I have a sneaking suspicion that "installed" doesn't mean what I think it does. My grpc++ package didn't come with any cmake files. It has headers and static libraries though...

I was able to get this to build by:

• installing the packages above
• changing $GRPC_INSTALL_PATH/protoc to protoc
• changing the dependency names to grpc++ and protobuf
• changing the plugin line to --plugin=protoc-gen-grpc=/usr/bin/grpc_cpp_plugin (this needs detection)

This seems pretty reasonable (more so than requiring everyone to check out grpc and build from source), we're just missing the detection logic. Unless grpc provides a cmake recipe that discovers the system-installed (i.e. package manager) grpc, maybe we need to write this detection.

156 ↗

(On Diff #256267)

this should be controlled by a top-level LLVM_ENABLE_GRPC or LLVM_USE_GRPC or so flag (not sure what the convention is).
Using GRPC_INSTALL_PATH is tempting now but there are multiple ways to configure it so it won't scale.
And at least in some cases we should be able to autodetect it, so we'll need a dedicated enable flag.

156 ↗

(On Diff #256267)

GRPC_INSTALL_PATH should be set() instead of option().

clang-tools-extra/clangd/index/shared/CMakeLists.txt

21 ↗

(On Diff #256267)

these targets should be called clangd-index-server etc, this is a global namespace

54 ↗

(On Diff #256267)

why is the client depending on clangd?

clang-tools-extra/clangd/index/shared/SharedIndexServer.cpp

96

you should include the header for this function. In the version of grpc I installed, it wasn't transitively included.

[kbobyrev]

Address a bunch of comments (still a couple left though).

[kbobyrev]

Also

clang-tools-extra/clangd/CMakeLists.txt

164 ↗

(On Diff #256267)

Inlined everything except (newly) GRPC_CPP_PLUGIN.

169 ↗

(On Diff #256267)

Yep, this one was used within Dexp when I was trying to extend it in this patch, but I realized I would need to either hide a bunch of commands or support some of them which would require the full Index interface implementation, Symbol deep copy and passing it through gRPC, etc. I guess we'd need to use it at some point anyway since there will be at least _some_ path-specific code if we don't build with gRPC by default (not rational for keeping it in this patch, just a bit of context in case you're interested).

Good catch, will remove!

clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp

270

This one is super weird, I even reset the file for the revision I was basing arc diff on, but it didn't work for some reason :(

clang-tools-extra/clangd/index/shared/CMakeLists.txt

4 ↗

(On Diff #256267)

Great idea, thanks!

5 ↗

(On Diff #256267)

Why once? It's used at least 3 times at the moment - once in the generation command and in both targets. Maybe once I put all of it in the library that becomes twice? Let me see.

13 ↗

(On Diff #256267)

I'm afraid it's needed, I tried to get by without it but protoc fails with an error:

File does not reside within any path specified using --proto_path (or -I).  You must specify a --proto_path which encompasses this file.  Note that the proto_path must be an
 exact prefix of the .proto file names -- protoc is too dumb to figure out when two paths (e.g. absolute and relative) are equivalent (it's harder than you think).

clang-tools-extra/clangd/index/shared/SharedIndex.proto

15

Yep, thought this would be confusing :) We already have a bunch of *Request things but I didn't know package <...> would wrap it into the appropriate namespace. Thanks!

[kbobyrev]

Improve CMake infrastructure.

• Move client and server into separate directories and enable LLVM's error logic
• Address a bunch of comments regarding flags enabling gRPC & remote index build
• Simplify protobuf generation script

clang-tools-extra/clangd/CMakeLists.txt

156 ↗

(On Diff #256267)

Do you mean moving gRPC library setup logic to llvm/CMakeLists.txt?

clang-tools-extra/clangd/index/shared/CMakeLists.txt

8 ↗

(On Diff #256267)

Are you proposing making a function (e.g. generate_protos) that would emit required source files? I'd have to do some manual dependency management in this case, that's why I did add_custom_command which seems to be the idiomatic way of generating targets with the right dependencies and properties (being generated files).

Could you please explain the benefit of wrapping this into a function?

[kbobyrev]

Still need to do:

• Add documentation for enabling gRPC
• Simplify clangd-index-(server|client) as proposed
• Find out why lookup is working differently than in Dexp (debug a little bit, I'm pretty sure there is some minor bug)

[sammccall]

clang-tools-extra/clangd/index/remote/CMakeLists.txt

19 ↗

(On Diff #257270)

sorry, what I meant by "less weird names" was can we call these libraries grpc++ instead of gRPC::grpc++ and protobuf instead of protobuf::libprotobuf?
Those thare the names that the libraries are installed as on my system at least...

[kbobyrev]

Improve CMake machinery and cleanup code

[kbobyrev]

Give gRPC and Protobuf libraries better names in CMake.

clang-tools-extra/clangd/index/remote/CMakeLists.txt

19 ↗

(On Diff #257270)

I'm afraid those are going to be called differently depending on how they are imported. I've changed it to PROTOBUF_LIBRARY and GRPC_LIBRARY, is that OK?

[kbobyrev]

Alias libraries in CMake: gRPC::grpc++ to grpc++ and protobuf::libprotobuf to protobuf.

[sammccall]

clang-tools-extra/clangd/CMakeLists.txt

157 ↗

(On Diff #257341)

Having thought about this more - I think this flag should (at least for now) be called something like CLANGD_ENABLE_REMOTE and documented as requiring grpc.

158 ↗

(On Diff #257341)

I think this code should be moved to llvm/cmake/modules/FindGRPC.cmake and included here via include(FindGRPC)

158 ↗

(On Diff #257353)

can we add a comment to the top of this section describing the setup that it expects? (GRPC built from source and installed into ${GRPC_INSTALL_PATH})

164 ↗

(On Diff #257353)

Comment: "grpc cmakelists gives the libraries slightly odd names, make them match the conventional system-installed names"

170 ↗

(On Diff #257353)

Add primary function comment before the note.

this comment is a bit confusing:

• it says callers of the function, when it means users of the proto
• it says source directory, I think it means binary directory
• it doesn't say why

I'd suggest:

Proto headers are generated in ${CMAKE_CURRENT_BINARY_DIR}.
Libraries that use these headers should adjust the include path.

178 ↗

(On Diff #257353)

this should be optional, with a parameter to generate_protos (along with the plugin and grpc_out args) - AIUI it's required for protos that define services only.

Conventional name for this param is HasServices

182 ↗

(On Diff #257353)

I believe this should be Protobuf_DIR or so (find_package output) to avoid getting confused if find_package found it somewhere else

191 ↗

(On Diff #257353)

nit: grpc++ protobuf

194 ↗

(On Diff #257353)

these global side-effects are pretty scary, can we limit them somehow?

clang-tools-extra/clangd/index/remote/Index.proto

11 ↗

(On Diff #257341)

package clang.clangd.remote, to get namespaces compatible with the c++ code

clang-tools-extra/clangd/index/remote/server/CMakeLists.txt

12 ↗

(On Diff #257341)

protobuf and grpc++?

llvm/CMakeLists.txt

1112 ↗

(On Diff #257341)

Sorry my thought before was incomplete - this should probably be CLANGD_USE_GRPC for now with a fixme to move up to LLVM. Especially since all the cmake code for this is in clangd for now.

1114 ↗

(On Diff #257341)

This doesn't make sense - it's not a universally-usable directory, and there's almost no chance that the cmake files are in /usr/lib/cmake/... since the packages we've found don't include them.

I'd suggest for now we always require this to be set if using an installed-grpc-with-cmakelists setup, and work out how to relax later.

[kbobyrev]

Address the current round of comments.

[kbobyrev]

clang-tools-extra/clangd/CMakeLists.txt

194 ↗

(On Diff #257353)

I'll be using target_compile_definitions() manually then. Not sure if it's much better (since users would have to manually add those defines), maybe if there are more protos in the future it'd be better to add function for setting up the target which will be linked against generated protobufs.

[kbobyrev]

Trim dexp output in remote index README.

[kbobyrev]

Fix protobuf & grpc_cpp_plugin settings in system-installed libs scenario and
confirm that everything works as expected with -DLLVM_OPTIMIZED_TABLEGEN=On.

[sammccall]

Thanks, this look really close now. A few things still in the wrong place, and naming/wording nits.

clang-tools-extra/clangd/CMakeLists.txt

156 ↗

(On Diff #257664)

This comment belongs in the relevant section of FindGRPC, not here

162 ↗

(On Diff #257664)

revert this move?

clang-tools-extra/clangd/index/remote/CMakeLists.txt

7 ↗

(On Diff #257664)

inline these into the client/server CMakeLists?

clang-tools-extra/clangd/index/remote/Index.proto

14 ↗

(On Diff #257664)

nit: Lookup, without the request prefix
UpperCamelCase is conventional for protobuf functions, the user-defined names will be alongside names in the generated code that follow that convention.

19 ↗

(On Diff #257664)

symbol_yaml, lowercase

(this is how all the generated code looks and conventional for protobufs)

clang-tools-extra/clangd/index/remote/README.md

3 ↗

(On Diff #257664)

This first sentence doesn't parse (missing a verb and some commas) but should really be split. It should probably avoid so many parentheses too. Maybe:

Clangd uses a global index for project-wide code completion, navigation and other features.
For large projects, building this can take many hours and keeping it loaded uses a lot of memory.

(I don't think the last sentence is needed, it's implied)

5 ↗

(On Diff #257664)

("overhead" implies it's not used directly for the task at hand, so it's not really accurate here)

7 ↗

(On Diff #257664)

Vague references to "the best experience" sound like bad marketing, we should be more specific (or just use fewer words)

10 ↗

(On Diff #257664)

and shared between developers

18 ↗

(On Diff #257664)

However you install the dependencies, ...

(or at least "way" -> "method")

54 ↗

(On Diff #257664)

drop dead sentence?

62 ↗

(On Diff #257664)

I wouldn't lead with the same-machine limitation, the headline is this doesn't work at all with clangd yet.

I also don't think it's worth going into detail about the proof-of-concept: they aren't really interesting to anyone else and will be replaced soon.

Maybe just: the remote index isn't usable with clangd yet, but you can try the proof-of-concept tools in client/ and server/ subdirectories.

clang-tools-extra/clangd/index/remote/client/CMakeLists.txt

7 ↗

(On Diff #257664)

why does this link to clangdbasic?

I forget how cmake transitive deps work, but surely it either needs clangDaemon only, or clangDaemon and all of its deps?

llvm/CMakeLists.txt

378 ↗

(On Diff #257664)

this code all belongs in clangd cmakelists

llvm/cmake/modules/FindGRPC.cmake

26 ↗

(On Diff #257664)

optional generation of protos only seems backwards - optional generation of grpc code?

28 ↗

(On Diff #257664)

lib name is probably the conventional first arg?
also works better if we're going to allow multiple input files in future

46 ↗

(On Diff #257664)

what's the effect of adding the headers to the library?

[kbobyrev]

Address a bunch of comments.

[sammccall]

Awesome, ship it!

clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp

 #include "llvm/LineEditor/LineEditor.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Signals.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
-llvm::cl::opt<std::string> IndexPath(llvm::cl::desc("[PATH TO INDEX]"),
+llvm::cl::opt<std::string> IndexPath("index-path",
+                                     llvm::cl::desc("Path to the index"),
                                      llvm::cl::Positional, llvm::cl::Required);
 
 llvm::cl::opt<std::string>
     ExecCommand("c", llvm::cl::desc("Command to execute and then exit"));
 
-#ifdef CLANGD_SHARED_INDEX
-llvm::cl::opt<std::string>
-    ServerAddress("server-address",
-                  llvm::cl::desc("Address of shared index server to use."),
-                  llvm::cl::init("0.0.0.0:50051"));
-#endif
-
 static const std::string Overview = R"(
 This is an **experimental** interactive tool to process user-provided search
 queries over given symbol collection obtained via clangd-indexer. The
 tool can be used to evaluate search quality of existing index implementations
 and manually construct non-trivial test cases.
 
 Type use "help" request to get information about the details.
 )";
void run() override {
     size_t Rank = 0;
     Index->fuzzyFind(Request, [&](const Symbol &Sym) {
       llvm::outs() << llvm::formatv(OutputFormat, Rank++, Sym.ID.str(),
                                     Sym.Scope + Sym.Name);
     });
   }
 };
 
-#ifndef CLANGD_SHARED_INDEX
 class Lookup : public Command {
   llvm::cl::opt<std::string> ID{
       "id",
       llvm::cl::Positional,
       llvm::cl::desc("Symbol ID to look up (hex)"),
   };
   llvm::cl::opt<std::string> Name{
       "name",
void run() override {
     Index->lookup(Request, [&](const Symbol &Sym) {
       FoundSymbol = true;
       llvm::outs() << toYAML(Sym);
     });
     if (!FoundSymbol)
       llvm::outs() << "not found\n";
   }
 };
-#endif
 
 class Refs : public Command {
   llvm::cl::opt<std::string> ID{
       "id",
       llvm::cl::Positional,
       llvm::cl::desc("Symbol ID of the symbol being queried (hex)."),
   };
   llvm::cl::opt<std::string> Name{
Index->refs(RefRequest, [&RegexFilter](const Ref &R) {
         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", std::make_unique<FuzzyFind>},
-#ifndef CLANGD_SHARED_INDEX
     {"lookup", "Dump symbol details by ID or qualified name",
      std::make_unique<Lookup>},
     {"refs", "Find references by ID or qualified name", std::make_unique<Refs>},
-#endif
 };
 
 std::unique_ptr<SymbolIndex> openIndex(llvm::StringRef Index) {
   return loadIndex(Index, /*UseDex=*/true);
 }
 
 bool runCommand(std::string Request, const SymbolIndex &Index) {
   // Split on spaces and add required null-termination.
for (const auto &Cmd : CommandInfo) {
     if (Cmd.Name == Args.front())
       return Cmd.Implementation()->parseAndRun(FakeArgv, Cmd.Description,
                                                Index);
   }
   llvm::outs() << "Unknown command. Try 'help'.\n";
   return false;
 }
 
-class SharedIndex : public SymbolIndex {
-private:
-  std::unique_ptr<Greeter::Stub> stub_;
-};
-
 } // namespace
 } // namespace clangd
 } // namespace clang
 
 int main(int argc, const char *argv[]) {
   using namespace clang::clangd;
 
   llvm::cl::ParseCommandLineOptions(argc, argv, Overview);
   llvm::cl::ResetCommandLineParser(); // We reuse it for REPL commands.
   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
 
   std::unique_ptr<SymbolIndex> Index;
-#ifdef CLANGD_SHARED_INDEX
-
-#else
   reportTime("Dex build", [&]() { Index = openIndex(IndexPath); });
-#endif
 
   if (!Index) {
     llvm::outs() << "Failed to open the index.\n";
     return -1;
   }
 
   if (!ExecCommand.empty())
     return runCommand(ExecCommand, *Index) ? 0 : 1;
 
   llvm::LineEditor LE("dexp");
   while (llvm::Optional<std::string> Request = LE.readLine())
     runCommand(std::move(*Request), *Index);
 }

clang-tools-extra/clangd/index/shared/SharedIndex.proto

 //===--- Completion.proto - Shared index code completion protobuf ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 syntax = "proto3";
 
 service SharedIndex {
-  rpc FuzzyFind (FuzzyFindProtoRequest) returns (stream FuzzyFindReply) {}
+  rpc requestLookup(LookupRequestProto) returns (stream LookupReply) {}
 }
 
-message FuzzyFindProtoRequest {
-  string Query = 1;
-  repeated string Scopes = 2;
-  bool AnyScope = 3;
-  uint32 Limit = 4;
-  bool RestrictForCodeCompletion = 5;
-  repeated string ProximityPaths = 6;
-  repeated string PreferredTypes = 7;
-}
+message LookupRequestProto { string Name = 1; }
 
-message FuzzyFindReply {
-  string Name = 1;
-  string Scope = 2;
-  string ID = 3;
-}
+message LookupReply { string SymbolYAML = 1; }

clang-tools-extra/clangd/index/shared/SharedIndexClient.cpp

 
 llvm::cl::opt<std::string>
     ServerAddress("server-address",
                   llvm::cl::desc("Address of shared index server to use."),
                   llvm::cl::init("0.0.0.0:50051"));
 
 static const std::string Overview = R"(
 This is an **experimental** interactive tool to process user-provided search
-queries over given symbol collection obtained via clangd-indexer. The
-tool can be used to evaluate search quality of existing index implementations
-and manually construct non-trivial test cases.
-
-Type use "help" request to get information about the details.
+queries over given symbol collection obtained via clangd-indexer with the help
+of shared index server. The client will connect to shared index server and pass
+it lookup queries.
 )";
 
 class SharedIndexClient {
 public:
   SharedIndexClient(std::shared_ptr<grpc::Channel> Channel)
       : Stub(SharedIndex::NewStub(Channel)) {}
 
+  void lookup(llvm::StringRef Name) {
+    llvm::outs() << "Lookup of symbol with Name " << Name << '\n';
+    LookupRequestProto Proto;
+    Proto.set_name(Name.str());
+
+    grpc::ClientContext Context;
+    LookupReply Reply;
+    std::unique_ptr<grpc::ClientReader<LookupReply>> Reader(
+        Stub->requestLookup(&Context, Proto));
+    while (Reader->Read(&Reply)) {
+      llvm::outs() << Reply.symbolyaml();
+    }
+    grpc::Status Status = Reader->Finish();
+    if (Status.ok()) {
+      llvm::outs() << "lookupRequest rpc succeeded.\n";
+    } else {
+      llvm::outs() << "lookupRequest rpc failed.\n";
+    }
+  }
+
 private:
   std::unique_ptr<SharedIndex::Stub> Stub;
 };
 
-void fuzzyFind(llvm::StringRef Request) {
-
-}
-
 } // namespace
 } // namespace clangd
 } // namespace clang
 
 int main(int argc, const char *argv[]) {
   using namespace clang::clangd;
 
   llvm::cl::ParseCommandLineOptions(argc, argv, Overview);
   llvm::cl::ResetCommandLineParser(); // We reuse it for REPL commands.
   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
 
+  SharedIndexClient IndexClient(
+      grpc::CreateChannel(ServerAddress, grpc::InsecureChannelCredentials()));
+
   llvm::LineEditor LE("shared-index-client");
   while (llvm::Optional<std::string> Request = LE.readLine())
-    fuzzyFind(std::move(*Request));
+    IndexClient.lookup(std::move(*Request));
 }

clang-tools-extra/clangd/index/shared/SharedIndexServer.cpp

 
 #include "SharedIndex.grpc.pb.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
 static const std::string Overview = R"(
+This is an experimental shared index implementation. The server opens Dex and
+awaits gRPC lookup requests from the client.
 )";
 
 llvm::cl::opt<std::string> IndexPath(llvm::cl::desc("[PATH TO INDEX]"),
                                      llvm::cl::Positional, llvm::cl::Required);
 
 llvm::cl::opt<std::string> ServerAddress("server-address",
                                          llvm::cl::init("0.0.0.0:50051"));
 
 std::unique_ptr<SymbolIndex> openIndex(llvm::StringRef Index) {
   return loadIndex(Index, /*UseIndex=*/true);
 }
 
+// FIXME(kbobyrev): This is copied
+std::vector<SymbolID> getSymbolIDsFromIndex(llvm::StringRef QualifiedName,
+                                            const SymbolIndex *Index) {
+  FuzzyFindRequest Request;
+  // 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 = {std::string(Names.first)};
+  else
+    // QualifiedName refers to a symbol in global scope (e.g. "GlobalSymbol"),
+    // add the global scope to the request.
+    Request.Scopes = {""};
+
+  Request.Query = std::string(Names.second);
+  std::vector<SymbolID> SymIDs;
+  Index->fuzzyFind(Request, [&](const Symbol &Sym) {
+    std::string SymQualifiedName = (Sym.Scope + Sym.Name).str();
+    if (QualifiedName == SymQualifiedName)
+      SymIDs.push_back(Sym.ID);
+  });
+  return SymIDs;
+}
+
 class SharedIndexServer final : public SharedIndex::Service {
 public:
   SharedIndexServer(std::unique_ptr<SymbolIndex> Index)
       : Index(std::move(Index)) {}
 
 private:
-  grpc::Status FuzzyFind(grpc::ServerContext *Context,
-                         const FuzzyFindProtoRequest *Request,
-                         grpc::ServerWriter<FuzzyFindReply> *Reply) override {
-    FuzzyFindRequest Req;
-    Index->fuzzyFind(Req, [&](const Symbol &Sym) {
-      FuzzyFindReply NextSymbol;
-      NextSymbol.set_name(Sym.Name.str());
-      NextSymbol.set_scope(Sym.Scope.str());
-      NextSymbol.set_id(Sym.ID.str());
+  grpc::Status requestLookup(grpc::ServerContext *Context,
+                             const LookupRequestProto *Request,
+                             grpc::ServerWriter<LookupReply> *Reply) override {
+    llvm::outs() << "Lookup of symbol with ID " << Request->name() << '\n';
+    LookupRequest Req;
+    for (const auto &ID : getSymbolIDsFromIndex(Request->name(), Index.get())) {
+      Req.IDs.insert(ID);
+    }
+    Index->lookup(Req, [&](const Symbol &Sym) {
+      LookupReply NextSymbol;
+      NextSymbol.set_symbolyaml(toYAML(Sym));
       Reply->Write(NextSymbol);
     });
     return grpc::Status::OK;
   }
 
   std::unique_ptr<SymbolIndex> Index;
 };
 
-int runServer(std::unique_ptr<SymbolIndex> Index,
+void runServer(std::unique_ptr<SymbolIndex> Index,
                const std::string &ServerAddress) {
   SharedIndexServer Service(std::move(Index));
 
   grpc::EnableDefaultHealthCheckService(true);
   grpc::ServerBuilder Builder;
   Builder.AddListeningPort(ServerAddress, grpc::InsecureServerCredentials());
   Builder.RegisterService(&Service);
   std::unique_ptr<grpc::Server> Server(Builder.BuildAndStart());
   llvm::outs() << "Server listening on " << ServerAddress << '\n';
 
-  // Wait for the server to shutdown.
   Server->Wait();
-
-  return 0;
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang
 
 int main(int argc, char *argv[]) {
   using namespace clang::clangd;
   llvm::cl::ParseCommandLineOptions(argc, argv, clang::clangd::Overview);
   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
 
   std::unique_ptr<SymbolIndex> Index = openIndex(IndexPath);
 
   if (!Index) {
     llvm::outs() << "Failed to open the index.\n";
     return -1;
   }
 
-  return runServer(std::move(Index), ServerAddress);
+  runServer(std::move(Index), ServerAddress);
 }

llvm/cmake/modules/LLVMProcessSources.cmake

if (NOT "${fn}" MATCHES "^\\.")
       if( idx LESS 0 )
         list(FIND listed ${gp} idx)
         if( idx LESS 0 )
           if(ARG_SOURCE_DIR)
               set(fn_relative "${ARG_SOURCE_DIR}/${fn}")
           else()
               set(fn_relative "${fn}")
           endif()
-          message(SEND_ERROR "Found unknown source file ${fn_relative}
-Please update ${CMAKE_CURRENT_LIST_FILE}\n")
+#           message(SEND_ERROR "Found unknown source file ${fn_relative}
+# Please update ${CMAKE_CURRENT_LIST_FILE}\n")
         endif()
       endif()
     endif()
   endforeach()
 endfunction(llvm_check_source_file_list)