[clangd] Simplify code of ClangdLSPServer::onCommand

[ilya-biryukov]

Summary

By inlining a complicated lambda into its single call-site.

Also ensure we call Reply() exactly once even if tweaks return both
ShowMessage and ApplyEdit effects.

[hokein]

thanks.

clang-tools-extra/trunk/clangd/ClangdLSPServer.cpp

 }
 
 void ClangdLSPServer::onFileEvent(const DidChangeWatchedFilesParams &Params) {
   Server->onFileEvent(Params);
 }
 
 void ClangdLSPServer::onCommand(const ExecuteCommandParams &Params,
                                 Callback<llvm::json::Value> Reply) {
-  auto ApplyEdit = [this](WorkspaceEdit WE,
-                          Callback<ApplyWorkspaceEditResponse> Reply) {
+  auto ApplyEdit = [this](WorkspaceEdit WE, std::string SuccessMessage,
+                          decltype(Reply) Reply) {
     ApplyWorkspaceEditParams Edit;
     Edit.edit = std::move(WE);
-    call("workspace/applyEdit", std::move(Edit), std::move(Reply));
-  };
-  // FIXME: this lambda is tangled and confusing, refactor it.
-  auto ReplyAfterApplyingEdit =
-      [](decltype(Reply) Reply, std::string SuccessMessage,
-         llvm::Expected<ApplyWorkspaceEditResponse> Response) {
+    call<ApplyWorkspaceEditResponse>(
+        "workspace/applyEdit", std::move(Edit),
+        [Reply = std::move(Reply), SuccessMessage = std::move(SuccessMessage)](
+            llvm::Expected<ApplyWorkspaceEditResponse> Response) mutable {
           if (!Response)
             return Reply(Response.takeError());
           if (!Response->applied) {
             std::string Reason = Response->failureReason
                                      ? *Response->failureReason
                                      : "unknown reason";
             return Reply(llvm::createStringError(
                 llvm::inconvertibleErrorCode(),
                 ("edits were not applied: " + Reason).c_str()));
           }
           return Reply(SuccessMessage);
-      };
+        });
+
   if (Params.command == ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND &&
       Params.workspaceEdit) {
     // The flow for "apply-fix" :
     // 1. We publish a diagnostic, including fixits
     // 2. The user clicks on the diagnostic, the editor asks us for code actions
     // 3. We send code actions, with the fixit embedded as context
     // 4. The user selects the fixit, the editor asks us to apply it
     // 5. We unwrap the changes and send them back to the editor
     // 6. The editor applies the changes (applyEdit), and sends us a reply
     // 7. We unwrap the reply and send a reply to the editor.
-    ApplyEdit(*Params.workspaceEdit,
-              [Reply = std::move(Reply), ReplyAfterApplyingEdit](
-                  llvm::Expected<ApplyWorkspaceEditResponse> Response) mutable {
-                ReplyAfterApplyingEdit(std::move(Reply), "Fix applied.",
-                                       std::move(Response));
-              });
+    ApplyEdit(*Params.workspaceEdit, "Fix applied.", std::move(Reply));
   } else if (Params.command == ExecuteCommandParams::CLANGD_APPLY_TWEAK &&
              Params.tweakArgs) {
     auto Code = DraftMgr.getDraft(Params.tweakArgs->file.file());
     if (!Code)
       return Reply(llvm::createStringError(
           llvm::inconvertibleErrorCode(),
           "trying to apply a code action for a non-added file"));
 
-    auto Action = [this, ApplyEdit, ReplyAfterApplyingEdit,
-                   Reply = std::move(Reply), File = Params.tweakArgs->file,
-                   Code = std::move(*Code)](
+    auto Action = [this, ApplyEdit, Reply = std::move(Reply),
+                   File = Params.tweakArgs->file, Code = std::move(*Code)](
                       llvm::Expected<Tweak::Effect> R) mutable {
       if (!R)
         return Reply(R.takeError());
 
-      if (R->ApplyEdit) {
-        WorkspaceEdit WE;
-        WE.changes.emplace();
-        (*WE.changes)[File.uri()] = replacementsToEdits(Code, *R->ApplyEdit);
-        ApplyEdit(
-            std::move(WE),
-            [Reply = std::move(Reply), ReplyAfterApplyingEdit](
-                llvm::Expected<ApplyWorkspaceEditResponse> Response) mutable {
-              ReplyAfterApplyingEdit(std::move(Reply), "Tweak applied.",
-                                     std::move(Response));
-            });
-      }
+      assert(R->ShowMessage || R->ApplyEdit && "tweak has no effect");
+
       if (R->ShowMessage) {
         ShowMessageParams Msg;
         Msg.message = *R->ShowMessage;
         Msg.type = MessageType::Info;
         notify("window/showMessage", Msg);
-        Reply("Tweak applied.");
       }
+      if (R->ApplyEdit) {
+        WorkspaceEdit WE;
+        WE.changes.emplace();
+        (*WE.changes)[File.uri()] = replacementsToEdits(Code, *R->ApplyEdit);
+        // ApplyEdit will take care of calling Reply().
+        return ApplyEdit(std::move(WE), "Tweak applied.", std::move(Reply));
+      }
+      // When no edit is specified, make sure we Reply().
+      return Reply("Tweak applied.");
     };
     Server->applyTweak(Params.tweakArgs->file.file(),
                        Params.tweakArgs->selection, Params.tweakArgs->tweakID,
                        std::move(Action));
   } else {
     // We should not get here because ExecuteCommandParams would not have
     // parsed in the first place and this handler should not be called. But if
     // more commands are added, this will be here has a safe guard.