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

   1 //===--- ClangdMain.cpp - clangd server loop ------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "ClangdMain.h"
  10 #include "ClangdLSPServer.h"
  11 #include "CodeComplete.h"
  12 #include "Compiler.h"
  13 #include "Config.h"
  14 #include "ConfigProvider.h"
  15 #include "Feature.h"
  16 #include "IncludeCleaner.h"
  17 #include "PathMapping.h"
  18 #include "Protocol.h"
  19 #include "TidyProvider.h"
  20 #include "Transport.h"
  21 #include "index/Background.h"
  22 #include "index/Index.h"
  23 #include "index/MemIndex.h"
  24 #include "index/Merge.h"
  25 #include "index/ProjectAware.h"
  26 #include "index/remote/Client.h"
  27 #include "support/Path.h"
  28 #include "support/Shutdown.h"
  29 #include "support/ThreadCrashReporter.h"
  30 #include "support/ThreadsafeFS.h"
  31 #include "support/Trace.h"
  32 #include "clang/Basic/Stack.h"
  33 #include "clang/Format/Format.h"
  34 #include "llvm/ADT/SmallString.h"
  35 #include "llvm/ADT/StringRef.h"
  36 #include "llvm/Support/CommandLine.h"
  37 #include "llvm/Support/FileSystem.h"
  38 #include "llvm/Support/InitLLVM.h"
  39 #include "llvm/Support/Path.h"
  40 #include "llvm/Support/Process.h"
  41 #include "llvm/Support/Program.h"
  42 #include "llvm/Support/Signals.h"
  43 #include "llvm/Support/TargetSelect.h"
  44 #include "llvm/Support/raw_ostream.h"
  45 #include <chrono>
  46 #include <cstdlib>
  47 #include <memory>
  48 #include <mutex>
  49 #include <optional>
  50 #include <string>
  51 #include <thread>
  52 #include <utility>
  53 #include <vector>
  54
  55 #ifndef _WIN32
  56 #include <unistd.h>
  57 #endif
  58
  59 #ifdef __GLIBC__
  60 #include <malloc.h>
  61 #endif
  62
  63 namespace clang {
  64 namespace clangd {
  65
  66 // Implemented in Check.cpp.
  67 bool check(const llvm::StringRef File, const ThreadsafeFS &TFS,
  68            const ClangdLSPServer::Options &Opts);
  69
  70 namespace {
  71
  72 using llvm::cl::cat;
  73 using llvm::cl::CommaSeparated;
  74 using llvm::cl::desc;
  75 using llvm::cl::Hidden;
  76 using llvm::cl::init;
  77 using llvm::cl::list;
  78 using llvm::cl::opt;
  79 using llvm::cl::OptionCategory;
  80 using llvm::cl::ValueOptional;
  81 using llvm::cl::values;
  82
  83 // All flags must be placed in a category, or they will be shown neither in
  84 // --help, nor --help-hidden!
  85 OptionCategory CompileCommands("clangd compilation flags options");
  86 OptionCategory Features("clangd feature options");
  87 OptionCategory Misc("clangd miscellaneous options");
  88 OptionCategory Protocol("clangd protocol and logging options");
  89 OptionCategory Retired("clangd flags no longer in use");
  90 const OptionCategory *ClangdCategories[] = {&Features, &Protocol,
  91                                             &CompileCommands, &Misc, &Retired};
  92
  93 template <typename T> class RetiredFlag {
  94   opt<T> Option;
  95
  96 public:
  97   RetiredFlag(llvm::StringRef Name)
  98       : Option(Name, cat(Retired), desc("Obsolete flag, ignored"), Hidden,
  99                llvm::cl::callback([Name](const T &) {
 100                  llvm::errs()
 101                      << "The flag `-" << Name << "` is obsolete and ignored.\n";
 102                })) {}
 103 };
 104
 105 enum CompileArgsFrom { LSPCompileArgs, FilesystemCompileArgs };
 106 opt<CompileArgsFrom> CompileArgsFrom{
 107     "compile_args_from",
 108     cat(CompileCommands),
 109     desc("The source of compile commands"),
 110     values(clEnumValN(LSPCompileArgs, "lsp",
 111                       "All compile commands come from LSP and "
 112                       "'compile_commands.json' files are ignored"),
 113            clEnumValN(FilesystemCompileArgs, "filesystem",
 114                       "All compile commands come from the "
 115                       "'compile_commands.json' files")),
 116     init(FilesystemCompileArgs),
 117     Hidden,
 118 };
 119
 120 opt<Path> CompileCommandsDir{
 121     "compile-commands-dir",
 122     cat(CompileCommands),
 123     desc("Specify a path to look for compile_commands.json. If path "
 124          "is invalid, clangd will look in the current directory and "
 125          "parent paths of each source file"),
 126 };
 127
 128 opt<Path> ResourceDir{
 129     "resource-dir",
 130     cat(CompileCommands),
 131     desc("Directory for system clang headers"),
 132     init(""),
 133     Hidden,
 134 };
 135
 136 list<std::string> QueryDriverGlobs{
 137     "query-driver",
 138     cat(CompileCommands),
 139     desc(
 140         "Comma separated list of globs for white-listing gcc-compatible "
 141         "drivers that are safe to execute. Drivers matching any of these globs "
 142         "will be used to extract system includes. e.g. "
 143         "/usr/bin/**/clang-*,/path/to/repo/**/g++-*"),
 144     CommaSeparated,
 145 };
 146
 147 // FIXME: Flags are the wrong mechanism for user preferences.
 148 // We should probably read a dotfile or similar.
 149 opt<bool> AllScopesCompletion{
 150     "all-scopes-completion",
 151     cat(Features),
 152     desc("If set to true, code completion will include index symbols that are "
 153          "not defined in the scopes (e.g. "
 154          "namespaces) visible from the code completion point. Such completions "
 155          "can insert scope qualifiers"),
 156     init(true),
 157 };
 158
 159 opt<bool> ShowOrigins{
 160     "debug-origin",
 161     cat(Features),
 162     desc("Show origins of completion items"),
 163     init(CodeCompleteOptions().ShowOrigins),
 164     Hidden,
 165 };
 166
 167 opt<bool> EnableBackgroundIndex{
 168     "background-index",
 169     cat(Features),
 170     desc("Index project code in the background and persist index on disk."),
 171     init(true),
 172 };
 173
 174 opt<llvm::ThreadPriority> BackgroundIndexPriority{
 175     "background-index-priority",
 176     cat(Features),
 177     desc("Thread priority for building the background index. "
 178          "The effect of this flag is OS-specific."),
 179     values(clEnumValN(llvm::ThreadPriority::Background, "background",
 180                       "Minimum priority, runs on idle CPUs. "
 181                       "May leave 'performance' cores unused."),
 182            clEnumValN(llvm::ThreadPriority::Low, "low",
 183                       "Reduced priority compared to interactive work."),
 184            clEnumValN(llvm::ThreadPriority::Default, "normal",
 185                       "Same priority as other clangd work.")),
 186     init(llvm::ThreadPriority::Low),
 187 };
 188
 189 opt<bool> EnableClangTidy{
 190     "clang-tidy",
 191     cat(Features),
 192     desc("Enable clang-tidy diagnostics"),
 193     init(true),
 194 };
 195
 196 opt<CodeCompleteOptions::CodeCompletionParse> CodeCompletionParse{
 197     "completion-parse",
 198     cat(Features),
 199     desc("Whether the clang-parser is used for code-completion"),
 200     values(clEnumValN(CodeCompleteOptions::AlwaysParse, "always",
 201                       "Block until the parser can be used"),
 202            clEnumValN(CodeCompleteOptions::ParseIfReady, "auto",
 203                       "Use text-based completion if the parser "
 204                       "is not ready"),
 205            clEnumValN(CodeCompleteOptions::NeverParse, "never",
 206                       "Always used text-based completion")),
 207     init(CodeCompleteOptions().RunParser),
 208     Hidden,
 209 };
 210
 211 opt<CodeCompleteOptions::CodeCompletionRankingModel> RankingModel{
 212     "ranking-model",
 213     cat(Features),
 214     desc("Model to use to rank code-completion items"),
 215     values(clEnumValN(CodeCompleteOptions::Heuristics, "heuristics",
 216                       "Use heuristics to rank code completion items"),
 217            clEnumValN(CodeCompleteOptions::DecisionForest, "decision_forest",
 218                       "Use Decision Forest model to rank completion items")),
 219     init(CodeCompleteOptions().RankingModel),
 220     Hidden,
 221 };
 222
 223 // FIXME: also support "plain" style where signatures are always omitted.
 224 enum CompletionStyleFlag { Detailed, Bundled };
 225 opt<CompletionStyleFlag> CompletionStyle{
 226     "completion-style",
 227     cat(Features),
 228     desc("Granularity of code completion suggestions"),
 229     values(clEnumValN(Detailed, "detailed",
 230                       "One completion item for each semantically distinct "
 231                       "completion, with full type information"),
 232            clEnumValN(Bundled, "bundled",
 233                       "Similar completion items (e.g. function overloads) are "
 234                       "combined. Type information shown where possible")),
 235 };
 236
 237 opt<std::string> FallbackStyle{
 238     "fallback-style",
 239     cat(Features),
 240     desc("clang-format style to apply by default when "
 241          "no .clang-format file is found"),
 242     init(clang::format::DefaultFallbackStyle),
 243 };
 244
 245 opt<int> EnableFunctionArgSnippets{
 246     "function-arg-placeholders",
 247     cat(Features),
 248     desc("When disabled (0), completions contain only parentheses for "
 249          "function calls. When enabled (1), completions also contain "
 250          "placeholders for method parameters"),
 251     init(-1),
 252 };
 253
 254 opt<CodeCompleteOptions::IncludeInsertion> HeaderInsertion{
 255     "header-insertion",
 256     cat(Features),
 257     desc("Add #include directives when accepting code completions"),
 258     init(CodeCompleteOptions().InsertIncludes),
 259     values(
 260         clEnumValN(CodeCompleteOptions::IWYU, "iwyu",
 261                    "Include what you use. "
 262                    "Insert the owning header for top-level symbols, unless the "
 263                    "header is already directly included or the symbol is "
 264                    "forward-declared"),
 265         clEnumValN(
 266             CodeCompleteOptions::NeverInsert, "never",
 267             "Never insert #include directives as part of code completion")),
 268 };
 269
 270 opt<bool> ImportInsertions{
 271     "import-insertions",
 272     cat(Features),
 273     desc("If header insertion is enabled, add #import directives when "
 274          "accepting code completions or fixing includes in Objective-C code"),
 275     init(CodeCompleteOptions().ImportInsertions),
 276 };
 277
 278 opt<bool> HeaderInsertionDecorators{
 279     "header-insertion-decorators",
 280     cat(Features),
 281     desc("Prepend a circular dot or space before the completion "
 282          "label, depending on whether "
 283          "an include line will be inserted or not"),
 284     init(true),
 285 };
 286
 287 opt<bool> HiddenFeatures{
 288     "hidden-features",
 289     cat(Features),
 290     desc("Enable hidden features mostly useful to clangd developers"),
 291     init(false),
 292     Hidden,
 293 };
 294
 295 opt<bool> IncludeIneligibleResults{
 296     "include-ineligible-results",
 297     cat(Features),
 298     desc("Include ineligible completion results (e.g. private members)"),
 299     init(CodeCompleteOptions().IncludeIneligibleResults),
 300     Hidden,
 301 };
 302
 303 RetiredFlag<bool> EnableIndex("index");
 304 RetiredFlag<bool> SuggestMissingIncludes("suggest-missing-includes");
 305 RetiredFlag<bool> RecoveryAST("recovery-ast");
 306 RetiredFlag<bool> RecoveryASTType("recovery-ast-type");
 307 RetiredFlag<bool> AsyncPreamble("async-preamble");
 308 RetiredFlag<bool> CollectMainFileRefs("collect-main-file-refs");
 309 RetiredFlag<bool> CrossFileRename("cross-file-rename");
 310 RetiredFlag<std::string> ClangTidyChecks("clang-tidy-checks");
 311 RetiredFlag<bool> InlayHints("inlay-hints");
 312 RetiredFlag<bool> FoldingRanges("folding-ranges");
 313 RetiredFlag<bool> IncludeCleanerStdlib("include-cleaner-stdlib");
 314
 315 opt<int> LimitResults{
 316     "limit-results",
 317     cat(Features),
 318     desc("Limit the number of results returned by clangd. "
 319          "0 means no limit (default=100)"),
 320     init(100),
 321 };
 322
 323 opt<int> ReferencesLimit{
 324     "limit-references",
 325     cat(Features),
 326     desc("Limit the number of references returned by clangd. "
 327          "0 means no limit (default=1000)"),
 328     init(1000),
 329 };
 330
 331 opt<int> RenameFileLimit{
 332     "rename-file-limit",
 333     cat(Features),
 334     desc("Limit the number of files to be affected by symbol renaming. "
 335          "0 means no limit (default=50)"),
 336     init(50),
 337 };
 338
 339 list<std::string> TweakList{
 340     "tweaks",
 341     cat(Features),
 342     desc("Specify a list of Tweaks to enable (only for clangd developers)."),
 343     Hidden,
 344     CommaSeparated,
 345 };
 346
 347 opt<unsigned> WorkerThreadsCount{
 348     "j",
 349     cat(Misc),
 350     desc("Number of async workers used by clangd. Background index also "
 351          "uses this many workers."),
 352     init(getDefaultAsyncThreadsCount()),
 353 };
 354
 355 opt<Path> IndexFile{
 356     "index-file",
 357     cat(Misc),
 358     desc(
 359         "Index file to build the static index. The file must have been created "
 360         "by a compatible clangd-indexer\n"
 361         "WARNING: This option is experimental only, and will be removed "
 362         "eventually. Don't rely on it"),
 363     init(""),
 364     Hidden,
 365 };
 366
 367 opt<bool> Test{
 368     "lit-test",
 369     cat(Misc),
 370     desc("Abbreviation for -input-style=delimited -pretty -sync "
 371          "-enable-test-scheme -enable-config=0 -log=verbose -crash-pragmas. "
 372          "Also sets config options: Index.StandardLibrary=false. "
 373          "Intended to simplify lit tests"),
 374     init(false),
 375     Hidden,
 376 };
 377
 378 opt<bool> CrashPragmas{
 379     "crash-pragmas",
 380     cat(Misc),
 381     desc("Respect `#pragma clang __debug crash` and friends."),
 382     init(false),
 383     Hidden,
 384 };
 385
 386 opt<Path> CheckFile{
 387     "check",
 388     cat(Misc),
 389     desc("Parse one file in isolation instead of acting as a language server. "
 390          "Useful to investigate/reproduce crashes or configuration problems. "
 391          "With --check=<filename>, attempts to parse a particular file."),
 392     init(""),
 393     ValueOptional,
 394 };
 395
 396 enum PCHStorageFlag { Disk, Memory };
 397 opt<PCHStorageFlag> PCHStorage{
 398     "pch-storage",
 399     cat(Misc),
 400     desc("Storing PCHs in memory increases memory usages, but may "
 401          "improve performance"),
 402     values(
 403         clEnumValN(PCHStorageFlag::Disk, "disk", "store PCHs on disk"),
 404         clEnumValN(PCHStorageFlag::Memory, "memory", "store PCHs in memory")),
 405     init(PCHStorageFlag::Disk),
 406 };
 407
 408 opt<bool> Sync{
 409     "sync",
 410     cat(Misc),
 411     desc("Handle client requests on main thread. Background index still uses "
 412          "its own thread."),
 413     init(false),
 414     Hidden,
 415 };
 416
 417 opt<JSONStreamStyle> InputStyle{
 418     "input-style",
 419     cat(Protocol),
 420     desc("Input JSON stream encoding"),
 421     values(
 422         clEnumValN(JSONStreamStyle::Standard, "standard", "usual LSP protocol"),
 423         clEnumValN(JSONStreamStyle::Delimited, "delimited",
 424                    "messages delimited by --- lines, with # comment support")),
 425     init(JSONStreamStyle::Standard),
 426     Hidden,
 427 };
 428
 429 opt<bool> EnableTestScheme{
 430     "enable-test-uri-scheme",
 431     cat(Protocol),
 432     desc("Enable 'test:' URI scheme. Only use in lit tests"),
 433     init(false),
 434     Hidden,
 435 };
 436
 437 opt<std::string> PathMappingsArg{
 438     "path-mappings",
 439     cat(Protocol),
 440     desc(
 441         "Translates between client paths (as seen by a remote editor) and "
 442         "server paths (where clangd sees files on disk). "
 443         "Comma separated list of '<client_path>=<server_path>' pairs, the "
 444         "first entry matching a given path is used. "
 445         "e.g. /home/project/incl=/opt/include,/home/project=/workarea/project"),
 446     init(""),
 447 };
 448
 449 opt<Path> InputMirrorFile{
 450     "input-mirror-file",
 451     cat(Protocol),
 452     desc("Mirror all LSP input to the specified file. Useful for debugging"),
 453     init(""),
 454     Hidden,
 455 };
 456
 457 opt<Logger::Level> LogLevel{
 458     "log",
 459     cat(Protocol),
 460     desc("Verbosity of log messages written to stderr"),
 461     values(clEnumValN(Logger::Error, "error", "Error messages only"),
 462            clEnumValN(Logger::Info, "info", "High level execution tracing"),
 463            clEnumValN(Logger::Debug, "verbose", "Low level details")),
 464     init(Logger::Info),
 465 };
 466
 467 opt<OffsetEncoding> ForceOffsetEncoding{
 468     "offset-encoding",
 469     cat(Protocol),
 470     desc("Force the offsetEncoding used for character positions. "
 471          "This bypasses negotiation via client capabilities"),
 472     values(
 473         clEnumValN(OffsetEncoding::UTF8, "utf-8", "Offsets are in UTF-8 bytes"),
 474         clEnumValN(OffsetEncoding::UTF16, "utf-16",
 475                    "Offsets are in UTF-16 code units"),
 476         clEnumValN(OffsetEncoding::UTF32, "utf-32",
 477                    "Offsets are in unicode codepoints")),
 478     init(OffsetEncoding::UnsupportedEncoding),
 479 };
 480
 481 opt<bool> PrettyPrint{
 482     "pretty",
 483     cat(Protocol),
 484     desc("Pretty-print JSON output"),
 485     init(false),
 486 };
 487
 488 opt<bool> EnableConfig{
 489     "enable-config",
 490     cat(Misc),
 491     desc(
 492         "Read user and project configuration from YAML files.\n"
 493         "Project config is from a .clangd file in the project directory.\n"
 494         "User config is from clangd/config.yaml in the following directories:\n"
 495         "\tWindows: %USERPROFILE%\\AppData\\Local\n"
 496         "\tMac OS: ~/Library/Preferences/\n"
 497         "\tOthers: $XDG_CONFIG_HOME, usually ~/.config\n"
 498         "Configuration is documented at https://clangd.llvm.org/config.html"),
 499     init(true),
 500 };
 501
 502 opt<bool> UseDirtyHeaders{"use-dirty-headers", cat(Misc),
 503                           desc("Use files open in the editor when parsing "
 504                                "headers instead of reading from the disk"),
 505                           Hidden,
 506                           init(ClangdServer::Options().UseDirtyHeaders)};
 507
 508 opt<bool> PreambleParseForwardingFunctions{
 509     "parse-forwarding-functions",
 510     cat(Misc),
 511     desc("Parse all emplace-like functions in included headers"),
 512     Hidden,
 513     init(ParseOptions().PreambleParseForwardingFunctions),
 514 };
 515
 516 #if defined(__GLIBC__) && CLANGD_MALLOC_TRIM
 517 opt<bool> EnableMallocTrim{
 518     "malloc-trim",
 519     cat(Misc),
 520     desc("Release memory periodically via malloc_trim(3)."),
 521     init(true),
 522 };
 523
 524 std::function<void()> getMemoryCleanupFunction() {
 525   if (!EnableMallocTrim)
 526     return nullptr;
 527   // Leave a few MB at the top of the heap: it is insignificant
 528   // and will most likely be needed by the main thread
 529   constexpr size_t MallocTrimPad = 20'000'000;
 530   return []() {
 531     if (malloc_trim(MallocTrimPad))
 532       vlog("Released memory via malloc_trim");
 533   };
 534 }
 535 #else
 536 std::function<void()> getMemoryCleanupFunction() { return nullptr; }
 537 #endif
 538
 539 #if CLANGD_ENABLE_REMOTE
 540 opt<std::string> RemoteIndexAddress{
 541     "remote-index-address",
 542     cat(Features),
 543     desc("Address of the remote index server"),
 544 };
 545
 546 // FIXME(kirillbobyrev): Should this be the location of compile_commands.json?
 547 opt<std::string> ProjectRoot{
 548     "project-root",
 549     cat(Features),
 550     desc("Path to the project root. Requires remote-index-address to be set."),
 551 };
 552 #endif
 553
 554 opt<bool> ExperimentalModulesSupport{
 555     "experimental-modules-support",
 556     cat(Features),
 557     desc("Experimental support for standard c++ modules"),
 558     init(false),
 559 };
 560
 561 /// Supports a test URI scheme with relaxed constraints for lit tests.
 562 /// The path in a test URI will be combined with a platform-specific fake
 563 /// directory to form an absolute path. For example, test:///a.cpp is resolved
 564 /// C:\clangd-test\a.cpp on Windows and /clangd-test/a.cpp on Unix.
 565 class TestScheme : public URIScheme {
 566 public:
 567   llvm::Expected<std::string>
 568   getAbsolutePath(llvm::StringRef /*Authority*/, llvm::StringRef Body,
 569                   llvm::StringRef /*HintPath*/) const override {
 570     using namespace llvm::sys;
 571     // Still require "/" in body to mimic file scheme, as we want lengths of an
 572     // equivalent URI in both schemes to be the same.
 573     if (!Body.starts_with("/"))
 574       return error(
 575           "Expect URI body to be an absolute path starting with '/': {0}",
 576           Body);
 577     Body = Body.ltrim('/');
 578     llvm::SmallString<16> Path(Body);
 579     path::native(Path);
 580     fs::make_absolute(TestScheme::TestDir, Path);
 581     return std::string(Path);
 582   }
 583
 584   llvm::Expected<URI>
 585   uriFromAbsolutePath(llvm::StringRef AbsolutePath) const override {
 586     llvm::StringRef Body = AbsolutePath;
 587     if (!Body.consume_front(TestScheme::TestDir))
 588       return error("Path {0} doesn't start with root {1}", AbsolutePath,
 589                    TestDir);
 590
 591     return URI("test", /*Authority=*/"",
 592                llvm::sys::path::convert_to_slash(Body));
 593   }
 594
 595 private:
 596   const static char TestDir[];
 597 };
 598
 599 #ifdef _WIN32
 600 const char TestScheme::TestDir[] = "C:\\clangd-test";
 601 #else
 602 const char TestScheme::TestDir[] = "/clangd-test";
 603 #endif
 604
 605 std::unique_ptr<SymbolIndex>
 606 loadExternalIndex(const Config::ExternalIndexSpec &External,
 607                   AsyncTaskRunner *Tasks) {
 608   static const trace::Metric RemoteIndexUsed("used_remote_index",
 609                                              trace::Metric::Value, "address");
 610   switch (External.Kind) {
 611   case Config::ExternalIndexSpec::None:
 612     break;
 613   case Config::ExternalIndexSpec::Server:
 614     RemoteIndexUsed.record(1, External.Location);
 615     log("Associating {0} with remote index at {1}.", External.MountPoint,
 616         External.Location);
 617     return remote::getClient(External.Location, External.MountPoint);
 618   case Config::ExternalIndexSpec::File:
 619     log("Associating {0} with monolithic index at {1}.", External.MountPoint,
 620         External.Location);
 621     auto NewIndex = std::make_unique<SwapIndex>(std::make_unique<MemIndex>());
 622     auto IndexLoadTask = [File = External.Location,
 623                           PlaceHolder = NewIndex.get()] {
 624       if (auto Idx = loadIndex(File, SymbolOrigin::Static, /*UseDex=*/true))
 625         PlaceHolder->reset(std::move(Idx));
 626     };
 627     if (Tasks) {
 628       Tasks->runAsync("Load-index:" + External.Location,
 629                       std::move(IndexLoadTask));
 630     } else {
 631       IndexLoadTask();
 632     }
 633     return std::move(NewIndex);
 634   }
 635   llvm_unreachable("Invalid ExternalIndexKind.");
 636 }
 637
 638 class FlagsConfigProvider : public config::Provider {
 639 private:
 640   config::CompiledFragment Frag;
 641
 642   std::vector<config::CompiledFragment>
 643   getFragments(const config::Params &,
 644                config::DiagnosticCallback) const override {
 645     return {Frag};
 646   }
 647
 648 public:
 649   FlagsConfigProvider() {
 650     std::optional<Config::CDBSearchSpec> CDBSearch;
 651     std::optional<Config::ExternalIndexSpec> IndexSpec;
 652     std::optional<Config::BackgroundPolicy> BGPolicy;
 653     std::optional<Config::ArgumentListsPolicy> ArgumentLists;
 654
 655     // If --compile-commands-dir arg was invoked, check value and override
 656     // default path.
 657     if (!CompileCommandsDir.empty()) {
 658       if (llvm::sys::fs::exists(CompileCommandsDir)) {
 659         // We support passing both relative and absolute paths to the
 660         // --compile-commands-dir argument, but we assume the path is absolute
 661         // in the rest of clangd so we make sure the path is absolute before
 662         // continuing.
 663         llvm::SmallString<128> Path(CompileCommandsDir);
 664         if (std::error_code EC = llvm::sys::fs::make_absolute(Path)) {
 665           elog("Error while converting the relative path specified by "
 666                "--compile-commands-dir to an absolute path: {0}. The argument "
 667                "will be ignored.",
 668                EC.message());
 669         } else {
 670           CDBSearch = {Config::CDBSearchSpec::FixedDir, Path.str().str()};
 671         }
 672       } else {
 673         elog("Path specified by --compile-commands-dir does not exist. The "
 674              "argument will be ignored.");
 675       }
 676     }
 677     if (!IndexFile.empty()) {
 678       Config::ExternalIndexSpec Spec;
 679       Spec.Kind = Spec.File;
 680       Spec.Location = IndexFile;
 681       IndexSpec = std::move(Spec);
 682     }
 683 #if CLANGD_ENABLE_REMOTE
 684     if (!RemoteIndexAddress.empty()) {
 685       assert(!ProjectRoot.empty() && IndexFile.empty());
 686       Config::ExternalIndexSpec Spec;
 687       Spec.Kind = Spec.Server;
 688       Spec.Location = RemoteIndexAddress;
 689       Spec.MountPoint = ProjectRoot;
 690       IndexSpec = std::move(Spec);
 691       BGPolicy = Config::BackgroundPolicy::Skip;
 692     }
 693 #endif
 694     if (!EnableBackgroundIndex) {
 695       BGPolicy = Config::BackgroundPolicy::Skip;
 696     }
 697
 698     if (EnableFunctionArgSnippets >= 0) {
 699       ArgumentLists = EnableFunctionArgSnippets
 700                           ? Config::ArgumentListsPolicy::FullPlaceholders
 701                           : Config::ArgumentListsPolicy::Delimiters;
 702     }
 703
 704     Frag = [=](const config::Params &, Config &C) {
 705       if (CDBSearch)
 706         C.CompileFlags.CDBSearch = *CDBSearch;
 707       if (IndexSpec)
 708         C.Index.External = *IndexSpec;
 709       if (BGPolicy)
 710         C.Index.Background = *BGPolicy;
 711       if (ArgumentLists)
 712         C.Completion.ArgumentLists = *ArgumentLists;
 713       if (AllScopesCompletion.getNumOccurrences())
 714         C.Completion.AllScopes = AllScopesCompletion;
 715
 716       if (Test)
 717         C.Index.StandardLibrary = false;
 718       return true;
 719     };
 720   }
 721 };
 722 } // namespace
 723
 724 enum class ErrorResultCode : int {
 725   NoShutdownRequest = 1,
 726   CantRunAsXPCService = 2,
 727   CheckFailed = 3
 728 };
 729
 730 int clangdMain(int argc, char *argv[]) {
 731   // Clang could run on the main thread. e.g., when the flag '-check' or '-sync'
 732   // is enabled.
 733   clang::noteBottomOfStack();
 734   llvm::InitLLVM X(argc, argv);
 735   llvm::InitializeAllTargetInfos();
 736   llvm::sys::AddSignalHandler(
 737       [](void *) {
 738         ThreadCrashReporter::runCrashHandlers();
 739         // Ensure ThreadCrashReporter and PrintStackTrace output is visible.
 740         llvm::errs().flush();
 741       },
 742       nullptr);
 743   llvm::sys::SetInterruptFunction(&requestShutdown);
 744   llvm::cl::SetVersionPrinter([](llvm::raw_ostream &OS) {
 745     OS << versionString() << "\n"
 746        << "Features: " << featureString() << "\n"
 747        << "Platform: " << platformString() << "\n";
 748   });
 749   const char *FlagsEnvVar = "CLANGD_FLAGS";
 750   const char *Overview =
 751       R"(clangd is a language server that provides IDE-like features to editors.
 752
 753 It should be used via an editor plugin rather than invoked directly. For more information, see:
 754         https://clangd.llvm.org/
 755         https://microsoft.github.io/language-server-protocol/
 756
 757 clangd accepts flags on the commandline, and in the CLANGD_FLAGS environment variable.
 758 )";
 759   llvm::cl::HideUnrelatedOptions(ClangdCategories);
 760   llvm::cl::ParseCommandLineOptions(argc, argv, Overview,
 761                                     /*Errs=*/nullptr, FlagsEnvVar);
 762   if (Test) {
 763     if (!Sync.getNumOccurrences())
 764       Sync = true;
 765     if (!CrashPragmas.getNumOccurrences())
 766       CrashPragmas = true;
 767     InputStyle = JSONStreamStyle::Delimited;
 768     LogLevel = Logger::Verbose;
 769     PrettyPrint = true;
 770     // Disable config system by default to avoid external reads.
 771     if (!EnableConfig.getNumOccurrences())
 772       EnableConfig = false;
 773     // Disable background index on lit tests by default to prevent disk writes.
 774     if (!EnableBackgroundIndex.getNumOccurrences())
 775       EnableBackgroundIndex = false;
 776     // Ensure background index makes progress.
 777     else if (EnableBackgroundIndex)
 778       BackgroundQueue::preventThreadStarvationInTests();
 779   }
 780   if (Test || EnableTestScheme) {
 781     static URISchemeRegistry::Add<TestScheme> X(
 782         "test", "Test scheme for clangd lit tests.");
 783   }
 784   if (CrashPragmas)
 785     allowCrashPragmasForTest();
 786
 787   if (!Sync && WorkerThreadsCount == 0) {
 788     llvm::errs() << "A number of worker threads cannot be 0. Did you mean to "
 789                     "specify -sync?";
 790     return 1;
 791   }
 792
 793   if (Sync) {
 794     if (WorkerThreadsCount.getNumOccurrences())
 795       llvm::errs() << "Ignoring -j because -sync is set.\n";
 796     WorkerThreadsCount = 0;
 797   }
 798   if (FallbackStyle.getNumOccurrences())
 799     clang::format::DefaultFallbackStyle = FallbackStyle.c_str();
 800
 801   // Validate command line arguments.
 802   std::optional<llvm::raw_fd_ostream> InputMirrorStream;
 803   if (!InputMirrorFile.empty()) {
 804     std::error_code EC;
 805     InputMirrorStream.emplace(InputMirrorFile, /*ref*/ EC,
 806                               llvm::sys::fs::FA_Read | llvm::sys::fs::FA_Write);
 807     if (EC) {
 808       InputMirrorStream.reset();
 809       llvm::errs() << "Error while opening an input mirror file: "
 810                    << EC.message();
 811     } else {
 812       InputMirrorStream->SetUnbuffered();
 813     }
 814   }
 815
 816 #if !CLANGD_DECISION_FOREST
 817   if (RankingModel == clangd::CodeCompleteOptions::DecisionForest) {
 818     llvm::errs() << "Clangd was compiled without decision forest support.\n";
 819     return 1;
 820   }
 821 #endif
 822
 823   // Setup tracing facilities if CLANGD_TRACE is set. In practice enabling a
 824   // trace flag in your editor's config is annoying, launching with
 825   // `CLANGD_TRACE=trace.json vim` is easier.
 826   std::optional<llvm::raw_fd_ostream> TracerStream;
 827   std::unique_ptr<trace::EventTracer> Tracer;
 828   const char *JSONTraceFile = getenv("CLANGD_TRACE");
 829   const char *MetricsCSVFile = getenv("CLANGD_METRICS");
 830   const char *TracerFile = JSONTraceFile ? JSONTraceFile : MetricsCSVFile;
 831   if (TracerFile) {
 832     std::error_code EC;
 833     TracerStream.emplace(TracerFile, /*ref*/ EC,
 834                          llvm::sys::fs::FA_Read | llvm::sys::fs::FA_Write);
 835     if (EC) {
 836       TracerStream.reset();
 837       llvm::errs() << "Error while opening trace file " << TracerFile << ": "
 838                    << EC.message();
 839     } else {
 840       Tracer = (TracerFile == JSONTraceFile)
 841                    ? trace::createJSONTracer(*TracerStream, PrettyPrint)
 842                    : trace::createCSVMetricTracer(*TracerStream);
 843     }
 844   }
 845
 846   std::optional<trace::Session> TracingSession;
 847   if (Tracer)
 848     TracingSession.emplace(*Tracer);
 849
 850   // If a user ran `clangd` in a terminal without redirecting anything,
 851   // it's somewhat likely they're confused about how to use clangd.
 852   // Show them the help overview, which explains.
 853   if (llvm::outs().is_displayed() && llvm::errs().is_displayed() &&
 854       !CheckFile.getNumOccurrences())
 855     llvm::errs() << Overview << "\n";
 856   // Use buffered stream to stderr (we still flush each log message). Unbuffered
 857   // stream can cause significant (non-deterministic) latency for the logger.
 858   llvm::errs().SetBuffered();
 859   StreamLogger Logger(llvm::errs(), LogLevel);
 860   LoggingSession LoggingSession(Logger);
 861   // Write some initial logs before we start doing any real work.
 862   log("{0}", versionString());
 863   log("Features: {0}", featureString());
 864   log("PID: {0}", llvm::sys::Process::getProcessId());
 865   {
 866     SmallString<128> CWD;
 867     if (auto Err = llvm::sys::fs::current_path(CWD))
 868       log("Working directory unknown: {0}", Err.message());
 869     else
 870       log("Working directory: {0}", CWD);
 871   }
 872   for (int I = 0; I < argc; ++I)
 873     log("argv[{0}]: {1}", I, argv[I]);
 874   if (auto EnvFlags = llvm::sys::Process::GetEnv(FlagsEnvVar))
 875     log("{0}: {1}", FlagsEnvVar, *EnvFlags);
 876
 877   ClangdLSPServer::Options Opts;
 878   Opts.UseDirBasedCDB = (CompileArgsFrom == FilesystemCompileArgs);
 879   Opts.EnableExperimentalModulesSupport = ExperimentalModulesSupport;
 880
 881   switch (PCHStorage) {
 882   case PCHStorageFlag::Memory:
 883     Opts.StorePreamblesInMemory = true;
 884     break;
 885   case PCHStorageFlag::Disk:
 886     Opts.StorePreamblesInMemory = false;
 887     break;
 888   }
 889   if (!ResourceDir.empty())
 890     Opts.ResourceDir = ResourceDir;
 891   Opts.BuildDynamicSymbolIndex = true;
 892   std::vector<std::unique_ptr<SymbolIndex>> IdxStack;
 893 #if CLANGD_ENABLE_REMOTE
 894   if (RemoteIndexAddress.empty() != ProjectRoot.empty()) {
 895     llvm::errs() << "remote-index-address and project-path have to be "
 896                     "specified at the same time.";
 897     return 1;
 898   }
 899   if (!RemoteIndexAddress.empty()) {
 900     if (IndexFile.empty()) {
 901       log("Connecting to remote index at {0}", RemoteIndexAddress);
 902     } else {
 903       elog("When enabling remote index, IndexFile should not be specified. "
 904            "Only one can be used at time. Remote index will ignored.");
 905     }
 906   }
 907 #endif
 908   Opts.BackgroundIndex = EnableBackgroundIndex;
 909   Opts.BackgroundIndexPriority = BackgroundIndexPriority;
 910   Opts.ReferencesLimit = ReferencesLimit;
 911   Opts.Rename.LimitFiles = RenameFileLimit;
 912   auto PAI = createProjectAwareIndex(loadExternalIndex, Sync);
 913   Opts.StaticIndex = PAI.get();
 914   Opts.AsyncThreadsCount = WorkerThreadsCount;
 915   Opts.MemoryCleanup = getMemoryCleanupFunction();
 916
 917   Opts.CodeComplete.IncludeIneligibleResults = IncludeIneligibleResults;
 918   Opts.CodeComplete.Limit = LimitResults;
 919   if (CompletionStyle.getNumOccurrences())
 920     Opts.CodeComplete.BundleOverloads = CompletionStyle != Detailed;
 921   Opts.CodeComplete.ShowOrigins = ShowOrigins;
 922   Opts.CodeComplete.InsertIncludes = HeaderInsertion;
 923   Opts.CodeComplete.ImportInsertions = ImportInsertions;
 924   if (!HeaderInsertionDecorators) {
 925     Opts.CodeComplete.IncludeIndicator.Insert.clear();
 926     Opts.CodeComplete.IncludeIndicator.NoInsert.clear();
 927   }
 928   Opts.CodeComplete.RunParser = CodeCompletionParse;
 929   Opts.CodeComplete.RankingModel = RankingModel;
 930   // FIXME: If we're using C++20 modules, force the lookup process to load
 931   // external decls, since currently the index doesn't support C++20 modules.
 932   Opts.CodeComplete.ForceLoadPreamble = ExperimentalModulesSupport;
 933
 934   RealThreadsafeFS TFS;
 935   std::vector<std::unique_ptr<config::Provider>> ProviderStack;
 936   std::unique_ptr<config::Provider> Config;
 937   if (EnableConfig) {
 938     ProviderStack.push_back(
 939         config::Provider::fromAncestorRelativeYAMLFiles(".clangd", TFS));
 940     llvm::SmallString<256> UserConfig;
 941     if (llvm::sys::path::user_config_directory(UserConfig)) {
 942       llvm::sys::path::append(UserConfig, "clangd", "config.yaml");
 943       vlog("User config file is {0}", UserConfig);
 944       ProviderStack.push_back(config::Provider::fromYAMLFile(
 945           UserConfig, /*Directory=*/"", TFS, /*Trusted=*/true));
 946     } else {
 947       elog("Couldn't determine user config file, not loading");
 948     }
 949   }
 950   ProviderStack.push_back(std::make_unique<FlagsConfigProvider>());
 951   std::vector<const config::Provider *> ProviderPointers;
 952   for (const auto &P : ProviderStack)
 953     ProviderPointers.push_back(P.get());
 954   Config = config::Provider::combine(std::move(ProviderPointers));
 955   Opts.ConfigProvider = Config.get();
 956
 957   // Create an empty clang-tidy option.
 958   TidyProvider ClangTidyOptProvider;
 959   if (EnableClangTidy) {
 960     std::vector<TidyProvider> Providers;
 961     Providers.reserve(4 + EnableConfig);
 962     Providers.push_back(provideEnvironment());
 963     Providers.push_back(provideClangTidyFiles(TFS));
 964     if (EnableConfig)
 965       Providers.push_back(provideClangdConfig());
 966     Providers.push_back(provideDefaultChecks());
 967     Providers.push_back(disableUnusableChecks());
 968     ClangTidyOptProvider = combine(std::move(Providers));
 969     Opts.ClangTidyProvider = ClangTidyOptProvider;
 970   }
 971   Opts.UseDirtyHeaders = UseDirtyHeaders;
 972   Opts.PreambleParseForwardingFunctions = PreambleParseForwardingFunctions;
 973   Opts.ImportInsertions = ImportInsertions;
 974   Opts.QueryDriverGlobs = std::move(QueryDriverGlobs);
 975   Opts.TweakFilter = [&](const Tweak &T) {
 976     if (T.hidden() && !HiddenFeatures)
 977       return false;
 978     if (TweakList.getNumOccurrences())
 979       return llvm::is_contained(TweakList, T.id());
 980     return true;
 981   };
 982   if (ForceOffsetEncoding != OffsetEncoding::UnsupportedEncoding)
 983     Opts.Encoding = ForceOffsetEncoding;
 984
 985   if (CheckFile.getNumOccurrences()) {
 986     llvm::SmallString<256> Path;
 987     if (auto Error =
 988             llvm::sys::fs::real_path(CheckFile, Path, /*expand_tilde=*/true)) {
 989       elog("Failed to resolve path {0}: {1}", CheckFile, Error.message());
 990       return 1;
 991     }
 992     log("Entering check mode (no LSP server)");
 993     return check(Path, TFS, Opts)
 994                ? 0
 995                : static_cast<int>(ErrorResultCode::CheckFailed);
 996   }
 997
 998   // Initialize and run ClangdLSPServer.
 999   // Change stdin to binary to not lose \r\n on windows.
1000   llvm::sys::ChangeStdinToBinary();
1001   std::unique_ptr<Transport> TransportLayer;
1002   if (getenv("CLANGD_AS_XPC_SERVICE")) {
1003 #if CLANGD_BUILD_XPC
1004     log("Starting LSP over XPC service");
1005     TransportLayer = newXPCTransport();
1006 #else
1007     llvm::errs() << "This clangd binary wasn't built with XPC support.\n";
1008     return static_cast<int>(ErrorResultCode::CantRunAsXPCService);
1009 #endif
1010   } else {
1011     log("Starting LSP over stdin/stdout");
1012     TransportLayer = newJSONTransport(
1013         stdin, llvm::outs(), InputMirrorStream ? &*InputMirrorStream : nullptr,
1014         PrettyPrint, InputStyle);
1015   }
1016   if (!PathMappingsArg.empty()) {
1017     auto Mappings = parsePathMappings(PathMappingsArg);
1018     if (!Mappings) {
1019       elog("Invalid -path-mappings: {0}", Mappings.takeError());
1020       return 1;
1021     }
1022     TransportLayer = createPathMappingTransport(std::move(TransportLayer),
1023                                                 std::move(*Mappings));
1024   }
1025
1026   ClangdLSPServer LSPServer(*TransportLayer, TFS, Opts);
1027   llvm::set_thread_name("clangd.main");
1028   int ExitCode = LSPServer.run()
1029                      ? 0
1030                      : static_cast<int>(ErrorResultCode::NoShutdownRequest);
1031   log("LSP finished, exiting with status {0}", ExitCode);
1032
1033   // There may still be lingering background threads (e.g. slow requests
1034   // whose results will be dropped, background index shutting down).
1035   //
1036   // These should terminate quickly, and ~ClangdLSPServer blocks on them.
1037   // However if a bug causes them to run forever, we want to ensure the process
1038   // eventually exits. As clangd isn't directly user-facing, an editor can
1039   // "leak" clangd processes. Crashing in this case contains the damage.
1040   abortAfterTimeout(std::chrono::minutes(5));
1041
1042   return ExitCode;
1043 }
1044
1045 } // namespace clangd
1046 } // namespace clang