kbobyrev updated this revision to Diff 275672.
kbobyrev added a comment.
Use std::string() instead of static_cast<std::string>()
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D82938/new/
https://reviews.llvm.org/D82938
Files:
clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp
clang-tools-extra/clangd/index/remote/Client.cpp
clang-tools-extra/clangd/index/remote/Client.h
clang-tools-extra/clangd/index/remote/Index.proto
clang-tools-extra/clangd/index/remote/marshalling/Marshalling.cpp
clang-tools-extra/clangd/index/remote/marshalling/Marshalling.h
clang-tools-extra/clangd/index/remote/server/Server.cpp
clang-tools-extra/clangd/index/remote/unimplemented/UnimplementedClient.cpp
clang-tools-extra/clangd/unittests/remote/MarshallingTests.cpp
Index: clang-tools-extra/clangd/unittests/remote/MarshallingTests.cpp
===================================================================
--- clang-tools-extra/clangd/unittests/remote/MarshallingTests.cpp
+++ 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 <cstring>
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
Index: clang-tools-extra/clangd/index/remote/unimplemented/UnimplementedClient.cpp
===================================================================
--- clang-tools-extra/clangd/index/remote/unimplemented/UnimplementedClient.cpp
+++ 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<clangd::SymbolIndex> getClient(llvm::StringRef Address) {
+std::unique_ptr<clangd::SymbolIndex> getClient(llvm::StringRef Address,
+ llvm::StringRef IndexRoot) {
elog("Can't create SymbolIndex client without Remote Index support.");
return nullptr;
}
Index: clang-tools-extra/clangd/index/remote/server/Server.cpp
===================================================================
--- clang-tools-extra/clangd/index/remote/server/Server.cpp
+++ 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 <grpc++/grpc++.h>
@@ -31,6 +32,9 @@
llvm::cl::opt<std::string> IndexPath(llvm::cl::desc("<INDEX FILE>"),
llvm::cl::Positional, llvm::cl::Required);
+llvm::cl::opt<std::string> IndexRoot(llvm::cl::desc("<PROJECT ROOT>"),
+ llvm::cl::Positional, llvm::cl::Required);
+
llvm::cl::opt<std::string> 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<clangd::SymbolIndex> 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<clangd::SymbolIndex> Index;
+ std::string IndexedProjectRoot;
};
void runServer(std::unique_ptr<clangd::SymbolIndex> 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<clang::clangd::SymbolIndex> Index = openIndex(IndexPath);
if (!Index) {
Index: clang-tools-extra/clangd/index/remote/marshalling/Marshalling.h
===================================================================
--- clang-tools-extra/clangd/index/remote/marshalling/Marshalling.h
+++ clang-tools-extra/clangd/index/remote/marshalling/Marshalling.h
@@ -6,7 +6,23 @@
//
//===----------------------------------------------------------------------===//
//
-// 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 (expected to have UNIX slashes) to construct the full path and
+// build the final URI.
//
//===----------------------------------------------------------------------===//
@@ -15,6 +31,7 @@
#include "Index.pb.h"
#include "index/Index.h"
+#include "llvm/ADT/StringRef.h"
#include "llvm/Support/StringSaver.h"
namespace clang {
@@ -22,17 +39,24 @@
namespace remote {
clangd::FuzzyFindRequest fromProtobuf(const FuzzyFindRequest *Request);
+/// Deserializes clangd types and translates relative paths into
+/// machine-native URIs.
llvm::Optional<clangd::Symbol> fromProtobuf(const Symbol &Message,
- llvm::UniqueStringSaver *Strings);
+ llvm::UniqueStringSaver *Strings,
+ llvm::StringRef IndexRoot);
llvm::Optional<clangd::Ref> 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
Index: clang-tools-extra/clangd/index/remote/marshalling/Marshalling.cpp
===================================================================
--- clang-tools-extra/clangd/index/remote/marshalling/Marshalling.cpp
+++ 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,48 @@
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. \p IndexRoot is expected to have UNIX slashes.
+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;
+ 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 std::string(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<uint32_t>(Message.column()));
@@ -59,33 +105,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 +167,8 @@
}
llvm::Optional<clangd::Symbol> 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 +177,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 +185,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<clangd::SymbolOrigin>(Message.origin());
Result.Signature = Message.signature();
@@ -137,20 +197,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<clangd::Symbol::SymbolFlag>(Message.flags());
return Result;
}
llvm::Optional<clangd::Ref> 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<clangd::RefKind>(Message.kind());
return Result;
}
@@ -188,15 +249,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<uint32_t>(From.Origin));
Result.set_signature(From.Signature.str());
@@ -208,16 +271,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<uint32_t>(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<uint32_t>(From.Kind));
- *Result.mutable_location() = toProtobuf(From.Location);
+ *Result.mutable_location() = toProtobuf(From.Location, IndexedProjectRoot);
return Result;
}
Index: clang-tools-extra/clangd/index/remote/Index.proto
===================================================================
--- clang-tools-extra/clangd/index/remote/Index.proto
+++ 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 {
Index: clang-tools-extra/clangd/index/remote/Client.h
===================================================================
--- clang-tools-extra/clangd/index/remote/Client.h
+++ 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<clangd::SymbolIndex> getClient(llvm::StringRef Address);
+std::unique_ptr<clangd::SymbolIndex> getClient(llvm::StringRef Address,
+ llvm::StringRef IndexRoot);
} // namespace remote
} // namespace clangd
Index: clang-tools-extra/clangd/index/remote/Client.cpp
===================================================================
--- clang-tools-extra/clangd/index/remote/Client.cpp
+++ 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<grpc::Channel> Channel)
- : Stub(remote::SymbolIndex::NewStub(Channel)) {}
+ IndexClient(std::shared_ptr<grpc::Channel> Channel,
+ llvm::StringRef ProjectRoot)
+ : Stub(remote::SymbolIndex::NewStub(Channel)), ProjectRoot(ProjectRoot) {}
void lookup(const clangd::LookupRequest &Request,
llvm::function_ref<void(const clangd::Symbol &)> Callback) const {
@@ -84,15 +86,18 @@
private:
std::unique_ptr<remote::SymbolIndex::Stub> Stub;
+ std::string ProjectRoot;
};
} // namespace
-std::unique_ptr<clangd::SymbolIndex> getClient(llvm::StringRef Address) {
+std::unique_ptr<clangd::SymbolIndex> getClient(llvm::StringRef Address,
+ llvm::StringRef ProjectRoot) {
const auto Channel =
grpc::CreateChannel(Address.str(), grpc::InsecureChannelCredentials());
Channel->GetState(true);
- return std::unique_ptr<clangd::SymbolIndex>(new IndexClient(Channel));
+ return std::unique_ptr<clangd::SymbolIndex>(
+ new IndexClient(Channel, ProjectRoot));
}
} // namespace remote
Index: clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp
===================================================================
--- clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp
+++ clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp
@@ -32,6 +32,9 @@
llvm::cl::opt<std::string>
ExecCommand("c", llvm::cl::desc("Command to execute and then exit"));
+llvm::cl::opt<std::string> 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<SymbolIndex> 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);
}
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
