[clangd][remote-client] Set HasMore to true for failure

[kadircet]

Summary

Currently client was setting the HasMore to true iff stream said so.
Hence if we had a broken stream for whatever reason (e.g. hitting deadline for a
huge response), HasMore would be false, which is semantically incorrect (e.g.
will throw rename off).

[kbobyrev]

Good catch, thanks!

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

using StreamingCall = std::unique_ptr<grpc::ClientReader<ReplyT>> (
                                         const RequestT &);
 
   template <typename RequestT, typename ReplyT, typename ClangdRequestT,
             typename CallbackT>
   bool streamRPC(ClangdRequestT Request,
                  StreamingCall<RequestT, ReplyT> RPCCall,
                  CallbackT Callback) const {
     updateConnectionStatus();
-    bool FinalResult = false;
+    // We initialize to true because stream might be broken before we see the
+    // final message. In such a case there are actually more results on the
+    // stream, but we couldn't get to them.
+    bool HasMore = true;
     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 StartTime =
         std::chrono::system_clock::now();
     auto Deadline = StartTime + DeadlineWaitingTime;
     Context.set_deadline(Deadline);
     auto Reader = (Stub.get()->*RPCCall)(&Context, RPCRequest);
     dlog("Sending {0}: {1}", RequestT::descriptor()->name(),
          RPCRequest.DebugString());
     ReplyT Reply;
     unsigned Successful = 0;
     unsigned FailedToParse = 0;
     while (Reader->Read(&Reply)) {
       if (!Reply.has_stream_result()) {
-        FinalResult = Reply.final_result().has_more();
+        HasMore = Reply.final_result().has_more();
         continue;
       }
       auto Response = ProtobufMarshaller->fromProtobuf(Reply.stream_result());
       if (!Response) {
         elog("Received invalid {0}: {1}. Reason: {2}",
              ReplyT::descriptor()->name(), Reply.stream_result().DebugString(),
              Response.takeError());
         ++FailedToParse;
         continue;
       }
       Callback(*Response);
       ++Successful;
     }
     auto Millis = std::chrono::duration_cast<std::chrono::milliseconds>(
                       std::chrono::system_clock::now() - StartTime)
                       .count();
     vlog("Remote index [{0}]: {1} => {2} results in {3}ms.", ServerAddress,
          RequestT::descriptor()->name(), Successful, Millis);
     SPAN_ATTACH(Tracer, "Status", Reader->Finish().ok());
     SPAN_ATTACH(Tracer, "Successful", Successful);
     SPAN_ATTACH(Tracer, "Failed to parse", FailedToParse);
     updateConnectionStatus();
-    return FinalResult;
+    return HasMore;
   }
 
 public:
   IndexClient(
       std::shared_ptr<grpc::Channel> Channel, llvm::StringRef Address,
       llvm::StringRef ProjectRoot,
       std::chrono::milliseconds DeadlineTime = std::chrono::milliseconds(1000))
       : Stub(remote::v1::SymbolIndex::NewStub(Channel)), Channel(Channel),