[clangd][NFC] Improve clangd status messages

[qchateau]

Summary

clangd actions have various naming schemes, the most
common being PascalCase. This commit applies PascalCase
to all clangd actions, and fix the status rendering
in renderTUAction to look more consistent.

[sammccall]

Thanks! Changes to ClangdServer are definitely good, I'm less sure about renderTUAction.

clang-tools-extra/clangd/TUScheduler.cpp

1197

Hmm, I'm not sure if this is more consistent or just different.

In vscode I think this currently renders as "clangd: running CallHierarchy", and after this change it's "clangd: Running CallHierarchy". I'm not sure we need a capital letter here?

1222

(if we do change this, this needs to be capitalized too)

[qchateau]

• dont capitalize first letter of status

[sammccall]

Thanks, LG - want me to land it?

[qchateau]

Sure !
Email: [e-mail]

I guess I'll need to ask for commit access

[sammccall]

It's up to you - it's easy for me/others to land them on your behalf. Having your own commit access gives you more control, ability to deal with build breakages quickly, fix trivial things without review etc.

clang-tools-extra/clangd/ClangdServer.cpp

void ClangdServer::typeHierarchy(PathRef File, Position Pos, int Resolve,
   auto Action = [File = File.str(), Pos, Resolve, Direction, CB = std::move(CB),
                  this](Expected<InputsAndAST> InpAST) mutable {
     if (!InpAST)
       return CB(InpAST.takeError());
     CB(clangd::getTypeHierarchy(InpAST->AST, Pos, Resolve, Direction, Index,
                                 File));
   };
 
-  WorkScheduler.runWithAST("Type Hierarchy", File, std::move(Action));
+  WorkScheduler.runWithAST("TypeHierarchy", File, std::move(Action));
 }
 
 void ClangdServer::resolveTypeHierarchy(
     TypeHierarchyItem Item, int Resolve, TypeHierarchyDirection Direction,
     Callback<llvm::Optional<TypeHierarchyItem>> CB) {
   WorkScheduler.run(
       "Resolve Type Hierarchy", "", [=, CB = std::move(CB)]() mutable {
         clangd::resolveTypeHierarchy(Item, Resolve, Direction, Index);
         CB(Item);
       });
 }
 
 void ClangdServer::prepareCallHierarchy(
     PathRef File, Position Pos, Callback<std::vector<CallHierarchyItem>> CB) {
   auto Action = [File = File.str(), Pos,
                  CB = std::move(CB)](Expected<InputsAndAST> InpAST) mutable {
     if (!InpAST)
       return CB(InpAST.takeError());
     CB(clangd::prepareCallHierarchy(InpAST->AST, Pos, File));
   };
-  WorkScheduler.runWithAST("Call Hierarchy", File, std::move(Action));
+  WorkScheduler.runWithAST("CallHierarchy", File, std::move(Action));
 }
 
 void ClangdServer::incomingCalls(
     const CallHierarchyItem &Item,
     Callback<std::vector<CallHierarchyIncomingCall>> CB) {
   WorkScheduler.run("Incoming Calls", "",
                     [CB = std::move(CB), Item, this]() mutable {
                       CB(clangd::incomingCalls(Item, Index));

 void ClangdServer::documentSymbols(llvm::StringRef File,
                                    Callback<std::vector<DocumentSymbol>> CB) {
   auto Action =
       [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
         if (!InpAST)
           return CB(InpAST.takeError());
         CB(clangd::getDocumentSymbols(InpAST->AST));
       };
-  WorkScheduler.runWithAST("documentSymbols", File, std::move(Action),
+  WorkScheduler.runWithAST("DocumentSymbols", File, std::move(Action),
                            TUScheduler::InvalidateOnUpdate);
 }
 
 void ClangdServer::foldingRanges(llvm::StringRef File,
                                  Callback<std::vector<FoldingRange>> CB) {
   auto Action =
       [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
         if (!InpAST)
           return CB(InpAST.takeError());
         CB(clangd::getFoldingRanges(InpAST->AST));
       };
-  WorkScheduler.runWithAST("foldingRanges", File, std::move(Action),
+  WorkScheduler.runWithAST("FoldingRanges", File, std::move(Action),
                            TUScheduler::InvalidateOnUpdate);
 }
 
 void ClangdServer::findImplementations(
     PathRef File, Position Pos, Callback<std::vector<LocatedSymbol>> CB) {
   auto Action = [Pos, CB = std::move(CB),
                  this](llvm::Expected<InputsAndAST> InpAST) mutable {
     if (!InpAST)

clang-tools-extra/clangd/TUScheduler.cpp

bool ASTWorker::blockUntilIdle(Deadline Timeout) const {
   // Finally make sure ASTWorker has processed all of the preamble updates.
   return WaitUntilASTWorkerIsIdle();
 }
 
 // Render a TUAction to a user-facing string representation.
 // TUAction represents clangd-internal states, we don't intend to expose them
 // to users (say C++ programmers) directly to avoid confusion, we use terms that
 // are familiar by C++ programmers.
 std::string renderTUAction(const PreambleAction PA, const ASTAction &AA) {
   llvm::SmallVector<std::string, 2> Result;
   switch (PA) {
   case PreambleAction::Building:
     Result.push_back("parsing includes");
     break;
   case PreambleAction::Idle:
     // We handle idle specially below.
     break;
   }
   switch (AA.K) {
   case ASTAction::Queued:
     Result.push_back("file is queued");
     break;
   case ASTAction::RunningAction:
     Result.push_back("running " + AA.Name);
     break;
   case ASTAction::Building:
     Result.push_back("parsing main file");
     break;
   case ASTAction::Idle:
     // We handle idle specially below.
     break;
   }
   if (Result.empty())
     return "idle";
-  return llvm::join(Result, ",");
+  return llvm::join(Result, ", ");
 }
 
 } // namespace
 
 unsigned getDefaultAsyncThreadsCount() {
   return llvm::heavyweight_hardware_concurrency().compute_thread_count();
 }