[clangd] LLVM-ify codebase

[omtcyfz]

Summary

This patch introduces cosmetic changes while making ClangD code slightly more LLVM Coding Standards-compliant by

• Convert names of struct fields in Protocol.h from camelCase to CamelCase
• Enclose code in .cpp implementation files in appropriate namespaces instead of doing using namespace clang; using namespace clangd;
• Putting few consts and references where appropriate

Testing:
$ ninja check-clang-tools
All ClangD-related tests are green.

[ilya-biryukov]

I've stumbled upon your review by accident, I don't know if it's final or not, but still wanted to add a comment.

I think the original idea for camelCase identifiers was to mimic the names from LSP specification.
IMO, we should follow LLVM code style there, but nevertheless it's probably a good idea to ask original author.

clangd/ClangdServer.h

115

Why do you feel pass-by-const-ref here is better than pass-by-value?

We're storing functions inside a vector there, so we would need a copy anyway.
Using pass-by-value allows to std::move into the function, pass-by-const-ref doesn't allow that.

[ilya-biryukov]

clangd/Protocol.h

56

The idea is to follow LSP spec closely, so it's probably better to call it 'Character' (i.e. let the name be the same modulo naming conventions).
See: https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md#position

[omtcyfz]

@ilya-biryukov thanks for the comments!

Overall, the patch adds literally zero functionality, so I'd better focus on doing something meaningful. I removed reviewers and abandoned the efforts for now because more recent patches were submitted and thus this one should be rebased and I'd need to tweak a couple of things.

clangd/ClangdServer.h

115

Fair point. There is one copying happening anyway, though.

clangd/Protocol.h

56

Yes, I had that impression after reading protocol specification. However, I inspected the clangd codebase and found that it doesn't use exactly the same names and structures everywhere. Therefore, I thought it would be correct to use llvm-ish style anyway. I don't have any objections if the naming would be exactly like in protocol's code snippets. I just felt like this could be a readability improvement since most of the code has different naming style and it simply becomes a mix. Anyway, that's not too important.

[omtcyfz]

No longer relevant.

clangd/ClangdLSPServer.cpp

 //===--- ClangdLSPServer.cpp - LSP server ------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
 #include "ClangdLSPServer.h"
 #include "JSONRPCDispatcher.h"
 #include "ProtocolHandlers.h"
 
-using namespace clang::clangd;
-using namespace clang;
+namespace clang {
+namespace clangd {
 
 namespace {
 
 std::string
 replacementsToEdits(StringRef Code,
                     const std::vector<tooling::Replacement> &Replacements) {
   // Turn the replacements into the format specified by the Language Server
   // Protocol. Fuse them into one big JSON array.

 }
 
 void ClangdLSPServer::LSPProtocolCallbacks::onShutdown(JSONOutput &Out) {
   LangServer.IsDone = true;
 }
 
 void ClangdLSPServer::LSPProtocolCallbacks::onDocumentDidOpen(
     DidOpenTextDocumentParams Params, JSONOutput &Out) {
-  LangServer.Server.addDocument(Params.textDocument.uri.file,
-                                Params.textDocument.text);
+  LangServer.Server.addDocument(Params.TextDocument.uri.File,
+                                Params.TextDocument.Text);
 }
 
 void ClangdLSPServer::LSPProtocolCallbacks::onDocumentDidChange(
     DidChangeTextDocumentParams Params, JSONOutput &Out) {
   // We only support full syncing right now.
-  LangServer.Server.addDocument(Params.textDocument.uri.file,
-                                Params.contentChanges[0].text);
+  LangServer.Server.addDocument(Params.TextDocument.uri.File,
+                                Params.contentChanges[0].Text);
 }
 
 void ClangdLSPServer::LSPProtocolCallbacks::onDocumentDidClose(
     DidCloseTextDocumentParams Params, JSONOutput &Out) {
-  LangServer.Server.removeDocument(Params.textDocument.uri.file);
+  LangServer.Server.removeDocument(Params.TextDocument.uri.File);
 }
 
 void ClangdLSPServer::LSPProtocolCallbacks::onDocumentOnTypeFormatting(
     DocumentOnTypeFormattingParams Params, StringRef ID, JSONOutput &Out) {
-  auto File = Params.textDocument.uri.file;
+  auto File = Params.TextDocument.uri.File;
   std::string Code = LangServer.Server.getDocument(File);
   std::string Edits = replacementsToEdits(
-      Code, LangServer.Server.formatOnType(File, Params.position));
+      Code, LangServer.Server.formatOnType(File, Params.RequestPosition));
 
   Out.writeMessage(R"({"jsonrpc":"2.0","id":)" + ID.str() +
                    R"(,"result":[)" + Edits + R"(]})");
 }
 
 void ClangdLSPServer::LSPProtocolCallbacks::onDocumentRangeFormatting(
     DocumentRangeFormattingParams Params, StringRef ID, JSONOutput &Out) {
-  auto File = Params.textDocument.uri.file;
+  auto File = Params.TextDocument.uri.File;
   std::string Code = LangServer.Server.getDocument(File);
   std::string Edits = replacementsToEdits(
-      Code, LangServer.Server.formatRange(File, Params.range));
-
+      Code, LangServer.Server.formatRange(File, Params.FormatRange));
   Out.writeMessage(R"({"jsonrpc":"2.0","id":)" + ID.str() +
                    R"(,"result":[)" + Edits + R"(]})");
 }
 
 void ClangdLSPServer::LSPProtocolCallbacks::onDocumentFormatting(
     DocumentFormattingParams Params, StringRef ID, JSONOutput &Out) {
-  auto File = Params.textDocument.uri.file;
+  auto File = Params.TextDocument.uri.File;
   std::string Code = LangServer.Server.getDocument(File);
   std::string Edits =
       replacementsToEdits(Code, LangServer.Server.formatFile(File));
 
   Out.writeMessage(R"({"jsonrpc":"2.0","id":)" + ID.str() +
                    R"(,"result":[)" + Edits + R"(]})");
 }
 
 void ClangdLSPServer::LSPProtocolCallbacks::onCodeAction(
     CodeActionParams Params, StringRef ID, JSONOutput &Out) {
   // We provide a code action for each diagnostic at the requested location
   // which has FixIts available.
   std::string Code =
-      LangServer.Server.getDocument(Params.textDocument.uri.file);
+      LangServer.Server.getDocument(Params.TextDocument.uri.File);
   std::string Commands;
-  for (Diagnostic &D : Params.context.diagnostics) {
+  for (Diagnostic &D : Params.Context.Diagnostics) {
     std::vector<clang::tooling::Replacement> Fixes =
-        LangServer.getFixIts(Params.textDocument.uri.file, D);
+        LangServer.getFixIts(Params.TextDocument.uri.File, D);
     std::string Edits = replacementsToEdits(Code, Fixes);
 
     if (!Edits.empty())
       Commands +=
-          R"({"title":"Apply FixIt ')" + llvm::yaml::escape(D.message) +
+          R"({"title":"Apply FixIt ')" + llvm::yaml::escape(D.Message) +
           R"('", "command": "clangd.applyFix", "arguments": [")" +
-          llvm::yaml::escape(Params.textDocument.uri.uri) +
+          llvm::yaml::escape(Params.TextDocument.uri.uri) +
           R"(", [)" + Edits +
           R"(]]},)";
   }
   if (!Commands.empty())
     Commands.pop_back();
 
   Out.writeMessage(
       R"({"jsonrpc":"2.0","id":)" + ID.str() +
       R"(, "result": [)" + Commands +
       R"(]})");
 }
 
 void ClangdLSPServer::LSPProtocolCallbacks::onCompletion(
     TextDocumentPositionParams Params, StringRef ID, JSONOutput &Out) {
 
-  auto Items = LangServer.Server.codeComplete(
-      Params.textDocument.uri.file,
-      Position{Params.position.line, Params.position.character}).Value;
+  auto Items = LangServer.Server
+                   .codeComplete(Params.TextDocument.uri.File,
+                                 Position{Params.Position.Line,
+                                          Params.Position.LineOffset})
+                   .Value;
 
   std::string Completions;
   for (const auto &Item : Items) {
     Completions += CompletionItem::unparse(Item);
     Completions += ",";
   }
   if (!Completions.empty())
     Completions.pop_back();

 }
 
 void ClangdLSPServer::consumeDiagnostics(
     PathRef File, std::vector<DiagWithFixIts> Diagnostics) {
   std::string DiagnosticsJSON;
 
   DiagnosticToReplacementMap LocalFixIts; // Temporary storage
   for (auto &DiagWithFixes : Diagnostics) {
-    auto Diag = DiagWithFixes.Diag;
+    const auto Diag = DiagWithFixes.Diag;
     DiagnosticsJSON +=
-        R"({"range":)" + Range::unparse(Diag.range) +
-        R"(,"severity":)" + std::to_string(Diag.severity) +
-        R"(,"message":")" + llvm::yaml::escape(Diag.message) +
+        R"({"range":)" + Range::unparse(Diag.Range) +
+        R"(,"severity":)" + std::to_string(Diag.Severity) +
+        R"(,"message":")" + llvm::yaml::escape(Diag.Message) +
         R"("},)";
 
     // We convert to Replacements to become independent of the SourceManager.
     auto &FixItsForDiagnostic = LocalFixIts[Diag];
     std::copy(DiagWithFixes.FixIts.begin(), DiagWithFixes.FixIts.end(),
               std::back_inserter(FixItsForDiagnostic));
   }
 
   // Cache FixIts
   {
     // FIXME(ibiryukov): should be deleted when documents are removed
     std::lock_guard<std::mutex> Lock(FixItsMutex);
     FixItsMap[File] = LocalFixIts;
   }
 
   // Publish diagnostics.
   if (!DiagnosticsJSON.empty())
     DiagnosticsJSON.pop_back(); // Drop trailing comma.
   Out.writeMessage(
       R"({"jsonrpc":"2.0","method":"textDocument/publishDiagnostics","params":{"uri":")" +
       URI::fromFile(File).uri + R"(","diagnostics":[)" + DiagnosticsJSON +
       R"(]}})");
 }
+
+} // namespace clangd
+} // namespace clang

clangd/ClangdServer.h

 public:
   ClangdScheduler(bool RunSynchronously);
   ~ClangdScheduler();
 
   /// Add \p Request to the start of the queue. \p Request will be run on a
   /// separate worker thread.
   /// \p Request is scheduled to be executed before all currently added
   /// requests.
-  void addToFront(std::function<void()> Request);
+  void addToFront(const std::function<void()> &Request);
   /// Add \p Request to the end of the queue. \p Request will be run on a
   /// separate worker thread.
   /// \p Request is scheduled to be executed after all currently added
   /// requests.
-  void addToEnd(std::function<void()> Request);
+  void addToEnd(const std::function<void()> &Request);
 
 private:
   bool RunSynchronously;
   std::mutex Mutex;
   /// We run some tasks on a separate thread(parsing, ClangdUnit cleanup).
   /// This thread looks into RequestQueue to find requests to handle and
   /// terminates when Done is set to true.
   std::thread Worker;

clangd/ClangdServer.cpp

 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include <future>
 
-using namespace clang;
-using namespace clang::clangd;
+namespace clang {
+namespace clangd {
 
 namespace {
 
 std::vector<tooling::Replacement> formatCode(StringRef Code, StringRef Filename,
                                              ArrayRef<tooling::Range> Ranges) {
   // Call clang-format.
   // FIXME: Don't ignore style.
   format::FormatStyle Style = format::getLLVMStyle();
   auto Result = format::reformat(Style, Code, Ranges, Filename);
 
   return std::vector<tooling::Replacement>(Result.begin(), Result.end());
 }
 
 } // namespace
 
-size_t clangd::positionToOffset(StringRef Code, Position P) {
+size_t positionToOffset(StringRef Code, Position P) {
   size_t Offset = 0;
-  for (int I = 0; I != P.line; ++I) {
+  for (unsigned I = 0; I != P.Line; ++I) {
     // FIXME: \r\n
     // FIXME: UTF-8
     size_t F = Code.find('\n', Offset);
     if (F == StringRef::npos)
       return 0; // FIXME: Is this reasonable?
     Offset = F + 1;
   }
-  return (Offset == 0 ? 0 : (Offset - 1)) + P.character;
+  return (Offset == 0 ? 0 : (Offset - 1)) + P.LineOffset;
 }
 
 /// Turn an offset in Code into a [line, column] pair.
-Position clangd::offsetToPosition(StringRef Code, size_t Offset) {
+Position offsetToPosition(StringRef Code, size_t Offset) {
   StringRef JustBefore = Code.substr(0, Offset);
   // FIXME: \r\n
   // FIXME: UTF-8
-  int Lines = JustBefore.count('\n');
-  int Cols = JustBefore.size() - JustBefore.rfind('\n') - 1;
+  unsigned Lines = JustBefore.count('\n');
+  unsigned Cols = JustBefore.size() - JustBefore.rfind('\n') - 1;
   return {Lines, Cols};
 }
 
 Tagged<IntrusiveRefCntPtr<vfs::FileSystem>>
 RealFileSystemProvider::getTaggedFileSystem(PathRef File) {
   return make_tagged(vfs::getRealFileSystem(), VFSTag());
 }
 
if (RunSynchronously)
     std::lock_guard<std::mutex> Lock(Mutex);
     // Wake up the worker thread
     Done = true;
   } // unlock Mutex
   RequestCV.notify_one();
   Worker.join();
 }
 
-void ClangdScheduler::addToFront(std::function<void()> Request) {
+void ClangdScheduler::addToFront(const std::function<void()> &Request) {
   if (RunSynchronously) {
     Request();
     return;
   }
 
   {
     std::lock_guard<std::mutex> Lock(Mutex);
     RequestQueue.push_front(Request);
   }
   RequestCV.notify_one();
 }
 
-void ClangdScheduler::addToEnd(std::function<void()> Request) {
+void ClangdScheduler::addToEnd(const std::function<void()> &Request) {
   if (RunSynchronously) {
     Request();
     return;
   }
 
   {
     std::lock_guard<std::mutex> Lock(Mutex);
     RequestQueue.push_back(Request);
Units.runOnUnit(File, *OverridenContents, CDB, PCHs, TaggedFS.Value,
                   });
   return make_tagged(std::move(Result), TaggedFS.Tag);
 }
 
 std::vector<tooling::Replacement> ClangdServer::formatRange(PathRef File,
                                                             Range Rng) {
   std::string Code = getDocument(File);
 
-  size_t Begin = positionToOffset(Code, Rng.start);
-  size_t Len = positionToOffset(Code, Rng.end) - Begin;
+  size_t Begin = positionToOffset(Code, Rng.Start);
+  size_t Len = positionToOffset(Code, Rng.End) - Begin;
   return formatCode(Code, File, {tooling::Range(Begin, Len)});
 }
 
 std::vector<tooling::Replacement> ClangdServer::formatFile(PathRef File) {
   // Format everything.
   std::string Code = getDocument(File);
   return formatCode(Code, File, {tooling::Range(0, Code.size())});
 }
Units.runOnExistingUnit(File, [&DumpPromise](ClangdUnit &Unit) {
       Unit.dumpAST(ResultOS);
       ResultOS.flush();
 
       DumpPromise.set_value(std::move(Result));
     });
   });
   return DumpFuture.get();
 }
+
+} // namespace clangd
+} // namespace clang

clangd/ClangdUnit.h

 #include "clang/Tooling/Core/Replacement.h"
 #include <memory>
 
 namespace llvm {
 class raw_ostream;
 }
 
 namespace clang {
+
 class ASTUnit;
 class PCHContainerOperations;
 
 namespace vfs {
 class FileSystem;
 }
 
 namespace tooling {

 private:
   Path FileName;
   std::unique_ptr<ASTUnit> Unit;
   std::shared_ptr<PCHContainerOperations> PCHs;
 };
 
 } // namespace clangd
 } // namespace clang
+
 #endif

clangd/ClangdUnit.cpp

 #include "ClangdUnit.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/Support/Format.h"
 
-using namespace clang::clangd;
-using namespace clang;
+namespace clang {
+namespace clangd {
 
 ClangdUnit::ClangdUnit(PathRef FileName, StringRef Contents,
                        std::shared_ptr<PCHContainerOperations> PCHs,
                        std::vector<tooling::CompileCommand> Commands,
                        IntrusiveRefCntPtr<vfs::FileSystem> VFS)
     : FileName(FileName), PCHs(PCHs) {
   assert(!Commands.empty() && "No compile commands provided");
 
for (unsigned I = 0; I != NumResults; ++I) {
       CodeCompletionString *CCS = Result.CreateCodeCompletionString(
           S, Context, *Allocator, CCTUInfo,
           CodeCompleteOpts.IncludeBriefComments);
       if (CCS) {
         CompletionItem Item;
         for (CodeCompletionString::Chunk C : *CCS) {
           switch (C.Kind) {
           case CodeCompletionString::CK_ResultType:
-            Item.detail = C.Text;
+            Item.Detail = C.Text;
             break;
           case CodeCompletionString::CK_Optional:
             break;
           default:
-            Item.label += C.Text;
+            Item.Label += C.Text;
             break;
           }
         }
         assert(CCS->getTypedText());
-        Item.kind = getKind(Result.CursorKind);
+        Item.Kind = getKind(Result.CursorKind);
         // Priority is a 16-bit integer, hence at most 5 digits.
         // Since identifiers with higher priority need to come first,
         // we subtract the priority from 99999.
         // For example, the sort text of the identifier 'a' with priority 35
         // is 99964a.
         assert(CCS->getPriority() < 99999 && "Expecting code completion result "
                                              "priority to have at most "
                                              "5-digits");
-        llvm::raw_string_ostream(Item.sortText) << llvm::format(
+        llvm::raw_string_ostream(Item.SortText) << llvm::format(
             "%05d%s", 99999 - CCS->getPriority(), CCS->getTypedText());
-        Item.insertText = Item.filterText = CCS->getTypedText();
+        Item.InsertText = Item.FilterText = CCS->getTypedText();
         if (CCS->getBriefComment())
-          Item.documentation = CCS->getBriefComment();
+          Item.Documentation = CCS->getBriefComment();
         Items->push_back(std::move(Item));
       }
     }
   }
 
   GlobalCodeCompletionAllocator &getAllocator() override { return *Allocator; }
 
   CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
ClangdUnit::codeComplete(StringRef Contents, Position Pos,
 
   IntrusiveRefCntPtr<FileManager> FileMgr(
       new FileManager(Unit->getFileSystemOpts(), VFS));
   IntrusiveRefCntPtr<SourceManager> SourceMgr(
       new SourceManager(*DiagEngine, *FileMgr));
   // CodeComplete seems to require fresh LangOptions.
   LangOptions LangOpts = Unit->getLangOpts();
   // The language server protocol uses zero-based line and column numbers.
-  // The clang code completion uses one-based numbers.
-  Unit->CodeComplete(FileName, Pos.line + 1, Pos.character + 1, RemappedSource,
+  // The Clang code completion uses one-based numbers.
+  Unit->CodeComplete(FileName, Pos.Line + 1, Pos.LineOffset + 1, RemappedSource,
                      CCO.IncludeMacros, CCO.IncludeCodePatterns,
                      CCO.IncludeBriefComments, Collector, PCHs, *DiagEngine,
                      LangOpts, *SourceMgr, *FileMgr, StoredDiagnostics,
                      OwnedBuffers);
   for (const llvm::MemoryBuffer *Buffer : OwnedBuffers)
     delete Buffer;
   return Items;
 }
std::vector<DiagWithFixIts> ClangdUnit::getLocalDiagnostics() const {
   std::vector<DiagWithFixIts> Result;
   for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(),
                                      DEnd = Unit->stored_diag_end();
        D != DEnd; ++D) {
     if (!D->getLocation().isValid() ||
         !D->getLocation().getManager().isInMainFile(D->getLocation()))
       continue;
     Position P;
-    P.line = D->getLocation().getSpellingLineNumber() - 1;
-    P.character = D->getLocation().getSpellingColumnNumber();
+    P.Line= D->getLocation().getSpellingLineNumber() - 1;
+    P.LineOffset= D->getLocation().getSpellingColumnNumber();
     Range R = {P, P};
     clangd::Diagnostic Diag = {R, getSeverity(D->getLevel()), D->getMessage()};
 
     llvm::SmallVector<tooling::Replacement, 1> FixItsForDiagnostic;
     for (const FixItHint &Fix : D->getFixIts()) {
       FixItsForDiagnostic.push_back(clang::tooling::Replacement(
           Unit->getSourceManager(), Fix.RemoveRange, Fix.CodeToInsert));
     }
     Result.push_back({Diag, std::move(FixItsForDiagnostic)});
   }
   return Result;
 }
 
 void ClangdUnit::dumpAST(llvm::raw_ostream &OS) const {
   Unit->getASTContext().getTranslationUnitDecl()->dump(OS, true);
 }
+
+} // namespace clangd
+} // namespace clang

clangd/ClangdUnitStore.cpp

 //===--- ClangdUnitStore.cpp - A ClangdUnits container -----------*-C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangdUnitStore.h"
 #include "llvm/Support/Path.h"
 
-using namespace clang::clangd;
-using namespace clang;
+namespace clang {
+namespace clangd {
 
 void ClangdUnitStore::removeUnitIfPresent(PathRef File) {
   std::lock_guard<std::mutex> Lock(Mutex);
 
   auto It = OpenedFiles.find(File);
   if (It == OpenedFiles.end())
     return;
   OpenedFiles.erase(It);
 }
 
-std::vector<tooling::CompileCommand> ClangdUnitStore::getCompileCommands(GlobalCompilationDatabase &CDB, PathRef File) {
+std::vector<tooling::CompileCommand>
+ClangdUnitStore::getCompileCommands(GlobalCompilationDatabase &CDB,
+                                    PathRef File) {
   std::vector<tooling::CompileCommand> Commands = CDB.getCompileCommands(File);
   if (Commands.empty()) {
     // Add a fake command line if we know nothing.
     Commands.push_back(tooling::CompileCommand(
         llvm::sys::path::parent_path(File), llvm::sys::path::filename(File),
         {"clang", "-fsyntax-only", File.str()}, ""));
   }
   return Commands;
 }
+
+} // namespace clangd
+} // namespace clang

clangd/DraftStore.cpp

 //===--- DraftStore.cpp - File contents container ---------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DraftStore.h"
 
-using namespace clang;
-using namespace clang::clangd;
+namespace clang {
+namespace clangd {
 
 VersionedDraft DraftStore::getDraft(PathRef File) const {
   std::lock_guard<std::mutex> Lock(Mutex);
 
   auto It = Drafts.find(File);
   if (It == Drafts.end())
     return {0, llvm::None};
   return It->second;

 DocVersion DraftStore::removeDraft(PathRef File) {
   std::lock_guard<std::mutex> Lock(Mutex);
 
   auto &Entry = Drafts[File];
   DocVersion NewVersion = ++Entry.Version;
   Entry.Draft = llvm::None;
   return NewVersion;
 }
+
+} // namespace clangd
+} // namespace clang

clangd/GlobalCompilationDatabase.cpp

 //===--- GlobalCompilationDatabase.cpp --------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
 #include "GlobalCompilationDatabase.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
-using namespace clang::clangd;
-using namespace clang;
+namespace clang {
+namespace clangd {
 
 std::vector<tooling::CompileCommand>
 DirectoryBasedGlobalCompilationDatabase::getCompileCommands(PathRef File) {
   std::vector<tooling::CompileCommand> Commands;
 
   auto CDB = getCompilationDatabase(File);
   if (!CDB)
     return {};
for (auto Path = path::parent_path(File); !Path.empty();
     return result;
   }
 
   // FIXME(ibiryukov): logging
   // Output.log("Failed to find compilation database for " + Twine(File) +
   // "\n");
   return nullptr;
 }
+
+} // namespace clangd
+} // namespace clang

clangd/JSONRPCDispatcher.cpp

 //===--- JSONRPCDispatcher.cpp - Main JSON parser entry point -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "JSONRPCDispatcher.h"
 #include "ProtocolHandlers.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/YAMLParser.h"
 #include <istream>
 
-using namespace clang;
-using namespace clangd;
+namespace clang {
+namespace clangd {
 
 void JSONOutput::writeMessage(const Twine &Message) {
   llvm::SmallString<128> Storage;
   StringRef M = Message.toStringRef(Storage);
 
   std::lock_guard<std::mutex> Guard(StreamMutex);
   // Log without headers.
   Logs << "--> " << M << '\n';

 void JSONRPCDispatcher::registerHandler(StringRef Method,
                                         std::unique_ptr<Handler> H) {
   assert(!Handlers.count(Method) && "Handler already registered!");
   Handlers[Method] = std::move(H);
 }
 
 static void
 callHandler(const llvm::StringMap<std::unique_ptr<Handler>> &Handlers,
-            llvm::yaml::ScalarNode *Method, llvm::yaml::ScalarNode *Id,
+            llvm::yaml::ScalarNode *Method, llvm::yaml::ScalarNode *ID,
             llvm::yaml::MappingNode *Params, Handler *UnknownHandler) {
   llvm::SmallString<10> MethodStorage;
   auto I = Handlers.find(Method->getValue(MethodStorage));
   auto *Handler = I != Handlers.end() ? I->second.get() : UnknownHandler;
-  if (Id)
-    Handler->handleMethod(Params, Id->getRawValue());
-  else
-    Handler->handleNotification(Params);
+  return (ID) ? Handler->handleMethod(Params, ID->getRawValue())
+              : Handler->handleNotification(Params);
 }
 
 bool JSONRPCDispatcher::call(StringRef Content) const {
   llvm::SourceMgr SM;
   llvm::yaml::Stream YAMLStream(Content, SM);
 
   auto Doc = YAMLStream.begin();
   if (Doc == YAMLStream.end())
for (auto &NextKeyValue : *Object) {
     StringRef KeyValue = KeyString->getValue(KeyStorage);
     llvm::yaml::Node *Value = NextKeyValue.getValue();
     if (!Value)
       return false;
 
     if (KeyValue == "jsonrpc") {
       // This should be "2.0". Always.
       Version = dyn_cast<llvm::yaml::ScalarNode>(Value);
-      if (!Version || Version->getRawValue() != "\"2.0\"")
+      if (!Version || Version->getRawValue() != R"("2.0")")
         return false;
     } else if (KeyValue == "method") {
       Method = dyn_cast<llvm::yaml::ScalarNode>(Value);
     } else if (KeyValue == "id") {
       Id = dyn_cast<llvm::yaml::ScalarNode>(Value);
     } else if (KeyValue == "params") {
       if (!Method)
         return false;
bool JSONRPCDispatcher::call(StringRef Content) const {
   // leftovers.
   if (!Method)
     return false;
   callHandler(Handlers, Method, Id, nullptr, UnknownHandler.get());
 
   return true;
 }
 
-void clangd::runLanguageServerLoop(std::istream &In, JSONOutput &Out,
-                                   JSONRPCDispatcher &Dispatcher,
-                                   bool &IsDone) {
+void runLanguageServerLoop(std::istream &In, JSONOutput &Out,
+                           JSONRPCDispatcher &Dispatcher, bool &IsDone) {
   while (In.good()) {
     // A Language Server Protocol message starts with a HTTP header, delimited
     // by \r\n.
     std::string Line;
     std::getline(In, Line);
     if (!In.good() && errno == EINTR) {
       In.clear();
       continue;
     }
 
     // Skip empty lines.
     llvm::StringRef LineRef(Line);
     if (LineRef.trim().empty())
       continue;
 
     // We allow YAML-style comments. Technically this isn't part of the
     // LSP specification, but makes writing tests easier.
+    // FIXME: It's probably worth to reflect that in documentation.
     if (LineRef.startswith("#"))
       continue;
 
     unsigned long long Len = 0;
     // FIXME: Content-Type is a specified header, but does nothing.
     // Content-Length is a mandatory header. It specifies the length of the
     // following JSON.
     if (LineRef.consume_front("Content-Length: "))
if (Len > 0) {
         Out.log("JSON dispatch failed!\n");
 
       // If we're done, exit the loop.
       if (IsDone)
         break;
     }
   }
 }
+
+} // namespace clangd
+} // namespace clang

clangd/Protocol.h

 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 
 struct URI {
   std::string uri;
-  std::string file;
+  std::string File;
 
   static URI fromUri(llvm::StringRef uri);
-  static URI fromFile(llvm::StringRef file);
+  static URI fromFile(llvm::StringRef Filename);
 
   static URI parse(llvm::yaml::ScalarNode *Param);
   static std::string unparse(const URI &U);
 };
 
 struct TextDocumentIdentifier {
   /// The text document's URI.
   URI uri;
 
   static llvm::Optional<TextDocumentIdentifier>
   parse(llvm::yaml::MappingNode *Params);
 };
 
 struct Position {
   /// Line position in a document (zero-based).
-  int line;
+  unsigned Line;
 
   /// Character offset on a line in a document (zero-based).
-  int character;
+  unsigned LineOffset;
 
   friend bool operator==(const Position &LHS, const Position &RHS) {
-    return std::tie(LHS.line, LHS.character) ==
-           std::tie(RHS.line, RHS.character);
+    return std::tie(LHS.Line, LHS.LineOffset) ==
+           std::tie(RHS.Line, RHS.LineOffset);
   }
+
   friend bool operator<(const Position &LHS, const Position &RHS) {
-    return std::tie(LHS.line, LHS.character) <
-           std::tie(RHS.line, RHS.character);
+    return std::tie(LHS.Line, LHS.LineOffset) <
+           std::tie(RHS.Line, RHS.LineOffset);
   }
 
   static llvm::Optional<Position> parse(llvm::yaml::MappingNode *Params);
   static std::string unparse(const Position &P);
 };
 
 struct Range {
   /// The range's start position.
-  Position start;
+  Position Start;
 
   /// The range's end position.
-  Position end;
+  Position End;
 
   friend bool operator==(const Range &LHS, const Range &RHS) {
-    return std::tie(LHS.start, LHS.end) == std::tie(RHS.start, RHS.end);
+    return std::tie(LHS.Start, LHS.End) == std::tie(RHS.Start, RHS.End);
   }
   friend bool operator<(const Range &LHS, const Range &RHS) {
-    return std::tie(LHS.start, LHS.end) < std::tie(RHS.start, RHS.end);
+    return std::tie(LHS.Start, LHS.End) < std::tie(RHS.Start, RHS.End);
   }
 
   static llvm::Optional<Range> parse(llvm::yaml::MappingNode *Params);
   static std::string unparse(const Range &P);
 };
 
 struct TextEdit {
   /// The range of the text document to be manipulated. To insert
   /// text into a document create a range where start === end.
-  Range range;
+  Range Range;
 
   /// The string to be inserted. For delete operations use an
   /// empty string.
-  std::string newText;
+  std::string NewText;
 
   static llvm::Optional<TextEdit> parse(llvm::yaml::MappingNode *Params);
   static std::string unparse(const TextEdit &P);
 };
 
 struct TextDocumentItem {
   /// The text document's URI.
   URI uri;
 
   /// The text document's language identifier.
-  std::string languageId;
+  std::string LanguageId;
 
   /// The version number of this document (it will strictly increase after each
-  int version;
+  int Version;
 
   /// The content of the opened text document.
-  std::string text;
+  std::string Text;
 
   static llvm::Optional<TextDocumentItem>
   parse(llvm::yaml::MappingNode *Params);
 };
 
 struct DidOpenTextDocumentParams {
   /// The document that was opened.
-  TextDocumentItem textDocument;
+  TextDocumentItem TextDocument;
 
   static llvm::Optional<DidOpenTextDocumentParams>
   parse(llvm::yaml::MappingNode *Params);
 };
 
 struct DidCloseTextDocumentParams {
   /// The document that was closed.
-  TextDocumentIdentifier textDocument;
+  TextDocumentIdentifier TextDocument;
 
   static llvm::Optional<DidCloseTextDocumentParams>
   parse(llvm::yaml::MappingNode *Params);
 };
 
 struct TextDocumentContentChangeEvent {
   /// The new text of the document.
-  std::string text;
+  std::string Text;
 
   static llvm::Optional<TextDocumentContentChangeEvent>
   parse(llvm::yaml::MappingNode *Params);
 };
 
 struct DidChangeTextDocumentParams {
   /// The document that did change. The version number points
   /// to the version after all provided content changes have
   /// been applied.
-  TextDocumentIdentifier textDocument;
+  TextDocumentIdentifier TextDocument;
 
   /// The actual content changes.
   std::vector<TextDocumentContentChangeEvent> contentChanges;
 
   static llvm::Optional<DidChangeTextDocumentParams>
   parse(llvm::yaml::MappingNode *Params);
 };
 
 struct FormattingOptions {
   /// Size of a tab in spaces.
-  int tabSize;
+  unsigned TabSize;
 
   /// Prefer spaces over tabs.
-  bool insertSpaces;
+  bool InsertSpaces;
 
   static llvm::Optional<FormattingOptions>
   parse(llvm::yaml::MappingNode *Params);
   static std::string unparse(const FormattingOptions &P);
 };
 
 struct DocumentRangeFormattingParams {
   /// The document to format.
-  TextDocumentIdentifier textDocument;
+  TextDocumentIdentifier TextDocument;
 
   /// The range to format
-  Range range;
+  Range FormatRange;
 
   /// The format options
-  FormattingOptions options;
+  FormattingOptions Options;
 
   static llvm::Optional<DocumentRangeFormattingParams>
   parse(llvm::yaml::MappingNode *Params);
 };
 
 struct DocumentOnTypeFormattingParams {
   /// The document to format.
-  TextDocumentIdentifier textDocument;
+  TextDocumentIdentifier TextDocument;
 
   /// The position at which this request was sent.
-  Position position;
+  Position RequestPosition;
 
   /// The character that has been typed.
-  std::string ch;
+  std::string TypedCharacter;
 
   /// The format options.
-  FormattingOptions options;
+  FormattingOptions Options;
 
   static llvm::Optional<DocumentOnTypeFormattingParams>
   parse(llvm::yaml::MappingNode *Params);
 };
 
 struct DocumentFormattingParams {
   /// The document to format.
-  TextDocumentIdentifier textDocument;
+  TextDocumentIdentifier TextDocument;
 
   /// The format options
-  FormattingOptions options;
+  FormattingOptions Options;
 
   static llvm::Optional<DocumentFormattingParams>
   parse(llvm::yaml::MappingNode *Params);
 };
 
 struct Diagnostic {
   /// The range at which the message applies.
-  Range range;
+  Range Range;
 
   /// The diagnostic's severity. Can be omitted. If omitted it is up to the
   /// client to interpret diagnostics as error, warning, info or hint.
-  int severity;
+  int Severity;
 
   /// The diagnostic's message.
-  std::string message;
+  std::string Message;
 
   friend bool operator==(const Diagnostic &LHS, const Diagnostic &RHS) {
-    return std::tie(LHS.range, LHS.severity, LHS.message) ==
-           std::tie(RHS.range, RHS.severity, RHS.message);
+    return std::tie(LHS.Range, LHS.Severity, LHS.Message) ==
+           std::tie(RHS.Range, RHS.Severity, RHS.Message);
   }
   friend bool operator<(const Diagnostic &LHS, const Diagnostic &RHS) {
-    return std::tie(LHS.range, LHS.severity, LHS.message) <
-           std::tie(RHS.range, RHS.severity, RHS.message);
+    return std::tie(LHS.Range, LHS.Severity, LHS.Message) <
+           std::tie(RHS.Range, RHS.Severity, RHS.Message);
   }
 
   static llvm::Optional<Diagnostic> parse(llvm::yaml::MappingNode *Params);
 };
 
 struct CodeActionContext {
   /// An array of diagnostics.
-  std::vector<Diagnostic> diagnostics;
+  std::vector<Diagnostic> Diagnostics;
 
   static llvm::Optional<CodeActionContext>
   parse(llvm::yaml::MappingNode *Params);
 };
 
 struct CodeActionParams {
   /// The document in which the command was invoked.
-  TextDocumentIdentifier textDocument;
+  TextDocumentIdentifier TextDocument;
 
   /// The range for which the command was invoked.
-  Range range;
+  Range Range;
 
   /// Context carrying additional information.
-  CodeActionContext context;
+  CodeActionContext Context;
 
   static llvm::Optional<CodeActionParams>
   parse(llvm::yaml::MappingNode *Params);
 };
 
 struct TextDocumentPositionParams {
   /// The text document.
-  TextDocumentIdentifier textDocument;
+  TextDocumentIdentifier TextDocument;
 
   /// The position inside the text document.
-  Position position;
+  Position Position;
 
   static llvm::Optional<TextDocumentPositionParams>
   parse(llvm::yaml::MappingNode *Params);
 };
 
 /// The kind of a completion entry.
 enum class CompletionItemKind {
   Missing = 0,
enum class InsertTextFormat {
   /// See also:
   /// https//github.com/Microsoft/vscode/blob/master/src/vs/editor/contrib/snippet/common/snippet.md
   Snippet = 2,
 };
 
 struct CompletionItem {
   /// The label of this completion item. By default also the text that is
   /// inserted when selecting this completion.
-  std::string label;
+  std::string Label;
 
   /// The kind of this completion item. Based of the kind an icon is chosen by
   /// the editor.
-  CompletionItemKind kind = CompletionItemKind::Missing;
+  CompletionItemKind Kind = CompletionItemKind::Missing;
 
   /// A human-readable string with additional information about this item, like
   /// type or symbol information.
-  std::string detail;
+  std::string Detail;
 
   /// A human-readable string that represents a doc-comment.
-  std::string documentation;
+  std::string Documentation;
 
   /// A string that should be used when comparing this item with other items.
   /// When `falsy` the label is used.
-  std::string sortText;
+  std::string SortText;
 
   /// A string that should be used when filtering a set of completion items.
   /// When `falsy` the label is used.
-  std::string filterText;
+  std::string FilterText;
 
   /// A string that should be inserted to a document when selecting this
   /// completion. When `falsy` the label is used.
-  std::string insertText;
+  std::string InsertText;
 
   /// The format of the insert text. The format applies to both the `insertText`
   /// property and the `newText` property of a provided `textEdit`.
-  InsertTextFormat insertTextFormat = InsertTextFormat::Missing;
+  InsertTextFormat InsertTextFormat = InsertTextFormat::Missing;
 
   /// An edit which is applied to a document when selecting this completion.
   /// When an edit is provided `insertText` is ignored.
   ///
   /// Note: The range of the edit must be a single line range and it must
   /// contain the position at which completion has been requested.
-  llvm::Optional<TextEdit> textEdit;
+  llvm::Optional<TextEdit> Edit;
 
   /// An optional array of additional text edits that are applied when selecting
   /// this completion. Edits must not overlap with the main edit nor with
   /// themselves.
-  std::vector<TextEdit> additionalTextEdits;
+  std::vector<TextEdit> AdditionalTextEdits;
 
   // TODO(krasimir): The following optional fields defined by the language
   // server protocol are unsupported:
   //
   // command?: Command - An optional command that is executed *after* inserting
   //                     this completion.
   //
   // data?: any - A data entry field that is preserved on a completion item
   //              between a completion and a completion resolve request.
   static std::string unparse(const CompletionItem &P);
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clangd/Protocol.cpp

 // FIXME: This is extremely repetetive and ugly. Is there a better way?
 //
 //===----------------------------------------------------------------------===//
 
 #include "Protocol.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Format.h"
-#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/Path.h"
-using namespace clang::clangd;
+#include "llvm/Support/raw_ostream.h"
 
+namespace clang {
+namespace clangd {
 
 URI URI::fromUri(llvm::StringRef uri) {
   URI Result;
   Result.uri = uri;
   uri.consume_front("file://");
   // Also trim authority-less URIs
   uri.consume_front("file:");
   // For Windows paths e.g. /X:
   if (uri.size() > 2 && uri[0] == '/' && uri[2] == ':')
     uri.consume_front("/");
   // Make sure that file paths are in native separators
-  Result.file = llvm::sys::path::convert_to_slash(uri);
+  Result.File = llvm::sys::path::convert_to_slash(uri);
   return Result;
 }
 
-URI URI::fromFile(llvm::StringRef file) {
+URI URI::fromFile(llvm::StringRef Filename) {
   using namespace llvm::sys;
   URI Result;
-  Result.file = file;
+  Result.File = Filename;
   Result.uri = "file://";
   // For Windows paths e.g. X:
-  if (file.size() > 1 && file[1] == ':')
+  if (Filename.size() > 1 && Filename[1] == ':')
     Result.uri += "/";
   // Make sure that uri paths are with posix separators
-  Result.uri += path::convert_to_slash(file, path::Style::posix);
+  Result.uri += path::convert_to_slash(Filename, path::Style::posix);
   return Result;
 }
 
 URI URI::parse(llvm::yaml::ScalarNode *Param) {
   llvm::SmallString<10> Storage;
   return URI::fromUri(Param->getValue(Storage));
 }
 
-std::string URI::unparse(const URI &U) {
-  return U.uri;
-}
+std::string URI::unparse(const URI &U) { return U.uri; }
 
 llvm::Optional<TextDocumentIdentifier>
 TextDocumentIdentifier::parse(llvm::yaml::MappingNode *Params) {
   TextDocumentIdentifier Result;
   for (auto &NextKeyValue : *Params) {
     auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
     if (!KeyString)
       return llvm::None;
for (auto &NextKeyValue : *Params) {
     if (!Value)
       return llvm::None;
 
     llvm::SmallString<10> Storage;
     if (KeyValue == "line") {
       long long Val;
       if (llvm::getAsSignedInteger(Value->getValue(Storage), 0, Val))
         return llvm::None;
-      Result.line = Val;
+      Result.Line = Val;
     } else if (KeyValue == "character") {
       long long Val;
       if (llvm::getAsSignedInteger(Value->getValue(Storage), 0, Val))
         return llvm::None;
-      Result.character = Val;
+      Result.LineOffset = Val;
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 std::string Position::unparse(const Position &P) {
   std::string Result;
   llvm::raw_string_ostream(Result)
-      << llvm::format(R"({"line": %d, "character": %d})", P.line, P.character);
+      << llvm::format(R"({"line": %d, "character": %d})", P.Line, P.LineOffset);
   return Result;
 }
 
 llvm::Optional<Range> Range::parse(llvm::yaml::MappingNode *Params) {
   Range Result;
   for (auto &NextKeyValue : *Params) {
     auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
     if (!KeyString)
       return llvm::None;
 
     llvm::SmallString<10> KeyStorage;
     StringRef KeyValue = KeyString->getValue(KeyStorage);
     auto *Value =
         dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
     if (!Value)
       return llvm::None;
 
     llvm::SmallString<10> Storage;
     if (KeyValue == "start") {
       auto Parsed = Position::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.start = std::move(*Parsed);
+      Result.Start = std::move(*Parsed);
     } else if (KeyValue == "end") {
       auto Parsed = Position::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.end = std::move(*Parsed);
+      Result.End = std::move(*Parsed);
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 std::string Range::unparse(const Range &P) {
   std::string Result;
   llvm::raw_string_ostream(Result) << llvm::format(
-      R"({"start": %s, "end": %s})", Position::unparse(P.start).c_str(),
-      Position::unparse(P.end).c_str());
+      R"({"start": %s, "end": %s})", Position::unparse(P.Start).c_str(),
+      Position::unparse(P.End).c_str());
   return Result;
 }
 
 llvm::Optional<TextDocumentItem>
 TextDocumentItem::parse(llvm::yaml::MappingNode *Params) {
   TextDocumentItem Result;
   for (auto &NextKeyValue : *Params) {
     auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
     if (!KeyString)
       return llvm::None;
 
     llvm::SmallString<10> KeyStorage;
     StringRef KeyValue = KeyString->getValue(KeyStorage);
     auto *Value =
         dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
     if (!Value)
       return llvm::None;
 
     llvm::SmallString<10> Storage;
     if (KeyValue == "uri") {
       Result.uri = URI::parse(Value);
     } else if (KeyValue == "languageId") {
-      Result.languageId = Value->getValue(Storage);
+      Result.LanguageId = Value->getValue(Storage);
     } else if (KeyValue == "version") {
       long long Val;
       if (llvm::getAsSignedInteger(Value->getValue(Storage), 0, Val))
         return llvm::None;
-      Result.version = Val;
+      Result.Version = Val;
     } else if (KeyValue == "text") {
-      Result.text = Value->getValue(Storage);
+      Result.Text = Value->getValue(Storage);
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 llvm::Optional<TextEdit> TextEdit::parse(llvm::yaml::MappingNode *Params) {
for (auto &NextKeyValue : *Params) {
     llvm::SmallString<10> Storage;
     if (KeyValue == "range") {
       auto *Map = dyn_cast<llvm::yaml::MappingNode>(Value);
       if (!Map)
         return llvm::None;
       auto Parsed = Range::parse(Map);
       if (!Parsed)
         return llvm::None;
-      Result.range = std::move(*Parsed);
+      Result.Range = std::move(*Parsed);
     } else if (KeyValue == "newText") {
       auto *Node = dyn_cast<llvm::yaml::ScalarNode>(Value);
       if (!Node)
         return llvm::None;
-      Result.newText = Node->getValue(Storage);
+      Result.NewText = Node->getValue(Storage);
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 std::string TextEdit::unparse(const TextEdit &P) {
   std::string Result;
   llvm::raw_string_ostream(Result) << llvm::format(
-      R"({"range": %s, "newText": "%s"})", Range::unparse(P.range).c_str(),
-      llvm::yaml::escape(P.newText).c_str());
+      R"({"range": %s, "newText": "%s"})", Range::unparse(P.Range).c_str(),
+      llvm::yaml::escape(P.NewText).c_str());
   return Result;
 }
 
 llvm::Optional<DidOpenTextDocumentParams>
 DidOpenTextDocumentParams::parse(llvm::yaml::MappingNode *Params) {
   DidOpenTextDocumentParams Result;
   for (auto &NextKeyValue : *Params) {
     auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
     if (!KeyString)
       return llvm::None;
 
     llvm::SmallString<10> KeyStorage;
     StringRef KeyValue = KeyString->getValue(KeyStorage);
     auto *Value =
         dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
     if (!Value)
       return llvm::None;
 
     llvm::SmallString<10> Storage;
     if (KeyValue == "textDocument") {
       auto Parsed = TextDocumentItem::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.textDocument = std::move(*Parsed);
+      Result.TextDocument = std::move(*Parsed);
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 llvm::Optional<DidCloseTextDocumentParams>
for (auto &NextKeyValue : *Params) {
 
     if (KeyValue == "textDocument") {
       auto *Map = dyn_cast<llvm::yaml::MappingNode>(Value);
       if (!Map)
         return llvm::None;
       auto Parsed = TextDocumentIdentifier::parse(Map);
       if (!Parsed)
         return llvm::None;
-      Result.textDocument = std::move(*Parsed);
+      Result.TextDocument = std::move(*Parsed);
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 llvm::Optional<DidChangeTextDocumentParams>
for (auto &NextKeyValue : *Params) {
     llvm::SmallString<10> Storage;
     if (KeyValue == "textDocument") {
       auto *Map = dyn_cast<llvm::yaml::MappingNode>(Value);
       if (!Map)
         return llvm::None;
       auto Parsed = TextDocumentIdentifier::parse(Map);
       if (!Parsed)
         return llvm::None;
-      Result.textDocument = std::move(*Parsed);
+      Result.TextDocument = std::move(*Parsed);
     } else if (KeyValue == "contentChanges") {
       auto *Seq = dyn_cast<llvm::yaml::SequenceNode>(Value);
       if (!Seq)
         return llvm::None;
       for (auto &Item : *Seq) {
         auto *I = dyn_cast<llvm::yaml::MappingNode>(&Item);
         if (!I)
           return llvm::None;
for (auto &NextKeyValue : *Params) {
     StringRef KeyValue = KeyString->getValue(KeyStorage);
     auto *Value =
         dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
     if (!Value)
       return llvm::None;
 
     llvm::SmallString<10> Storage;
     if (KeyValue == "text") {
-      Result.text = Value->getValue(Storage);
+      Result.Text = Value->getValue(Storage);
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 llvm::Optional<FormattingOptions>
for (auto &NextKeyValue : *Params) {
     if (!Value)
       return llvm::None;
 
     llvm::SmallString<10> Storage;
     if (KeyValue == "tabSize") {
       long long Val;
       if (llvm::getAsSignedInteger(Value->getValue(Storage), 0, Val))
         return llvm::None;
-      Result.tabSize = Val;
+      Result.TabSize = Val;
     } else if (KeyValue == "insertSpaces") {
       long long Val;
       StringRef Str = Value->getValue(Storage);
       if (llvm::getAsSignedInteger(Str, 0, Val)) {
         if (Str == "true")
           Val = 1;
         else if (Str == "false")
           Val = 0;
         else
           return llvm::None;
       }
-      Result.insertSpaces = Val;
+      Result.InsertSpaces = Val;
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 std::string FormattingOptions::unparse(const FormattingOptions &P) {
   std::string Result;
   llvm::raw_string_ostream(Result) << llvm::format(
-      R"({"tabSize": %d, "insertSpaces": %d})", P.tabSize, P.insertSpaces);
+      R"({"tabSize": %d, "insertSpaces": %d})", P.TabSize, P.InsertSpaces);
   return Result;
 }
 
 llvm::Optional<DocumentRangeFormattingParams>
 DocumentRangeFormattingParams::parse(llvm::yaml::MappingNode *Params) {
   DocumentRangeFormattingParams Result;
   for (auto &NextKeyValue : *Params) {
     auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
     if (!KeyString)
       return llvm::None;
 
     llvm::SmallString<10> KeyStorage;
     StringRef KeyValue = KeyString->getValue(KeyStorage);
     auto *Value =
         dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
     if (!Value)
       return llvm::None;
 
     llvm::SmallString<10> Storage;
     if (KeyValue == "textDocument") {
       auto Parsed = TextDocumentIdentifier::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.textDocument = std::move(*Parsed);
+      Result.TextDocument = std::move(*Parsed);
     } else if (KeyValue == "range") {
       auto Parsed = Range::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.range = std::move(*Parsed);
+      Result.FormatRange = std::move(*Parsed);
     } else if (KeyValue == "options") {
       auto Parsed = FormattingOptions::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.options = std::move(*Parsed);
+      Result.Options = std::move(*Parsed);
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 llvm::Optional<DocumentOnTypeFormattingParams>
 DocumentOnTypeFormattingParams::parse(llvm::yaml::MappingNode *Params) {
   DocumentOnTypeFormattingParams Result;
   for (auto &NextKeyValue : *Params) {
     auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
     if (!KeyString)
       return llvm::None;
 
     llvm::SmallString<10> KeyStorage;
     StringRef KeyValue = KeyString->getValue(KeyStorage);
 
     if (KeyValue == "ch") {
       auto *ScalarValue =
           dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
       if (!ScalarValue)
         return llvm::None;
       llvm::SmallString<10> Storage;
-      Result.ch = ScalarValue->getValue(Storage);
+      Result.TypedCharacter = ScalarValue->getValue(Storage);
       continue;
     }
 
     auto *Value =
         dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
     if (!Value)
       return llvm::None;
     if (KeyValue == "textDocument") {
       auto Parsed = TextDocumentIdentifier::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.textDocument = std::move(*Parsed);
+      Result.TextDocument = std::move(*Parsed);
     } else if (KeyValue == "position") {
       auto Parsed = Position::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.position = std::move(*Parsed);
+      Result.RequestPosition = std::move(*Parsed);
     } else if (KeyValue == "options") {
       auto Parsed = FormattingOptions::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.options = std::move(*Parsed);
+      Result.Options = std::move(*Parsed);
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 llvm::Optional<DocumentFormattingParams>
for (auto &NextKeyValue : *Params) {
     if (!Value)
       return llvm::None;
 
     llvm::SmallString<10> Storage;
     if (KeyValue == "textDocument") {
       auto Parsed = TextDocumentIdentifier::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.textDocument = std::move(*Parsed);
+      Result.TextDocument = std::move(*Parsed);
     } else if (KeyValue == "options") {
       auto Parsed = FormattingOptions::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.options = std::move(*Parsed);
+      Result.Options = std::move(*Parsed);
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 llvm::Optional<Diagnostic> Diagnostic::parse(llvm::yaml::MappingNode *Params) {
for (auto &NextKeyValue : *Params) {
     if (KeyValue == "range") {
       auto *Value =
           dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
       if (!Value)
         return llvm::None;
       auto Parsed = Range::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.range = std::move(*Parsed);
+      Result.Range = std::move(*Parsed);
     } else if (KeyValue == "severity") {
       auto *Value =
           dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
       if (!Value)
         return llvm::None;
       long long Val;
       if (llvm::getAsSignedInteger(Value->getValue(Storage), 0, Val))
         return llvm::None;
-      Result.severity = Val;
+      Result.Severity = Val;
     } else if (KeyValue == "message") {
       auto *Value =
           dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
       if (!Value)
         return llvm::None;
-      Result.message = Value->getValue(Storage);
+      Result.Message = Value->getValue(Storage);
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 llvm::Optional<CodeActionContext>
if (KeyValue == "diagnostics") {
         return llvm::None;
       for (auto &Item : *Seq) {
         auto *I = dyn_cast<llvm::yaml::MappingNode>(&Item);
         if (!I)
           return llvm::None;
         auto Parsed = Diagnostic::parse(I);
         if (!Parsed)
           return llvm::None;
-        Result.diagnostics.push_back(std::move(*Parsed));
+        Result.Diagnostics.push_back(std::move(*Parsed));
       }
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
for (auto &NextKeyValue : *Params) {
     if (!Value)
       return llvm::None;
 
     llvm::SmallString<10> Storage;
     if (KeyValue == "textDocument") {
       auto Parsed = TextDocumentIdentifier::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.textDocument = std::move(*Parsed);
+      Result.TextDocument = std::move(*Parsed);
     } else if (KeyValue == "range") {
       auto Parsed = Range::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.range = std::move(*Parsed);
+      Result.Range = std::move(*Parsed);
     } else if (KeyValue == "context") {
       auto Parsed = CodeActionContext::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.context = std::move(*Parsed);
+      Result.Context = std::move(*Parsed);
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 llvm::Optional<TextDocumentPositionParams>
for (auto &NextKeyValue : *Params) {
     if (!Value)
       continue;
 
     llvm::SmallString<10> Storage;
     if (KeyValue == "textDocument") {
       auto Parsed = TextDocumentIdentifier::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.textDocument = std::move(*Parsed);
+      Result.TextDocument = std::move(*Parsed);
     } else if (KeyValue == "position") {
       auto Parsed = Position::parse(Value);
       if (!Parsed)
         return llvm::None;
-      Result.position = std::move(*Parsed);
+      Result.Position = std::move(*Parsed);
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
 
 std::string CompletionItem::unparse(const CompletionItem &CI) {
   std::string Result = "{";
-  llvm::raw_string_ostream Os(Result);
+  llvm::raw_string_ostream OS(Result);
   assert(!CI.label.empty() && "completion item label is required");
-  Os << R"("label":")" << llvm::yaml::escape(CI.label) << R"(",)";
-  if (CI.kind != CompletionItemKind::Missing)
-    Os << R"("kind":)" << static_cast<int>(CI.kind) << R"(,)";
-  if (!CI.detail.empty())
-    Os << R"("detail":")" << llvm::yaml::escape(CI.detail) << R"(",)";
-  if (!CI.documentation.empty())
-    Os << R"("documentation":")" << llvm::yaml::escape(CI.documentation)
+  OS << R"("label":")" << llvm::yaml::escape(CI.Label) << R"(",)";
+  if (CI.Kind != CompletionItemKind::Missing)
+    OS << R"("kind":)" << static_cast<int>(CI.Kind) << R"(,)";
+  if (!CI.Detail.empty())
+    OS << R"("detail":")" << llvm::yaml::escape(CI.Detail) << R"(",)";
+  if (!CI.Documentation.empty())
+    OS << R"("documentation":")" << llvm::yaml::escape(CI.Documentation)
        << R"(",)";
-  if (!CI.sortText.empty())
-    Os << R"("sortText":")" << llvm::yaml::escape(CI.sortText) << R"(",)";
-  if (!CI.filterText.empty())
-    Os << R"("filterText":")" << llvm::yaml::escape(CI.filterText) << R"(",)";
-  if (!CI.insertText.empty())
-    Os << R"("insertText":")" << llvm::yaml::escape(CI.insertText) << R"(",)";
-  if (CI.insertTextFormat != InsertTextFormat::Missing) {
-    Os << R"("insertTextFormat":")" << static_cast<int>(CI.insertTextFormat)
+  if (!CI.SortText.empty())
+    OS << R"("sortText":")" << llvm::yaml::escape(CI.SortText) << R"(",)";
+  if (!CI.FilterText.empty())
+    OS << R"("filterText":")" << llvm::yaml::escape(CI.FilterText) << R"(",)";
+  if (!CI.InsertText.empty())
+    OS << R"("insertText":")" << llvm::yaml::escape(CI.InsertText) << R"(",)";
+  if (CI.InsertTextFormat != InsertTextFormat::Missing) {
+    OS << R"("insertTextFormat":")" << static_cast<int>(CI.InsertTextFormat)
        << R"(",)";
   }
-  if (CI.textEdit)
-    Os << R"("textEdit":)" << TextEdit::unparse(*CI.textEdit) << ',';
-  if (!CI.additionalTextEdits.empty()) {
-    Os << R"("additionalTextEdits":[)";
-    for (const auto &Edit : CI.additionalTextEdits)
-      Os << TextEdit::unparse(Edit) << ",";
-    Os.flush();
+  if (CI.Edit)
+    OS << R"("textEdit":)" << TextEdit::unparse(*CI.Edit) << ',';
+  if (!CI.AdditionalTextEdits.empty()) {
+    OS << R"("additionalTextEdits":[)";
+    for (const auto &Edit : CI.AdditionalTextEdits)
+      OS << TextEdit::unparse(Edit) << ",";
+    OS.flush();
     // The list additionalTextEdits is guaranteed nonempty at this point.
     // Replace the trailing comma with right brace.
     Result.back() = ']';
   }
-  Os.flush();
+  OS.flush();
   // Label is required, so Result is guaranteed to have a trailing comma.
   Result.back() = '}';
   return Result;
 }
+
+} // namespace clangd
+} // namespace clang

clangd/ProtocolHandlers.cpp

 //===--- ProtocolHandlers.cpp - LSP callbacks -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ProtocolHandlers.h"
 #include "ClangdLSPServer.h"
 #include "ClangdServer.h"
 #include "DraftStore.h"
-using namespace clang;
-using namespace clangd;
+
+namespace clang {
+namespace clangd {
 
 namespace {
 
 struct InitializeHandler : Handler {
   InitializeHandler(JSONOutput &Output, ProtocolCallbacks &Callbacks)
       : Handler(Output), Callbacks(Callbacks) {}
 
   void handleMethod(llvm::yaml::MappingNode *Params, StringRef ID) override {
struct CompletionHandler : Handler {
   }
 
 private:
   ProtocolCallbacks &Callbacks;
 };
 
 } // namespace
 
-void clangd::regiterCallbackHandlers(JSONRPCDispatcher &Dispatcher,
+void regiterCallbackHandlers(JSONRPCDispatcher &Dispatcher,
                                      JSONOutput &Out,
                                      ProtocolCallbacks &Callbacks) {
   Dispatcher.registerHandler(
       "initialize", llvm::make_unique<InitializeHandler>(Out, Callbacks));
   Dispatcher.registerHandler(
       "shutdown", llvm::make_unique<ShutdownHandler>(Out, Callbacks));
   Dispatcher.registerHandler(
       "textDocument/didOpen",
Dispatcher.registerHandler(
       llvm::make_unique<TextDocumentFormattingHandler>(Out, Callbacks));
   Dispatcher.registerHandler(
       "textDocument/codeAction",
       llvm::make_unique<CodeActionHandler>(Out, Callbacks));
   Dispatcher.registerHandler(
       "textDocument/completion",
       llvm::make_unique<CompletionHandler>(Out, Callbacks));
 }
+
+} // namespace clangd
+} // namespace clang

clangd/tool/ClangdMain.cpp

 #include <memory>
 #include <string>
 
 using namespace clang;
 using namespace clang::clangd;
 
 static llvm::cl::opt<bool>
     RunSynchronously("run-synchronously",
-                     llvm::cl::desc("parse on main thread"),
+                     llvm::cl::desc("Parse code in main thread"),
                      llvm::cl::init(false), llvm::cl::Hidden);
 
 int main(int argc, char *argv[]) {
   llvm::cl::ParseCommandLineOptions(argc, argv, "clangd");
 
   llvm::raw_ostream &Outs = llvm::outs();
   llvm::raw_ostream &Logs = llvm::errs();
   JSONOutput Out(Outs, Logs);
 
   // Change stdin to binary to not lose \r\n on windows.
   llvm::sys::ChangeStdinToBinary();
 
   ClangdLSPServer LSPServer(Out, RunSynchronously);
   LSPServer.run(std::cin);
 }

unittests/clangd/ClangdTests.cpp

 public:
   void onDiagnosticsReady(PathRef File,
                           Tagged<std::vector<DiagWithFixIts>> Diagnostics) override {
     bool HadError = false;
     for (const auto &DiagAndFixIts : Diagnostics.Value) {
       // FIXME: severities returned by clangd should have a descriptive
       // diagnostic severity enum
       const int ErrorSeverity = 1;
-      HadError = DiagAndFixIts.Diag.severity == ErrorSeverity;
+      HadError = DiagAndFixIts.Diag.Severity == ErrorSeverity;
     }
 
     std::lock_guard<std::mutex> Lock(Mutex);
     HadErrorInLastDiags = HadError;
     LastVFSTag = Diagnostics.Tag;
   }
 
   bool hadErrorInLastDiags() {
TEST_F(ClangdVFSTest, CheckVersions) {
   EXPECT_EQ(DiagConsumer.lastVFSTag(), FS.Tag);
   EXPECT_EQ(Server.codeComplete(FooCpp, Position{0, 0}).Tag, FS.Tag);
 }
 
 class ClangdCompletionTest : public ClangdVFSTest {
 protected:
   bool ContainsItem(std::vector<CompletionItem> const &Items, StringRef Name) {
     for (const auto &Item : Items) {
-      if (Item.insertText == Name)
+      if (Item.InsertText == Name)
         return true;
     }
     return false;
   }
 };
 
 TEST_F(ClangdCompletionTest, CheckContentsOverride) {
   MockFSProvider FS;