[clangd] Enable folding ranges by default.

[Trass3r]

Whenever I tried this option in the past it crashed clangd.
I recommend doing some more testing before flipping the switch.

[kadircet]

clang-tools-extra/clangd/tool/ClangdMain.cpp

337–338

i think we should just retire the flag altogether, ATM this is only preventing clangdlspserver from announcing the capability.

the only benefit of keeping it as a flag is, we can turn it off quickly if its crashing constantly. but we should fix those crashes instead. so do you mind:

• moving it to be near other retiredflags (around line 320)
• always announce foldingrangeprovider capability and bind the method in clangdlspserver.cpp
• get rid of the option inside clangdserver.h

[kadircet]

In D132919#3757685, @Trass3r wrote:

Whenever I tried this option in the past it crashed clangd.
I recommend doing some more testing before flipping the switch.

we've a new implementation of folding ranges based on pseudo parsing now. hence no more crashes 🎉

[usaxena95]

Addressed comments.

[kadircet]

thanks, lgtm!

clang-tools-extra/clangd/ClangdLSPServer.cpp

llvm::json::Object ServerCaps{
       // extension we really have support for the standardized one as well.
       {"standardTypeHierarchyProvider", true}, // clangd extension
       {"memoryUsageProvider", true},           // clangd extension
       {"compilationDatabase",                  // clangd extension
        llvm::json::Object{{"automaticReload", true}}},
       {"callHierarchyProvider", true},
       {"clangdInlayHintsProvider", true},
       {"inlayHintProvider", true},
+      {"foldingRangeProvider", true},
   };
 
   {
     LSPBinder Binder(Handlers, *this);
     bindMethods(Binder, Params.capabilities);
     if (Opts.FeatureModules)
       for (auto &Mod : *Opts.FeatureModules)
         Mod.initializeLSP(Binder, Params.rawCapabilities, ServerCaps);
void ClangdLSPServer::onInitialize(const InitializeParams &Params,
   ServerCaps["codeActionProvider"] =
       Params.capabilities.CodeActionStructure
           ? llvm::json::Object{{"codeActionKinds",
                                 {CodeAction::QUICKFIX_KIND,
                                  CodeAction::REFACTOR_KIND,
                                  CodeAction::INFO_KIND}}}
           : llvm::json::Value(true);
 
-  if (Opts.FoldingRanges)
-    ServerCaps["foldingRangeProvider"] = true;
 
   std::vector<llvm::StringRef> Commands;
   for (llvm::StringRef Command : Handlers.CommandHandlers.keys())
     Commands.push_back(Command);
   llvm::sort(Commands);
   ServerCaps["executeCommandProvider"] =
       llvm::json::Object{{"commands", Commands}};
 
void ClangdLSPServer::bindMethods(LSPBinder &Bind,
   Bind.method("callHierarchy/incomingCalls", this, &ClangdLSPServer::onCallHierarchyIncomingCalls);
   Bind.method("textDocument/selectionRange", this, &ClangdLSPServer::onSelectionRange);
   Bind.method("textDocument/documentLink", this, &ClangdLSPServer::onDocumentLink);
   Bind.method("textDocument/semanticTokens/full", this, &ClangdLSPServer::onSemanticTokens);
   Bind.method("textDocument/semanticTokens/full/delta", this, &ClangdLSPServer::onSemanticTokensDelta);
   Bind.method("clangd/inlayHints", this, &ClangdLSPServer::onClangdInlayHints);
   Bind.method("textDocument/inlayHint", this, &ClangdLSPServer::onInlayHint);
   Bind.method("$/memoryUsage", this, &ClangdLSPServer::onMemoryUsage);
-  if (Opts.FoldingRanges)
-    Bind.method("textDocument/foldingRange", this, &ClangdLSPServer::onFoldingRange);
   Bind.command(ApplyFixCommand, this, &ClangdLSPServer::onCommandApplyEdit);
   Bind.command(ApplyTweakCommand, this, &ClangdLSPServer::onCommandApplyTweak);
 
   ApplyWorkspaceEdit = Bind.outgoingMethod("workspace/applyEdit");
   PublishDiagnostics = Bind.outgoingNotification("textDocument/publishDiagnostics");
   ShowMessage = Bind.outgoingNotification("window/showMessage");
   NotifyFileStatus = Bind.outgoingNotification("textDocument/clangd.fileStatus");
   CreateWorkDoneProgress = Bind.outgoingMethod("window/workDoneProgress/create");

clang-tools-extra/clangd/ClangdServer.h

struct Options {
     /// likely implicitly generated, and avoids redundant work if clients forget
     /// to cancel. Clients that always cancel stale requests should clear this.
     bool ImplicitCancellation = true;
 
     /// Clangd will execute compiler drivers matching one of these globs to
     /// fetch system include path.
     std::vector<std::string> QueryDriverGlobs;
 
-    /// Enable preview of FoldingRanges feature.
-    bool FoldingRanges = false;
-
     // Whether the client supports folding only complete lines.
     bool LineFoldingOnly = false;
 
     FeatureModuleSet *FeatureModules = nullptr;
     /// If true, use the dirty buffer contents when building Preambles.
     bool UseDirtyHeaders = false;
 
     // If true, parse emplace-like functions in the preamble.

clang-tools-extra/clangd/test/initialize-params.test

 # CHECK-NEXT:      "documentRangeFormattingProvider": true,
 # CHECK-NEXT:      "documentSymbolProvider": true,
 # CHECK-NEXT:      "executeCommandProvider": {
 # CHECK-NEXT:        "commands": [
 # CHECK-NEXT:          "clangd.applyFix",
 # CHECK-NEXT:          "clangd.applyTweak"
 # CHECK-NEXT:        ]
 # CHECK-NEXT:      },
+# CHECK-NEXT:      "foldingRangeProvider": true,
 # CHECK-NEXT:      "hoverProvider": true,
 # CHECK-NEXT:      "implementationProvider": true,
 # CHECK-NEXT:      "inlayHintProvider": true,
 # CHECK-NEXT:      "memoryUsageProvider": true,
 # CHECK-NEXT:      "referencesProvider": true,
 # CHECK-NEXT:      "renameProvider": true,
 # CHECK-NEXT:      "selectionRangeProvider": true,
 # CHECK-NEXT:      "semanticTokensProvider": {

clang-tools-extra/clangd/tool/ClangdMain.cpp

 RetiredFlag<bool> SuggestMissingIncludes("suggest-missing-includes");
 RetiredFlag<bool> RecoveryAST("recovery-ast");
 RetiredFlag<bool> RecoveryASTType("recovery-ast-type");
 RetiredFlag<bool> AsyncPreamble("async-preamble");
 RetiredFlag<bool> CollectMainFileRefs("collect-main-file-refs");
 RetiredFlag<bool> CrossFileRename("cross-file-rename");
 RetiredFlag<std::string> ClangTidyChecks("clang-tidy-checks");
 RetiredFlag<std::string> InlayHints("inlay-hints");
+RetiredFlag<std::string> FoldingRanges("folding-ranges");
+
 
 opt<int> LimitResults{
     "limit-results",
     cat(Features),
     desc("Limit the number of results returned by clangd. "
          "0 means no limit (default=100)"),
     init(100),
 };
 
 opt<int> ReferencesLimit{
     "limit-references",
     cat(Features),
     desc("Limit the number of references returned by clangd. "
          "0 means no limit (default=1000)"),
     init(1000),
 };
 
 list<std::string> TweakList{
     "tweaks",
     cat(Features),
     desc("Specify a list of Tweaks to enable (only for clangd developers)."),
     Hidden,
     CommaSeparated,
 };
 
-opt<bool> FoldingRanges{
-    "folding-ranges",
-    cat(Features),
-    desc("Enable preview of FoldingRanges feature"),
-    init(false),
-    Hidden,
-};
-
 opt<unsigned> WorkerThreadsCount{
     "j",
     cat(Misc),
     desc("Number of async workers used by clangd. Background index also "
          "uses this many workers."),
     init(getDefaultAsyncThreadsCount()),
 };
 
 opt<Path> IndexFile{
if (StaticIdx) {
     IdxStack.emplace_back(std::move(StaticIdx));
     IdxStack.emplace_back(
         std::make_unique<MergedIndex>(PAI.get(), IdxStack.back().get()));
     Opts.StaticIndex = IdxStack.back().get();
   } else {
     Opts.StaticIndex = PAI.get();
   }
   Opts.AsyncThreadsCount = WorkerThreadsCount;
-  Opts.FoldingRanges = FoldingRanges;
   Opts.MemoryCleanup = getMemoryCleanupFunction();
 
   Opts.CodeComplete.IncludeIneligibleResults = IncludeIneligibleResults;
   Opts.CodeComplete.Limit = LimitResults;
   if (CompletionStyle.getNumOccurrences())
     Opts.CodeComplete.BundleOverloads = CompletionStyle != Detailed;
   Opts.CodeComplete.ShowOrigins = ShowOrigins;
   Opts.CodeComplete.InsertIncludes = HeaderInsertion;