[clangd] Give the server information about client's remote index protocol version

[kbobyrev]

Summary

And also introduce package versioning. This is a breaking change, so both clients and servers have to be updated to the new version.

[kbobyrev]

clang-tools-extra/clangd/index/remote/ProtocolVersion.h

4 ↗

(On Diff #299617)

Not sure if having a separate file with a hard-coded string is a good idea, should I use something like ProtocolVersion.inc and have a macro definition there?

[kadircet]

Regarding versioning of grpc layer. In addition to including a version number in every request, looks like there's the concept of "versioned-services".

So we basically change the package name to be versioned, i.e. package clang.clangd.remote.v1 and every time we make a breaking change, we increment the version number and start a new service (while keeping the old one).
Hopefully most of the core pieces will be re-usable, hence this will likely only end up adding a new service definition with possibly new reply/request types.

That might be more manageable than having a version in every request. It will also make handling a little bit easier, as dispatch will happen in grpc layer and server wouldn't have to perform conditional checks.

[sammccall]

What's the goal here?

There are at least 3 mechanisms we can use to mitigate client/server skew:

1. extending payloads in compatible way, so mismatched versions result in correct behavior (switching from proto3 to proto2 gives us more options here if it's possible)
2. signalling the version in-band as in this patch
3. defining a new incompatible protocol with a new name, as in versioned services

IME 1 is the most maintainable way to handle minor changes, while 3 is the most maintainable way to handle dramatic changes. Maybe there's an intermediate spot where 2 is the best option, but I'd like to understand concretely what scenario we might be solving.

OTOH, including/logging client version to make it easier to *debug* errors, without changing server logic, makes a lot of sense.
In that case we should use the VCS version (the version included in clangd --version) so we don't have another string we need to bump.

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

59

rather than add this to every message, can we use ClientContext::AddMetadata to do this in a cross-cutting way?

[sammccall]

In D89862#2346714, @sammccall wrote:

IME 1 is the most maintainable way to handle minor changes, while 3 is the most maintainable way to handle dramatic changes.

(I realize I haven't backed this up - it's basically about how many codepaths you have to maintain for how long, and how complex they are. Happy to get into details if it's useful, but didn't want to derail too much)

[kbobyrev]

Use ClientContext::AddMetadata to propagate VCS version info.

[kbobyrev]

Remove formatting change.

[kbobyrev]

In D89862#2346645, @kadircet wrote:

Regarding versioning of grpc layer. In addition to including a version number in every request, looks like there's the concept of "versioned-services".

So we basically change the package name to be versioned, i.e. package clang.clangd.remote.v1 and every time we make a breaking change, we increment the version number and start a new service (while keeping the old one).
Hopefully most of the core pieces will be re-usable, hence this will likely only end up adding a new service definition with possibly new reply/request types.

That might be more manageable than having a version in every request. It will also make handling a little bit easier, as dispatch will happen in grpc layer and server wouldn't have to perform conditional checks.

Good point! @sammccall should we do the package versioning and update to mitigate potential breaking changes?

[sammccall]

In D89862#2346967, @kbobyrev wrote:

In D89862#2346645, @kadircet wrote:

Regarding versioning of grpc layer. In addition to including a version number in every request, looks like there's the concept of "versioned-services".

So we basically change the package name to be versioned, i.e. package clang.clangd.remote.v1 and every time we make a breaking change, we increment the version number and start a new service (while keeping the old one).
Hopefully most of the core pieces will be re-usable, hence this will likely only end up adding a new service definition with possibly new reply/request types.

That might be more manageable than having a version in every request. It will also make handling a little bit easier, as dispatch will happen in grpc layer and server wouldn't have to perform conditional checks.

Good point! @sammccall should we do the package versioning and update to mitigate potential breaking changes?

Yep, tacking "v1" on this preemptively SGTM.

Note this itself is a breaking change :-)

[kbobyrev]

Add package versioning and make current version v1.

[sammccall]

In D89862#2348173, @kbobyrev wrote:

Add package versioning and make current version v1.

Sorry, I didn't mean in this patch - seems not that related.... up to you whether to tie them together.

I don't think we need to put the actual messages into versioned namespaces, it makes a mess of the code. (We may need to do this later for some messages if we actually make use of this versioning, but we should pay for it if we use it - moving messages between namespaces is a backwards-compatible change)

clang-tools-extra/clangd/index/remote/Client.cpp

 
 #include "Client.h"
 #include "Index.grpc.pb.h"
 #include "index/Index.h"
 #include "index/Serialization.h"
 #include "marshalling/Marshalling.h"
 #include "support/Logger.h"
 #include "support/Trace.h"
+#include "clang/Basic/Version.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 
 #include <chrono>
 
 namespace clang {
 namespace clangd {
 namespace remote {
 namespace {
 
 class IndexClient : public clangd::SymbolIndex {
   template <typename RequestT, typename ReplyT>
   using StreamingCall = std::unique_ptr<grpc::ClientReader<ReplyT>> (
-      remote::SymbolIndex::Stub::*)(grpc::ClientContext *, const RequestT &);
+      remote::v1::SymbolIndex::Stub::*)(grpc::ClientContext *,
+                                        const RequestT &);
 
   template <typename RequestT, typename ReplyT, typename ClangdRequestT,
             typename CallbackT>
   bool streamRPC(ClangdRequestT Request,
                  StreamingCall<RequestT, ReplyT> RPCCall,
                  CallbackT Callback) const {
     bool FinalResult = false;
     trace::Span Tracer(RequestT::descriptor()->name());
     const auto RPCRequest = ProtobufMarshaller->toProtobuf(Request);
     SPAN_ATTACH(Tracer, "Request", RPCRequest.DebugString());
     grpc::ClientContext Context;
+    Context.AddMetadata("version", clang::getClangToolFullVersion("clangd"));
     std::chrono::system_clock::time_point Deadline =
         std::chrono::system_clock::now() + DeadlineWaitingTime;
     Context.set_deadline(Deadline);
     auto Reader = (Stub.get()->*RPCCall)(&Context, RPCRequest);
     ReplyT Reply;
     unsigned Successful = 0;
     unsigned FailedToParse = 0;
     while (Reader->Read(&Reply)) {
bool streamRPC(ClangdRequestT Request,
     SPAN_ATTACH(Tracer, "Failed to parse", FailedToParse);
     return FinalResult;
   }
 
 public:
   IndexClient(
       std::shared_ptr<grpc::Channel> Channel, llvm::StringRef ProjectRoot,
       std::chrono::milliseconds DeadlineTime = std::chrono::milliseconds(1000))
-      : Stub(remote::SymbolIndex::NewStub(Channel)),
+      : Stub(remote::v1::SymbolIndex::NewStub(Channel)),
         ProtobufMarshaller(new Marshaller(/*RemoteIndexRoot=*/"",
                                           /*LocalIndexRoot=*/ProjectRoot)),
         DeadlineWaitingTime(DeadlineTime) {
     assert(!ProjectRoot.empty());
   }
 
   void lookup(const clangd::LookupRequest &Request,
               llvm::function_ref<void(const clangd::Symbol &)> Callback) const {
-    streamRPC(Request, &remote::SymbolIndex::Stub::Lookup, Callback);
+    streamRPC(Request, &remote::v1::SymbolIndex::Stub::Lookup, Callback);
   }
 
   bool
   fuzzyFind(const clangd::FuzzyFindRequest &Request,
             llvm::function_ref<void(const clangd::Symbol &)> Callback) const {
-    return streamRPC(Request, &remote::SymbolIndex::Stub::FuzzyFind, Callback);
+    return streamRPC(Request, &remote::v1::SymbolIndex::Stub::FuzzyFind,
+                     Callback);
   }
 
   bool refs(const clangd::RefsRequest &Request,
             llvm::function_ref<void(const clangd::Ref &)> Callback) const {
-    return streamRPC(Request, &remote::SymbolIndex::Stub::Refs, Callback);
+    return streamRPC(Request, &remote::v1::SymbolIndex::Stub::Refs, Callback);
   }
 
   void
   relations(const clangd::RelationsRequest &Request,
             llvm::function_ref<void(const SymbolID &, const clangd::Symbol &)>
                 Callback) const {
-    streamRPC(Request, &remote::SymbolIndex::Stub::Relations,
+    streamRPC(Request, &remote::v1::SymbolIndex::Stub::Relations,
               // Unpack protobuf Relation.
               [&](std::pair<SymbolID, clangd::Symbol> SubjectAndObject) {
                 Callback(SubjectAndObject.first, SubjectAndObject.second);
               });
   }
 
   // IndexClient does not take any space since the data is stored on the
   // server.
   size_t estimateMemoryUsage() const { return 0; }
 
 private:
-  std::unique_ptr<remote::SymbolIndex::Stub> Stub;
+  std::unique_ptr<remote::v1::SymbolIndex::Stub> Stub;
   std::unique_ptr<Marshaller> ProtobufMarshaller;
   // Each request will be terminated if it takes too long.
   std::chrono::milliseconds DeadlineWaitingTime;
 };
 
 } // namespace
 
 std::unique_ptr<clangd::SymbolIndex> getClient(llvm::StringRef Address,

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

 //===--- Index.proto - Remote index Protocol Buffers definition -----------===//
 //
 // 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";
 
-package clang.clangd.remote;
+package clang.clangd.remote.v1;
 
 // Semantics of SymbolIndex match clangd::SymbolIndex with all required
 // structures corresponding to their clangd::* counterparts.
 service SymbolIndex {
   rpc Lookup(LookupRequest) returns (stream LookupReply) {}
 
   rpc FuzzyFind(FuzzyFindRequest) returns (stream FuzzyFindReply) {}
 
oneof kind {
     bool final_result = 2; // HasMore
   }
 }
 
 message RefsRequest {
   repeated string ids = 1;
   uint32 filter = 2;
   uint32 limit = 3;
 }
 
 // The response is a stream of reference messages, and one terminating has_more
 // message.
 message RefsReply {
   oneof kind {
     Ref stream_result = 1;
     bool final_result = 2; // HasMore
   }

clang-tools-extra/clangd/index/remote/marshalling/Marshalling.h

 /// relative path and constructs a URI that points to the relevant file in the
 /// filesystem. The relative path is appended to LocalIndexRoot to construct the
 /// full path and build the final URI.
 class Marshaller {
 public:
   Marshaller() = delete;
   Marshaller(llvm::StringRef RemoteIndexRoot, llvm::StringRef LocalIndexRoot);
 
-  llvm::Expected<clangd::Symbol> fromProtobuf(const Symbol &Message);
-  llvm::Expected<clangd::Ref> fromProtobuf(const Ref &Message);
+  llvm::Expected<clangd::Symbol> fromProtobuf(const v1::Symbol &Message);
+  llvm::Expected<clangd::Ref> fromProtobuf(const v1::Ref &Message);
   llvm::Expected<std::pair<clangd::SymbolID, clangd::Symbol>>
-  fromProtobuf(const Relation &Message);
+  fromProtobuf(const v1::Relation &Message);
 
   llvm::Expected<clangd::LookupRequest>
-  fromProtobuf(const LookupRequest *Message);
+  fromProtobuf(const v1::LookupRequest *Message);
   llvm::Expected<clangd::FuzzyFindRequest>
-  fromProtobuf(const FuzzyFindRequest *Message);
-  llvm::Expected<clangd::RefsRequest> fromProtobuf(const RefsRequest *Message);
+  fromProtobuf(const v1::FuzzyFindRequest *Message);
+  llvm::Expected<clangd::RefsRequest>
+  fromProtobuf(const v1::RefsRequest *Message);
   llvm::Expected<clangd::RelationsRequest>
-  fromProtobuf(const RelationsRequest *Message);
+  fromProtobuf(const v1::RelationsRequest *Message);
 
   /// toProtobuf() functions serialize native clangd types and strip IndexRoot
   /// from the file paths specific to indexing machine. fromProtobuf() functions
   /// deserialize clangd types and translate relative paths into machine-native
   /// URIs.
-  LookupRequest toProtobuf(const clangd::LookupRequest &From);
-  FuzzyFindRequest toProtobuf(const clangd::FuzzyFindRequest &From);
-  RefsRequest toProtobuf(const clangd::RefsRequest &From);
-  RelationsRequest toProtobuf(const clangd::RelationsRequest &From);
-
-  llvm::Expected<Symbol> toProtobuf(const clangd::Symbol &From);
-  llvm::Expected<Ref> toProtobuf(const clangd::Ref &From);
-  llvm::Expected<Relation> toProtobuf(const clangd::SymbolID &Subject,
+  v1::LookupRequest toProtobuf(const clangd::LookupRequest &From);
+  v1::FuzzyFindRequest toProtobuf(const clangd::FuzzyFindRequest &From);
+  v1::RefsRequest toProtobuf(const clangd::RefsRequest &From);
+  v1::RelationsRequest toProtobuf(const clangd::RelationsRequest &From);
+
+  llvm::Expected<v1::Symbol> toProtobuf(const clangd::Symbol &From);
+  llvm::Expected<v1::Ref> toProtobuf(const clangd::Ref &From);
+  llvm::Expected<v1::Relation> toProtobuf(const clangd::SymbolID &Subject,
                                           const clangd::Symbol &Object);
 
   /// 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.
   ///
   /// The relative path passed over the wire has unix slashes.
   llvm::Expected<std::string> relativePathToURI(llvm::StringRef RelativePath);
   /// Translates a URI from the server's backing index to a relative path
   /// suitable to send over the wire to the client.
   llvm::Expected<std::string> uriToRelativePath(llvm::StringRef URI);
 
 private:
-  clangd::SymbolLocation::Position fromProtobuf(const Position &Message);
-  Position toProtobuf(const clangd::SymbolLocation::Position &Position);
-  clang::index::SymbolInfo fromProtobuf(const SymbolInfo &Message);
-  SymbolInfo toProtobuf(const clang::index::SymbolInfo &Info);
+  clangd::SymbolLocation::Position fromProtobuf(const v1::Position &Message);
+  v1::Position toProtobuf(const clangd::SymbolLocation::Position &Position);
+  clang::index::SymbolInfo fromProtobuf(const v1::SymbolInfo &Message);
+  v1::SymbolInfo toProtobuf(const clang::index::SymbolInfo &Info);
   llvm::Expected<clangd::SymbolLocation>
-  fromProtobuf(const SymbolLocation &Message);
-  llvm::Expected<SymbolLocation>
+  fromProtobuf(const v1::SymbolLocation &Message);
+  llvm::Expected<v1::SymbolLocation>
   toProtobuf(const clangd::SymbolLocation &Location);
-  llvm::Expected<HeaderWithReferences>
+  llvm::Expected<v1::HeaderWithReferences>
   toProtobuf(const clangd::Symbol::IncludeHeaderWithReferences &IncludeHeader);
   llvm::Expected<clangd::Symbol::IncludeHeaderWithReferences>
-  fromProtobuf(const HeaderWithReferences &Message);
+  fromProtobuf(const v1::HeaderWithReferences &Message);
 
   /// RemoteIndexRoot and LocalIndexRoot are absolute paths to the project (on
   /// remote and local machine respectively) and include a trailing slash. One
   /// of them can be missing (if the machines are different they don't know each
   /// other's specifics and will only do one-way translation), but both can not
   /// be missing at the same time.
   llvm::Optional<std::string> RemoteIndexRoot;
   llvm::Optional<std::string> LocalIndexRoot;

clang-tools-extra/clangd/index/remote/marshalling/Marshalling.cpp

if (!LocalIndexRoot.empty()) {
     llvm::StringRef Path(*this->LocalIndexRoot);
     if (!Path.endswith(PosixSeparator))
       *this->LocalIndexRoot += PosixSeparator;
   }
   assert(!RemoteIndexRoot.empty() || !LocalIndexRoot.empty());
 }
 
 llvm::Expected<clangd::LookupRequest>
-Marshaller::fromProtobuf(const LookupRequest *Message) {
+Marshaller::fromProtobuf(const v1::LookupRequest *Message) {
   clangd::LookupRequest Req;
   auto IDs = getIDs(Message->ids());
   if (!IDs)
     return IDs.takeError();
   Req.IDs = std::move(*IDs);
   return Req;
 }
 
 llvm::Expected<clangd::FuzzyFindRequest>
-Marshaller::fromProtobuf(const FuzzyFindRequest *Message) {
+Marshaller::fromProtobuf(const v1::FuzzyFindRequest *Message) {
   assert(RemoteIndexRoot);
   clangd::FuzzyFindRequest Result;
   Result.Query = Message->query();
   for (const auto &Scope : Message->scopes())
     Result.Scopes.push_back(Scope);
   Result.AnyScope = Message->any_scope();
   if (Message->limit())
     Result.Limit = Message->limit();
   Result.RestrictForCodeCompletion = Message->restricted_for_code_completion();
   for (const auto &Path : Message->proximity_paths()) {
     llvm::SmallString<256> LocalPath = llvm::StringRef(*RemoteIndexRoot);
     llvm::sys::path::append(LocalPath, Path);
     // FuzzyFindRequest requires proximity paths to have platform-native format
     // in order for SymbolIndex to process the query correctly.
     llvm::sys::path::native(LocalPath);
     Result.ProximityPaths.push_back(std::string(LocalPath));
   }
   for (const auto &Type : Message->preferred_types())
     Result.ProximityPaths.push_back(Type);
   return Result;
 }
 
 llvm::Expected<clangd::RefsRequest>
-Marshaller::fromProtobuf(const RefsRequest *Message) {
+Marshaller::fromProtobuf(const v1::RefsRequest *Message) {
   clangd::RefsRequest Req;
   auto IDs = getIDs(Message->ids());
   if (!IDs)
     return IDs.takeError();
   Req.IDs = std::move(*IDs);
   Req.Filter = static_cast<RefKind>(Message->filter());
   if (Message->limit())
     Req.Limit = Message->limit();
   return Req;
 }
 
 llvm::Expected<clangd::RelationsRequest>
-Marshaller::fromProtobuf(const RelationsRequest *Message) {
+Marshaller::fromProtobuf(const v1::RelationsRequest *Message) {
   clangd::RelationsRequest Req;
   auto IDs = getIDs(Message->subjects());
   if (!IDs)
     return IDs.takeError();
   Req.Subjects = std::move(*IDs);
   Req.Predicate = static_cast<RelationKind>(Message->predicate());
   if (Message->limit())
     Req.Limit = Message->limit();
   return Req;
 }
 
-llvm::Expected<clangd::Symbol> Marshaller::fromProtobuf(const Symbol &Message) {
+llvm::Expected<clangd::Symbol>
+Marshaller::fromProtobuf(const v1::Symbol &Message) {
   if (!Message.has_info() || !Message.has_canonical_declaration())
     return error("Missing info or declaration.");
   clangd::Symbol Result;
   auto ID = SymbolID::fromStr(Message.id());
   if (!ID)
     return ID.takeError();
   Result.ID = *ID;
   Result.SymInfo = fromProtobuf(Message.info());
for (const auto &Header : Message.headers()) {
     if (!SerializedHeader)
       return SerializedHeader.takeError();
     Result.IncludeHeaders.push_back(*SerializedHeader);
   }
   Result.Flags = static_cast<clangd::Symbol::SymbolFlag>(Message.flags());
   return Result;
 }
 
-llvm::Expected<clangd::Ref> Marshaller::fromProtobuf(const Ref &Message) {
+llvm::Expected<clangd::Ref> Marshaller::fromProtobuf(const v1::Ref &Message) {
   if (!Message.has_location())
     return error("Missing location.");
   clangd::Ref Result;
   auto Location = fromProtobuf(Message.location());
   if (!Location)
     return Location.takeError();
   Result.Location = *Location;
   Result.Kind = static_cast<clangd::RefKind>(Message.kind());
   return Result;
 }
 
 llvm::Expected<std::pair<clangd::SymbolID, clangd::Symbol>>
-Marshaller::fromProtobuf(const Relation &Message) {
+Marshaller::fromProtobuf(const v1::Relation &Message) {
   auto SubjectID = SymbolID::fromStr(Message.subject_id());
   if (!SubjectID)
     return SubjectID.takeError();
   if (!Message.has_object())
     return error("Missing Object.");
   auto Object = fromProtobuf(Message.object());
   if (!Object)
     return Object.takeError();
   return std::make_pair(*SubjectID, *Object);
 }
 
-LookupRequest Marshaller::toProtobuf(const clangd::LookupRequest &From) {
-  LookupRequest RPCRequest;
+v1::LookupRequest Marshaller::toProtobuf(const clangd::LookupRequest &From) {
+  v1::LookupRequest RPCRequest;
   for (const auto &SymbolID : From.IDs)
     RPCRequest.add_ids(SymbolID.str());
   return RPCRequest;
 }
 
-FuzzyFindRequest Marshaller::toProtobuf(const clangd::FuzzyFindRequest &From) {
+v1::FuzzyFindRequest
+Marshaller::toProtobuf(const clangd::FuzzyFindRequest &From) {
   assert(LocalIndexRoot);
-  FuzzyFindRequest RPCRequest;
+  v1::FuzzyFindRequest RPCRequest;
   RPCRequest.set_query(From.Query);
   for (const auto &Scope : From.Scopes)
     RPCRequest.add_scopes(Scope);
   RPCRequest.set_any_scope(From.AnyScope);
   if (From.Limit)
     RPCRequest.set_limit(*From.Limit);
   RPCRequest.set_restricted_for_code_completion(From.RestrictForCodeCompletion);
   for (const auto &Path : From.ProximityPaths) {
     llvm::SmallString<256> RelativePath = llvm::StringRef(Path);
     if (llvm::sys::path::replace_path_prefix(RelativePath, *LocalIndexRoot, ""))
       RPCRequest.add_proximity_paths(llvm::sys::path::convert_to_slash(
           RelativePath, llvm::sys::path::Style::windows));
   }
   for (const auto &Type : From.PreferredTypes)
     RPCRequest.add_preferred_types(Type);
   return RPCRequest;
 }
 
-RefsRequest Marshaller::toProtobuf(const clangd::RefsRequest &From) {
-  RefsRequest RPCRequest;
+v1::RefsRequest Marshaller::toProtobuf(const clangd::RefsRequest &From) {
+  v1::RefsRequest RPCRequest;
   for (const auto &ID : From.IDs)
     RPCRequest.add_ids(ID.str());
   RPCRequest.set_filter(static_cast<uint32_t>(From.Filter));
   if (From.Limit)
     RPCRequest.set_limit(*From.Limit);
   return RPCRequest;
 }
 
-RelationsRequest Marshaller::toProtobuf(const clangd::RelationsRequest &From) {
-  RelationsRequest RPCRequest;
+v1::RelationsRequest
+Marshaller::toProtobuf(const clangd::RelationsRequest &From) {
+  v1::RelationsRequest RPCRequest;
   for (const auto &ID : From.Subjects)
     RPCRequest.add_subjects(ID.str());
   RPCRequest.set_predicate(static_cast<uint32_t>(From.Predicate));
   if (From.Limit)
     RPCRequest.set_limit(*From.Limit);
   return RPCRequest;
 }
 
-llvm::Expected<Symbol> Marshaller::toProtobuf(const clangd::Symbol &From) {
-  Symbol Result;
+llvm::Expected<v1::Symbol> Marshaller::toProtobuf(const clangd::Symbol &From) {
+  v1::Symbol Result;
   Result.set_id(From.ID.str());
   *Result.mutable_info() = toProtobuf(From.SymInfo);
   Result.set_name(From.Name.str());
   if (*From.Definition.FileURI) {
     auto Definition = toProtobuf(From.Definition);
     if (!Definition)
       return Definition.takeError();
     *Result.mutable_definition() = *Definition;
if (!Serialized)
       return Serialized.takeError();
     auto *NextHeader = Result.add_headers();
     *NextHeader = *Serialized;
   }
   Result.set_flags(static_cast<uint32_t>(From.Flags));
   return Result;
 }
 
-llvm::Expected<Ref> Marshaller::toProtobuf(const clangd::Ref &From) {
-  Ref Result;
+llvm::Expected<v1::Ref> Marshaller::toProtobuf(const clangd::Ref &From) {
+  v1::Ref Result;
   Result.set_kind(static_cast<uint32_t>(From.Kind));
   auto Location = toProtobuf(From.Location);
   if (!Location)
     return Location.takeError();
   *Result.mutable_location() = *Location;
   return Result;
 }
 
-llvm::Expected<Relation> Marshaller::toProtobuf(const clangd::SymbolID &Subject,
-                                                const clangd::Symbol &Object) {
-  Relation Result;
+llvm::Expected<v1::Relation>
+Marshaller::toProtobuf(const clangd::SymbolID &Subject,
+  v1::Relation Result;
   *Result.mutable_subject_id() = Subject.str();
   auto SerializedObject = toProtobuf(Object);
   if (!SerializedObject)
     return SerializedObject.takeError();
   *Result.mutable_object() = *SerializedObject;
   return Result;
 }
 
if (!llvm::sys::path::replace_path_prefix(Result, *RemoteIndexRoot, ""))
     return error("File path '{0}' doesn't start with '{1}'.", Result.str(),
                  *RemoteIndexRoot);
   assert(Result == llvm::sys::path::convert_to_slash(
                        Result, llvm::sys::path::Style::windows));
   return std::string(Result);
 }
 
 clangd::SymbolLocation::Position
-Marshaller::fromProtobuf(const Position &Message) {
+Marshaller::fromProtobuf(const v1::Position &Message) {
   clangd::SymbolLocation::Position Result;
   Result.setColumn(static_cast<uint32_t>(Message.column()));
   Result.setLine(static_cast<uint32_t>(Message.line()));
   return Result;
 }
 
-Position
+v1::Position
 Marshaller::toProtobuf(const clangd::SymbolLocation::Position &Position) {
-  remote::Position Result;
+  remote::v1::Position Result;
   Result.set_column(Position.column());
   Result.set_line(Position.line());
   return Result;
 }
 
-clang::index::SymbolInfo Marshaller::fromProtobuf(const SymbolInfo &Message) {
+clang::index::SymbolInfo
+Marshaller::fromProtobuf(const v1::SymbolInfo &Message) {
   clang::index::SymbolInfo Result;
   Result.Kind = static_cast<clang::index::SymbolKind>(Message.kind());
   Result.SubKind = static_cast<clang::index::SymbolSubKind>(Message.subkind());
   Result.Lang = static_cast<clang::index::SymbolLanguage>(Message.language());
   Result.Properties =
       static_cast<clang::index::SymbolPropertySet>(Message.properties());
   return Result;
 }
 
-SymbolInfo Marshaller::toProtobuf(const clang::index::SymbolInfo &Info) {
-  SymbolInfo Result;
+v1::SymbolInfo Marshaller::toProtobuf(const clang::index::SymbolInfo &Info) {
+  v1::SymbolInfo Result;
   Result.set_kind(static_cast<uint32_t>(Info.Kind));
   Result.set_subkind(static_cast<uint32_t>(Info.SubKind));
   Result.set_language(static_cast<uint32_t>(Info.Lang));
   Result.set_properties(static_cast<uint32_t>(Info.Properties));
   return Result;
 }
 
 llvm::Expected<clangd::SymbolLocation>
-Marshaller::fromProtobuf(const SymbolLocation &Message) {
+Marshaller::fromProtobuf(const v1::SymbolLocation &Message) {
   clangd::SymbolLocation Location;
   auto URIString = relativePathToURI(Message.file_path());
   if (!URIString)
     return URIString.takeError();
   Location.FileURI = Strings.save(*URIString).begin();
   Location.Start = fromProtobuf(Message.start());
   Location.End = fromProtobuf(Message.end());
   return Location;
 }
 
-llvm::Expected<SymbolLocation>
+llvm::Expected<v1::SymbolLocation>
 Marshaller::toProtobuf(const clangd::SymbolLocation &Location) {
-  remote::SymbolLocation Result;
+  remote::v1::SymbolLocation Result;
   auto RelativePath = uriToRelativePath(Location.FileURI);
   if (!RelativePath)
     return RelativePath.takeError();
   *Result.mutable_file_path() = *RelativePath;
   *Result.mutable_start() = toProtobuf(Location.Start);
   *Result.mutable_end() = toProtobuf(Location.End);
   return Result;
 }
 
-llvm::Expected<HeaderWithReferences> Marshaller::toProtobuf(
+llvm::Expected<v1::HeaderWithReferences> Marshaller::toProtobuf(
     const clangd::Symbol::IncludeHeaderWithReferences &IncludeHeader) {
-  HeaderWithReferences Result;
+  v1::HeaderWithReferences Result;
   Result.set_references(IncludeHeader.References);
   const std::string Header = IncludeHeader.IncludeHeader.str();
   if (isLiteralInclude(Header)) {
     Result.set_header(Header);
     return Result;
   }
   auto RelativePath = uriToRelativePath(Header);
   if (!RelativePath)
     return RelativePath.takeError();
   Result.set_header(*RelativePath);
   return Result;
 }
 
 llvm::Expected<clangd::Symbol::IncludeHeaderWithReferences>
-Marshaller::fromProtobuf(const HeaderWithReferences &Message) {
+Marshaller::fromProtobuf(const v1::HeaderWithReferences &Message) {
   std::string Header = Message.header();
   if (!isLiteralInclude(Header)) {
     auto URIString = relativePathToURI(Header);
     if (!URIString)
       return URIString.takeError();
     Header = *URIString;
   }
   return clangd::Symbol::IncludeHeaderWithReferences{Strings.save(Header),
                                                      Message.references()};
 }
 
 } // namespace remote
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/unittests/remote/MarshallingTests.cpp

TEST(RemoteMarshallingTest, URITranslation) {
   WithInvalidURI.Location.FileURI =
       Strings.save(UnittestURI->toString()).begin();
   auto DeserializedSymbol = ProtobufMarshaller.toProtobuf(WithInvalidURI);
   EXPECT_FALSE(bool(DeserializedSymbol));
   llvm::consumeError(DeserializedSymbol.takeError());
 
   // Paths transmitted over the wire can not be absolute, they have to be
   // relative.
-  Ref WithAbsolutePath;
+  v1::Ref WithAbsolutePath;
   *WithAbsolutePath.mutable_location()->mutable_file_path() =
       "/usr/local/user/home/HelloWorld.cpp";
   Deserialized = ProtobufMarshaller.fromProtobuf(WithAbsolutePath);
   EXPECT_FALSE(bool(Deserialized));
   llvm::consumeError(Deserialized.takeError());
 }
 
 TEST(RemoteMarshallingTest, SymbolSerialization) {
TEST(RemoteMarshallingTest, IncludeHeaderURIs) {
   Serialized = ProtobufMarshaller.toProtobuf(Sym);
   EXPECT_FALSE(bool(Serialized));
   llvm::consumeError(Serialized.takeError());
 
   // Try putting an invalid header into already serialized symbol.
   Sym.IncludeHeaders.pop_back();
   Serialized = ProtobufMarshaller.toProtobuf(Sym);
   ASSERT_TRUE(bool(Serialized));
-  HeaderWithReferences InvalidHeader;
+  v1::HeaderWithReferences InvalidHeader;
   InvalidHeader.set_header(convert_to_slash("/absolute/path/Header.h"));
   InvalidHeader.set_references(9000);
   *Serialized->add_headers() = InvalidHeader;
   Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized);
   EXPECT_FALSE(bool(Deserialized));
   llvm::consumeError(Deserialized.takeError());
 }
 
TEST(RemoteMarshallingTest, RelationsRequestSerialization) {
   ASSERT_TRUE(bool(Deserialized));
   EXPECT_EQ(Deserialized->Subjects, Request.Subjects);
   ASSERT_TRUE(Deserialized->Limit);
   EXPECT_EQ(*Deserialized->Limit, Request.Limit);
   EXPECT_EQ(Deserialized->Predicate, Request.Predicate);
 }
 
 TEST(RemoteMarshallingTest, RelationsRequestFailingSerialization) {
-  RelationsRequest Serialized;
+  v1::RelationsRequest Serialized;
   Serialized.add_subjects("ZZZZZZZZZZZZZZZZ");
   Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/"));
   auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized);
   EXPECT_FALSE(bool(Deserialized));
   llvm::consumeError(Deserialized.takeError());
 }
 
 TEST(RemoteMarshallingTest, RelationsSerializion) {