/build/source/clang-tools-extra/clangd/ClangdServer.cpp

Bug Summary

File:	build/source/clang-tools-extra/clangd/ClangdServer.cpp
Warning:	line 85, column 5 Potential leak of memory pointed to by field '_M_head_impl'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ClangdServer.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-17/lib/clang/17 -D CLANG_REPOSITORY_STRING="++20230322120329+2b21327fee50-1~exp1~20230322000449.1178" -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/clang/tools/extra/clangd -I /build/source/clang-tools-extra/clangd -I /build/source/clang-tools-extra/clangd/../include-cleaner/include -I tools/clang/tools/extra/clangd/../clang-tidy -I /build/source/clang/include -I tools/clang/include -I include -I /build/source/llvm/include -I /build/source/clang-tools-extra/pseudo/lib/../include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-17/lib/clang/17/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1679443490 -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-03-22-005342-16304-1 -x c++ /build/source/clang-tools-extra/clangd/ClangdServer.cpp

/build/source/clang-tools-extra/clangd/ClangdServer.cpp

→

1//===--- ClangdServer.cpp - Main clangd server code --------------*- C++-*-===//
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//===-------------------------------------------------------------------===//

9#include "ClangdServer.h"
10#include "CodeComplete.h"
11#include "Config.h"
12#include "Diagnostics.h"
13#include "DumpAST.h"
14#include "FindSymbols.h"
15#include "Format.h"
16#include "HeaderSourceSwitch.h"
17#include "InlayHints.h"
18#include "ParsedAST.h"
19#include "Preamble.h"
20#include "Protocol.h"
21#include "SemanticHighlighting.h"
22#include "SemanticSelection.h"
23#include "SourceCode.h"
24#include "TUScheduler.h"
25#include "XRefs.h"
26#include "index/CanonicalIncludes.h"
27#include "index/FileIndex.h"
28#include "index/Merge.h"
29#include "index/StdLib.h"
30#include "refactor/Rename.h"
31#include "refactor/Tweak.h"
32#include "support/Cancellation.h"
33#include "support/Logger.h"
34#include "support/MemoryTree.h"
35#include "support/ThreadsafeFS.h"
36#include "support/Trace.h"
37#include "clang/Format/Format.h"
38#include "clang/Lex/Preprocessor.h"
39#include "clang/Tooling/CompilationDatabase.h"
40#include "clang/Tooling/Core/Replacement.h"
41#include "llvm/ADT/ArrayRef.h"
42#include "llvm/ADT/STLExtras.h"
43#include "llvm/ADT/StringRef.h"
44#include "llvm/Support/Error.h"
45#include "llvm/Support/Path.h"
46#include "llvm/Support/raw_ostream.h"
47#include <algorithm>
48#include <chrono>
49#include <future>
50#include <memory>
51#include <mutex>
52#include <optional>
53#include <string>
54#include <type_traits>

56namespace clang {
57namespace clangd {
58namespace {

60// Update the FileIndex with new ASTs and plumb the diagnostics responses.
61struct UpdateIndexCallbacks : public ParsingCallbacks {
UpdateIndexCallbacks(FileIndex *FIndex,
                     ClangdServer::Callbacks *ServerCallbacks,
                     const ThreadsafeFS &TFS, AsyncTaskRunner *Tasks)
    : FIndex(FIndex), ServerCallbacks(ServerCallbacks), TFS(TFS),
      Stdlib{std::make_shared<StdLibSet>()}, Tasks(Tasks) {}

void onPreambleAST(PathRef Path, llvm::StringRef Version,
                   const CompilerInvocation &CI, ASTContext &Ctx,
                   Preprocessor &PP,
                   const CanonicalIncludes &CanonIncludes) override {
  // If this preamble uses a standard library we haven't seen yet, index it.
  if (FIndex)
1
Assuming field 'FIndex' is non-null→
2
←
Taking true branch→
    if (auto Loc = Stdlib->add(*CI.getLangOpts(), PP.getHeaderSearchInfo()))
3
←
Assuming the condition is true→
4
←
Taking true branch→
      indexStdlib(CI, std::move(*Loc));
5
←
Calling 'UpdateIndexCallbacks::indexStdlib'→

  if (FIndex)
    FIndex->updatePreamble(Path, Version, Ctx, PP, CanonIncludes);
}

void indexStdlib(const CompilerInvocation &CI, StdLibLocation Loc) {
  // This task is owned by Tasks, which outlives the TUScheduler and
  // therefore the UpdateIndexCallbacks.
  // We must be careful that the references we capture outlive TUScheduler.
  auto Task = [LO(*CI.getLangOpts()), Loc(std::move(Loc)),
9
←
Potential leak of memory pointed to by field '_M_head_impl'
               CI(std::make_unique<CompilerInvocation>(CI)),
6
←
Calling 'make_unique<clang::CompilerInvocation, const clang::CompilerInvocation &>'→
8
←
Returned allocated memory→
               // External values that outlive ClangdServer
               TFS(&TFS),
               // Index outlives TUScheduler (declared first)
               FIndex(FIndex),
               // shared_ptr extends lifetime
               Stdlib(Stdlib)]() mutable {
    IndexFileIn IF;
    IF.Symbols = indexStandardLibrary(std::move(CI), Loc, *TFS);
    if (Stdlib->isBest(LO))
      FIndex->updatePreamble(std::move(IF));
  };
  if (Tasks)
    // This doesn't have a semaphore to enforce -j, but it's rare.
    Tasks->runAsync("IndexStdlib", std::move(Task));
  else
    Task();
}

void onMainAST(PathRef Path, ParsedAST &AST, PublishFn Publish) override {
  if (FIndex)
    FIndex->updateMain(Path, AST);

  assert(AST.getDiagnostics() &&(static_cast <bool> (AST.getDiagnostics() && "We issue callback only with fresh preambles"
) ? void (0) : __assert_fail ("AST.getDiagnostics() && \"We issue callback only with fresh preambles\""
, "clang-tools-extra/clangd/ClangdServer.cpp", 110, __extension__
 __PRETTY_FUNCTION__))
         "We issue callback only with fresh preambles")(static_cast <bool> (AST.getDiagnostics() && "We issue callback only with fresh preambles"
) ? void (0) : __assert_fail ("AST.getDiagnostics() && \"We issue callback only with fresh preambles\""
, "clang-tools-extra/clangd/ClangdServer.cpp", 110, __extension__
 __PRETTY_FUNCTION__));
  std::vector<Diag> Diagnostics = *AST.getDiagnostics();
  if (ServerCallbacks)
    Publish([&]() {
      ServerCallbacks->onDiagnosticsReady(Path, AST.version(),
                                          std::move(Diagnostics));
    });
}

void onFailedAST(PathRef Path, llvm::StringRef Version,
                 std::vector<Diag> Diags, PublishFn Publish) override {
  if (ServerCallbacks)
    Publish(
        [&]() { ServerCallbacks->onDiagnosticsReady(Path, Version, Diags); });
}

void onFileUpdated(PathRef File, const TUStatus &Status) override {
  if (ServerCallbacks)
    ServerCallbacks->onFileUpdated(File, Status);
}

void onPreamblePublished(PathRef File) override {
  if (ServerCallbacks)
    ServerCallbacks->onSemanticsMaybeChanged(File);
}

136private:
FileIndex *FIndex;
ClangdServer::Callbacks *ServerCallbacks;
const ThreadsafeFS &TFS;
std::shared_ptr<StdLibSet> Stdlib;
AsyncTaskRunner *Tasks;
142};

144class DraftStoreFS : public ThreadsafeFS {
145public:
DraftStoreFS(const ThreadsafeFS &Base, const DraftStore &Drafts)
    : Base(Base), DirtyFiles(Drafts) {}

149private:
llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> viewImpl() const override {
  auto OFS = llvm::makeIntrusiveRefCnt<llvm::vfs::OverlayFileSystem>(
      Base.view(std::nullopt));
  OFS->pushOverlay(DirtyFiles.asVFS());
  return OFS;
}

const ThreadsafeFS &Base;
const DraftStore &DirtyFiles;
159};

161} // namespace

163ClangdServer::Options ClangdServer::optsForTest() {
ClangdServer::Options Opts;
Opts.UpdateDebounce = DebouncePolicy::fixed(/*zero*/ {});
Opts.StorePreamblesInMemory = true;
Opts.AsyncThreadsCount = 4; // Consistent!
return Opts;
169}

171ClangdServer::Options::operator TUScheduler::Options() const {
TUScheduler::Options Opts;
Opts.AsyncThreadsCount = AsyncThreadsCount;
Opts.RetentionPolicy = RetentionPolicy;
Opts.StorePreamblesInMemory = StorePreamblesInMemory;
Opts.UpdateDebounce = UpdateDebounce;
Opts.ContextProvider = ContextProvider;
Opts.PreambleThrottler = PreambleThrottler;
return Opts;
180}

182ClangdServer::ClangdServer(const GlobalCompilationDatabase &CDB,
                         const ThreadsafeFS &TFS, const Options &Opts,
                         Callbacks *Callbacks)
  : FeatureModules(Opts.FeatureModules), CDB(CDB), TFS(TFS),
    DynamicIdx(Opts.BuildDynamicSymbolIndex ? new FileIndex() : nullptr),
    ClangTidyProvider(Opts.ClangTidyProvider),
    UseDirtyHeaders(Opts.UseDirtyHeaders),
    LineFoldingOnly(Opts.LineFoldingOnly),
    PreambleParseForwardingFunctions(Opts.PreambleParseForwardingFunctions),
    ImportInsertions(Opts.ImportInsertions),
    WorkspaceRoot(Opts.WorkspaceRoot),
    Transient(Opts.ImplicitCancellation ? TUScheduler::InvalidateOnUpdate
                                        : TUScheduler::NoInvalidation),
    DirtyFS(std::make_unique<DraftStoreFS>(TFS, DraftMgr)) {
if (Opts.AsyncThreadsCount != 0)
  IndexTasks.emplace();
// Pass a callback into `WorkScheduler` to extract symbols from a newly
// parsed file and rebuild the file index synchronously each time an AST
// is parsed.
WorkScheduler.emplace(CDB, TUScheduler::Options(Opts),
                      std::make_unique<UpdateIndexCallbacks>(
                          DynamicIdx.get(), Callbacks, TFS,
                          IndexTasks ? &*IndexTasks : nullptr));
// Adds an index to the stack, at higher priority than existing indexes.
auto AddIndex = [&](SymbolIndex *Idx) {
  if (this->Index != nullptr) {
    MergedIdx.push_back(std::make_unique<MergedIndex>(Idx, this->Index));
    this->Index = MergedIdx.back().get();
  } else {
    this->Index = Idx;
  }
};
if (Opts.StaticIndex)
  AddIndex(Opts.StaticIndex);
if (Opts.BackgroundIndex) {
  BackgroundIndex::Options BGOpts;
  BGOpts.ThreadPoolSize = std::max(Opts.AsyncThreadsCount, 1u);
  BGOpts.OnProgress = [Callbacks](BackgroundQueue::Stats S) {
    if (Callbacks)
      Callbacks->onBackgroundIndexProgress(S);
  };
  BGOpts.ContextProvider = Opts.ContextProvider;
  BackgroundIdx = std::make_unique<BackgroundIndex>(
      TFS, CDB,
      BackgroundIndexStorage::createDiskBackedStorageFactory(
          [&CDB](llvm::StringRef File) { return CDB.getProjectInfo(File); }),
      std::move(BGOpts));
  AddIndex(BackgroundIdx.get());
}
if (DynamicIdx)
  AddIndex(DynamicIdx.get());

if (Opts.FeatureModules) {
  FeatureModule::Facilities F{
      *this->WorkScheduler,
      this->Index,
      this->TFS,
  };
  for (auto &Mod : *Opts.FeatureModules)
    Mod.initialize(F);
}
243}

245ClangdServer::~ClangdServer() {
// Destroying TUScheduler first shuts down request threads that might
// otherwise access members concurrently.
// (Nobody can be using TUScheduler because we're on the main thread).
WorkScheduler.reset();
// Now requests have stopped, we can shut down feature modules.
if (FeatureModules) {
  for (auto &Mod : *FeatureModules)
    Mod.stop();
  for (auto &Mod : *FeatureModules)
    Mod.blockUntilIdle(Deadline::infinity());
}
257}

259void ClangdServer::addDocument(PathRef File, llvm::StringRef Contents,
                             llvm::StringRef Version,
                             WantDiagnostics WantDiags, bool ForceRebuild) {
std::string ActualVersion = DraftMgr.addDraft(File, Version, Contents);
ParseOptions Opts;
Opts.PreambleParseForwardingFunctions = PreambleParseForwardingFunctions;
Opts.ImportInsertions = ImportInsertions;

// Compile command is set asynchronously during update, as it can be slow.
ParseInputs Inputs;
Inputs.TFS = &getHeaderFS();
Inputs.Contents = std::string(Contents);
Inputs.Version = std::move(ActualVersion);
Inputs.ForceRebuild = ForceRebuild;
Inputs.Opts = std::move(Opts);
Inputs.Index = Index;
Inputs.ClangTidyProvider = ClangTidyProvider;
Inputs.FeatureModules = FeatureModules;
bool NewFile = WorkScheduler->update(File, Inputs, WantDiags);
// If we loaded Foo.h, we want to make sure Foo.cpp is indexed.
if (NewFile && BackgroundIdx)
  BackgroundIdx->boostRelated(File);
281}

283void ClangdServer::reparseOpenFilesIfNeeded(
  llvm::function_ref<bool(llvm::StringRef File)> Filter) {
// Reparse only opened files that were modified.
for (const Path &FilePath : DraftMgr.getActiveFiles())
  if (Filter(FilePath))
    if (auto Draft = DraftMgr.getDraft(FilePath)) // else disappeared in race?
      addDocument(FilePath, *Draft->Contents, Draft->Version,
                  WantDiagnostics::Auto);
291}

293std::shared_ptr<const std::string> ClangdServer::getDraft(PathRef File) const {
auto Draft = DraftMgr.getDraft(File);
if (!Draft)
  return nullptr;
return std::move(Draft->Contents);
298}

300std::function<Context(PathRef)>
301ClangdServer::createConfiguredContextProvider(const config::Provider *Provider,
                                            Callbacks *Publish) {
if (!Provider)
  return [](llvm::StringRef) { return Context::current().clone(); };

struct Impl {
  const config::Provider *Provider;
  ClangdServer::Callbacks *Publish;
  std::mutex PublishMu;

  Impl(const config::Provider *Provider, ClangdServer::Callbacks *Publish)
      : Provider(Provider), Publish(Publish) {}

  Context operator()(llvm::StringRef File) {
    config::Params Params;
    // Don't reread config files excessively often.
    // FIXME: when we see a config file change event, use the event timestamp?
    Params.FreshTime =
        std::chrono::steady_clock::now() - std::chrono::seconds(5);
    llvm::SmallString<256> PosixPath;
    if (!File.empty()) {
      assert(llvm::sys::path::is_absolute(File))(static_cast <bool> (llvm::sys::path::is_absolute(File)
) ? void (0) : __assert_fail ("llvm::sys::path::is_absolute(File)"
, "clang-tools-extra/clangd/ClangdServer.cpp", 322, __extension__
 __PRETTY_FUNCTION__));
      llvm::sys::path::native(File, PosixPath, llvm::sys::path::Style::posix);
      Params.Path = PosixPath.str();
    }

    llvm::StringMap<std::vector<Diag>> ReportableDiagnostics;
    Config C = Provider->getConfig(Params, [&](const llvm::SMDiagnostic &D) {
      // Create the map entry even for note diagnostics we don't report.
      // This means that when the file is parsed with no warnings, we
      // publish an empty set of diagnostics, clearing any the client has.
      handleDiagnostic(D, !Publish || D.getFilename().empty()
                              ? nullptr
                              : &ReportableDiagnostics[D.getFilename()]);
    });
    // Blindly publish diagnostics for the (unopened) parsed config files.
    // We must avoid reporting diagnostics for *the same file* concurrently.
    // Source diags are published elsewhere, but those are different files.
    if (!ReportableDiagnostics.empty()) {
      std::lock_guard<std::mutex> Lock(PublishMu);
      for (auto &Entry : ReportableDiagnostics)
        Publish->onDiagnosticsReady(Entry.first(), /*Version=*/"",
                                    std::move(Entry.second));
    }
    return Context::current().derive(Config::Key, std::move(C));
  }

  void handleDiagnostic(const llvm::SMDiagnostic &D,
                        std::vector<Diag> *ClientDiagnostics) {
    switch (D.getKind()) {
    case llvm::SourceMgr::DK_Error:
      elog("config error at {0}:{1}:{2}: {3}", D.getFilename(), D.getLineNo(),
           D.getColumnNo(), D.getMessage());
      break;
    case llvm::SourceMgr::DK_Warning:
      log("config warning at {0}:{1}:{2}: {3}", D.getFilename(),
          D.getLineNo(), D.getColumnNo(), D.getMessage());
      break;
    case llvm::SourceMgr::DK_Note:
    case llvm::SourceMgr::DK_Remark:
      vlog("config note at {0}:{1}:{2}: {3}", D.getFilename(), D.getLineNo(),
           D.getColumnNo(), D.getMessage());
      ClientDiagnostics = nullptr; // Don't emit notes as LSP diagnostics.
      break;
    }
    if (ClientDiagnostics)
      ClientDiagnostics->push_back(toDiag(D, Diag::ClangdConfig));
  }
};

// Copyable wrapper.
return [I(std::make_shared<Impl>(Provider, Publish))](llvm::StringRef Path) {
  return (*I)(Path);
};
375}

377void ClangdServer::removeDocument(PathRef File) {
DraftMgr.removeDraft(File);
WorkScheduler->remove(File);
380}

382void ClangdServer::codeComplete(PathRef File, Position Pos,
                              const clangd::CodeCompleteOptions &Opts,
                              Callback<CodeCompleteResult> CB) {
// Copy completion options for passing them to async task handler.
auto CodeCompleteOpts = Opts;
if (!CodeCompleteOpts.Index) // Respect overridden index.
  CodeCompleteOpts.Index = Index;

auto Task = [Pos, CodeCompleteOpts, File = File.str(), CB = std::move(CB),
             this](llvm::Expected<InputsAndPreamble> IP) mutable {
  if (!IP)
    return CB(IP.takeError());
  if (auto Reason = isCancelled())
    return CB(llvm::make_error<CancelledError>(Reason));

  std::optional<SpeculativeFuzzyFind> SpecFuzzyFind;
  if (!IP->Preamble) {
    // No speculation in Fallback mode, as it's supposed to be much faster
    // without compiling.
    vlog("Build for file {0} is not ready. Enter fallback mode.", File);
  } else if (CodeCompleteOpts.Index) {
    SpecFuzzyFind.emplace();
    {
      std::lock_guard<std::mutex> Lock(CachedCompletionFuzzyFindRequestMutex);
      SpecFuzzyFind->CachedReq = CachedCompletionFuzzyFindRequestByFile[File];
    }
  }
  ParseInputs ParseInput{IP->Command, &getHeaderFS(), IP->Contents.str()};
  // FIXME: Add traling new line if there is none at eof, workaround a crash,
  // see https://github.com/clangd/clangd/issues/332
  if (!IP->Contents.endswith("\n"))
    ParseInput.Contents.append("\n");
  ParseInput.Index = Index;

  CodeCompleteOpts.MainFileSignals = IP->Signals;
  CodeCompleteOpts.AllScopes = Config::current().Completion.AllScopes;
  // FIXME(ibiryukov): even if Preamble is non-null, we may want to check
  // both the old and the new version in case only one of them matches.
  CodeCompleteResult Result = clangd::codeComplete(
      File, Pos, IP->Preamble, ParseInput, CodeCompleteOpts,
      SpecFuzzyFind ? &*SpecFuzzyFind : nullptr);
  {
    clang::clangd::trace::Span Tracer("Completion results callback");
    CB(std::move(Result));
  }
  if (SpecFuzzyFind && SpecFuzzyFind->NewReq) {
    std::lock_guard<std::mutex> Lock(CachedCompletionFuzzyFindRequestMutex);
    CachedCompletionFuzzyFindRequestByFile[File] = *SpecFuzzyFind->NewReq;
  }
  // SpecFuzzyFind is only destroyed after speculative fuzzy find finishes.
  // We don't want `codeComplete` to wait for the async call if it doesn't use
  // the result (e.g. non-index completion, speculation fails), so that `CB`
  // is called as soon as results are available.
};

// We use a potentially-stale preamble because latency is critical here.
WorkScheduler->runWithPreamble(
    "CodeComplete", File,
    (Opts.RunParser == CodeCompleteOptions::AlwaysParse)
        ? TUScheduler::Stale
        : TUScheduler::StaleOrAbsent,
    std::move(Task));
444}

446void ClangdServer::signatureHelp(PathRef File, Position Pos,
                               MarkupKind DocumentationFormat,
                               Callback<SignatureHelp> CB) {

auto Action = [Pos, File = File.str(), CB = std::move(CB),
               DocumentationFormat,
               this](llvm::Expected<InputsAndPreamble> IP) mutable {
  if (!IP)
    return CB(IP.takeError());

  const auto *PreambleData = IP->Preamble;
  if (!PreambleData)
    return CB(error("Failed to parse includes"));

  ParseInputs ParseInput{IP->Command, &getHeaderFS(), IP->Contents.str()};
  // FIXME: Add traling new line if there is none at eof, workaround a crash,
  // see https://github.com/clangd/clangd/issues/332
  if (!IP->Contents.endswith("\n"))
    ParseInput.Contents.append("\n");
  ParseInput.Index = Index;
  CB(clangd::signatureHelp(File, Pos, *PreambleData, ParseInput,
                           DocumentationFormat));
};

// Unlike code completion, we wait for a preamble here.
WorkScheduler->runWithPreamble("SignatureHelp", File, TUScheduler::Stale,
                               std::move(Action));
473}

475void ClangdServer::formatFile(PathRef File, std::optional<Range> Rng,
                            Callback<tooling::Replacements> CB) {
auto Code = getDraft(File);
if (!Code)
  return CB(llvm::make_error<LSPError>("trying to format non-added document",
                                       ErrorCode::InvalidParams));
tooling::Range RequestedRange;
if (Rng) {
  llvm::Expected<size_t> Begin = positionToOffset(*Code, Rng->start);
  if (!Begin)
    return CB(Begin.takeError());
  llvm::Expected<size_t> End = positionToOffset(*Code, Rng->end);
  if (!End)
    return CB(End.takeError());
  RequestedRange = tooling::Range(*Begin, *End - *Begin);
} else {
  RequestedRange = tooling::Range(0, Code->size());
}

// Call clang-format.
auto Action = [File = File.str(), Code = std::move(*Code),
               Ranges = std::vector<tooling::Range>{RequestedRange},
               CB = std::move(CB), this]() mutable {
  format::FormatStyle Style = getFormatStyleForFile(File, Code, TFS);
  tooling::Replacements IncludeReplaces =
      format::sortIncludes(Style, Code, Ranges, File);
  auto Changed = tooling::applyAllReplacements(Code, IncludeReplaces);
  if (!Changed)
    return CB(Changed.takeError());

  CB(IncludeReplaces.merge(format::reformat(
      Style, *Changed,
      tooling::calculateRangesAfterReplacements(IncludeReplaces, Ranges),
      File)));
};
WorkScheduler->runQuick("Format", File, std::move(Action));
511}

513void ClangdServer::formatOnType(PathRef File, Position Pos,
                              StringRef TriggerText,
                              Callback<std::vector<TextEdit>> CB) {
auto Code = getDraft(File);
if (!Code)
  return CB(llvm::make_error<LSPError>("trying to format non-added document",
                                       ErrorCode::InvalidParams));
llvm::Expected<size_t> CursorPos = positionToOffset(*Code, Pos);
if (!CursorPos)
  return CB(CursorPos.takeError());
auto Action = [File = File.str(), Code = std::move(*Code),
               TriggerText = TriggerText.str(), CursorPos = *CursorPos,
               CB = std::move(CB), this]() mutable {
  auto Style = format::getStyle(format::DefaultFormatStyle, File,
                                format::DefaultFallbackStyle, Code,
                                TFS.view(/*CWD=*/std::nullopt).get());
  if (!Style)
    return CB(Style.takeError());

  std::vector<TextEdit> Result;
  for (const tooling::Replacement &R :
       formatIncremental(Code, CursorPos, TriggerText, *Style))
    Result.push_back(replacementToEdit(Code, R));
  return CB(Result);
};
WorkScheduler->runQuick("FormatOnType", File, std::move(Action));
539}

541void ClangdServer::prepareRename(PathRef File, Position Pos,
                               std::optional<std::string> NewName,
                               const RenameOptions &RenameOpts,
                               Callback<RenameResult> CB) {
auto Action = [Pos, File = File.str(), CB = std::move(CB),
               NewName = std::move(NewName),
               RenameOpts](llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  // prepareRename is latency-sensitive: we don't query the index, as we
  // only need main-file references
  auto Results =
      clangd::rename({Pos, NewName.value_or("__clangd_rename_placeholder"),
                      InpAST->AST, File, /*FS=*/nullptr,
                      /*Index=*/nullptr, RenameOpts});
  if (!Results) {
    // LSP says to return null on failure, but that will result in a generic
    // failure message. If we send an LSP error response, clients can surface
    // the message to users (VSCode does).
    return CB(Results.takeError());
  }
  return CB(*Results);
};
WorkScheduler->runWithAST("PrepareRename", File, std::move(Action));
565}

567void ClangdServer::rename(PathRef File, Position Pos, llvm::StringRef NewName,
                        const RenameOptions &Opts,
                        Callback<RenameResult> CB) {
auto Action = [File = File.str(), NewName = NewName.str(), Pos, Opts,
               CB = std::move(CB),
               this](llvm::Expected<InputsAndAST> InpAST) mutable {
  // Tracks number of files edited per invocation.
  static constexpr trace::Metric RenameFiles("rename_files",
                                             trace::Metric::Distribution);
  if (!InpAST)
    return CB(InpAST.takeError());
  auto R = clangd::rename({Pos, NewName, InpAST->AST, File,
                           DirtyFS->view(std::nullopt), Index, Opts});
  if (!R)
    return CB(R.takeError());

  if (Opts.WantFormat) {
    auto Style = getFormatStyleForFile(File, InpAST->Inputs.Contents,
                                       *InpAST->Inputs.TFS);
    llvm::Error Err = llvm::Error::success();
    for (auto &E : R->GlobalChanges)
      Err =
          llvm::joinErrors(reformatEdit(E.getValue(), Style), std::move(Err));

    if (Err)
      return CB(std::move(Err));
  }
  RenameFiles.record(R->GlobalChanges.size());
  return CB(*R);
};
WorkScheduler->runWithAST("Rename", File, std::move(Action));
598}

600// May generate several candidate selections, due to SelectionTree ambiguity.
601// vector of pointers because GCC doesn't like non-copyable Selection.
602static llvm::Expected<std::vector<std::unique_ptr<Tweak::Selection>>>
603tweakSelection(const Range &Sel, const InputsAndAST &AST,
             llvm::vfs::FileSystem *FS) {
auto Begin = positionToOffset(AST.Inputs.Contents, Sel.start);
if (!Begin)
  return Begin.takeError();
auto End = positionToOffset(AST.Inputs.Contents, Sel.end);
if (!End)
  return End.takeError();
std::vector<std::unique_ptr<Tweak::Selection>> Result;
SelectionTree::createEach(
    AST.AST.getASTContext(), AST.AST.getTokens(), *Begin, *End,
    [&](SelectionTree T) {
      Result.push_back(std::make_unique<Tweak::Selection>(
          AST.Inputs.Index, AST.AST, *Begin, *End, std::move(T), FS));
      return false;
    });
assert(!Result.empty() && "Expected at least one SelectionTree")(static_cast <bool> (!Result.empty() && "Expected at least one SelectionTree"
) ? void (0) : __assert_fail ("!Result.empty() && \"Expected at least one SelectionTree\""
, "clang-tools-extra/clangd/ClangdServer.cpp", 619, __extension__
 __PRETTY_FUNCTION__));
return std::move(Result);
621}

623void ClangdServer::enumerateTweaks(
  PathRef File, Range Sel, llvm::unique_function<bool(const Tweak &)> Filter,
  Callback<std::vector<TweakRef>> CB) {
// Tracks number of times a tweak has been offered.
static constexpr trace::Metric TweakAvailable(
    "tweak_available", trace::Metric::Counter, "tweak_id");
auto Action = [Sel, CB = std::move(CB), Filter = std::move(Filter),
               FeatureModules(this->FeatureModules)](
                  Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  auto Selections = tweakSelection(Sel, *InpAST, /*FS=*/nullptr);
  if (!Selections)
    return CB(Selections.takeError());
  std::vector<TweakRef> Res;
  // Don't allow a tweak to fire more than once across ambiguous selections.
  llvm::DenseSet<llvm::StringRef> PreparedTweaks;
  auto DeduplicatingFilter = [&](const Tweak &T) {
    return Filter(T) && !PreparedTweaks.count(T.id());
  };
  for (const auto &Sel : *Selections) {
    for (auto &T : prepareTweaks(*Sel, DeduplicatingFilter, FeatureModules)) {
      Res.push_back({T->id(), T->title(), T->kind()});
      PreparedTweaks.insert(T->id());
      TweakAvailable.record(1, T->id());
    }
  }

  CB(std::move(Res));
};

WorkScheduler->runWithAST("EnumerateTweaks", File, std::move(Action),
                          Transient);
656}

658void ClangdServer::applyTweak(PathRef File, Range Sel, StringRef TweakID,
                            Callback<Tweak::Effect> CB) {
// Tracks number of times a tweak has been attempted.
static constexpr trace::Metric TweakAttempt(
    "tweak_attempt", trace::Metric::Counter, "tweak_id");
// Tracks number of times a tweak has failed to produce edits.
static constexpr trace::Metric TweakFailed(
    "tweak_failed", trace::Metric::Counter, "tweak_id");
TweakAttempt.record(1, TweakID);
auto Action = [File = File.str(), Sel, TweakID = TweakID.str(),
               CB = std::move(CB),
               this](Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  auto FS = DirtyFS->view(std::nullopt);
  auto Selections = tweakSelection(Sel, *InpAST, FS.get());
  if (!Selections)
    return CB(Selections.takeError());
  std::optional<llvm::Expected<Tweak::Effect>> Effect;
  // Try each selection, take the first one that prepare()s.
  // If they all fail, Effect will hold get the last error.
  for (const auto &Selection : *Selections) {
    auto T = prepareTweak(TweakID, *Selection, FeatureModules);
    if (T) {
      Effect = (*T)->apply(*Selection);
      break;
    }
    Effect = T.takeError();
  }
  assert(Effect && "Expected at least one selection")(static_cast <bool> (Effect && "Expected at least one selection"
) ? void (0) : __assert_fail ("Effect && \"Expected at least one selection\""
, "clang-tools-extra/clangd/ClangdServer.cpp", 687, __extension__
 __PRETTY_FUNCTION__));
  if (*Effect && (*Effect)->FormatEdits) {
    // Format tweaks that require it centrally here.
    for (auto &It : (*Effect)->ApplyEdits) {
      Edit &E = It.second;
      format::FormatStyle Style =
          getFormatStyleForFile(File, E.InitialCode, TFS);
      if (llvm::Error Err = reformatEdit(E, Style))
        elog("Failed to format {0}: {1}", It.first(), std::move(Err));
    }
  } else {
    TweakFailed.record(1, TweakID);
  }
  return CB(std::move(*Effect));
};
WorkScheduler->runWithAST("ApplyTweak", File, std::move(Action));
703}

705void ClangdServer::locateSymbolAt(PathRef File, Position Pos,
                                Callback<std::vector<LocatedSymbol>> CB) {
auto Action = [Pos, CB = std::move(CB),
               this](llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::locateSymbolAt(InpAST->AST, Pos, Index));
};

WorkScheduler->runWithAST("Definitions", File, std::move(Action));
715}

717void ClangdServer::switchSourceHeader(
  PathRef Path, Callback<std::optional<clangd::Path>> CB) {
// We want to return the result as fast as possible, strategy is:
//  1) use the file-only heuristic, it requires some IO but it is much
//     faster than building AST, but it only works when .h/.cc files are in
//     the same directory.
//  2) if 1) fails, we use the AST&Index approach, it is slower but supports
//     different code layout.
if (auto CorrespondingFile =
        getCorrespondingHeaderOrSource(Path, TFS.view(std::nullopt)))
  return CB(std::move(CorrespondingFile));
auto Action = [Path = Path.str(), CB = std::move(CB),
               this](llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(getCorrespondingHeaderOrSource(Path, InpAST->AST, Index));
};
WorkScheduler->runWithAST("SwitchHeaderSource", Path, std::move(Action));
735}

737void ClangdServer::findDocumentHighlights(
  PathRef File, Position Pos, Callback<std::vector<DocumentHighlight>> CB) {
auto Action =
    [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      CB(clangd::findDocumentHighlights(InpAST->AST, Pos));
    };

WorkScheduler->runWithAST("Highlights", File, std::move(Action), Transient);
747}

749void ClangdServer::findHover(PathRef File, Position Pos,
                           Callback<std::optional<HoverInfo>> CB) {
auto Action = [File = File.str(), Pos, CB = std::move(CB),
               this](llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  format::FormatStyle Style = getFormatStyleForFile(
      File, InpAST->Inputs.Contents, *InpAST->Inputs.TFS);
  CB(clangd::getHover(InpAST->AST, Pos, std::move(Style), Index));
};

WorkScheduler->runWithAST("Hover", File, std::move(Action), Transient);
761}

763void ClangdServer::typeHierarchy(PathRef File, Position Pos, int Resolve,
                               TypeHierarchyDirection Direction,
                               Callback<std::vector<TypeHierarchyItem>> CB) {
auto Action = [File = File.str(), Pos, Resolve, Direction, CB = std::move(CB),
               this](Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::getTypeHierarchy(InpAST->AST, Pos, Resolve, Direction, Index,
                              File));
};

WorkScheduler->runWithAST("TypeHierarchy", File, std::move(Action));
775}

777void ClangdServer::superTypes(
  const TypeHierarchyItem &Item,
  Callback<std::optional<std::vector<TypeHierarchyItem>>> CB) {
WorkScheduler->run("typeHierarchy/superTypes", /*Path=*/"",
                   [=, CB = std::move(CB)]() mutable {
                     CB(clangd::superTypes(Item, Index));
                   });
784}

786void ClangdServer::subTypes(const TypeHierarchyItem &Item,
                          Callback<std::vector<TypeHierarchyItem>> CB) {
WorkScheduler->run(
    "typeHierarchy/subTypes", /*Path=*/"",
    [=, CB = std::move(CB)]() mutable { CB(clangd::subTypes(Item, Index)); });
791}

793void ClangdServer::resolveTypeHierarchy(
  TypeHierarchyItem Item, int Resolve, TypeHierarchyDirection Direction,
  Callback<std::optional<TypeHierarchyItem>> CB) {
WorkScheduler->run(
    "Resolve Type Hierarchy", "", [=, CB = std::move(CB)]() mutable {
      clangd::resolveTypeHierarchy(Item, Resolve, Direction, Index);
      CB(Item);
    });
801}

803void ClangdServer::prepareCallHierarchy(
  PathRef File, Position Pos, Callback<std::vector<CallHierarchyItem>> CB) {
auto Action = [File = File.str(), Pos,
               CB = std::move(CB)](Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::prepareCallHierarchy(InpAST->AST, Pos, File));
};
WorkScheduler->runWithAST("CallHierarchy", File, std::move(Action));
812}

814void ClangdServer::incomingCalls(
  const CallHierarchyItem &Item,
  Callback<std::vector<CallHierarchyIncomingCall>> CB) {
WorkScheduler->run("Incoming Calls", "",
                   [CB = std::move(CB), Item, this]() mutable {
                     CB(clangd::incomingCalls(Item, Index));
                   });
821}

823void ClangdServer::inlayHints(PathRef File, std::optional<Range> RestrictRange,
                            Callback<std::vector<InlayHint>> CB) {
auto Action = [RestrictRange(std::move(RestrictRange)),
               CB = std::move(CB)](Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::inlayHints(InpAST->AST, std::move(RestrictRange)));
};
WorkScheduler->runWithAST("InlayHints", File, std::move(Action), Transient);
832}

834void ClangdServer::onFileEvent(const DidChangeWatchedFilesParams &Params) {
// FIXME: Do nothing for now. This will be used for indexing and potentially
// invalidating other caches.
837}

839void ClangdServer::workspaceSymbols(
  llvm::StringRef Query, int Limit,
  Callback<std::vector<SymbolInformation>> CB) {
WorkScheduler->run(
    "getWorkspaceSymbols", /*Path=*/"",
    [Query = Query.str(), Limit, CB = std::move(CB), this]() mutable {
      CB(clangd::getWorkspaceSymbols(Query, Limit, Index,
                                     WorkspaceRoot.value_or("")));
    });
848}

850void ClangdServer::documentSymbols(llvm::StringRef File,
                                 Callback<std::vector<DocumentSymbol>> CB) {
auto Action =
    [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      CB(clangd::getDocumentSymbols(InpAST->AST));
    };
WorkScheduler->runWithAST("DocumentSymbols", File, std::move(Action),
                          Transient);
860}

862void ClangdServer::foldingRanges(llvm::StringRef File,
                               Callback<std::vector<FoldingRange>> CB) {
auto Code = getDraft(File);
if (!Code)
  return CB(llvm::make_error<LSPError>(
      "trying to compute folding ranges for non-added document",
      ErrorCode::InvalidParams));
auto Action = [LineFoldingOnly = LineFoldingOnly, CB = std::move(CB),
               Code = std::move(*Code)]() mutable {
  CB(clangd::getFoldingRanges(Code, LineFoldingOnly));
};
// We want to make sure folding ranges are always available for all the open
// files, hence prefer runQuick to not wait for operations on other files.
WorkScheduler->runQuick("FoldingRanges", File, std::move(Action));
876}

878void ClangdServer::findType(llvm::StringRef File, Position Pos,
                          Callback<std::vector<LocatedSymbol>> CB) {
auto Action =
    [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      CB(clangd::findType(InpAST->AST, Pos));
    };
WorkScheduler->runWithAST("FindType", File, std::move(Action));
887}

889void ClangdServer::findImplementations(
  PathRef File, Position Pos, Callback<std::vector<LocatedSymbol>> CB) {
auto Action = [Pos, CB = std::move(CB),
               this](llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::findImplementations(InpAST->AST, Pos, Index));
};

WorkScheduler->runWithAST("Implementations", File, std::move(Action));
899}

901void ClangdServer::findReferences(PathRef File, Position Pos, uint32_t Limit,
                                bool AddContainer,
                                Callback<ReferencesResult> CB) {
auto Action = [Pos, Limit, AddContainer, CB = std::move(CB),
               this](llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::findReferences(InpAST->AST, Pos, Limit, Index, AddContainer));
};

WorkScheduler->runWithAST("References", File, std::move(Action));
912}

914void ClangdServer::symbolInfo(PathRef File, Position Pos,
                            Callback<std::vector<SymbolDetails>> CB) {
auto Action =
    [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      CB(clangd::getSymbolInfo(InpAST->AST, Pos));
    };

WorkScheduler->runWithAST("SymbolInfo", File, std::move(Action));
924}

926void ClangdServer::semanticRanges(PathRef File,
                                const std::vector<Position> &Positions,
                                Callback<std::vector<SelectionRange>> CB) {
auto Action = [Positions, CB = std::move(CB)](
                  llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  std::vector<SelectionRange> Result;
  for (const auto &Pos : Positions) {
    if (auto Range = clangd::getSemanticRanges(InpAST->AST, Pos))
      Result.push_back(std::move(*Range));
    else
      return CB(Range.takeError());
  }
  CB(std::move(Result));
};
WorkScheduler->runWithAST("SemanticRanges", File, std::move(Action));
943}

945void ClangdServer::documentLinks(PathRef File,
                               Callback<std::vector<DocumentLink>> CB) {
auto Action =
    [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      CB(clangd::getDocumentLinks(InpAST->AST));
    };
WorkScheduler->runWithAST("DocumentLinks", File, std::move(Action),
                          Transient);
955}

957void ClangdServer::semanticHighlights(
  PathRef File, Callback<std::vector<HighlightingToken>> CB) {
auto Action =
    [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      CB(clangd::getSemanticHighlightings(InpAST->AST));
    };
WorkScheduler->runWithAST("SemanticHighlights", File, std::move(Action),
                          Transient);
967}

969void ClangdServer::getAST(PathRef File, std::optional<Range> R,
                        Callback<std::optional<ASTNode>> CB) {
auto Action =
    [R, CB(std::move(CB))](llvm::Expected<InputsAndAST> Inputs) mutable {
      if (!Inputs)
        return CB(Inputs.takeError());
      if (!R) {
        // It's safe to pass in the TU, as dumpAST() does not
        // deserialize the preamble.
        auto Node = DynTypedNode::create(
            *Inputs->AST.getASTContext().getTranslationUnitDecl());
        return CB(dumpAST(Node, Inputs->AST.getTokens(),
                          Inputs->AST.getASTContext()));
      }
      unsigned Start, End;
      if (auto Offset = positionToOffset(Inputs->Inputs.Contents, R->start))
        Start = *Offset;
      else
        return CB(Offset.takeError());
      if (auto Offset = positionToOffset(Inputs->Inputs.Contents, R->end))
        End = *Offset;
      else
        return CB(Offset.takeError());
      bool Success = SelectionTree::createEach(
          Inputs->AST.getASTContext(), Inputs->AST.getTokens(), Start, End,
          [&](SelectionTree T) {
            if (const SelectionTree::Node *N = T.commonAncestor()) {
              CB(dumpAST(N->ASTNode, Inputs->AST.getTokens(),
                         Inputs->AST.getASTContext()));
              return true;
            }
            return false;
          });
      if (!Success)
        CB(std::nullopt);
    };
WorkScheduler->runWithAST("GetAST", File, std::move(Action));
1006}

1008void ClangdServer::customAction(PathRef File, llvm::StringRef Name,
                              Callback<InputsAndAST> Action) {
WorkScheduler->runWithAST(Name, File, std::move(Action));
1011}

1013void ClangdServer::diagnostics(PathRef File, Callback<std::vector<Diag>> CB) {
auto Action =
    [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      if (auto Diags = InpAST->AST.getDiagnostics())
        return CB(*Diags);
      // FIXME: Use ServerCancelled error once it is settled in LSP-3.17.
      return CB(llvm::make_error<LSPError>("server is busy parsing includes",
                                           ErrorCode::InternalError));
    };

WorkScheduler->runWithAST("Diagnostics", File, std::move(Action));
1026}

1028llvm::StringMap<TUScheduler::FileStats> ClangdServer::fileStats() const {
return WorkScheduler->fileStats();
1030}

1032[[nodiscard]] bool
1033ClangdServer::blockUntilIdleForTest(std::optional<double> TimeoutSeconds) {
// Order is important here: we don't want to block on A and then B,
// if B might schedule work on A.

1037#if defined(__has_feature)0 &&                                                  \
  (__has_feature(address_sanitizer)0 || __has_feature(hwaddress_sanitizer)0 || \
   __has_feature(memory_sanitizer)0 || __has_feature(thread_sanitizer)0)
(*TimeoutSeconds) *= 10;
1041#endif

// Nothing else can schedule work on TUScheduler, because it's not threadsafe
// and we're blocking the main thread.
if (!WorkScheduler->blockUntilIdle(timeoutSeconds(TimeoutSeconds)))
  return false;
// TUScheduler is the only thing that starts background indexing work.
if (IndexTasks && !IndexTasks->wait(timeoutSeconds(TimeoutSeconds)))
  return false;

// Unfortunately we don't have strict topological order between the rest of
// the components. E.g. CDB broadcast triggers backrgound indexing.
// This queries the CDB which may discover new work if disk has changed.
//
// So try each one a few times in a loop.
// If there are no tricky interactions then all after the first are no-ops.
// Then on the last iteration, verify they're idle without waiting.
//
// There's a small chance they're juggling work and we didn't catch them :-(
for (std::optional<double> Timeout :
     {TimeoutSeconds, TimeoutSeconds, std::optional<double>(0)}) {
  if (!CDB.blockUntilIdle(timeoutSeconds(Timeout)))
    return false;
  if (BackgroundIdx && !BackgroundIdx->blockUntilIdleForTest(Timeout))
    return false;
  if (FeatureModules && llvm::any_of(*FeatureModules, [&](FeatureModule &M) {
        return !M.blockUntilIdle(timeoutSeconds(Timeout));
      }))
    return false;
}

assert(WorkScheduler->blockUntilIdle(Deadline::zero()) &&(static_cast <bool> (WorkScheduler->blockUntilIdle(Deadline
::zero()) && "Something scheduled work while we're blocking the main thread!"
) ? void (0) : __assert_fail ("WorkScheduler->blockUntilIdle(Deadline::zero()) && \"Something scheduled work while we're blocking the main thread!\""
, "clang-tools-extra/clangd/ClangdServer.cpp", 1073, __extension__
 __PRETTY_FUNCTION__))
       "Something scheduled work while we're blocking the main thread!")(static_cast <bool> (WorkScheduler->blockUntilIdle(Deadline
::zero()) && "Something scheduled work while we're blocking the main thread!"
) ? void (0) : __assert_fail ("WorkScheduler->blockUntilIdle(Deadline::zero()) && \"Something scheduled work while we're blocking the main thread!\""
, "clang-tools-extra/clangd/ClangdServer.cpp", 1073, __extension__
 __PRETTY_FUNCTION__));
return true;
1075}

1077void ClangdServer::profile(MemoryTree &MT) const {
if (DynamicIdx)
  DynamicIdx->profile(MT.child("dynamic_index"));
if (BackgroundIdx)
  BackgroundIdx->profile(MT.child("background_index"));
WorkScheduler->profile(MT.child("tuscheduler"));
1083}
1084} // namespace clangd
1085} // namespace clang

←

/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unique_ptr.h

1// unique_ptr implementation -*- C++ -*-

3// Copyright (C) 2008-2020 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/** @file bits/unique_ptr.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

30#ifndef _UNIQUE_PTR_H1
31#define _UNIQUE_PTR_H1 1

33#include <bits/c++config.h>
34#include <debug/assertions.h>
35#include <type_traits>
36#include <utility>
37#include <tuple>
38#include <bits/stl_function.h>
39#include <bits/functional_hash.h>
40#if __cplusplus201703L > 201703L
41# include <compare>
42# include <ostream>
43#endif

45namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
46{
47_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup pointer_abstractions
 * @{
 */

54#if _GLIBCXX_USE_DEPRECATED1
55#pragma GCC diagnostic push
56#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
template<typename> class auto_ptr;
58#pragma GCC diagnostic pop
59#endif

/// Primary template of default_delete, used by unique_ptr for single objects
template<typename _Tp>
  struct default_delete
  {
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for objects of another type, `_Up`,
     * only if `_Up*` is convertible to `_Tp*`.
     */
    template<typename _Up,
      typename = _Require<is_convertible<_Up*, _Tp*>>>
      default_delete(const default_delete<_Up>&) noexcept { }

    /// Calls `delete __ptr`
    void
    operator()(_Tp* __ptr) const
    {
static_assert(!is_void<_Tp>::value,
      "can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
      "can't delete pointer to incomplete type");
delete __ptr;
    }
  };

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length

/// Specialization of default_delete for arrays, used by `unique_ptr<T[]>`
template<typename _Tp>
  struct default_delete<_Tp[]>
  {
  public:
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for arrays of another type, such as
     * a const-qualified version of `_Tp`.
     *
     * Conversions from types derived from `_Tp` are not allowed because
     * it is undefined to `delete[]` an array of derived types through a
     * pointer to the base type.
     */
    template<typename _Up,
      typename = _Require<is_convertible<_Up(*)[], _Tp(*)[]>>>
      default_delete(const default_delete<_Up[]>&) noexcept { }

    /// Calls `delete[] __ptr`
    template<typename _Up>
typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
operator()(_Up* __ptr) const
{
 static_assert(sizeof(_Tp)>0,
	"can't delete pointer to incomplete type");
 delete [] __ptr;
}
  };

/// @cond undocumented

// Manages the pointer and deleter of a unique_ptr
template <typename _Tp, typename _Dp>
  class __uniq_ptr_impl
  {
    template <typename _Up, typename _Ep, typename = void>
struct _Ptr
{
 using type = _Up*;
};

    template <typename _Up, typename _Ep>
struct
_Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
{
 using type = typename remove_reference<_Ep>::type::pointer;
};

  public:
    using _DeleterConstraint = enable_if<
      __and_<__not_<is_pointer<_Dp>>,
      is_default_constructible<_Dp>>::value>;

    using pointer = typename _Ptr<_Tp, _Dp>::type;

    static_assert( !is_rvalue_reference<_Dp>::value,
     "unique_ptr's deleter type must be a function object type"
     " or an lvalue reference type" );

    __uniq_ptr_impl() = default;
    __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }

    template<typename _Del>
    __uniq_ptr_impl(pointer __p, _Del&& __d)
: _M_t(__p, std::forward<_Del>(__d)) { }

    __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept
    : _M_t(std::move(__u._M_t))
    { __u._M_ptr() = nullptr; }

    __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept
    {
reset(__u.release());
_M_deleter() = std::forward<_Dp>(__u._M_deleter());
return *this;
    }

    pointer&   _M_ptr() { return std::get<0>(_M_t); }
    pointer    _M_ptr() const { return std::get<0>(_M_t); }
    _Dp&       _M_deleter() { return std::get<1>(_M_t); }
    const _Dp& _M_deleter() const { return std::get<1>(_M_t); }

    void reset(pointer __p) noexcept
    {
const pointer __old_p = _M_ptr();
_M_ptr() = __p;
if (__old_p)
 _M_deleter()(__old_p);
    }

    pointer release() noexcept
    {
pointer __p = _M_ptr();
_M_ptr() = nullptr;
return __p;
    }

    void
    swap(__uniq_ptr_impl& __rhs) noexcept
    {
using std::swap;
swap(this->_M_ptr(), __rhs._M_ptr());
swap(this->_M_deleter(), __rhs._M_deleter());
    }

  private:
    tuple<pointer, _Dp> _M_t;
  };

// Defines move construction + assignment as either defaulted or deleted.
template <typename _Tp, typename _Dp,
   bool = is_move_constructible<_Dp>::value,
   bool = is_move_assignable<_Dp>::value>
  struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = default;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
  };

template <typename _Tp, typename _Dp>
  struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = default;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
  };

template <typename _Tp, typename _Dp>
  struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = delete;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
  };

template <typename _Tp, typename _Dp>
  struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = delete;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
  };
/// @endcond

/// 20.7.1.2 unique_ptr for single objects.
template <typename _Tp, typename _Dp = default_delete<_Tp>>
  class unique_ptr
  {
    template <typename _Up>
using _DeleterConstraint =
 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_data<_Tp, _Dp> _M_t;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

  private:
    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep>
using __safe_conversion_up = __and_<
 is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
 __not_<is_array<_Up>>
      >;

  public:
    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr() noexcept
: _M_t()
{ }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    template<typename _Del = deleter_type,
      typename = _Require<is_copy_constructible<_Del>>>
unique_ptr(pointer __p, const deleter_type& __d) noexcept
: _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  An rvalue reference to a (non-reference) deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    template<typename _Del = deleter_type,
      typename = _Require<is_move_constructible<_Del>>>
unique_ptr(pointer __p,
   __enable_if_t<!is_lvalue_reference<_Del>::value,
		 _Del&&> __d) noexcept
: _M_t(__p, std::move(__d))
{ }

    template<typename _Del = deleter_type,
      typename _DelUnref = typename remove_reference<_Del>::type>
unique_ptr(pointer,
   __enable_if_t<is_lvalue_reference<_Del>::value,
		 _DelUnref&&>) = delete;

    /// Creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr(nullptr_t) noexcept
: _M_t()
{ }

    // Move constructors.

    /// Move constructor.
    unique_ptr(unique_ptr&&) = default;

    /** @brief Converting constructor from another type
     *
     * Requires that the pointer owned by @p __u is convertible to the
     * type of pointer owned by this object, @p __u does not own an array,
     * and @p __u has a compatible deleter type.
     */
    template<typename _Up, typename _Ep, typename = _Require<
             __safe_conversion_up<_Up, _Ep>,
      typename conditional<is_reference<_Dp>::value,
		    is_same<_Ep, _Dp>,
		    is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

344#if _GLIBCXX_USE_DEPRECATED1
345#pragma GCC diagnostic push
346#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    /// Converting constructor from @c auto_ptr
    template<typename _Up, typename = _Require<
      is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
351#pragma GCC diagnostic pop
352#endif

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr() noexcept
    {
static_assert(__is_invocable<deleter_type&, pointer>::value,
      "unique_ptr's deleter must be invocable with a pointer");
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
 get_deleter()(std::move(__ptr));
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    unique_ptr& operator=(unique_ptr&&) = default;

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to a non-array object.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
      typename enable_if< __and_<
        __safe_conversion_up<_Up, _Ep>,
        is_assignable<deleter_type&, _Ep&&>
        >::value,
        unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Dereference the stored pointer.
    typename add_lvalue_reference<element_type>::type
    operator*() const
    {
__glibcxx_assert(get() != pointer())do { if (! (get() != pointer())) std::__replacement_assert("/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unique_ptr.h"
, 407, __PRETTY_FUNCTION__, "get() != pointer()"); } while (false
);
return *get();
    }

    /// Return the stored pointer.
    pointer
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
return get();
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    { return _M_t.release(); }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    void
    reset(pointer __p = pointer()) noexcept
    {
static_assert(__is_invocable<deleter_type&, pointer>::value,
      "unique_ptr's deleter must be invocable with a pointer");
_M_t.reset(std::move(__p));
    }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
_M_t.swap(__u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
};

/// 20.7.1.3 unique_ptr for array objects with a runtime length
// [unique.ptr.runtime]
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
template<typename _Tp, typename _Dp>
  class unique_ptr<_Tp[], _Dp>
  {
    template <typename _Up>
    using _DeleterConstraint =
typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_data<_Tp, _Dp> _M_t;

    template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;

    // like is_base_of<_Tp, _Up> but false if unqualified types are the same
    template<typename _Up>
using __is_derived_Tp
 = __and_< is_base_of<_Tp, _Up>,
    __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep,
             typename _UPtr = unique_ptr<_Up, _Ep>,
      typename _UP_pointer = typename _UPtr::pointer,
      typename _UP_element_type = typename _UPtr::element_type>
using __safe_conversion_up = __and_<
        is_array<_Up>,
        is_same<pointer, element_type*>,
        is_same<_UP_pointer, _UP_element_type*>,
        is_convertible<_UP_element_type(*)[], element_type(*)[]>
      >;

    // helper template for detecting a safe conversion from a raw pointer
    template<typename _Up>
      using __safe_conversion_raw = __and_<
        __or_<__or_<is_same<_Up, pointer>,
                    is_same<_Up, nullptr_t>>,
              __and_<is_pointer<_Up>,
                     is_same<pointer, element_type*>,
                     is_convertible<
                       typename remove_pointer<_Up>::type(*)[],
                       element_type(*)[]>
              >
        >
      >;

    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr() noexcept
: _M_t()
{ }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template<typename _Up,
      typename _Vp = _Dp,
      typename = _DeleterConstraint<_Vp>,
      typename = typename enable_if<
               __safe_conversion_raw<_Up>::value, bool>::type>
explicit
unique_ptr(_Up __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    template<typename _Up, typename _Del = deleter_type,
      typename = _Require<__safe_conversion_raw<_Up>,
		   is_copy_constructible<_Del>>>
    unique_ptr(_Up __p, const deleter_type& __d) noexcept
    : _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    template<typename _Up, typename _Del = deleter_type,
      typename = _Require<__safe_conversion_raw<_Up>,
		   is_move_constructible<_Del>>>
unique_ptr(_Up __p,
   __enable_if_t<!is_lvalue_reference<_Del>::value,
		 _Del&&> __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ }

    template<typename _Up, typename _Del = deleter_type,
      typename _DelUnref = typename remove_reference<_Del>::type,
      typename = _Require<__safe_conversion_raw<_Up>>>
unique_ptr(_Up,
   __enable_if_t<is_lvalue_reference<_Del>::value,
		 _DelUnref&&>) = delete;

    /// Move constructor.
    unique_ptr(unique_ptr&&) = default;

    /// Creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr(nullptr_t) noexcept
: _M_t()
      { }

    template<typename _Up, typename _Ep, typename = _Require<
      __safe_conversion_up<_Up, _Ep>,
      typename conditional<is_reference<_Dp>::value,
		    is_same<_Ep, _Dp>,
		    is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr()
    {
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
 get_deleter()(__ptr);
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    unique_ptr&
    operator=(unique_ptr&&) = default;

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to an array object.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
typename
enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
                       is_assignable<deleter_type&, _Ep&&>
                >::value,
                unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Access an element of owned array.
    typename std::add_lvalue_reference<element_type>::type
    operator[](size_t __i) const
    {
__glibcxx_assert(get() != pointer())do { if (! (get() != pointer())) std::__replacement_assert("/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unique_ptr.h"
, 659, __PRETTY_FUNCTION__, "get() != pointer()"); } while (false
);
return get()[__i];
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    { return _M_t.release(); }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    template <typename _Up,
              typename = _Require<
                __or_<is_same<_Up, pointer>,
                      __and_<is_same<pointer, element_type*>,
                             is_pointer<_Up>,
                             is_convertible<
                               typename remove_pointer<_Up>::type(*)[],
                               element_type(*)[]
                             >
                      >
                >
             >>
    void
    reset(_Up __p) noexcept
    { _M_t.reset(std::move(__p)); }

    void reset(nullptr_t = nullptr) noexcept
    { reset(pointer()); }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
_M_t.swap(__u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
  };

/// @relates unique_ptr @{

/// Swap overload for unique_ptr
template<typename _Tp, typename _Dp>
  inline
732#if __cplusplus201703L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
  // Constrained free swap overload, see p0185r1
  typename enable_if<__is_swappable<_Dp>::value>::type
735#else
  void
737#endif
  swap(unique_ptr<_Tp, _Dp>& __x,
unique_ptr<_Tp, _Dp>& __y) noexcept
  { __x.swap(__y); }

742#if __cplusplus201703L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
template<typename _Tp, typename _Dp>
  typename enable_if<!__is_swappable<_Dp>::value>::type
  swap(unique_ptr<_Tp, _Dp>&,
unique_ptr<_Tp, _Dp>&) = delete;
747#endif

/// Equality operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() == __y.get(); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return !__x; }

763#ifndef __cpp_lib_three_way_comparison
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return !__x; }

/// Inequality operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() != __y.get(); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return (bool)__x; }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return (bool)__x; }
789#endif // three way comparison

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  {
    typedef typename
std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
                typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
    return std::less<_CT>()(__x.get(), __y.get());
  }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr);
  }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get());
  }

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__y < __x); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(nullptr < __x); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(__x < nullptr); }

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  { return (__y < __x); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get());
  }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr);
  }

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__x < __y); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(__x < nullptr); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(nullptr < __x); }

888#ifdef __cpp_lib_three_way_comparison
template<typename _Tp, typename _Dp, typename _Up, typename _Ep>
  requires three_way_comparable_with<typename unique_ptr<_Tp, _Dp>::pointer,
		       typename unique_ptr<_Up, _Ep>::pointer>
  inline
  compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer,
	       typename unique_ptr<_Up, _Ep>::pointer>
  operator<=>(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
  { return compare_three_way()(__x.get(), __y.get()); }

template<typename _Tp, typename _Dp>
  requires three_way_comparable<typename unique_ptr<_Tp, _Dp>::pointer>
  inline
  compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer>
  operator<=>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  {
    using pointer = typename unique_ptr<_Tp, _Dp>::pointer;
    return compare_three_way()(__x.get(), static_cast<pointer>(nullptr));
  }
908#endif
// @} relates unique_ptr

/// @cond undocumented
template<typename _Up, typename _Ptr = typename _Up::pointer,
  bool = __poison_hash<_Ptr>::__enable_hash_call>
  struct __uniq_ptr_hash
915#if ! _GLIBCXX_INLINE_VERSION0
  : private __poison_hash<_Ptr>
917#endif
  {
    size_t
    operator()(const _Up& __u) const
    noexcept(noexcept(std::declval<hash<_Ptr>>()(std::declval<_Ptr>())))
    { return hash<_Ptr>()(__u.get()); }
  };

template<typename _Up, typename _Ptr>
  struct __uniq_ptr_hash<_Up, _Ptr, false>
  : private __poison_hash<_Ptr>
  { };
/// @endcond

/// std::hash specialization for unique_ptr.
template<typename _Tp, typename _Dp>
  struct hash<unique_ptr<_Tp, _Dp>>
  : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
    public __uniq_ptr_hash<unique_ptr<_Tp, _Dp>>
  { };

938#if __cplusplus201703L >= 201402L
/// @relates unique_ptr @{
940#define __cpp_lib_make_unique201304 201304

/// @cond undocumented

template<typename _Tp>
  struct _MakeUniq
  { typedef unique_ptr<_Tp> __single_object; };

template<typename _Tp>
  struct _MakeUniq<_Tp[]>
  { typedef unique_ptr<_Tp[]> __array; };

template<typename _Tp, size_t _Bound>
  struct _MakeUniq<_Tp[_Bound]>
  { struct __invalid_type { }; };

/// @endcond

/// std::make_unique for single objects
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__single_object
  make_unique(_Args&&... __args)
  { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
7
←
Memory is allocated→

/// std::make_unique for arrays of unknown bound
template<typename _Tp>
  inline typename _MakeUniq<_Tp>::__array
  make_unique(size_t __num)
  { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }

/// Disable std::make_unique for arrays of known bound
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__invalid_type
  make_unique(_Args&&...) = delete;
// @} relates unique_ptr
975#endif // C++14

977#if __cplusplus201703L > 201703L && __cpp_concepts
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2948. unique_ptr does not define operator<< for stream output
/// Stream output operator for unique_ptr
template<typename _CharT, typename _Traits, typename _Tp, typename _Dp>
  inline basic_ostream<_CharT, _Traits>&
  operator<<(basic_ostream<_CharT, _Traits>& __os,
      const unique_ptr<_Tp, _Dp>& __p)
  requires requires { __os << __p.get(); }
  {
    __os << __p.get();
    return __os;
  }
990#endif // C++20

// @} group pointer_abstractions

994#if __cplusplus201703L >= 201703L
namespace __detail::__variant
{
  template<typename> struct _Never_valueless_alt; // see <variant>

  // Provide the strong exception-safety guarantee when emplacing a
  // unique_ptr into a variant.
  template<typename _Tp, typename _Del>
    struct _Never_valueless_alt<std::unique_ptr<_Tp, _Del>>
    : std::true_type
    { };
}  // namespace __detail::__variant
1006#endif // C++17

1008_GLIBCXX_END_NAMESPACE_VERSION
1009} // namespace

1011#endif /* _UNIQUE_PTR_H */