diff --git a/clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp b/clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp --- a/clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp +++ b/clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp @@ -32,6 +32,9 @@ llvm::cl::opt ExecCommand("c", llvm::cl::desc("Command to execute and then exit")); +llvm::cl::opt ProjectRoot("project-root", + llvm::cl::desc("Path to the project")); + static constexpr char Overview[] = R"( This is an **experimental** interactive tool to process user-provided search queries over given symbol collection obtained via clangd-indexer. The @@ -326,7 +329,8 @@ std::unique_ptr openIndex(llvm::StringRef Index) { return Index.startswith("remote:") - ? remote::getClient(Index.drop_front(strlen("remote:"))) + ? remote::getClient(Index.drop_front(strlen("remote:")), + ProjectRoot) : loadIndex(Index, /*UseDex=*/true); } diff --git a/clang-tools-extra/clangd/index/remote/Client.h b/clang-tools-extra/clangd/index/remote/Client.h --- a/clang-tools-extra/clangd/index/remote/Client.h +++ b/clang-tools-extra/clangd/index/remote/Client.h @@ -10,6 +10,7 @@ #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_REMOTE_INDEX_H #include "index/Index.h" +#include "llvm/ADT/StringRef.h" namespace clang { namespace clangd { @@ -17,12 +18,16 @@ /// Returns an SymbolIndex client that passes requests to remote index located /// at \p Address. The client allows synchronous RPC calls. +/// \p IndexRoot is an absolute path on the local machine to the source tree +/// described by the remote index. Paths returned by the index will be treated +/// as relative to this directory. /// /// This method attempts to resolve the address and establish the connection. /// /// \returns nullptr if the address is not resolved during the function call or /// if the project was compiled without Remote Index support. -std::unique_ptr getClient(llvm::StringRef Address); +std::unique_ptr getClient(llvm::StringRef Address, + llvm::StringRef IndexRoot); } // namespace remote } // namespace clangd diff --git a/clang-tools-extra/clangd/index/remote/Client.cpp b/clang-tools-extra/clangd/index/remote/Client.cpp --- a/clang-tools-extra/clangd/index/remote/Client.cpp +++ b/clang-tools-extra/clangd/index/remote/Client.cpp @@ -14,6 +14,7 @@ #include "marshalling/Marshalling.h" #include "support/Logger.h" #include "support/Trace.h" +#include "llvm/ADT/StringRef.h" namespace clang { namespace clangd { @@ -44,7 +45,7 @@ FinalResult = Reply.final_result(); continue; } - auto Sym = fromProtobuf(Reply.stream_result(), &Strings); + auto Sym = fromProtobuf(Reply.stream_result(), &Strings, ProjectRoot); if (!Sym) elog("Received invalid {0}", ReplyT::descriptor()->name()); Callback(*Sym); @@ -54,8 +55,9 @@ } public: - IndexClient(std::shared_ptr Channel) - : Stub(remote::SymbolIndex::NewStub(Channel)) {} + IndexClient(std::shared_ptr Channel, + llvm::StringRef ProjectRoot) + : Stub(remote::SymbolIndex::NewStub(Channel)), ProjectRoot(ProjectRoot) {} void lookup(const clangd::LookupRequest &Request, llvm::function_ref Callback) const { @@ -84,15 +86,18 @@ private: std::unique_ptr Stub; + std::string ProjectRoot; }; } // namespace -std::unique_ptr getClient(llvm::StringRef Address) { +std::unique_ptr getClient(llvm::StringRef Address, + llvm::StringRef ProjectRoot) { const auto Channel = grpc::CreateChannel(Address.str(), grpc::InsecureChannelCredentials()); Channel->GetState(true); - return std::unique_ptr(new IndexClient(Channel)); + return std::unique_ptr( + new IndexClient(Channel, ProjectRoot)); } } // namespace remote diff --git a/clang-tools-extra/clangd/index/remote/Index.proto b/clang-tools-extra/clangd/index/remote/Index.proto --- a/clang-tools-extra/clangd/index/remote/Index.proto +++ b/clang-tools-extra/clangd/index/remote/Index.proto @@ -99,7 +99,10 @@ message SymbolLocation { Position start = 1; Position end = 2; - string file_uri = 3; + // clangd::SymbolLocation storees FileURI, but the protocol transmits only a + // part of its body. Because paths are different on the remote and local + // machines they will be translated in the marshalling layer. + string file_path = 3; } message Position { diff --git a/clang-tools-extra/clangd/index/remote/marshalling/Marshalling.h b/clang-tools-extra/clangd/index/remote/marshalling/Marshalling.h --- a/clang-tools-extra/clangd/index/remote/marshalling/Marshalling.h +++ b/clang-tools-extra/clangd/index/remote/marshalling/Marshalling.h @@ -6,7 +6,22 @@ // //===----------------------------------------------------------------------===// // -// Transformations between native Clangd types and Protobuf-generated classes. +// Marshalling provides translation between native clangd types into the +// Protobuf-generated classes. Most translations are 1-to-1 and wrap variables +// into appropriate Protobuf types. +// +// A notable exception is URI translation. Because paths to files are different +// on indexing machine and client machine +// ("/remote/machine/projects/llvm/include/HelloWorld.h" versus +// "/usr/local/username/llvm/include/HelloWorld.h"), they need to be converted +// appropriately. Remote machine strips the prefix from an absolute path and +// passes paths relative to the project root over the wire +// ("include/HelloWorld.h" in this example). The indexed project root is passed +// passed to the remote server. It contains absolute path to the project root +// and includes a trailing slash. Relative path passed over the wire has unix +// slashes. Client receives this relative path and constructs a URI that points +// to the relevant file in the filesystem. Relative path is appended to +// IndexRoot to construct the full path and build the final URI. // //===----------------------------------------------------------------------===// @@ -15,6 +30,7 @@ #include "Index.pb.h" #include "index/Index.h" +#include "llvm/ADT/StringRef.h" #include "llvm/Support/StringSaver.h" namespace clang { @@ -22,17 +38,24 @@ namespace remote { clangd::FuzzyFindRequest fromProtobuf(const FuzzyFindRequest *Request); +/// Deserializes clangd types and translates relative paths into +/// machine-native URIs. llvm::Optional fromProtobuf(const Symbol &Message, - llvm::UniqueStringSaver *Strings); + llvm::UniqueStringSaver *Strings, + llvm::StringRef IndexRoot); llvm::Optional fromProtobuf(const Ref &Message, - llvm::UniqueStringSaver *Strings); + llvm::UniqueStringSaver *Strings, + llvm::StringRef IndexRoot); LookupRequest toProtobuf(const clangd::LookupRequest &From); FuzzyFindRequest toProtobuf(const clangd::FuzzyFindRequest &From); RefsRequest toProtobuf(const clangd::RefsRequest &From); -Ref toProtobuf(const clangd::Ref &From); -Symbol toProtobuf(const clangd::Symbol &From); +/// Serializes native clangd types and strips \p IndexedProjectRoot from the +/// file paths because they are specific to the indexing machine. +Ref toProtobuf(const clangd::Ref &From, llvm::StringRef IndexedProjectRoot); +Symbol toProtobuf(const clangd::Symbol &From, + llvm::StringRef IndexedProjectRoot); } // namespace remote } // namespace clangd diff --git a/clang-tools-extra/clangd/index/remote/marshalling/Marshalling.cpp b/clang-tools-extra/clangd/index/remote/marshalling/Marshalling.cpp --- a/clang-tools-extra/clangd/index/remote/marshalling/Marshalling.cpp +++ b/clang-tools-extra/clangd/index/remote/marshalling/Marshalling.cpp @@ -16,7 +16,11 @@ #include "index/SymbolOrigin.h" #include "support/Logger.h" #include "clang/Index/IndexSymbol.h" +#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/Error.h" +#include "llvm/Support/Path.h" #include "llvm/Support/StringSaver.h" namespace clang { @@ -25,6 +29,50 @@ namespace { +/// Translates \p RelativePath into the absolute path and builds URI for the +/// user machine. This translation happens on the client side with the +/// \p RelativePath received from remote index server and \p IndexRoot is +/// provided by the client. +std::string relativePathToURI(llvm::StringRef RelativePath, + llvm::StringRef IndexRoot) { + if (RelativePath.empty()) + return ""; + if (llvm::sys::path::is_absolute(RelativePath)) { + elog("{0} is not relative path", RelativePath); + return ""; + } + llvm::SmallString<256> FullPath = IndexRoot; + // Ensure that RelativePath is also using UNIX slashes as does RelativePath. + llvm::sys::path::native(FullPath, llvm::sys::path::Style::posix); + llvm::sys::path::append(FullPath, RelativePath); + const auto Result = URI::createFile(FullPath); + return Result.toString(); +} + +/// Translates a URI from the server's backing index to a relative path suitable +/// to send over the wire to the client. +std::string uriToRelativePath(llvm::StringRef URI, + llvm::StringRef IndexedProjectRoot) { + if (URI.empty()) + return ""; + auto ParsedURI = URI::parse(URI); + if (!ParsedURI) { + elog("Can not parse URI {0}: {1}", URI, ParsedURI.takeError()); + return ""; + } + llvm::SmallString<256> Result = ParsedURI->body(); + if (IndexedProjectRoot.empty()) + return static_cast(Result); + if (!llvm::sys::path::replace_path_prefix(Result, IndexedProjectRoot, "")) { + elog("Can not get relative path from the URI {0} given the index root {1}", + URI, IndexedProjectRoot); + return ""; + } + // Make sure the result has UNIX slashes. + return llvm::sys::path::convert_to_slash(Result, + llvm::sys::path::Style::posix); +} + clangd::SymbolLocation::Position fromProtobuf(const Position &Message) { clangd::SymbolLocation::Position Result; Result.setColumn(static_cast(Message.column())); @@ -59,33 +107,46 @@ } clangd::SymbolLocation fromProtobuf(const SymbolLocation &Message, - llvm::UniqueStringSaver *Strings) { + llvm::UniqueStringSaver *Strings, + llvm::StringRef IndexRoot) { clangd::SymbolLocation Location; Location.Start = fromProtobuf(Message.start()); Location.End = fromProtobuf(Message.end()); - Location.FileURI = Strings->save(Message.file_uri()).begin(); + Location.FileURI = + Strings->save(relativePathToURI(Message.file_path(), IndexRoot)).begin(); return Location; } -SymbolLocation toProtobuf(const clangd::SymbolLocation &Location) { +SymbolLocation toProtobuf(const clangd::SymbolLocation &Location, + llvm::StringRef IndexedProjectRoot) { remote::SymbolLocation Result; *Result.mutable_start() = toProtobuf(Location.Start); *Result.mutable_end() = toProtobuf(Location.End); - *Result.mutable_file_uri() = Location.FileURI; + *Result.mutable_file_path() = + uriToRelativePath(Location.FileURI, IndexedProjectRoot); return Result; } HeaderWithReferences -toProtobuf(const clangd::Symbol::IncludeHeaderWithReferences &IncludeHeader) { +toProtobuf(const clangd::Symbol::IncludeHeaderWithReferences &IncludeHeader, + llvm::StringRef IndexedProjectRoot) { HeaderWithReferences Result; - Result.set_header(IncludeHeader.IncludeHeader.str()); + const std::string Header = IncludeHeader.IncludeHeader.str(); + auto URI = URI::parse(Header); + Result.set_header(URI ? uriToRelativePath(IncludeHeader.IncludeHeader.str(), + IndexedProjectRoot) + : Header); Result.set_references(IncludeHeader.References); return Result; } clangd::Symbol::IncludeHeaderWithReferences -fromProtobuf(const HeaderWithReferences &Message) { - return clangd::Symbol::IncludeHeaderWithReferences{Message.header(), +fromProtobuf(const HeaderWithReferences &Message, + llvm::UniqueStringSaver *Strings, llvm::StringRef IndexRoot) { + std::string Header = Message.header(); + if (llvm::sys::path::is_relative(Header)) + Header = relativePathToURI(Header, IndexRoot); + return clangd::Symbol::IncludeHeaderWithReferences{Strings->save(Header), Message.references()}; } @@ -108,7 +169,8 @@ } llvm::Optional fromProtobuf(const Symbol &Message, - llvm::UniqueStringSaver *Strings) { + llvm::UniqueStringSaver *Strings, + llvm::StringRef IndexRoot) { if (!Message.has_info() || !Message.has_definition() || !Message.has_canonical_declarattion()) { elog("Cannot convert Symbol from Protobuf: {}", Message.ShortDebugString()); @@ -117,7 +179,7 @@ clangd::Symbol Result; auto ID = SymbolID::fromStr(Message.id()); if (!ID) { - elog("Cannot convert parse SymbolID {} from Protobuf: {}", ID.takeError(), + elog("Cannot parse SymbolID {} given Protobuf: {}", ID.takeError(), Message.ShortDebugString()); return llvm::None; } @@ -125,9 +187,9 @@ Result.SymInfo = fromProtobuf(Message.info()); Result.Name = Message.name(); Result.Scope = Message.scope(); - Result.Definition = fromProtobuf(Message.definition(), Strings); + Result.Definition = fromProtobuf(Message.definition(), Strings, IndexRoot); Result.CanonicalDeclaration = - fromProtobuf(Message.canonical_declarattion(), Strings); + fromProtobuf(Message.canonical_declarattion(), Strings, IndexRoot); Result.References = Message.references(); Result.Origin = static_cast(Message.origin()); Result.Signature = Message.signature(); @@ -137,20 +199,21 @@ Result.ReturnType = Message.return_type(); Result.Type = Message.type(); for (const auto &Header : Message.headers()) { - Result.IncludeHeaders.push_back(fromProtobuf(Header)); + Result.IncludeHeaders.push_back(fromProtobuf(Header, Strings, IndexRoot)); } Result.Flags = static_cast(Message.flags()); return Result; } llvm::Optional fromProtobuf(const Ref &Message, - llvm::UniqueStringSaver *Strings) { + llvm::UniqueStringSaver *Strings, + llvm::StringRef IndexRoot) { if (!Message.has_location()) { elog("Cannot convert Ref from Protobuf: {}", Message.ShortDebugString()); return llvm::None; } clangd::Ref Result; - Result.Location = fromProtobuf(Message.location(), Strings); + Result.Location = fromProtobuf(Message.location(), Strings, IndexRoot); Result.Kind = static_cast(Message.kind()); return Result; } @@ -188,15 +251,17 @@ return RPCRequest; } -Symbol toProtobuf(const clangd::Symbol &From) { +Symbol toProtobuf(const clangd::Symbol &From, + llvm::StringRef IndexedProjectRoot) { Symbol Result; Result.set_id(From.ID.str()); *Result.mutable_info() = toProtobuf(From.SymInfo); Result.set_name(From.Name.str()); - *Result.mutable_definition() = toProtobuf(From.Definition); + *Result.mutable_definition() = + toProtobuf(From.Definition, IndexedProjectRoot); Result.set_scope(From.Scope.str()); *Result.mutable_canonical_declarattion() = - toProtobuf(From.CanonicalDeclaration); + toProtobuf(From.CanonicalDeclaration, IndexedProjectRoot); Result.set_references(From.References); Result.set_origin(static_cast(From.Origin)); Result.set_signature(From.Signature.str()); @@ -208,16 +273,16 @@ Result.set_type(From.Type.str()); for (const auto &Header : From.IncludeHeaders) { auto *NextHeader = Result.add_headers(); - *NextHeader = toProtobuf(Header); + *NextHeader = toProtobuf(Header, IndexedProjectRoot); } Result.set_flags(static_cast(From.Flags)); return Result; } -Ref toProtobuf(const clangd::Ref &From) { +Ref toProtobuf(const clangd::Ref &From, llvm::StringRef IndexedProjectRoot) { Ref Result; Result.set_kind(static_cast(From.Kind)); - *Result.mutable_location() = toProtobuf(From.Location); + *Result.mutable_location() = toProtobuf(From.Location, IndexedProjectRoot); return Result; } diff --git a/clang-tools-extra/clangd/index/remote/server/Server.cpp b/clang-tools-extra/clangd/index/remote/server/Server.cpp --- a/clang-tools-extra/clangd/index/remote/server/Server.cpp +++ b/clang-tools-extra/clangd/index/remote/server/Server.cpp @@ -11,6 +11,7 @@ #include "index/remote/marshalling/Marshalling.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/CommandLine.h" +#include "llvm/Support/Path.h" #include "llvm/Support/Signals.h" #include @@ -31,6 +32,9 @@ llvm::cl::opt IndexPath(llvm::cl::desc(""), llvm::cl::Positional, llvm::cl::Required); +llvm::cl::opt IndexRoot(llvm::cl::desc(""), + llvm::cl::Positional, llvm::cl::Required); + llvm::cl::opt ServerAddress( "server-address", llvm::cl::init("0.0.0.0:50051"), llvm::cl::desc("Address of the invoked server. Defaults to 0.0.0.0:50051")); @@ -42,7 +46,11 @@ class RemoteIndexServer final : public SymbolIndex::Service { public: RemoteIndexServer(std::unique_ptr Index) - : Index(std::move(Index)) {} + : Index(std::move(Index)) { + llvm::SmallString<256> NativePath = llvm::StringRef(IndexRoot); + llvm::sys::path::native(NativePath); + IndexedProjectRoot = std::string(NativePath); + } private: grpc::Status Lookup(grpc::ServerContext *Context, @@ -57,7 +65,8 @@ } Index->lookup(Req, [&](const clangd::Symbol &Sym) { LookupReply NextMessage; - *NextMessage.mutable_stream_result() = toProtobuf(Sym); + *NextMessage.mutable_stream_result() = + toProtobuf(Sym, IndexedProjectRoot); Reply->Write(NextMessage); }); LookupReply LastMessage; @@ -72,7 +81,8 @@ const auto Req = fromProtobuf(Request); bool HasMore = Index->fuzzyFind(Req, [&](const clangd::Symbol &Sym) { FuzzyFindReply NextMessage; - *NextMessage.mutable_stream_result() = toProtobuf(Sym); + *NextMessage.mutable_stream_result() = + toProtobuf(Sym, IndexedProjectRoot); Reply->Write(NextMessage); }); FuzzyFindReply LastMessage; @@ -92,7 +102,7 @@ } bool HasMore = Index->refs(Req, [&](const clangd::Ref &Reference) { RefsReply NextMessage; - *NextMessage.mutable_stream_result() = toProtobuf(Reference); + *NextMessage.mutable_stream_result() = toProtobuf(Reference, IndexRoot); Reply->Write(NextMessage); }); RefsReply LastMessage; @@ -102,6 +112,7 @@ } std::unique_ptr Index; + std::string IndexedProjectRoot; }; void runServer(std::unique_ptr Index, @@ -128,6 +139,11 @@ llvm::cl::ParseCommandLineOptions(argc, argv, Overview); llvm::sys::PrintStackTraceOnErrorSignal(argv[0]); + if (!llvm::sys::path::is_absolute(IndexRoot)) { + llvm::outs() << "Index root should be an absolute path.\n"; + return -1; + } + std::unique_ptr Index = openIndex(IndexPath); if (!Index) { diff --git a/clang-tools-extra/clangd/index/remote/unimplemented/UnimplementedClient.cpp b/clang-tools-extra/clangd/index/remote/unimplemented/UnimplementedClient.cpp --- a/clang-tools-extra/clangd/index/remote/unimplemented/UnimplementedClient.cpp +++ b/clang-tools-extra/clangd/index/remote/unimplemented/UnimplementedClient.cpp @@ -8,12 +8,14 @@ #include "index/remote/Client.h" #include "support/Logger.h" +#include "llvm/ADT/StringRef.h" namespace clang { namespace clangd { namespace remote { -std::unique_ptr getClient(llvm::StringRef Address) { +std::unique_ptr getClient(llvm::StringRef Address, + llvm::StringRef IndexRoot) { elog("Can't create SymbolIndex client without Remote Index support."); return nullptr; } diff --git a/clang-tools-extra/clangd/unittests/remote/MarshallingTests.cpp b/clang-tools-extra/clangd/unittests/remote/MarshallingTests.cpp --- a/clang-tools-extra/clangd/unittests/remote/MarshallingTests.cpp +++ b/clang-tools-extra/clangd/unittests/remote/MarshallingTests.cpp @@ -7,16 +7,30 @@ //===----------------------------------------------------------------------===// #include "../TestTU.h" +#include "TestFS.h" #include "index/Serialization.h" #include "index/remote/marshalling/Marshalling.h" +#include "llvm/ADT/SmallString.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/Path.h" #include "llvm/Support/StringSaver.h" #include "gtest/gtest.h" +#include namespace clang { namespace clangd { namespace remote { namespace { +const char *unittestURIToFilesystem(const char *UnittestURI, + llvm::UniqueStringSaver &Strings) { + auto URI = URI::parse(UnittestURI); + EXPECT_TRUE(bool(URI)); + const auto FileSystemURI = + URI::createFile(testPath(llvm::sys::path::relative_path(URI->body()))); + return Strings.save(FileSystemURI.toString()).begin(); +} + TEST(RemoteMarshallingTest, SymbolSerialization) { const auto *Header = R"( // This is a class. @@ -39,9 +53,20 @@ EXPECT_GE(Symbols.size(), 5UL); llvm::BumpPtrAllocator Arena; llvm::UniqueStringSaver Strings(Arena); - for (auto &Sym : Symbols) { - const auto ProtobufMeessage = toProtobuf(Sym); - const auto SymToProtobufAndBack = fromProtobuf(ProtobufMeessage, &Strings); + llvm::SmallString<256> RootPath = llvm::StringRef("/"); + llvm::sys::path::native(RootPath); + for (auto Sym : Symbols) { + Sym.CanonicalDeclaration.FileURI = + unittestURIToFilesystem(Sym.CanonicalDeclaration.FileURI, Strings); + if (std::strlen(Sym.Definition.FileURI)) + Sym.Definition.FileURI = + unittestURIToFilesystem(Sym.Definition.FileURI, Strings); + for (auto &Header : Sym.IncludeHeaders) + Header.IncludeHeader = + unittestURIToFilesystem(Header.IncludeHeader.str().c_str(), Strings); + auto ProtobufMessage = toProtobuf(Sym, RootPath); + const auto SymToProtobufAndBack = + fromProtobuf(ProtobufMessage, &Strings, RootPath); EXPECT_TRUE(SymToProtobufAndBack.hasValue()); EXPECT_EQ(toYAML(Sym), toYAML(*SymToProtobufAndBack)); } @@ -76,16 +101,54 @@ const auto References = TU.headerRefs(); llvm::BumpPtrAllocator Arena; llvm::UniqueStringSaver Strings(Arena); + llvm::SmallString<256> RootPath = llvm::StringRef("/"); + llvm::sys::path::native(RootPath); // Sanity check: there are more than 5 references available. EXPECT_GE(References.numRefs(), 5UL); for (const auto &SymbolWithRefs : References) { - for (const auto &Ref : SymbolWithRefs.second) { - const auto RefToProtobufAndBack = fromProtobuf(toProtobuf(Ref), &Strings); + for (auto Ref : SymbolWithRefs.second) { + Ref.Location.FileURI = + unittestURIToFilesystem(Ref.Location.FileURI, Strings); + const auto RefToProtobufAndBack = + fromProtobuf(toProtobuf(Ref, RootPath), &Strings, RootPath); EXPECT_TRUE(RefToProtobufAndBack.hasValue()); EXPECT_EQ(toYAML(Ref), toYAML(*RefToProtobufAndBack)); } } -} // namespace +} + +TEST(RemoteMarshallingTest, URITranslation) { + llvm::BumpPtrAllocator Arena; + llvm::UniqueStringSaver Strings(Arena); + clangd::Ref Original; + const std::string RemoteIndexPrefix = testPath("remote/machine/project/"); + std::string RelativePath = "llvm-project/clang-tools-extra/clangd/" + "unittests/remote/MarshallingTests.cpp"; + llvm::SmallString<256> NativePath = StringRef(RelativePath); + llvm::sys::path::native(NativePath); + RelativePath = std::string(NativePath); + const auto URI = URI::createFile(RemoteIndexPrefix + RelativePath); + Original.Location.FileURI = Strings.save(URI.toString()).begin(); + Ref Serialized = toProtobuf(Original, RemoteIndexPrefix); + EXPECT_EQ(Serialized.location().file_path(), RelativePath); + const std::string LocalIndexPrefix = testPath("local/machine/project/"); + auto Deserialized = fromProtobuf(Serialized, &Strings, LocalIndexPrefix); + EXPECT_TRUE(Deserialized); + EXPECT_EQ(Deserialized->Location.FileURI, + URI::createFile(LocalIndexPrefix + RelativePath).toString()); + + clangd::Ref WithInvalidURI; + WithInvalidURI.Location.FileURI = "This is not a URI"; + Serialized = toProtobuf(WithInvalidURI, RemoteIndexPrefix); + // Invalid URI results in empty path. + EXPECT_EQ(Serialized.location().file_path(), ""); + + Ref WithAbsolutePath; + *WithAbsolutePath.mutable_location()->mutable_file_path() = "/usr/local/bin/"; + Deserialized = fromProtobuf(WithAbsolutePath, &Strings, LocalIndexPrefix); + // Can not build URI given absolute path. + EXPECT_EQ(std::string(Deserialized->Location.FileURI), ""); +} } // namespace } // namespace remote