[clangd] Upgrade logging facilities with levels and formatv.

[sammccall]

Summary

log() is split into four functions:

• elog()/log()/vlog() have different severity levels, allowing filtering
• dlog() is a lazy macro which uses LLVM_DEBUG - it logs to the logger, but conditionally based on -debug-only flag and is omitted in release builds

All logging functions use formatv-style format strings now, e.g:

log("Could not resolve URI {0}: {1}", URI, Result.takeError());

Existing log sites have been split between elog/log/vlog by best guess.

[sammccall]

This borrows from D44226 (log levels) which got stalled for various reasons (@simark - is it OK if I pick this up?).
It doesn't actually split the LSP messages vs LSP message names into different levels, but that's a simple followup.

Switching to formatv seems like a nice ergonomic win while we're breaking interfaces.
It also in principle allows loggers to extract the format string and args separately (formatv doesn't yet provide APIs for this, but architecturally it's easy) which can help log analysis.

[hokein]

Nice, look good.

clangd/tool/ClangdMain.cpp

104 ↗

(On Diff #154372)

Is it intended not to expose Verbose mode?

[sammccall]

clangd/tool/ClangdMain.cpp

104 ↗

(On Diff #154372)

dlog is already controlled by -debug/-debug-only flag, so it seems it doesn't need a distinct level here too. WDYT?

Renamed flag value to "verbose".

[sammccall]

Name debug->verbose

[hokein]

still LGTM.

The diff contains unrelated changes now.

clangd/tool/ClangdMain.cpp

104 ↗

(On Diff #154372)

Yeah, vlog is controlled by debug flag. A flag "verbose" is more natural than debug.

[sammccall]

rebase

[simark]

In D49008#1154196, @sammccall wrote:

@simark - is it OK if I pick this up?

Yes, totally fine. I didn't have time to follow up on my patch, and I think you did a great job here. I tested it, and I see that my main pain point was addressed. With the patch, clangd is more quiet by default, only outputting errors, so I'm happy :).

[sammccall]

Add workaround for formatv+error issues.

clang-tools-extra/trunk/clangd/ClangdLSPServer.cpp

llvm::Expected<std::string> Contents =
       DraftMgr.updateDraft(File, Params.contentChanges);
   if (!Contents) {
     // If this fails, we are most likely going to be not in sync anymore with
     // the client.  It is better to remove the draft and let further operations
     // fail rather than giving wrong results.
     DraftMgr.removeDraft(File);
     Server.removeDocument(File);
     CDB.invalidate(File);
-    log(llvm::toString(Contents.takeError()));
+    elog("Failed to update {0}: {1}", File, Contents.takeError());
     return;
   }
 
   Server.addDocument(File, *Contents, WantDiags);
 }
 
 void ClangdLSPServer::onFileEvent(DidChangeWatchedFilesParams &Params) {
   Server.onFileEvent(Params);

clang-tools-extra/trunk/clangd/ClangdServer.cpp

ClangdServer::ClangdServer(GlobalCompilationDatabase &CDB,
   else
     Index = nullptr;
 }
 
 void ClangdServer::setRootPath(PathRef RootPath) {
   auto FS = FSProvider.getFileSystem();
   auto Status = FS->status(RootPath);
   if (!Status)
-    log("Failed to get status for RootPath " + RootPath + ": " +
+    elog("Failed to get status for RootPath {0}: {1}", RootPath,
          Status.getError().message());
   else if (Status->isDirectory())
     this->RootPath = RootPath;
   else
-    log("The provided RootPath " + RootPath + " is not a directory.");
+    elog("The provided RootPath {0} is not a directory.", RootPath);
 }
 
 void ClangdServer::addDocument(PathRef File, StringRef Contents,
                                WantDiagnostics WantDiags) {
   DocVersion Version = ++InternalVersion[File];
   ParseInputs Inputs = {getCompileCommand(File), FSProvider.getFileSystem(),
                         Contents.str()};
 

clang-tools-extra/trunk/clangd/ClangdUnit.cpp

ParsedAST::Build(std::unique_ptr<clang::CompilerInvocation> CI,
 
   // Recover resources if we crash before exiting this method.
   llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> CICleanup(
       Clang.get());
 
   auto Action = llvm::make_unique<ClangdFrontendAction>();
   const FrontendInputFile &MainInput = Clang->getFrontendOpts().Inputs[0];
   if (!Action->BeginSourceFile(*Clang, MainInput)) {
-    log("BeginSourceFile() failed when building AST for " +
+    log("BeginSourceFile() failed when building AST for {0}",
         MainInput.getFile());
     return llvm::None;
   }
 
   // Copy over the includes from the preamble, then combine with the
   // non-preamble includes below.
   auto Includes = Preamble ? Preamble->Includes : IncludeStructure{};
   Clang->getPreprocessor().addPPCallbacks(
       collectIncludeStructureCallback(Clang->getSourceManager(), &Includes));
 
   if (!Action->Execute())
-    log("Execute() failed when building AST for " + MainInput.getFile());
+    log("Execute() failed when building AST for {0}", MainInput.getFile());
 
   // UnitDiagsConsumer is local, we can not store it in CompilerInstance that
   // has a longer lifetime.
   Clang->getDiagnostics().setClient(new IgnoreDiagnostics);
   // CompilerInstance won't run this callback, do it directly.
   ASTDiags.EndSourceFile();
 
   std::vector<Decl *> ParsedDecls = Action->takeTopLevelDecls();
std::shared_ptr<const PreambleData> clangd::buildPreamble(
   auto ContentsBuffer = llvm::MemoryBuffer::getMemBuffer(Inputs.Contents);
   auto Bounds =
       ComputePreambleBounds(*CI.getLangOpts(), ContentsBuffer.get(), 0);
 
   if (OldPreamble &&
       compileCommandsAreEqual(Inputs.CompileCommand, OldCompileCommand) &&
       OldPreamble->Preamble.CanReuse(CI, ContentsBuffer.get(), Bounds,
                                      Inputs.FS.get())) {
-    log("Reusing preamble for file " + Twine(FileName));
+    vlog("Reusing preamble for file {0}", Twine(FileName));
     return OldPreamble;
   }
-  log("Preamble for file " + Twine(FileName) +
-      " cannot be reused. Attempting to rebuild it.");
+  vlog("Preamble for file {0} cannot be reused. Attempting to rebuild it.",
+       FileName);
 
   trace::Span Tracer("BuildPreamble");
   SPAN_ATTACH(Tracer, "File", FileName);
   StoreDiags PreambleDiagnostics;
   IntrusiveRefCntPtr<DiagnosticsEngine> PreambleDiagsEngine =
       CompilerInstance::createDiagnostics(&CI.getDiagnosticOpts(),
                                           &PreambleDiagnostics, false);
 
auto BuiltPreamble = PrecompiledPreamble::Build(
       CI, ContentsBuffer.get(), Bounds, *PreambleDiagsEngine, Inputs.FS, PCHs,
       StoreInMemory, SerializedDeclsCollector);
 
   // When building the AST for the main file, we do want the function
   // bodies.
   CI.getFrontendOpts().SkipFunctionBodies = false;
 
   if (BuiltPreamble) {
-    log("Built preamble of size " + Twine(BuiltPreamble->getSize()) +
-        " for file " + Twine(FileName));
+    vlog("Built preamble of size {0} for file {1}", BuiltPreamble->getSize(),
+         FileName);
     return std::make_shared<PreambleData>(
         std::move(*BuiltPreamble), PreambleDiagnostics.take(),
         SerializedDeclsCollector.takeIncludes());
   } else {
-    log("Could not build a preamble for file " + Twine(FileName));
+    elog("Could not build a preamble for file {0}", FileName);
     return nullptr;
   }
 }
 
 llvm::Optional<ParsedAST> clangd::buildAST(
     PathRef FileName, std::unique_ptr<CompilerInvocation> Invocation,
     const ParseInputs &Inputs, std::shared_ptr<const PreambleData> Preamble,
     std::shared_ptr<PCHContainerOperations> PCHs) {

 
 SourceLocation clangd::getBeginningOfIdentifier(ParsedAST &Unit,
                                                 const Position &Pos,
                                                 const FileID FID) {
   const ASTContext &AST = Unit.getASTContext();
   const SourceManager &SourceMgr = AST.getSourceManager();
   auto Offset = positionToOffset(SourceMgr.getBufferData(FID), Pos);
   if (!Offset) {
-    log("getBeginningOfIdentifier: " + toString(Offset.takeError()));
+    log("getBeginningOfIdentifier: {0}", Offset.takeError());
     return SourceLocation();
   }
   SourceLocation InputLoc = SourceMgr.getComposedLoc(FID, *Offset);
 
   // GetBeginningOfToken(pos) is almost what we want, but does the wrong thing
   // if the cursor is at the end of the identifier.
   // Instead, we lex at GetBeginningOfToken(pos - 1). The cases are:
   //  1) at the beginning of an identifier, we'll be looking at something

clang-tools-extra/trunk/clangd/CodeComplete.cpp

if (auto Inserted = C.headerToInsertIfNotPresent()) {
                               Includes.shouldInsertInclude(*ResolvedDeclaring,
                                                            *ResolvedInserted));
       }();
       if (Include) {
         Completion.Header = Include->first;
         if (Include->second)
           Completion.HeaderInsertion = Includes.insert(Include->first);
       } else
-        log(llvm::formatv(
-            "Failed to generate include insertion edits for adding header "
+        log("Failed to generate include insertion edits for adding header "
             "(FileURI='{0}', IncludeHeader='{1}') into {2}",
             C.IndexResult->CanonicalDeclaration.FileURI,
-            C.IndexResult->Detail->IncludeHeader, FileName));
+            C.IndexResult->Detail->IncludeHeader, FileName);
     }
   }
 
   void add(const CompletionCandidate &C, CodeCompletionString *SemaCCS) {
     assert(bool(C.SemaResult) == bool(SemaCCS));
     Bundled.emplace_back();
     BundledEntry &S = Bundled.back();
     if (C.SemaResult) {
void ProcessCodeCompleteResults(class Sema &S, CodeCompletionContext Context,
                                   CodeCompletionResult *InResults,
                                   unsigned NumResults) override final {
     // If a callback is called without any sema result and the context does not
     // support index-based completion, we simply skip it to give way to
     // potential future callbacks with results.
     if (NumResults == 0 && !contextAllowsIndex(Context.getKind()))
       return;
     if (CCSema) {
-      log(llvm::formatv(
-          "Multiple code complete callbacks (parser backtracked?). "
+      log("Multiple code complete callbacks (parser backtracked?). "
           "Dropping results from context {0}, keeping results from {1}.",
           getCompletionKindString(Context.getKind()),
-          getCompletionKindString(this->CCContext.getKind())));
+          getCompletionKindString(this->CCContext.getKind()));
       return;
     }
     // Record the completion context.
     CCSema = &S;
     CCContext = Context;
 
     // Retain the results we might want.
     for (unsigned I = 0; I < NumResults; ++I) {
bool semaCodeComplete(std::unique_ptr<CodeCompleteConsumer> Consumer,
 
   IgnoreDiagnostics DummyDiagsConsumer;
   auto CI = createInvocationFromCommandLine(
       ArgStrs,
       CompilerInstance::createDiagnostics(new DiagnosticOptions,
                                           &DummyDiagsConsumer, false),
       Input.VFS);
   if (!CI) {
-    log("Couldn't create CompilerInvocation");
+    elog("Couldn't create CompilerInvocation");
     return false;
   }
   auto &FrontendOpts = CI->getFrontendOpts();
   FrontendOpts.DisableFree = false;
   FrontendOpts.SkipFunctionBodies = true;
   CI->getLangOpts()->CommentOpts.ParseAllComments = true;
   // Disable typo correction in Sema.
   CI->getLangOpts()->SpellChecking = false;
   // Setup code completion.
   FrontendOpts.CodeCompleteOpts = Options;
   FrontendOpts.CodeCompletionAt.FileName = Input.FileName;
   auto Offset = positionToOffset(Input.Contents, Input.Pos);
   if (!Offset) {
-    log("Code completion position was invalid " +
-        llvm::toString(Offset.takeError()));
+    elog("Code completion position was invalid {0}", Offset.takeError());
     return false;
   }
   std::tie(FrontendOpts.CodeCompletionAt.Line,
            FrontendOpts.CodeCompletionAt.Column) =
       offsetToClangLineColumn(Input.Contents, *Offset);
 
   std::unique_ptr<llvm::MemoryBuffer> ContentsBuffer =
       llvm::MemoryBuffer::getMemBufferCopy(Input.Contents, Input.FileName);
   // The diagnostic options must be set before creating a CompilerInstance.
   CI->getDiagnosticOpts().IgnoreWarnings = true;
   // We reuse the preamble whether it's valid or not. This is a
   // correctness/performance tradeoff: building without a preamble is slow, and
   // completion is latency-sensitive.
   // NOTE: we must call BeginSourceFile after prepareCompilerInstance. Otherwise
   // the remapped buffers do not get freed.
   auto Clang = prepareCompilerInstance(
       std::move(CI), Input.Preamble, std::move(ContentsBuffer),
       std::move(Input.PCHs), std::move(Input.VFS), DummyDiagsConsumer);
   Clang->setCodeCompletionConsumer(Consumer.release());
 
   SyntaxOnlyAction Action;
   if (!Action.BeginSourceFile(*Clang, Clang->getFrontendOpts().Inputs[0])) {
-    log("BeginSourceFile() failed when running codeComplete for " +
+    log("BeginSourceFile() failed when running codeComplete for {0}",
         Input.FileName);
     return false;
   }
   if (Includes)
     Clang->getPreprocessor().addPPCallbacks(
         collectIncludeStructureCallback(Clang->getSourceManager(), Includes));
   if (!Action.Execute()) {
-    log("Execute() failed when running codeComplete for " + Input.FileName);
+    log("Execute() failed when running codeComplete for {0}", Input.FileName);
     return false;
   }
   Action.EndSourceFile();
 
   return true;
 }
 
 // Should we allow index completions in the specified context?
CodeCompleteResult run(const SemaCompleteInput &SemaCCInput) && {
     CodeCompleteResult Output;
     auto RecorderOwner = llvm::make_unique<CompletionRecorder>(Opts, [&]() {
       assert(Recorder && "Recorder is not set");
       auto Style =
           format::getStyle(format::DefaultFormatStyle, SemaCCInput.FileName,
                            format::DefaultFallbackStyle, SemaCCInput.Contents,
                            SemaCCInput.VFS.get());
       if (!Style) {
-        log("Failed to get FormatStyle for file" + SemaCCInput.FileName + ": " +
-            llvm::toString(Style.takeError()) + ". Fallback is LLVM style.");
+        log("getStyle() failed for file {0}: {1}. Fallback is LLVM style.",
+            SemaCCInput.FileName, Style.takeError());
         Style = format::getLLVMStyle();
       }
       // If preprocessor was run, inclusions from preprocessor callback should
       // already be added to Includes.
       Inserter.emplace(
           SemaCCInput.FileName, SemaCCInput.Contents, *Style,
           SemaCCInput.Command.Directory,
           Recorder->CCSema->getPreprocessor().getHeaderSearchInfo());
auto RecorderOwner = llvm::make_unique<CompletionRecorder>(Opts, [&]() {
           Source.MaxUpTraversals = 1;
       }
       FileProximity.emplace(ProxSources, ProxOpts);
 
       Output = runWithSema();
       Inserter.reset(); // Make sure this doesn't out-live Clang.
       SPAN_ATTACH(Tracer, "sema_completion_kind",
                   getCompletionKindString(Recorder->CCContext.getKind()));
-      log(llvm::formatv(
-          "Code complete: sema context {0}, query scopes [{1}]",
+      log("Code complete: sema context {0}, query scopes [{1}]",
           getCompletionKindString(Recorder->CCContext.getKind()),
-          llvm::join(QueryScopes.begin(), QueryScopes.end(), ",")));
+          llvm::join(QueryScopes.begin(), QueryScopes.end(), ","));
     });
 
     Recorder = RecorderOwner.get();
     semaCodeComplete(std::move(RecorderOwner), Opts.getClangCompleteOpts(),
                      SemaCCInput, &Includes);
 
     SPAN_ATTACH(Tracer, "sema_results", NSema);
     SPAN_ATTACH(Tracer, "index_results", NIndex);
     SPAN_ATTACH(Tracer, "merged_results", NBoth);
     SPAN_ATTACH(Tracer, "returned_results", int64_t(Output.Completions.size()));
     SPAN_ATTACH(Tracer, "incomplete", Output.HasMore);
-    log(llvm::formatv("Code complete: {0} results from Sema, {1} from Index, "
-                      "{2} matched, {3} returned{4}.",
-                      NSema, NIndex, NBoth, Output.Completions.size(),
-                      Output.HasMore ? " (incomplete)" : ""));
+    log("Code complete: {0} results from Sema, {1} from Index, "
+        Output.HasMore ? " (incomplete)" : "");
     assert(!Opts.Limit || Output.Completions.size() <= Opts.Limit);
     // We don't assert that isIncomplete means we hit a limit.
     // Indexes may choose to impose their own limits even if we don't have one.
     return Output;
   }
 
 private:
   // This is called by run() once Sema code completion is done, but before the
SymbolSlab queryIndex() {
     FuzzyFindRequest Req;
     if (Opts.Limit)
       Req.MaxCandidateCount = Opts.Limit;
     Req.Query = Filter->pattern();
     Req.RestrictForCodeCompletion = true;
     Req.Scopes = QueryScopes;
     // FIXME: we should send multiple weighted paths here.
     Req.ProximityPaths.push_back(FileName);
-    log(llvm::formatv("Code complete: fuzzyFind(\"{0}\", scopes=[{1}])",
-                      Req.Query,
-                      llvm::join(Req.Scopes.begin(), Req.Scopes.end(), ",")));
+    vlog("Code complete: fuzzyFind(\"{0}\", scopes=[{1}])", Req.Query,
+         llvm::join(Req.Scopes.begin(), Req.Scopes.end(), ","));
     // Run the query against the index.
     if (Opts.Index->fuzzyFind(
             Req, [&](const Symbol &Sym) { ResultsBuilder.insert(Sym); }))
       Incomplete = true;
     return std::move(ResultsBuilder).build();
   }
 
   // Merges Sema and Index results where possible, to form CompletionCandidates.
void addCandidate(TopN<ScoredBundle, ScoredBundleGreater> &Candidates,
     Scores.Quality = Quality.evaluate();
     Scores.Relevance = Relevance.evaluate();
     Scores.Total = evaluateSymbolAndRelevance(Scores.Quality, Scores.Relevance);
     // NameMatch is in fact a multiplier on total score, so rescoring is sound.
     Scores.ExcludingName = Relevance.NameMatch
                                ? Scores.Total / Relevance.NameMatch
                                : Scores.Quality;
 
-    LLVM_DEBUG(llvm::dbgs() << "CodeComplete: " << First.Name << " (" << Origin
-                            << ") = " << Scores.Total << "\n"
-                            << Quality << Relevance << "\n");
+    dlog("CodeComplete: {0} ({1}) = {2}\n{3}{4}\n", First.Name,
+         llvm::to_string(Origin), Scores.Total, llvm::to_string(Quality),
+         llvm::to_string(Relevance));
 
     NSema += bool(Origin & SymbolOrigin::AST);
     NIndex += FromIndex;
     NBoth += bool(Origin & SymbolOrigin::AST) && FromIndex;
     if (Candidates.push({std::move(Bundle), Scores}))
       Incomplete = true;
   }
 

clang-tools-extra/trunk/clangd/Compiler.cpp

void IgnoreDiagnostics::log(DiagnosticsEngine::Level DiagLevel,
   if (Info.hasSourceManager() && Info.getLocation().isValid()) {
     auto &SourceMgr = Info.getSourceManager();
     auto Loc = SourceMgr.getFileLoc(Info.getLocation());
     llvm::raw_svector_ostream OS(Location);
     Loc.print(OS, SourceMgr);
     OS << ":";
   }
 
-  clangd::log(llvm::formatv("Ignored diagnostic. {0}{1}", Location, Message));
+  clangd::log("Ignored diagnostic. {0}{1}", Location, Message);
 }
 
 void IgnoreDiagnostics::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
                                          const clang::Diagnostic &Info) {
   IgnoreDiagnostics::log(DiagLevel, Info);
 }
 
 std::unique_ptr<CompilerInstance>

clang-tools-extra/trunk/clangd/Diagnostics.cpp

 }
 
 void StoreDiags::flushLastDiag() {
   if (!LastDiag)
     return;
   if (mentionsMainFile(*LastDiag))
     Output.push_back(std::move(*LastDiag));
   else
-    log(Twine("Dropped diagnostic outside main file:") + LastDiag->File + ":" +
+    log("Dropped diagnostic outside main file: {0}: {1}", LastDiag->File,
         LastDiag->Message);
   LastDiag.reset();
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/trunk/clangd/FileDistance.cpp

 // practice this is a small constant factor.
 //
 //===-------------------------------------------------------------------------//
 
 #include "FileDistance.h"
 #include "Logger.h"
 #include "llvm/ADT/STLExtras.h"
 #include <queue>
-#define DEBUG_TYPE "FileDistance"
 
 namespace clang {
 namespace clangd {
 using namespace llvm;
 
 // Convert a path into the canonical form.
 // Canonical form is either "/", or "/segment" * N:
 //   C:\foo\bar --> /c:/foo/bar

 FileDistance::FileDistance(StringMap<SourceParams> Sources,
                            const FileDistanceOptions &Opts)
     : Opts(Opts) {
   llvm::DenseMap<hash_code, SmallVector<hash_code, 4>> DownEdges;
   // Compute the best distance following only up edges.
   // Keep track of down edges, in case we can use them to improve on this.
   for (const auto &S : Sources) {
     auto Canonical = canonicalize(S.getKey());
-    LLVM_DEBUG(dbgs() << "Source " << Canonical << " = " << S.second.Cost
-                      << ", MaxUp=" << S.second.MaxUpTraversals << "\n");
+    dlog("Source {0} = {1}, MaxUp = {2}", Canonical, S.second.Cost,
+         S.second.MaxUpTraversals);
     // Walk up to ancestors of this source, assigning cost.
     StringRef Rest = Canonical;
     llvm::hash_code Hash = hash_value(Rest);
     for (unsigned I = 0; !Rest.empty(); ++I) {
       Rest = parent_path(Rest, sys::path::Style::posix);
       auto NextHash = hash_value(Rest);
       auto &Down = DownEdges[NextHash];
       if (std::find(Down.begin(), Down.end(), Hash) == Down.end())
unsigned FileDistance::distance(StringRef Path) {
   }
   // Now we know the costs for (known node, queried node].
   // Fill these in, walking down the directory tree.
   for (hash_code Hash : reverse(Ancestors)) {
     if (Cost != kUnreachable)
       Cost += Opts.DownCost;
     Cache.try_emplace(Hash, Cost);
   }
-  LLVM_DEBUG(dbgs() << "distance(" << Path << ") = " << Cost << "\n");
+  dlog("distance({0} = {1})", Path, Cost);
   return Cost;
 }
 
 unsigned URIDistance::distance(llvm::StringRef URI) {
   auto R = Cache.try_emplace(llvm::hash_value(URI), FileDistance::kUnreachable);
   if (!R.second)
     return R.first->getSecond();
   if (auto U = clangd::URI::parse(URI)) {
-    LLVM_DEBUG(dbgs() << "distance(" << URI << ") = distance(" << U->body()
-                      << ")\n");
+    dlog("distance({0} = {1})", URI, U->body());
     R.first->second = forScheme(U->scheme()).distance(U->body());
   } else {
-    log("URIDistance::distance() of unparseable " + URI + ": " +
-        llvm::toString(U.takeError()));
+    log("URIDistance::distance() of unparseable {0}: {1}", URI, U.takeError());
   }
   return R.first->second;
 }
 
 FileDistance &URIDistance::forScheme(llvm::StringRef Scheme) {
   auto &Delegate = ByScheme[Scheme];
   if (!Delegate) {
     llvm::StringMap<SourceParams> SchemeSources;
     for (const auto &Source : Sources) {
       if (auto U = clangd::URI::create(Source.getKey(), Scheme))
         SchemeSources.try_emplace(U->body(), Source.getValue());
       else
         consumeError(U.takeError());
     }
-    LLVM_DEBUG(dbgs() << "FileDistance for scheme " << Scheme << ": "
-                      << SchemeSources.size() << "/" << Sources.size()
-                      << " sources\n");
+    dlog("FileDistance for scheme {0}: {1}/{2} sources", Scheme,
+         SchemeSources.size(), Sources.size());
     Delegate.reset(new FileDistance(std::move(SchemeSources), Opts));
   }
   return *Delegate;
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/trunk/clangd/FindSymbols.cpp

if (Limit)
     Req.MaxCandidateCount = Limit;
   TopN<ScoredSymbolInfo, ScoredSymbolGreater> Top(Req.MaxCandidateCount);
   FuzzyMatcher Filter(Req.Query);
   Index->fuzzyFind(Req, [HintPath, &Top, &Filter](const Symbol &Sym) {
     // Prefer the definition over e.g. a function declaration in a header
     auto &CD = Sym.Definition ? Sym.Definition : Sym.CanonicalDeclaration;
     auto Uri = URI::parse(CD.FileURI);
     if (!Uri) {
-      log(llvm::formatv(
-          "Workspace symbol: Could not parse URI '{0}' for symbol '{1}'.",
-          CD.FileURI, Sym.Name));
+      log("Workspace symbol: Could not parse URI '{0}' for symbol '{1}'.",
+          CD.FileURI, Sym.Name);
       return;
     }
     auto Path = URI::resolve(*Uri, HintPath);
     if (!Path) {
-      log(llvm::formatv("Workspace symbol: Could not resolve path for URI "
-                        "'{0}' for symbol '{1}'.",
-                        (*Uri).toString(), Sym.Name.str()));
+      log("Workspace symbol: Could not resolve path for URI '{0}' for symbol "
+          "'{1}'.",
+          Uri->toString(), Sym.Name);
       return;
     }
     Location L;
     L.uri = URIForFile((*Path));
     Position Start, End;
     Start.line = CD.Start.Line;
     Start.character = CD.Start.Column;
     End.line = CD.End.Line;
     End.character = CD.End.Column;
     L.range = {Start, End};
     SymbolKind SK = indexSymbolKindToSymbolKind(Sym.SymInfo.Kind);
     std::string Scope = Sym.Scope;
     StringRef ScopeRef = Scope;
     ScopeRef.consume_back("::");
     SymbolInformation Info = {Sym.Name, SK, L, ScopeRef};
 
     SymbolQualitySignals Quality;
     Quality.merge(Sym);
     SymbolRelevanceSignals Relevance;
     Relevance.Query = SymbolRelevanceSignals::Generic;
     if (auto NameMatch = Filter.match(Sym.Name))
       Relevance.NameMatch = *NameMatch;
     else {
-      log(llvm::formatv("Workspace symbol: {0} didn't match query {1}",
-                        Sym.Name, Filter.pattern()));
+      log("Workspace symbol: {0} didn't match query {1}", Sym.Name,
+          Filter.pattern());
       return;
     }
     Relevance.merge(Sym);
     auto Score =
         evaluateSymbolAndRelevance(Quality.evaluate(), Relevance.evaluate());
-    LLVM_DEBUG(llvm::dbgs() << "FindSymbols: " << Sym.Scope << Sym.Name << " = "
-                            << Score << "\n"
-                            << Quality << Relevance << "\n");
+    dlog("FindSymbols: {0}{1} = {2}\n{3}{4}\n", Sym.Scope, Sym.Name, Score,
+         Quality, Relevance);
 
     Top.push({Score, std::move(Info)});
   });
   for (auto &R : std::move(Top).items())
     Result.push_back(std::move(R.second));
   return Result;
 }
 

clang-tools-extra/trunk/clangd/GlobalCompilationDatabase.cpp

 DirectoryBasedGlobalCompilationDatabase::getCompileCommand(PathRef File) const {
   if (auto CDB = getCDBForFile(File)) {
     auto Candidates = CDB->getCompileCommands(File);
     if (!Candidates.empty()) {
       addExtraFlags(File, Candidates.front());
       return std::move(Candidates.front());
     }
   } else {
-    log("Failed to find compilation database for " + Twine(File));
+    log("Failed to find compilation database for {0}", File);
   }
   return llvm::None;
 }
 
 tooling::CompileCommand
 DirectoryBasedGlobalCompilationDatabase::getFallbackCommand(
     PathRef File) const {
   auto C = GlobalCompilationDatabase::getFallbackCommand(File);

clang-tools-extra/trunk/clangd/JSONRPCDispatcher.h

 
 /// Encapsulates output and logs streams and provides thread-safe access to
 /// them.
 class JSONOutput : public Logger {
   // FIXME(ibiryukov): figure out if we can shrink the public interface of
   // JSONOutput now that we pass Context everywhere.
 public:
   JSONOutput(llvm::raw_ostream &Outs, llvm::raw_ostream &Logs,
-             llvm::raw_ostream *InputMirror = nullptr, bool Pretty = false)
-      : Pretty(Pretty), Outs(Outs), Logs(Logs), InputMirror(InputMirror) {}
+             Logger::Level MinLevel, llvm::raw_ostream *InputMirror = nullptr,
+             bool Pretty = false)
+      : Pretty(Pretty), MinLevel(MinLevel), Outs(Outs), Logs(Logs),
+        InputMirror(InputMirror) {}
 
   /// Emit a JSONRPC message.
   void writeMessage(const llvm::json::Value &Result);
 
   /// Write a line to the logging stream.
-  void log(const Twine &Message) override;
+  void log(Level, const llvm::formatv_object_base &Message) override;
 
   /// Mirror \p Message into InputMirror stream. Does nothing if InputMirror is
   /// null.
   /// Unlike other methods of JSONOutput, mirrorInput is not thread-safe.
   void mirrorInput(const Twine &Message);
 
   // Whether output should be pretty-printed.
   const bool Pretty;
 
 private:
+  Logger::Level MinLevel;
   llvm::raw_ostream &Outs;
   llvm::raw_ostream &Logs;
   llvm::raw_ostream *InputMirror;
 
   std::mutex StreamMutex;
 };
 
 /// Sends a successful reply.

clang-tools-extra/trunk/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 "Trace.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/Errno.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/SourceMgr.h"
 #include <istream>
 
 using namespace llvm;
 using namespace clang;
 using namespace clangd;
 
else
     OS << Message;
   OS.flush();
 
   {
     std::lock_guard<std::mutex> Guard(StreamMutex);
     Outs << "Content-Length: " << S.size() << "\r\n\r\n" << S;
     Outs.flush();
   }
-  log(llvm::Twine("--> ") + S + "\n");
+  vlog("--> {0}\n", S);
 }
 
-void JSONOutput::log(const Twine &Message) {
+void JSONOutput::log(Logger::Level Level,
+                     const llvm::formatv_object_base &Message) {
+  if (Level < MinLevel)
+    return;
   llvm::sys::TimePoint<> Timestamp = std::chrono::system_clock::now();
   trace::log(Message);
   std::lock_guard<std::mutex> Guard(StreamMutex);
-  Logs << llvm::formatv("[{0:%H:%M:%S.%L}] {1}\n", Timestamp, Message);
+  Logs << llvm::formatv("{0}[{1:%H:%M:%S.%L}] {2}\n", indicator(Level),
+                        Timestamp, Message);
   Logs.flush();
 }
 
 void JSONOutput::mirrorInput(const Twine &Message) {
   if (!InputMirror)
     return;
 
   *InputMirror << Message;
   InputMirror->flush();
 }
 
 void clangd::reply(json::Value &&Result) {
   auto ID = Context::current().get(RequestID);
   if (!ID) {
-    log("Attempted to reply to a notification!");
+    elog("Attempted to reply to a notification!");
     return;
   }
   RequestSpan::attach([&](json::Object &Args) { Args["Reply"] = Result; });
   Context::current()
       .getExisting(RequestOut)
       ->writeMessage(json::Object{
           {"jsonrpc", "2.0"},
           {"id", *ID},
           {"result", std::move(Result)},
       });
 }
 
 void clangd::replyError(ErrorCode code, const llvm::StringRef &Message) {
-  log("Error " + Twine(static_cast<int>(code)) + ": " + Message);
+  elog("Error {0}: {1}", static_cast<int>(code), Message);
   RequestSpan::attach([&](json::Object &Args) {
     Args["Error"] = json::Object{{"code", static_cast<int>(code)},
                                  {"message", Message.str()}};
   });
 
   if (auto ID = Context::current().get(RequestID)) {
     Context::current()
         .getExisting(RequestOut)
while (true) {
     // We allow comments in headers. Technically this isn't part
     // of the LSP specification, but makes writing tests easier.
     if (LineRef.startswith("#"))
       continue;
 
     // Content-Length is a mandatory header, and the only one we handle.
     if (LineRef.consume_front("Content-Length: ")) {
       if (ContentLength != 0) {
-        log("Warning: Duplicate Content-Length header received. "
-            "The previous value for this message (" +
-            llvm::Twine(ContentLength) + ") was ignored.");
+        elog("Warning: Duplicate Content-Length header received. "
+             "The previous value for this message ({0}) was ignored.",
+             ContentLength);
       }
       llvm::getAsUnsignedInteger(LineRef.trim(), 0, ContentLength);
       continue;
     } else if (!LineRef.trim().empty()) {
       // It's another header, ignore it.
       continue;
     } else {
       // An empty line indicates the end of headers.
       // Go ahead and read the JSON.
       break;
     }
   }
 
   // The fuzzer likes crashing us by sending "Content-Length: 9999999999999999"
   if (ContentLength > 1 << 30) { // 1024M
-    log("Refusing to read message with long Content-Length: " +
-        Twine(ContentLength) + ". Expect protocol errors.");
+    elog("Refusing to read message with long Content-Length: {0}. "
+         "Expect protocol errors",
+         ContentLength);
     return llvm::None;
   }
   if (ContentLength == 0) {
     log("Warning: Missing Content-Length header, or zero-length message.");
     return llvm::None;
   }
 
   std::string JSON(ContentLength, '\0');
   for (size_t Pos = 0, Read; Pos < ContentLength; Pos += Read) {
     // Handle EINTR which is sent when a debugger attaches on some platforms.
     Read = llvm::sys::RetryAfterSignal(0u, ::fread, &JSON[Pos], 1,
                                        ContentLength - Pos, In);
     Out.mirrorInput(StringRef(&JSON[Pos], Read));
     if (Read == 0) {
-      log("Input was aborted. Read only " + llvm::Twine(Pos) +
-          " bytes of expected " + llvm::Twine(ContentLength) + ".");
+      elog("Input was aborted. Read only {0} bytes of expected {1}.", Pos,
+           ContentLength);
       return llvm::None;
     }
     clearerr(In); // If we're done, the error was transient. If we're not done,
                   // either it was transient or we'll see it again on retry.
     Pos += Read;
   }
   return std::move(JSON);
 }
while (readLine(In, Line)) {
     // found a delimiter
     if (LineRef.rtrim() == "---")
       break;
 
     JSON += Line;
   }
 
   if (ferror(In)) {
-    log("Input error while reading message!");
+    elog("Input error while reading message!");
     return llvm::None;
   } else { // Including EOF
     Out.mirrorInput(
         llvm::formatv("Content-Length: {0}\r\n\r\n{1}", JSON.size(), JSON));
     return std::move(JSON);
   }
 }
 
 // The use of C-style std::FILE* IO deserves some explanation.
 // Previously, std::istream was used. When a debugger attached on MacOS, the
 // process received EINTR, the stream went bad, and clangd exited.
 // A retry-on-EINTR loop around reads solved this problem, but caused clangd to
 // sometimes hang rather than exit on other OSes. The interaction between
 // istreams and signals isn't well-specified, so it's hard to get this right.
 // The C APIs seem to be clearer in this respect.
 void clangd::runLanguageServerLoop(std::FILE *In, JSONOutput &Out,
                                    JSONStreamStyle InputStyle,
                                    JSONRPCDispatcher &Dispatcher,
                                    bool &IsDone) {
   auto &ReadMessage =
       (InputStyle == Delimited) ? readDelimitedMessage : readStandardMessage;
   while (!IsDone && !feof(In)) {
     if (ferror(In)) {
-      log("IO error: " + llvm::sys::StrError());
+      elog("IO error: {0}", llvm::sys::StrError());
       return;
     }
     if (auto JSON = ReadMessage(In, Out)) {
       if (auto Doc = json::parse(*JSON)) {
         // Log the formatted message.
-        log(llvm::formatv(Out.Pretty ? "<-- {0:2}\n" : "<-- {0}\n", *Doc));
+        vlog(Out.Pretty ? "<-- {0:2}\n" : "<-- {0}\n", *Doc);
         // Finally, execute the action for this JSON message.
         if (!Dispatcher.call(*Doc, Out))
-          log("JSON dispatch failed!");
+          elog("JSON dispatch failed!");
       } else {
         // Parse error. Log the raw message.
-        log(llvm::formatv("<-- {0}\n" , *JSON));
-        log(llvm::Twine("JSON parse error: ") +
-            llvm::toString(Doc.takeError()));
+        vlog("<-- {0}\n", *JSON);
+        elog("JSON parse error: {0}", llvm::toString(Doc.takeError()));
       }
     }
   }
 }

clang-tools-extra/trunk/clangd/Logger.h

 //===--- Logger.h - Logger interface for clangd ------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_LOGGER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_LOGGER_H
 
 #include "llvm/ADT/Twine.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/FormatVariadic.h"
 
 namespace clang {
 namespace clangd {
 
-/// Main logging function.
-/// Logs messages to a global logger, which can be set up by LoggingSesssion.
-/// If no logger is registered, writes to llvm::errs().
-void log(const llvm::Twine &Message);
-
 /// Interface to allow custom logging in clangd.
 class Logger {
 public:
   virtual ~Logger() = default;
 
+  enum Level { Debug, Verbose, Info, Error };
+  static char indicator(Level L) { return "DVIE"[L]; }
+
   /// Implementations of this method must be thread-safe.
-  virtual void log(const llvm::Twine &Message) = 0;
+  virtual void log(Level, const llvm::formatv_object_base &Message) = 0;
+};
+
+namespace detail {
+const char *debugType(const char *Filename);
+void log(Logger::Level, const llvm::formatv_object_base &);
+
+// We often want to consume llvm::Errors by value when passing them to log().
+// This is tricky because the logging infrastructure must mark them as handled.
+// When forwarding argument to formatv, we wrap Errors-by-value in this type
+// whose destructor handles the cleanup.
+// FIXME: simplify after D49170 lands.
+struct WrappedError {
+  llvm::Error E;
+  WrappedError(WrappedError &&) = default;
+  ~WrappedError() { consumeError(std::move(E)); }
 };
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                     const WrappedError &Err) {
+  return OS << Err.E;
+}
+template <typename T> T &&wrap(T &&V) { return std::forward<T>(V); }
+inline WrappedError wrap(llvm::Error &&V) { return WrappedError{std::move(V)}; }
+template <typename... Ts>
+void log(Logger::Level L, const char *Fmt, Ts &&... Vals) {
+  detail::log(L, llvm::formatv(Fmt, detail::wrap(std::forward<Ts>(Vals))...));
+}
+} // namespace detail
+
+// Clangd logging functions write to a global logger set by LoggingSession.
+// If no logger is registered, writes to llvm::errs().
+// All accept llvm::formatv()-style arguments, e.g. log("Text={0}", Text).
+
+// elog() is used for "loud" errors and warnings.
+// This level is often visible to users.
+template <typename... Ts> void elog(const char *Fmt, Ts &&... Vals) {
+  detail::log(Logger::Error, Fmt, std::forward<Ts>(Vals)...);
+}
+// log() is used for information important to understanding a clangd session.
+// e.g. the names of LSP messages sent are logged at this level.
+// This level could be enabled in production builds to allow later inspection.
+template <typename... Ts> void log(const char *Fmt, Ts &&... Vals) {
+  detail::log(Logger::Info, Fmt, std::forward<Ts>(Vals)...);
+}
+// vlog() is used for details often needed for debugging clangd sessions.
+// This level would typically be enabled for clangd developers.
+template <typename... Ts> void vlog(const char *Fmt, Ts &&... Vals) {
+  detail::log(Logger::Verbose, Fmt, std::forward<Ts>(Vals)...);
+}
+// dlog only logs if --debug was passed, or --debug_only=Basename.
+// This level would be enabled in a targeted way when debugging.
+#define dlog(...)                                                              \
+  DEBUG_WITH_TYPE(::clang::clangd::detail::debugType(__FILE__),                \
+                  ::clang::clangd::detail::log(Logger::Debug, __VA_ARGS__))
 
 /// Only one LoggingSession can be active at a time.
 class LoggingSession {
 public:
   LoggingSession(clangd::Logger &Instance);
   ~LoggingSession();
 
   LoggingSession(LoggingSession &&) = delete;

clang-tools-extra/trunk/clangd/Logger.cpp

 
 LoggingSession::LoggingSession(clangd::Logger &Instance) {
   assert(!L);
   L = &Instance;
 }
 
 LoggingSession::~LoggingSession() { L = nullptr; }
 
-void log(const llvm::Twine &Message) {
+void detail::log(Logger::Level Level,
+                 const llvm::formatv_object_base &Message) {
   if (L)
-    L->log(Message);
+    L->log(Level, Message);
   else {
     static std::mutex Mu;
     std::lock_guard<std::mutex> Guard(Mu);
     llvm::errs() << Message << "\n";
   }
 }
 
+const char *detail::debugType(const char *Filename) {
+  if (const char *Slash = strrchr(Filename, '/'))
+    return Slash + 1;
+  if (const char *Backslash = strrchr(Filename, '\\'))
+    return Backslash + 1;
+  return Filename;
+}
+
 } // namespace clangd
 } // namespace clang

clang-tools-extra/trunk/clangd/Protocol.cpp

URIForFile::URIForFile(std::string AbsPath) {
   assert(llvm::sys::path::is_absolute(AbsPath) && "the path is relative");
   File = std::move(AbsPath);
 }
 
 bool fromJSON(const json::Value &E, URIForFile &R) {
   if (auto S = E.getAsString()) {
     auto U = URI::parse(*S);
     if (!U) {
-      log("Failed to parse URI " + *S + ": " + llvm::toString(U.takeError()));
+      elog("Failed to parse URI {0}: {1}", *S, U.takeError());
       return false;
     }
     if (U->scheme() != "file" && U->scheme() != "test") {
-      log("Clangd only supports 'file' URI scheme for workspace files: " + *S);
+      elog("Clangd only supports 'file' URI scheme for workspace files: {0}",
+           *S);
       return false;
     }
     auto Path = URI::resolve(*U);
     if (!Path) {
-      log(llvm::toString(Path.takeError()));
+      log("{0}", Path.takeError());
       return false;
     }
     R = URIForFile(*Path);
     return true;
   }
   return false;
 }
 

clang-tools-extra/trunk/clangd/ProtocolHandlers.cpp

struct HandlerRegisterer {
   void operator()(StringRef Method, void (ProtocolCallbacks::*Handler)(Param)) {
     // Capture pointers by value, as the lambda will outlive this object.
     auto *Callbacks = this->Callbacks;
     Dispatcher.registerHandler(Method, [=](const json::Value &RawParams) {
       typename std::remove_reference<Param>::type P;
       if (fromJSON(RawParams, P)) {
         (Callbacks->*Handler)(P);
       } else {
-        log("Failed to decode " + Method + " request.");
+        elog("Failed to decode {0} request.", Method);
       }
     });
   }
 
   JSONRPCDispatcher &Dispatcher;
   ProtocolCallbacks *Callbacks;
 };
 

clang-tools-extra/trunk/clangd/SourceCode.cpp

 
 llvm::Optional<std::string>
 getAbsoluteFilePath(const FileEntry *F, const SourceManager &SourceMgr) {
   SmallString<64> FilePath = F->tryGetRealPathName();
   if (FilePath.empty())
     FilePath = F->getName();
   if (!llvm::sys::path::is_absolute(FilePath)) {
     if (!SourceMgr.getFileManager().makeAbsolutePath(FilePath)) {
-      log("Could not turn relative path to absolute: " + FilePath);
+      log("Could not turn relative path to absolute: {0}", FilePath);
       return llvm::None;
     }
   }
   return FilePath.str().str();
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/trunk/clangd/TUScheduler.cpp

void ASTWorker::update(
     ParseInputs Inputs, WantDiagnostics WantDiags,
     llvm::unique_function<void(std::vector<Diag>)> OnUpdated) {
   auto Task = [=](decltype(OnUpdated) OnUpdated) mutable {
     tooling::CompileCommand OldCommand = std::move(FileInputs.CompileCommand);
     FileInputs = Inputs;
     // Remove the old AST if it's still in cache.
     IdleASTs.take(this);
 
-    log("Updating file " + FileName + " with command [" +
-        Inputs.CompileCommand.Directory + "] " +
+    log("Updating file {0} with command [{1}] {2}", FileName,
+        Inputs.CompileCommand.Directory,
         llvm::join(Inputs.CompileCommand.CommandLine, " "));
     // Rebuild the preamble and the AST.
     std::unique_ptr<CompilerInvocation> Invocation =
         buildCompilerInvocation(Inputs);
     if (!Invocation) {
-      log("Could not build CompilerInvocation for file " + FileName);
+      elog("Could not build CompilerInvocation for file {0}", FileName);
       // Make sure anyone waiting for the preamble gets notified it could not
       // be built.
       PreambleWasBuilt.notify();
       return;
     }
 
     std::shared_ptr<const PreambleData> NewPreamble = buildPreamble(
         FileName, *Invocation, getPossiblyStalePreamble(), OldCommand, Inputs,
if (!FD) {
     FD->Command = Inputs.CompileCommand;
   }
   FD->Worker->update(std::move(Inputs), WantDiags, std::move(OnUpdated));
 }
 
 void TUScheduler::remove(PathRef File) {
   bool Removed = Files.erase(File);
   if (!Removed)
-    log("Trying to remove file from TUScheduler that is not tracked. File:" +
+    elog("Trying to remove file from TUScheduler that is not tracked: {0}",
          File);
 }
 
 void TUScheduler::runWithAST(
     llvm::StringRef Name, PathRef File,
     llvm::unique_function<void(llvm::Expected<InputsAndAST>)> Action) {
   auto It = Files.find(File);
   if (It == Files.end()) {
     Action(llvm::make_error<llvm::StringError>(

clang-tools-extra/trunk/clangd/XRefs.cpp

 // FIXME: figure out a good home for it, and share the implementation with
 // FindSymbols.
 llvm::Optional<Location> ToLSPLocation(const SymbolLocation &Loc,
                                        llvm::StringRef HintPath) {
   if (!Loc)
     return llvm::None;
   auto Uri = URI::parse(Loc.FileURI);
   if (!Uri) {
-    log("Could not parse URI: " + Loc.FileURI);
+    log("Could not parse URI: {0}", Loc.FileURI);
     return llvm::None;
   }
   auto Path = URI::resolve(*Uri, HintPath);
   if (!Path) {
-    log("Could not resolve URI: " + Loc.FileURI);
+    log("Could not resolve URI: {0}", Loc.FileURI);
     return llvm::None;
   }
   Location LSPLoc;
   LSPLoc.uri = URIForFile(*Path);
   LSPLoc.range.start.line = Loc.Start.Line;
   LSPLoc.range.start.character = Loc.Start.Column;
   LSPLoc.range.end.line = Loc.End.Line;
   LSPLoc.range.end.character = Loc.End.Column;

clang-tools-extra/trunk/clangd/index/SymbolCollector.cpp

 // The Path can be a path relative to the build directory, or retrieved from
 // the SourceManager.
 llvm::Optional<std::string> toURI(const SourceManager &SM, StringRef Path,
                                   const SymbolCollector::Options &Opts) {
   llvm::SmallString<128> AbsolutePath(Path);
   if (std::error_code EC =
           SM.getFileManager().getVirtualFileSystem()->makeAbsolute(
               AbsolutePath))
-    log("Warning: could not make absolute file: " + EC.message());
+    log("Warning: could not make absolute file: {0}", EC.message());
   if (llvm::sys::path::is_absolute(AbsolutePath)) {
     // Handle the symbolic link path case where the current working directory
     // (getCurrentWorkingDirectory) is a symlink./ We always want to the real
     // file path (instead of the symlink path) for the  C++ symbols.
     //
     // Consider the following example:
     //
     //   src dir: /project/src/foo.h
llvm::Optional<std::string> toURI(const SourceManager &SM, StringRef Path,
 
   std::string ErrMsg;
   for (const auto &Scheme : Opts.URISchemes) {
     auto U = URI::create(AbsolutePath, Scheme);
     if (U)
       return U->toString();
     ErrMsg += llvm::toString(U.takeError()) + "\n";
   }
-  log(llvm::Twine("Failed to create an URI for file ") + AbsolutePath + ": " +
-      ErrMsg);
+  log("Failed to create an URI for file {0}: {1}", AbsolutePath, ErrMsg);
   return llvm::None;
 }
 
 // All proto generated headers should start with this line.
 static const char *PROTO_HEADER_COMMENT =
     "// Generated by the protocol buffer compiler.  DO NOT EDIT!";
 
 // Checks whether the decl is a private symbol in a header generated by

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

llvm::cl::values(
         clEnumValN(JSONStreamStyle::Delimited, "delimited",
                    "messages delimited by --- lines, with # comment support")),
     llvm::cl::init(JSONStreamStyle::Standard));
 
 static llvm::cl::opt<bool>
     PrettyPrint("pretty", llvm::cl::desc("Pretty-print JSON output"),
                 llvm::cl::init(false));
 
+static llvm::cl::opt<Logger::Level> LogLevel(
+    "log", llvm::cl::desc("Verbosity of log messages written to stderr"),
+    llvm::cl::values(clEnumValN(Logger::Error, "error", "Error messages only"),
+                     clEnumValN(Logger::Info, "info",
+                                "High level execution tracing"),
+                     clEnumValN(Logger::Debug, "verbose", "Low level details")),
+    llvm::cl::init(Logger::Info));
+
 static llvm::cl::opt<bool> Test(
     "lit-test",
     llvm::cl::desc(
         "Abbreviation for -input-style=delimited -pretty -run-synchronously. "
         "Intended to simplify lit tests."),
     llvm::cl::init(false), llvm::cl::Hidden);
 
 static llvm::cl::opt<PCHStorageFlag> PCHStorage(
if (EC) {
       Tracer = trace::createJSONTracer(*TraceStream, PrettyPrint);
     }
   }
 
   llvm::Optional<trace::Session> TracingSession;
   if (Tracer)
     TracingSession.emplace(*Tracer);
 
-  JSONOutput Out(llvm::outs(), llvm::errs(),
+  JSONOutput Out(llvm::outs(), llvm::errs(), LogLevel,
                  InputMirrorStream ? InputMirrorStream.getPointer() : nullptr,
                  PrettyPrint);
 
   clangd::LoggingSession LoggingSession(Out);
 
   // If --compile-commands-dir arg was invoked, check value and override default
   // path.
   llvm::Optional<Path> CompileCommandsDirPath;