[clangd][Protocol] Drop optional from WorkspaceEdit::changes

[kadircet]

Summary

This is causing weird code patterns in various places and I can't see
any difference between None and empty change list. Neither in the current use
cases nor in the spec.

[sammccall]

changes is in fact optional, indicated by the ? in changes?: { [uri: DocumentUri]: TextEdit[]; };.

But the spec requires *some* field to be set, and this is the only one we support, so it's not optional in practice for us.

clang-tools-extra/clangd/Protocol.cpp

811

I'd suggest deleting this special case.
We no longer have two distinct states of our WorkspaceEdit struct to represent {changes:{}} and {}.

{changes:{}} is a well-defined empty edit, even if that never makes sense to actually send.
{} conforms to the typescript type definition of the spec, but doesn't actually define an edit per the spec text.

[kadircet]

Get rid of the special case around empty changes.

clang-tools-extra/clangd/ClangdLSPServer.cpp

auto Action = [this, Reply = std::move(Reply)](
     // When no edit is specified, make sure we Reply().
     if (R->ApplyEdits.empty())
       return Reply("Tweak applied.");
 
     if (auto Err = validateEdits(*Server, R->ApplyEdits))
       return Reply(std::move(Err));
 
     WorkspaceEdit WE;
-    WE.changes.emplace();
     for (const auto &It : R->ApplyEdits) {
-      (*WE.changes)[URI::createFile(It.first()).toString()] =
+      WE.changes[URI::createFile(It.first()).toString()] =
           It.second.asTextEdits();
     }
     // ApplyEdit will take care of calling Reply().
     return applyEdit(std::move(WE), "Tweak applied.", std::move(Reply));
   };
   Server->applyTweak(Args.file.file(), Args.selection, Args.tweakID,
                      std::move(Action));
 }

 }
 
 void ClangdLSPServer::onRename(const RenameParams &Params,
                                Callback<WorkspaceEdit> Reply) {
   Path File = std::string(Params.textDocument.uri.file());
   if (!Server->getDraft(File))
     return Reply(llvm::make_error<LSPError>(
         "onRename called for non-added file", ErrorCode::InvalidParams));
-  Server->rename(
-      File, Params.position, Params.newName, Opts.Rename,
+  Server->rename(File, Params.position, Params.newName, Opts.Rename,
                  [File, Params, Reply = std::move(Reply),
                   this](llvm::Expected<RenameResult> R) mutable {
                    if (!R)
                      return Reply(R.takeError());
                    if (auto Err = validateEdits(*Server, R->GlobalChanges))
                      return Reply(std::move(Err));
                    WorkspaceEdit Result;
-        Result.changes.emplace();
                    for (const auto &Rep : R->GlobalChanges) {
-          (*Result.changes)[URI::createFile(Rep.first()).toString()] =
+                     Result.changes[URI::createFile(Rep.first()).toString()] =
                          Rep.second.asTextEdits();
                    }
                    Reply(Result);
                  });
 }
 
 void ClangdLSPServer::onDocumentDidClose(
     const DidCloseTextDocumentParams &Params) {
   PathRef File = Params.textDocument.uri.file();
   Server->removeDocument(File);
 
   {

clang-tools-extra/clangd/Diagnostics.cpp

llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Diag &D) {
   return OS;
 }
 
 CodeAction toCodeAction(const Fix &F, const URIForFile &File) {
   CodeAction Action;
   Action.title = F.Message;
   Action.kind = std::string(CodeAction::QUICKFIX_KIND);
   Action.edit.emplace();
-  Action.edit->changes.emplace();
-  (*Action.edit->changes)[File.uri()] = {F.Edits.begin(), F.Edits.end()};
+  Action.edit->changes[File.uri()] = {F.Edits.begin(), F.Edits.end()};
   return Action;
 }
 
 Diag toDiag(const llvm::SMDiagnostic &D, Diag::DiagSource Source) {
   Diag Result;
   Result.Message = D.getMessage().str();
   switch (D.getKind()) {
   case llvm::SourceMgr::DK_Error:

clang-tools-extra/clangd/Protocol.h

struct CodeActionParams {
 
   /// Context carrying additional information.
   CodeActionContext context;
 };
 bool fromJSON(const llvm::json::Value &, CodeActionParams &, llvm::json::Path);
 
 struct WorkspaceEdit {
   /// Holds changes to existing resources.
-  llvm::Optional<std::map<std::string, std::vector<TextEdit>>> changes;
+  std::map<std::string, std::vector<TextEdit>> changes;
 
   /// Note: "documentChanges" is not currently used because currently there is
   /// no support for versioned edits.
 };
 bool fromJSON(const llvm::json::Value &, WorkspaceEdit &, llvm::json::Path);
 llvm::json::Value toJSON(const WorkspaceEdit &WE);
 
 /// Arguments for the 'applyTweak' command. The server sends these commands as a

clang-tools-extra/clangd/Protocol.cpp

if (!S.children.empty())
     Result["children"] = S.children;
   if (S.deprecated)
     Result["deprecated"] = true;
   // FIXME: workaround for older gcc/clang
   return std::move(Result);
 }
 
 llvm::json::Value toJSON(const WorkspaceEdit &WE) {
-  if (!WE.changes)
+  if (WE.changes.empty())
     return llvm::json::Object{};
   llvm::json::Object FileChanges;
-  for (auto &Change : *WE.changes)
+  for (auto &Change : WE.changes)
     FileChanges[Change.first] = llvm::json::Array(Change.second);
   return llvm::json::Object{{"changes", std::move(FileChanges)}};
 }
 
 bool fromJSON(const llvm::json::Value &Params, TweakArgs &A,
               llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
   return O && O.map("file", A.file) && O.map("selection", A.selection) &&