[clangd] Add ErrorCodes enum class.

[hokein]

Summary

Avoid using magic number in the code everywhere.

[sammccall]

clangd/Protocol.h

35

nit: could you call this ErrorCode? The plural doesn't make so much sense as a type name.

42

serverErrorStart/End are not error codes, they're for comparing the numeric values to a range.

Given this is an enum class and we have to cast to int to do comparisons, I don't think these belong inside the enum, but rather as ints, outside it.

However, these limits aren't used at all yet, so probably just remove them for now.

[hokein]

Address review comments:

• ErrorCodes => ErrorCode
• Remove serverErrorStart/serverErrorEnd

clangd/ClangdLSPServer.cpp

if (Params.metadata && !Params.metadata->extraFlags.empty())
     CDB.setExtraFlagsForFile(Params.textDocument.uri.file,
                              std::move(Params.metadata->extraFlags));
   Server.addDocument(Params.textDocument.uri.file, Params.textDocument.text);
 }
 
 void ClangdLSPServer::onDocumentDidChange(Ctx C,
                                           DidChangeTextDocumentParams &Params) {
   if (Params.contentChanges.size() != 1)
-    return C.replyError(-32602, "can only apply one change at a time");
+    return C.replyError(ErrorCode::InvalidParams,
+                        "can only apply one change at a time");
   // We only support full syncing right now.
   Server.addDocument(Params.textDocument.uri.file,
                      Params.contentChanges[0].text);
 }
 
 void ClangdLSPServer::onFileEvent(Ctx C, DidChangeWatchedFilesParams &Params) {
   Server.onFileEvent(Params);
 }
if (Params.command == ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND &&
     // Ideally, we would wait for the response and if there is no error, we
     // would reply success/failure to the original RPC.
     C.call("workspace/applyEdit", ApplyWorkspaceEditParams::unparse(ApplyEdit));
   } 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.
     C.replyError(
-        1, llvm::formatv("Unsupported command \"{0}\".", Params.command).str());
+        ErrorCode::InvalidParams,
+        llvm::formatv("Unsupported command \"{0}\".", Params.command).str());
   }
 }
 
 void ClangdLSPServer::onDocumentDidClose(Ctx C,
                                          DidCloseTextDocumentParams &Params) {
   Server.removeDocument(Params.textDocument.uri.file);
 }
 

 }
 
 void ClangdLSPServer::onSignatureHelp(Ctx C,
                                       TextDocumentPositionParams &Params) {
   auto SignatureHelp = Server.signatureHelp(
       Params.textDocument.uri.file,
       Position{Params.position.line, Params.position.character});
   if (!SignatureHelp)
-    return C.replyError(-32602, llvm::toString(SignatureHelp.takeError()));
+    return C.replyError(ErrorCode::InvalidParams,
+                        llvm::toString(SignatureHelp.takeError()));
   C.reply(SignatureHelp->Value);
 }
 
 void ClangdLSPServer::onGoToDefinition(Ctx C,
                                        TextDocumentPositionParams &Params) {
   auto Items = Server.findDefinitions(
       Params.textDocument.uri.file,
       Position{Params.position.line, Params.position.character});
   if (!Items)
-    return C.replyError(-32602, llvm::toString(Items.takeError()));
+    return C.replyError(ErrorCode::InvalidParams,
+                        llvm::toString(Items.takeError()));
   C.reply(json::ary(Items->Value));
 }
 
 void ClangdLSPServer::onSwitchSourceHeader(Ctx C,
                                            TextDocumentIdentifier &Params) {
   llvm::Optional<Path> Result = Server.switchSourceHeader(Params.uri.file);
   std::string ResultUri;
   C.reply(Result ? URI::fromFile(*Result).uri : "");
: Out(Out), CDB(/*Logger=*/Out, std::move(CompileCommandsDir)),
              /*Logger=*/Out, ResourceDir) {}
 
 bool ClangdLSPServer::run(std::istream &In) {
   assert(!IsDone && "Run was called before");
 
   // Set up JSONRPCDispatcher.
   JSONRPCDispatcher Dispatcher(
       [](RequestContext Ctx, llvm::yaml::MappingNode *Params) {
-        Ctx.replyError(-32601, "method not found");
+        Ctx.replyError(ErrorCode::MethodNotFound, "method not found");
       });
   registerCallbackHandlers(Dispatcher, Out, /*Callbacks=*/*this);
 
   // Run the Language Server loop.
   runLanguageServerLoop(In, Out, Dispatcher, IsDone);
 
   // Make sure IsDone is set to true after this method exits to ensure assertion
   // at the start of the method fires if it's ever executed again.

clangd/JSONRPCDispatcher.h

 //===--- JSONRPCDispatcher.h - Main JSON parser entry point -----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_JSONRPCDISPATCHER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_JSONRPCDISPATCHER_H
 
 #include "JSONExpr.h"
 #include "Logger.h"
+#include "Protocol.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/YAMLParser.h"
 #include <iosfwd>
 #include <mutex>
 
 namespace clang {

 class RequestContext {
 public:
   RequestContext(JSONOutput &Out, llvm::Optional<json::Expr> ID)
       : Out(Out), ID(std::move(ID)) {}
 
   /// Sends a successful reply.
   void reply(json::Expr &&Result);
   /// Sends an error response to the client, and logs it.
-  void replyError(int code, const llvm::StringRef &Message);
+  void replyError(ErrorCode code, const llvm::StringRef &Message);
   /// Sends a request to the client.
   void call(llvm::StringRef Method, json::Expr &&Params);
 
 private:
   JSONOutput &Out;
   llvm::Optional<json::Expr> ID;
 };
 

clangd/JSONRPCDispatcher.cpp

void RequestContext::reply(json::Expr &&Result) {
   }
   Out.writeMessage(json::obj{
       {"jsonrpc", "2.0"},
       {"id", *ID},
       {"result", std::move(Result)},
   });
 }
 
-void RequestContext::replyError(int code, const llvm::StringRef &Message) {
-  Out.log("Error " + llvm::Twine(code) + ": " + Message + "\n");
+void RequestContext::replyError(ErrorCode code, const llvm::StringRef &Message) {
+  Out.log("Error " + Twine(static_cast<int>(code)) + ": " + Message + "\n");
   if (ID) {
     Out.writeMessage(json::obj{
         {"jsonrpc", "2.0"},
         {"id", *ID},
-        {"error", json::obj{{"code", code}, {"message", Message}}},
+        {"error", json::obj{{"code", static_cast<int>(code)}, {"message", Message}}},
     });
   }
 }
 
 void RequestContext::call(StringRef Method, json::Expr &&Params) {
   // FIXME: Generate/Increment IDs for every request so that we can get proper
   // replies once we need to.
   Out.writeMessage(json::obj{

clangd/Protocol.h

 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 
 class Logger;
 
+enum class ErrorCode {
+  // Defined by JSON RPC.
+  ParseError = -32700,
+  InvalidRequest = -32600,
+  MethodNotFound = -32601,
+  InvalidParams = -32602,
+  InternalError = -32603,
+
+  ServerNotInitialized = -32002,
+  UnknownErrorCode = -32001,
+
+  // Defined by the protocol.
+  RequestCancelled = -32800,
+};
+
 struct URI {
   std::string uri;
   std::string file;
 
   static URI fromUri(llvm::StringRef uri);
   static URI fromFile(llvm::StringRef file);
 
   static URI parse(llvm::yaml::ScalarNode *Param);