/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/FunctionExtras.h

Bug Summary

File:	include/llvm/ADT/FunctionExtras.h
Warning:	line 143, column 5 Undefined or garbage value returned to caller

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ClangdServer.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/tools/extra/clangd -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/8/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/tools/extra/clangd -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-07-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp -faddrsig

/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp

→

1//===--- ClangdServer.cpp - Main clangd server code --------------*- C++-*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===-------------------------------------------------------------------===//

10#include "ClangdServer.h"
11#include "CodeComplete.h"
12#include "FindSymbols.h"
13#include "Headers.h"
14#include "SourceCode.h"
15#include "XRefs.h"
16#include "index/Merge.h"
17#include "clang/Format/Format.h"
18#include "clang/Frontend/CompilerInstance.h"
19#include "clang/Frontend/CompilerInvocation.h"
20#include "clang/Lex/Preprocessor.h"
21#include "clang/Tooling/CompilationDatabase.h"
22#include "clang/Tooling/Refactoring/RefactoringResultConsumer.h"
23#include "clang/Tooling/Refactoring/Rename/RenamingAction.h"
24#include "llvm/ADT/ArrayRef.h"
25#include "llvm/ADT/ScopeExit.h"
26#include "llvm/ADT/StringRef.h"
27#include "llvm/Support/Errc.h"
28#include "llvm/Support/FileSystem.h"
29#include "llvm/Support/Path.h"
30#include "llvm/Support/raw_ostream.h"
31#include <future>

33using namespace clang;
34using namespace clang::clangd;

36namespace {

38void ignoreError(llvm::Error Err) {
handleAllErrors(std::move(Err), [](const llvm::ErrorInfoBase &) {});
40}

42std::string getStandardResourceDir() {
static int Dummy; // Just an address in this process.
return CompilerInvocation::GetResourcesPath("clangd", (void *)&Dummy);
45}

47class RefactoringResultCollector final
  : public tooling::RefactoringResultConsumer {
49public:
void handleError(llvm::Error Err) override {
  assert(!Result.hasValue())(static_cast <bool> (!Result.hasValue()) ? void (0) : __assert_fail
 ("!Result.hasValue()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp"
, 51, __extension__ __PRETTY_FUNCTION__));
  // FIXME: figure out a way to return better message for DiagnosticError.
  // clangd uses llvm::toString to convert the Err to string, however, for
  // DiagnosticError, only "clang diagnostic" will be generated.
  Result = std::move(Err);
}

// Using the handle(SymbolOccurrences) from parent class.
using tooling::RefactoringResultConsumer::handle;

void handle(tooling::AtomicChanges SourceReplacements) override {
  assert(!Result.hasValue())(static_cast <bool> (!Result.hasValue()) ? void (0) : __assert_fail
 ("!Result.hasValue()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp"
, 62, __extension__ __PRETTY_FUNCTION__));
  Result = std::move(SourceReplacements);
}

Optional<Expected<tooling::AtomicChanges>> Result;
67};

69} // namespace

71ClangdServer::Options ClangdServer::optsForTest() {
ClangdServer::Options Opts;
Opts.UpdateDebounce = std::chrono::steady_clock::duration::zero(); // Faster!
Opts.StorePreamblesInMemory = true;
Opts.AsyncThreadsCount = 4; // Consistent!
return Opts;
77}

79ClangdServer::ClangdServer(GlobalCompilationDatabase &CDB,
                         FileSystemProvider &FSProvider,
                         DiagnosticsConsumer &DiagConsumer,
                         const Options &Opts)
  : CDB(CDB), DiagConsumer(DiagConsumer), FSProvider(FSProvider),
    ResourceDir(Opts.ResourceDir ? Opts.ResourceDir->str()
                                 : getStandardResourceDir()),
    FileIdx(Opts.BuildDynamicSymbolIndex ? new FileIndex(Opts.URISchemes)
                                         : nullptr),
    PCHs(std::make_shared<PCHContainerOperations>()),
    // 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.
    // FIXME(ioeric): this can be slow and we may be able to index on less
    // critical paths.
    WorkScheduler(
        Opts.AsyncThreadsCount, Opts.StorePreamblesInMemory,
        FileIdx
            ? [this](PathRef Path, ASTContext &AST,
                     std::shared_ptr<Preprocessor>
                         PP) { FileIdx->update(Path, &AST, std::move(PP)); }
            : PreambleParsedCallback(),
        Opts.UpdateDebounce, Opts.RetentionPolicy) {
if (FileIdx && Opts.StaticIndex) {
  MergedIndex = mergeIndex(FileIdx.get(), Opts.StaticIndex);
  Index = MergedIndex.get();
} else if (FileIdx)
  Index = FileIdx.get();
else if (Opts.StaticIndex)
  Index = Opts.StaticIndex;
else
  Index = nullptr;
111}

113void ClangdServer::setRootPath(PathRef RootPath) {
auto FS = FSProvider.getFileSystem();
auto Status = FS->status(RootPath);
if (!Status)
  elog("Failed to get status for RootPath {0}: {1}", RootPath,
       Status.getError().message());
else if (Status->isDirectory())
  this->RootPath = RootPath;
else
  elog("The provided RootPath {0} is not a directory.", RootPath);
123}

125void ClangdServer::addDocument(PathRef File, StringRef Contents,
                             WantDiagnostics WantDiags) {
DocVersion Version = ++InternalVersion[File];
ParseInputs Inputs = {getCompileCommand(File), FSProvider.getFileSystem(),
                      Contents.str()};

Path FileStr = File.str();
WorkScheduler.update(File, std::move(Inputs), WantDiags,
                     [this, FileStr, Version](std::vector<Diag> Diags) {
                       consumeDiagnostics(FileStr, Version, std::move(Diags));
                     });
136}

138void ClangdServer::removeDocument(PathRef File) {
++InternalVersion[File];
WorkScheduler.remove(File);
141}

143void 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;

// Copy PCHs to avoid accessing this->PCHs concurrently
std::shared_ptr<PCHContainerOperations> PCHs = this->PCHs;
auto FS = FSProvider.getFileSystem();
auto Task = [PCHs, Pos, FS,
             CodeCompleteOpts](Path File, Callback<CodeCompleteResult> CB,
                               llvm::Expected<InputsAndPreamble> IP) {
  if (!IP)
    return CB(IP.takeError());

  auto PreambleData = IP->Preamble;

  // 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, IP->Command, PreambleData ? &PreambleData->Preamble : nullptr,
      PreambleData ? PreambleData->Includes : IncludeStructure(),
      IP->Contents, Pos, FS, PCHs, CodeCompleteOpts);
  CB(std::move(Result));
};

WorkScheduler.runWithPreamble("CodeComplete", File,
                              Bind(Task, File.str(), std::move(CB)));
173}

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

auto PCHs = this->PCHs;
auto FS = FSProvider.getFileSystem();
auto Action = [Pos, FS, PCHs](Path File, Callback<SignatureHelp> CB,
                              llvm::Expected<InputsAndPreamble> IP) {
  if (!IP)
    return CB(IP.takeError());

  auto PreambleData = IP->Preamble;
  CB(clangd::signatureHelp(File, IP->Command,
                           PreambleData ? &PreambleData->Preamble : nullptr,
                           IP->Contents, Pos, FS, PCHs));
};

WorkScheduler.runWithPreamble("SignatureHelp", File,
                              Bind(Action, File.str(), std::move(CB)));
193}

195llvm::Expected<tooling::Replacements>
196ClangdServer::formatRange(StringRef Code, PathRef File, Range Rng) {
llvm::Expected<size_t> Begin = positionToOffset(Code, Rng.start);
if (!Begin)
  return Begin.takeError();
llvm::Expected<size_t> End = positionToOffset(Code, Rng.end);
if (!End)
  return End.takeError();
return formatCode(Code, File, {tooling::Range(*Begin, *End - *Begin)});
204}

206llvm::Expected<tooling::Replacements> ClangdServer::formatFile(StringRef Code,
                                                             PathRef File) {
// Format everything.
return formatCode(Code, File, {tooling::Range(0, Code.size())});
210}

212llvm::Expected<tooling::Replacements>
213ClangdServer::formatOnType(StringRef Code, PathRef File, Position Pos) {
// Look for the previous opening brace from the character position and
// format starting from there.
llvm::Expected<size_t> CursorPos = positionToOffset(Code, Pos);
if (!CursorPos)
  return CursorPos.takeError();
size_t PreviousLBracePos = StringRef(Code).find_last_of('{', *CursorPos);
if (PreviousLBracePos == StringRef::npos)
  PreviousLBracePos = *CursorPos;
size_t Len = *CursorPos - PreviousLBracePos;

return formatCode(Code, File, {tooling::Range(PreviousLBracePos, Len)});
225}

227void ClangdServer::rename(PathRef File, Position Pos, llvm::StringRef NewName,
                        Callback<std::vector<tooling::Replacement>> CB) {
auto Action = [Pos](Path File, std::string NewName,
                    Callback<std::vector<tooling::Replacement>> CB,
                    Expected<InputsAndAST> InpAST) {
  if (!InpAST)
    return CB(InpAST.takeError());
  auto &AST = InpAST->AST;

  RefactoringResultCollector ResultCollector;
  const SourceManager &SourceMgr = AST.getASTContext().getSourceManager();
  SourceLocation SourceLocationBeg =
      clangd::getBeginningOfIdentifier(AST, Pos, SourceMgr.getMainFileID());
  tooling::RefactoringRuleContext Context(
      AST.getASTContext().getSourceManager());
  Context.setASTContext(AST.getASTContext());
  auto Rename = clang::tooling::RenameOccurrences::initiate(
      Context, SourceRange(SourceLocationBeg), NewName);
  if (!Rename)
    return CB(Rename.takeError());

  Rename->invoke(ResultCollector, Context);

  assert(ResultCollector.Result.hasValue())(static_cast <bool> (ResultCollector.Result.hasValue())
 ? void (0) : __assert_fail ("ResultCollector.Result.hasValue()"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp"
, 250, __extension__ __PRETTY_FUNCTION__));
  if (!ResultCollector.Result.getValue())
    return CB(ResultCollector.Result->takeError());

  std::vector<tooling::Replacement> Replacements;
  for (const tooling::AtomicChange &Change : ResultCollector.Result->get()) {
    tooling::Replacements ChangeReps = Change.getReplacements();
    for (const auto &Rep : ChangeReps) {
      // FIXME: Right now we only support renaming the main file, so we
      // drop replacements not for the main file. In the future, we might
      // consider to support:
      //   * rename in any included header
      //   * rename only in the "main" header
      //   * provide an error if there are symbols we won't rename (e.g.
      //     std::vector)
      //   * rename globally in project
      //   * rename in open files
      if (Rep.getFilePath() == File)
        Replacements.push_back(Rep);
    }
  }
  return CB(std::move(Replacements));
};

WorkScheduler.runWithAST(
    "Rename", File, Bind(Action, File.str(), NewName.str(), std::move(CB)));
276}

278void ClangdServer::dumpAST(PathRef File,
                         llvm::unique_function<void(std::string)> Callback) {
auto Action = [](decltype(Callback) Callback,
                 llvm::Expected<InputsAndAST> InpAST) {
  if (!InpAST) {
    ignoreError(InpAST.takeError());
    return Callback("<no-ast>");
  }
  std::string Result;

  llvm::raw_string_ostream ResultOS(Result);
  clangd::dumpAST(InpAST->AST, ResultOS);
  ResultOS.flush();

  Callback(Result);
};

WorkScheduler.runWithAST("DumpAST", File, Bind(Action, std::move(Callback)));
296}

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

WorkScheduler.runWithAST("Definitions", File, Bind(Action, std::move(CB)));
308}

310llvm::Optional<Path> ClangdServer::switchSourceHeader(PathRef Path) {

StringRef SourceExtensions[] = {".cpp", ".c", ".cc", ".cxx",
                                ".c++", ".m", ".mm"};
StringRef HeaderExtensions[] = {".h", ".hh", ".hpp", ".hxx", ".inc"};

StringRef PathExt = llvm::sys::path::extension(Path);

// Lookup in a list of known extensions.
auto SourceIter =
    std::find_if(std::begin(SourceExtensions), std::end(SourceExtensions),
                 [&PathExt](PathRef SourceExt) {
                   return SourceExt.equals_lower(PathExt);
                 });
bool IsSource = SourceIter != std::end(SourceExtensions);

auto HeaderIter =
    std::find_if(std::begin(HeaderExtensions), std::end(HeaderExtensions),
                 [&PathExt](PathRef HeaderExt) {
                   return HeaderExt.equals_lower(PathExt);
                 });

bool IsHeader = HeaderIter != std::end(HeaderExtensions);

// We can only switch between the known extensions.
if (!IsSource && !IsHeader)
  return llvm::None;

// Array to lookup extensions for the switch. An opposite of where original
// extension was found.
ArrayRef<StringRef> NewExts;
if (IsSource)
  NewExts = HeaderExtensions;
else
  NewExts = SourceExtensions;

// Storage for the new path.
SmallString<128> NewPath = StringRef(Path);

// Instance of vfs::FileSystem, used for file existence checks.
auto FS = FSProvider.getFileSystem();

// Loop through switched extension candidates.
for (StringRef NewExt : NewExts) {
  llvm::sys::path::replace_extension(NewPath, NewExt);
  if (FS->exists(NewPath))
    return NewPath.str().str(); // First str() to convert from SmallString to
                                // StringRef, second to convert from StringRef
                                // to std::string

  // Also check NewExt in upper-case, just in case.
  llvm::sys::path::replace_extension(NewPath, NewExt.upper());
  if (FS->exists(NewPath))
    return NewPath.str().str();
}

return llvm::None;
367}

369llvm::Expected<tooling::Replacements>
370ClangdServer::formatCode(llvm::StringRef Code, PathRef File,
                       ArrayRef<tooling::Range> Ranges) {
// Call clang-format.
auto FS = FSProvider.getFileSystem();
auto Style = format::getStyle(format::DefaultFormatStyle, File,
                              format::DefaultFallbackStyle, Code, FS.get());
if (!Style)
  return Style.takeError();

tooling::Replacements IncludeReplaces =
    format::sortIncludes(*Style, Code, Ranges, File);
auto Changed = tooling::applyAllReplacements(Code, IncludeReplaces);
if (!Changed)
  return Changed.takeError();

return IncludeReplaces.merge(format::reformat(
    Style.get(), *Changed,
    tooling::calculateRangesAfterReplacements(IncludeReplaces, Ranges),
    File));
389}

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

WorkScheduler.runWithAST("Highlights", File, Bind(Action, std::move(CB)));
401}

403void ClangdServer::findHover(PathRef File, Position Pos,
                           Callback<llvm::Optional<Hover>> CB) {
auto Action = [Pos](Callback<llvm::Optional<Hover>> CB,
                    llvm::Expected<InputsAndAST> InpAST) {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::getHover(InpAST->AST, Pos));
};

WorkScheduler.runWithAST("Hover", File, Bind(Action, std::move(CB)));
413}

415void ClangdServer::consumeDiagnostics(PathRef File, DocVersion Version,
                                    std::vector<Diag> Diags) {
// We need to serialize access to resulting diagnostics to avoid calling
// `onDiagnosticsReady` in the wrong order.
std::lock_guard<std::mutex> DiagsLock(DiagnosticsMutex);
DocVersion &LastReportedDiagsVersion = ReportedDiagnosticVersions[File];

// FIXME(ibiryukov): get rid of '<' comparison here. In the current
// implementation diagnostics will not be reported after version counters'
// overflow. This should not happen in practice, since DocVersion is a
// 64-bit unsigned integer.
if (Version < LastReportedDiagsVersion)
  return;
LastReportedDiagsVersion = Version;

DiagConsumer.onDiagnosticsReady(File, std::move(Diags));
431}

433tooling::CompileCommand ClangdServer::getCompileCommand(PathRef File) {
llvm::Optional<tooling::CompileCommand> C = CDB.getCompileCommand(File);
if (!C) // FIXME: Suppress diagnostics? Let the user know?
  C = CDB.getFallbackCommand(File);

// Inject the resource dir.
// FIXME: Don't overwrite it if it's already there.
C->CommandLine.push_back("-resource-dir=" + ResourceDir);
return std::move(*C);
442}

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

449void ClangdServer::workspaceSymbols(
  StringRef Query, int Limit, Callback<std::vector<SymbolInformation>> CB) {
CB(clangd::getWorkspaceSymbols(Query, Limit, Index,
                               RootPath ? *RootPath : ""));
453}

455void ClangdServer::documentSymbols(
  StringRef File, Callback<std::vector<SymbolInformation>> CB) {
auto Action = [](Callback<std::vector<SymbolInformation>> CB,
                 llvm::Expected<InputsAndAST> InpAST) {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::getDocumentSymbols(InpAST->AST));
};
WorkScheduler.runWithAST("documentSymbols", File,
                         Bind(Action, std::move(CB)));
1
Calling 'Bind<(lambda at /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp:457:17), llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>>'→
465}

467std::vector<std::pair<Path, std::size_t>>
468ClangdServer::getUsedBytesPerFile() const {
return WorkScheduler.getUsedBytesPerFile();
470}

472LLVM_NODISCARD[[clang::warn_unused_result]] bool
473ClangdServer::blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds) {
return WorkScheduler.blockUntilIdle(timeoutSeconds(TimeoutSeconds));
475}

←

/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/Function.h

→

1//===--- Function.h - Utility callable wrappers  -----------------*- C++-*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file provides utilities for callable objects.
11//
12//===----------------------------------------------------------------------===//
13 
14#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_FUNCTION_H
15#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_FUNCTION_H
16 
17#include "llvm/ADT/FunctionExtras.h"
18#include "llvm/Support/Error.h"
19#include <tuple>
20#include <utility>
21 
22namespace clang {
23namespace clangd {
24 
25/// A Callback<T> is a void function that accepts Expected<T>.
26/// This is accepted by ClangdServer functions that logically return T.
27template <typename T>
28using Callback = llvm::unique_function<void(llvm::Expected<T>)>;
29 
30/// Stores a callable object (Func) and arguments (Args) and allows to call the
31/// callable with provided arguments later using `operator ()`. The arguments
32/// are std::forward'ed into the callable in the body of `operator()`. Therefore
33/// `operator()` can only be called once, as some of the arguments could be
34/// std::move'ed into the callable on first call.
35template <class Func, class... Args> struct ForwardBinder {
36  using Tuple = std::tuple<typename std::decay<Func>::type,
37                           typename std::decay<Args>::type...>;
38  Tuple FuncWithArguments;
39#ifndef NDEBUG
40  bool WasCalled = false;
41#endif
42 
43public:
44  ForwardBinder(Tuple FuncWithArguments)
45      : FuncWithArguments(std::move(FuncWithArguments)) {}
46 
47private:
48  template <std::size_t... Indexes, class... RestArgs>
49  auto CallImpl(llvm::integer_sequence<std::size_t, Indexes...> Seq,
50                RestArgs &&... Rest)
51      -> decltype(std::get<0>(this->FuncWithArguments)(
52          std::forward<Args>(std::get<Indexes + 1>(this->FuncWithArguments))...,
53          std::forward<RestArgs>(Rest)...)) {
54    return std::get<0>(this->FuncWithArguments)(
55        std::forward<Args>(std::get<Indexes + 1>(this->FuncWithArguments))...,
56        std::forward<RestArgs>(Rest)...);
57  }
58 
59public:
60  template <class... RestArgs>
61  auto operator()(RestArgs &&... Rest)
62      -> decltype(this->CallImpl(llvm::index_sequence_for<Args...>(),
63                                 std::forward<RestArgs>(Rest)...)) {
64 
65#ifndef NDEBUG
66    assert(!WasCalled && "Can only call result of Bind once.")(static_cast <bool> (!WasCalled && "Can only call result of Bind once."
) ? void (0) : __assert_fail ("!WasCalled && \"Can only call result of Bind once.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/Function.h"
, 66, __extension__ __PRETTY_FUNCTION__));
67    WasCalled = true;
68#endif
69    return CallImpl(llvm::index_sequence_for<Args...>(),
70                    std::forward<RestArgs>(Rest)...);
71  }
72};
73 
74/// Creates an object that stores a callable (\p F) and first arguments to the
75/// callable (\p As) and allows to call \p F with \Args at a later point.
76/// Similar to std::bind, but also works with move-only \p F and \p As.
77///
78/// The returned object must be called no more than once, as \p As are
79/// std::forwarded'ed (therefore can be moved) into \p F during the call.
80template <class Func, class... Args>
81ForwardBinder<Func, Args...> Bind(Func F, Args &&... As) {
82  return ForwardBinder<Func, Args...>(
83      std::make_tuple(std::forward<Func>(F), std::forward<Args>(As)...));
2
←
Calling 'make_tuple<(lambda at /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp:457:17), llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>>'→
19
←
Returning from 'make_tuple<(lambda at /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp:457:17), llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>>'→
20
←
Calling implicit destructor for 'tuple<(lambda at /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp:457:17), llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>>'→
21
←
Calling implicit destructor for '_Tuple_impl<0, (lambda at /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp:457:17), llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>>'→
22
←
Calling implicit destructor for '_Tuple_impl<1, llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>>'→
23
←
Calling implicit destructor for '_Head_base<1, llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>, false>'→
24
←
Calling '~unique_function'→
84}
85 
86} // namespace clangd
87} // namespace clang
88 
89#endif

←

/usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/tuple

→

1// <tuple> -*- C++ -*-

3// Copyright (C) 2007-2018 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 include/tuple
*  This is a Standard C++ Library header.
*/

29#ifndef _GLIBCXX_TUPLE1
30#define _GLIBCXX_TUPLE1 1

32#pragma GCC system_header

34#if __cplusplus201103L < 201103L
35# include <bits/c++0x_warning.h>
36#else

38#include <utility>
39#include <array>
40#include <bits/uses_allocator.h>
41#include <bits/invoke.h>

43namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
44{
45_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 *  @addtogroup utilities
 *  @{
 */

template<typename... _Elements>
  class tuple;

template<typename _Tp>
  struct __is_empty_non_tuple : is_empty<_Tp> { };

// Using EBO for elements that are tuples causes ambiguous base errors.
template<typename _El0, typename... _El>
  struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };

// Use the Empty Base-class Optimization for empty, non-final types.
template<typename _Tp>
  using __empty_not_final
  = typename conditional<__is_final(_Tp), false_type,
	   __is_empty_non_tuple<_Tp>>::type;

template<std::size_t _Idx, typename _Head,
  bool = __empty_not_final<_Head>::value>
  struct _Head_base;

template<std::size_t _Idx, typename _Head>
  struct _Head_base<_Idx, _Head, true>
  : public _Head
  {
    constexpr _Head_base()
    : _Head() { }

    constexpr _Head_base(const _Head& __h)
    : _Head(__h) { }

    constexpr _Head_base(const _Head_base&) = default;
    constexpr _Head_base(_Head_base&&) = default;

    template<typename _UHead>
      constexpr _Head_base(_UHead&& __h)
: _Head(std::forward<_UHead>(__h)) { }

    _Head_base(allocator_arg_t, __uses_alloc0)
    : _Head() { }

    template<typename _Alloc>
_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
: _Head(allocator_arg, *__a._M_a) { }

    template<typename _Alloc>
_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
: _Head(*__a._M_a) { }

    template<typename _UHead>
_Head_base(__uses_alloc0, _UHead&& __uhead)
: _Head(std::forward<_UHead>(__uhead)) { }

    template<typename _Alloc, typename _UHead>
_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
: _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }

    template<typename _Alloc, typename _UHead>
_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
: _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }

    static constexpr _Head&
    _M_head(_Head_base& __b) noexcept { return __b; }

    static constexpr const _Head&
    _M_head(const _Head_base& __b) noexcept { return __b; }
  };

template<std::size_t _Idx, typename _Head>
  struct _Head_base<_Idx, _Head, false>
  {
    constexpr _Head_base()
    : _M_head_impl() { }

    constexpr _Head_base(const _Head& __h)
    : _M_head_impl(__h) { }

    constexpr _Head_base(const _Head_base&) = default;
    constexpr _Head_base(_Head_base&&) = default;

    template<typename _UHead>
      constexpr _Head_base(_UHead&& __h)
: _M_head_impl(std::forward<_UHead>(__h)) { }
7
←
Calling move constructor for 'unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>'→
10
←
Returning from move constructor for 'unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>'→
11
←
Returning without writing to 'this->_M_head_impl.StorageUnion.OutOfLineStorage.StoragePtr'→

    _Head_base(allocator_arg_t, __uses_alloc0)
    : _M_head_impl() { }

    template<typename _Alloc>
_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
: _M_head_impl(allocator_arg, *__a._M_a) { }

    template<typename _Alloc>
_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
: _M_head_impl(*__a._M_a) { }

    template<typename _UHead>
_Head_base(__uses_alloc0, _UHead&& __uhead)
: _M_head_impl(std::forward<_UHead>(__uhead)) { }

    template<typename _Alloc, typename _UHead>
_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
: _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
{ }

    template<typename _Alloc, typename _UHead>
_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
: _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }

    static constexpr _Head&
    _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }

    static constexpr const _Head&
    _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }

    _Head _M_head_impl;
  };

/**
 * Contains the actual implementation of the @c tuple template, stored
 * as a recursive inheritance hierarchy from the first element (most
 * derived class) to the last (least derived class). The @c Idx
 * parameter gives the 0-based index of the element stored at this
 * point in the hierarchy; we use it to implement a constant-time
 * get() operation.
 */
template<std::size_t _Idx, typename... _Elements>
  struct _Tuple_impl;

/**
 * Recursive tuple implementation. Here we store the @c Head element
 * and derive from a @c Tuple_impl containing the remaining elements
 * (which contains the @c Tail).
 */
template<std::size_t _Idx, typename _Head, typename... _Tail>
  struct _Tuple_impl<_Idx, _Head, _Tail...>
  : public _Tuple_impl<_Idx + 1, _Tail...>,
    private _Head_base<_Idx, _Head>
  {
    template<std::size_t, typename...> friend class _Tuple_impl;

    typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
    typedef _Head_base<_Idx, _Head> _Base;

    static constexpr _Head&
    _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

    static constexpr const _Head&
    _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

    static constexpr _Inherited&
    _M_tail(_Tuple_impl& __t) noexcept { return __t; }

    static constexpr const _Inherited&
    _M_tail(const _Tuple_impl& __t) noexcept { return __t; }

    constexpr _Tuple_impl()
    : _Inherited(), _Base() { }

    explicit
    constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
    : _Inherited(__tail...), _Base(__head) { }

    template<typename _UHead, typename... _UTail, typename = typename
             enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
      explicit
      constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
: _Inherited(std::forward<_UTail>(__tail)...),
5
←
Calling constructor for '_Tuple_impl<1, llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>>'→
14
←
Returning from constructor for '_Tuple_impl<1, llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>>'→
 _Base(std::forward<_UHead>(__head)) { }
15
←
Returning without writing to 'this->_M_head_impl.StorageUnion.OutOfLineStorage.StoragePtr'→

    constexpr _Tuple_impl(const _Tuple_impl&) = default;

    constexpr
    _Tuple_impl(_Tuple_impl&& __in)
    noexcept(__and_<is_nothrow_move_constructible<_Head>,
             is_nothrow_move_constructible<_Inherited>>::value)
    : _Inherited(std::move(_M_tail(__in))),
_Base(std::forward<_Head>(_M_head(__in))) { }

    template<typename... _UElements>
      constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
: _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
 _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }

    template<typename _UHead, typename... _UTails>
      constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
: _Inherited(std::move
     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
 _Base(std::forward<_UHead>
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }

    template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
: _Inherited(__tag, __a),
        _Base(__tag, __use_alloc<_Head>(__a)) { }

    template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
    const _Head& __head, const _Tail&... __tail)
: _Inherited(__tag, __a, __tail...),
        _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }

    template<typename _Alloc, typename _UHead, typename... _UTail,
             typename = typename enable_if<sizeof...(_Tail)
			     == sizeof...(_UTail)>::type>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
           _UHead&& __head, _UTail&&... __tail)
: _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
        _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
       std::forward<_UHead>(__head)) { }

    template<typename _Alloc>
      _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
           const _Tuple_impl& __in)
: _Inherited(__tag, __a, _M_tail(__in)),
        _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }

    template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
           _Tuple_impl&& __in)
: _Inherited(__tag, __a, std::move(_M_tail(__in))),
 _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
       std::forward<_Head>(_M_head(__in))) { }

    template<typename _Alloc, typename... _UElements>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
           const _Tuple_impl<_Idx, _UElements...>& __in)
: _Inherited(__tag, __a,
     _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
 _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }

    template<typename _Alloc, typename _UHead, typename... _UTails>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
           _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
: _Inherited(__tag, __a, std::move
     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
 _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
              std::forward<_UHead>
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }

    _Tuple_impl&
    operator=(const _Tuple_impl& __in)
    {
_M_head(*this) = _M_head(__in);
_M_tail(*this) = _M_tail(__in);
return *this;
    }

    _Tuple_impl&
    operator=(_Tuple_impl&& __in)
    noexcept(__and_<is_nothrow_move_assignable<_Head>,
             is_nothrow_move_assignable<_Inherited>>::value)
    {
_M_head(*this) = std::forward<_Head>(_M_head(__in));
_M_tail(*this) = std::move(_M_tail(__in));
return *this;
    }

    template<typename... _UElements>
      _Tuple_impl&
      operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
      {
 _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
 _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
 return *this;
}

    template<typename _UHead, typename... _UTails>
      _Tuple_impl&
      operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
      {
 _M_head(*this) = std::forward<_UHead>
   (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
 _M_tail(*this) = std::move
   (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
 return *this;
}

  protected:
    void
    _M_swap(_Tuple_impl& __in)
    noexcept(__is_nothrow_swappable<_Head>::value
             && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
    {
using std::swap;
swap(_M_head(*this), _M_head(__in));
_Inherited::_M_swap(_M_tail(__in));
    }
  };

// Basis case of inheritance recursion.
template<std::size_t _Idx, typename _Head>
  struct _Tuple_impl<_Idx, _Head>
  : private _Head_base<_Idx, _Head>
  {
    template<std::size_t, typename...> friend class _Tuple_impl;

    typedef _Head_base<_Idx, _Head> _Base;

    static constexpr _Head&
    _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

    static constexpr const _Head&
    _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

    constexpr _Tuple_impl()
    : _Base() { }

    explicit
    constexpr _Tuple_impl(const _Head& __head)
    : _Base(__head) { }

    template<typename _UHead>
      explicit
      constexpr _Tuple_impl(_UHead&& __head)
: _Base(std::forward<_UHead>(__head)) { }
6
←
Calling constructor for '_Head_base<1, llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>, false>'→
12
←
Returning from constructor for '_Head_base<1, llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>, false>'→
13
←
Returning without writing to 'this->_M_head_impl.StorageUnion.OutOfLineStorage.StoragePtr'→

    constexpr _Tuple_impl(const _Tuple_impl&) = default;

    constexpr
    _Tuple_impl(_Tuple_impl&& __in)
    noexcept(is_nothrow_move_constructible<_Head>::value)
    : _Base(std::forward<_Head>(_M_head(__in))) { }

    template<typename _UHead>
      constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
: _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }

    template<typename _UHead>
      constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
: _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
{ }

    template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
: _Base(__tag, __use_alloc<_Head>(__a)) { }

    template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
    const _Head& __head)
: _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }

    template<typename _Alloc, typename _UHead>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
           _UHead&& __head)
: _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
       std::forward<_UHead>(__head)) { }

    template<typename _Alloc>
      _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
           const _Tuple_impl& __in)
: _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }

    template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
           _Tuple_impl&& __in)
: _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
       std::forward<_Head>(_M_head(__in))) { }

    template<typename _Alloc, typename _UHead>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
           const _Tuple_impl<_Idx, _UHead>& __in)
: _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }

    template<typename _Alloc, typename _UHead>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
           _Tuple_impl<_Idx, _UHead>&& __in)
: _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
              std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
{ }

    _Tuple_impl&
    operator=(const _Tuple_impl& __in)
    {
_M_head(*this) = _M_head(__in);
return *this;
    }

    _Tuple_impl&
    operator=(_Tuple_impl&& __in)
    noexcept(is_nothrow_move_assignable<_Head>::value)
    {
_M_head(*this) = std::forward<_Head>(_M_head(__in));
return *this;
    }

    template<typename _UHead>
      _Tuple_impl&
      operator=(const _Tuple_impl<_Idx, _UHead>& __in)
      {
 _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
 return *this;
}

    template<typename _UHead>
      _Tuple_impl&
      operator=(_Tuple_impl<_Idx, _UHead>&& __in)
      {
 _M_head(*this)
   = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
 return *this;
}

  protected:
    void
    _M_swap(_Tuple_impl& __in)
    noexcept(__is_nothrow_swappable<_Head>::value)
    {
using std::swap;
swap(_M_head(*this), _M_head(__in));
    }
  };

// Concept utility functions, reused in conditionally-explicit
// constructors.
template<bool, typename... _Elements>
struct _TC
{
  template<typename... _UElements>
  static constexpr bool _ConstructibleTuple()
  {
    return __and_<is_constructible<_Elements, const _UElements&>...>::value;
  }

  template<typename... _UElements>
  static constexpr bool _ImplicitlyConvertibleTuple()
  {
    return __and_<is_convertible<const _UElements&, _Elements>...>::value;
  }

  template<typename... _UElements>
  static constexpr bool _MoveConstructibleTuple()
  {
    return __and_<is_constructible<_Elements, _UElements&&>...>::value;
  }

  template<typename... _UElements>
  static constexpr bool _ImplicitlyMoveConvertibleTuple()
  {
    return __and_<is_convertible<_UElements&&, _Elements>...>::value;
  }

  template<typename _SrcTuple>
  static constexpr bool _NonNestedTuple()
  {
    return  __and_<__not_<is_same<tuple<_Elements...>,
                                 typename remove_cv<
                                   typename remove_reference<_SrcTuple>::type
                                 >::type>>,
                   __not_<is_convertible<_SrcTuple, _Elements...>>,
                   __not_<is_constructible<_Elements..., _SrcTuple>>
            >::value;
  }
  template<typename... _UElements>
  static constexpr bool _NotSameTuple()
  {
    return  __not_<is_same<tuple<_Elements...>,
	     typename remove_const<
	       typename remove_reference<_UElements...>::type
	       >::type>>::value;
  }
};

template<typename... _Elements>
struct _TC<false, _Elements...>
{
  template<typename... _UElements>
  static constexpr bool _ConstructibleTuple()
  {
    return false;
  }

  template<typename... _UElements>
  static constexpr bool _ImplicitlyConvertibleTuple()
  {
    return false;
  }

  template<typename... _UElements>
  static constexpr bool _MoveConstructibleTuple()
  {
    return false;
  }

  template<typename... _UElements>
  static constexpr bool _ImplicitlyMoveConvertibleTuple()
  {
    return false;
  }

  template<typename... _UElements>
  static constexpr bool _NonNestedTuple()
  {
    return true;
  }
  template<typename... _UElements>
  static constexpr bool _NotSameTuple()
  {
    return  true;
  }
};

/// Primary class template, tuple
template<typename... _Elements>
  class tuple : public _Tuple_impl<0, _Elements...>
  {
    typedef _Tuple_impl<0, _Elements...> _Inherited;

    // Used for constraining the default constructor so
    // that it becomes dependent on the constraints.
    template<typename _Dummy>
    struct _TC2
    {
      static constexpr bool _DefaultConstructibleTuple()
      {
        return __and_<is_default_constructible<_Elements>...>::value;
      }
      static constexpr bool _ImplicitlyDefaultConstructibleTuple()
      {
        return __and_<__is_implicitly_default_constructible<_Elements>...>
          ::value;
      }
    };

  public:
    template<typename _Dummy = void,
             typename enable_if<_TC2<_Dummy>::
                                  _ImplicitlyDefaultConstructibleTuple(),
                                bool>::type = true>
    constexpr tuple()
    : _Inherited() { }

    template<typename _Dummy = void,
             typename enable_if<_TC2<_Dummy>::
                                  _DefaultConstructibleTuple()
                                &&
                                !_TC2<_Dummy>::
                                  _ImplicitlyDefaultConstructibleTuple(),
                                bool>::type = false>
    explicit constexpr tuple()
    : _Inherited() { }

    // Shortcut for the cases where constructors taking _Elements...
    // need to be constrained.
    template<typename _Dummy> using _TCC =
      _TC<is_same<_Dummy, void>::value,
          _Elements...>;

    template<typename _Dummy = void,
             typename enable_if<
               _TCC<_Dummy>::template
                 _ConstructibleTuple<_Elements...>()
               && _TCC<_Dummy>::template
                 _ImplicitlyConvertibleTuple<_Elements...>()
               && (sizeof...(_Elements) >= 1),
             bool>::type=true>
      constexpr tuple(const _Elements&... __elements)
    : _Inherited(__elements...) { }

    template<typename _Dummy = void,
             typename enable_if<
               _TCC<_Dummy>::template
                 _ConstructibleTuple<_Elements...>()
               && !_TCC<_Dummy>::template
                 _ImplicitlyConvertibleTuple<_Elements...>()
               && (sizeof...(_Elements) >= 1),
             bool>::type=false>
    explicit constexpr tuple(const _Elements&... __elements)
    : _Inherited(__elements...) { }

    // Shortcut for the cases where constructors taking _UElements...
    // need to be constrained.
    template<typename... _UElements> using _TMC =
                _TC<(sizeof...(_Elements) == sizeof...(_UElements))
      && (_TC<(sizeof...(_UElements)==1), _Elements...>::
	  template _NotSameTuple<_UElements...>()),
                    _Elements...>;

    // Shortcut for the cases where constructors taking tuple<_UElements...>
    // need to be constrained.
    template<typename... _UElements> using _TMCT =
                _TC<(sizeof...(_Elements) == sizeof...(_UElements))
      && !is_same<tuple<_Elements...>,
		  tuple<_UElements...>>::value,
                    _Elements...>;

    template<typename... _UElements, typename
      enable_if<
  _TMC<_UElements...>::template
                  _MoveConstructibleTuple<_UElements...>()
                && _TMC<_UElements...>::template
                  _ImplicitlyMoveConvertibleTuple<_UElements...>()
                && (sizeof...(_Elements) >= 1),
      bool>::type=true>
      constexpr tuple(_UElements&&... __elements)
      : _Inherited(std::forward<_UElements>(__elements)...) { }

    template<typename... _UElements, typename
      enable_if<
  _TMC<_UElements...>::template
                  _MoveConstructibleTuple<_UElements...>()
                && !_TMC<_UElements...>::template
                  _ImplicitlyMoveConvertibleTuple<_UElements...>()
                && (sizeof...(_Elements) >= 1),
      bool>::type=false>
      explicit constexpr tuple(_UElements&&... __elements)
: _Inherited(std::forward<_UElements>(__elements)...) {	}

    constexpr tuple(const tuple&) = default;

    constexpr tuple(tuple&&) = default;

    // Shortcut for the cases where constructors taking tuples
    // must avoid creating temporaries.
    template<typename _Dummy> using _TNTC =
      _TC<is_same<_Dummy, void>::value && sizeof...(_Elements) == 1,
          _Elements...>;

    template<typename... _UElements, typename _Dummy = void, typename
      enable_if<_TMCT<_UElements...>::template
                  _ConstructibleTuple<_UElements...>()
                && _TMCT<_UElements...>::template
                  _ImplicitlyConvertibleTuple<_UElements...>()
                && _TNTC<_Dummy>::template
                  _NonNestedTuple<const tuple<_UElements...>&>(),
      bool>::type=true>
      constexpr tuple(const tuple<_UElements...>& __in)
      : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
      { }

    template<typename... _UElements, typename _Dummy = void, typename
      enable_if<_TMCT<_UElements...>::template
                  _ConstructibleTuple<_UElements...>()
                && !_TMCT<_UElements...>::template
                  _ImplicitlyConvertibleTuple<_UElements...>()
                && _TNTC<_Dummy>::template
                  _NonNestedTuple<const tuple<_UElements...>&>(),
      bool>::type=false>
      explicit constexpr tuple(const tuple<_UElements...>& __in)
      : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
      { }

    template<typename... _UElements, typename _Dummy = void, typename
      enable_if<_TMCT<_UElements...>::template
                  _MoveConstructibleTuple<_UElements...>()
                && _TMCT<_UElements...>::template
                  _ImplicitlyMoveConvertibleTuple<_UElements...>()
                && _TNTC<_Dummy>::template
                  _NonNestedTuple<tuple<_UElements...>&&>(),
      bool>::type=true>
      constexpr tuple(tuple<_UElements...>&& __in)
      : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }

    template<typename... _UElements, typename _Dummy = void, typename
      enable_if<_TMCT<_UElements...>::template
                  _MoveConstructibleTuple<_UElements...>()
                && !_TMCT<_UElements...>::template
                  _ImplicitlyMoveConvertibleTuple<_UElements...>()
                && _TNTC<_Dummy>::template
                  _NonNestedTuple<tuple<_UElements...>&&>(),
      bool>::type=false>
      explicit constexpr tuple(tuple<_UElements...>&& __in)
      : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }

    // Allocator-extended constructors.

    template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a)
: _Inherited(__tag, __a) { }

    template<typename _Alloc, typename _Dummy = void,
             typename enable_if<
               _TCC<_Dummy>::template
                 _ConstructibleTuple<_Elements...>()
               && _TCC<_Dummy>::template
                 _ImplicitlyConvertibleTuple<_Elements...>(),
             bool>::type=true>
tuple(allocator_arg_t __tag, const _Alloc& __a,
     const _Elements&... __elements)
: _Inherited(__tag, __a, __elements...) { }

    template<typename _Alloc, typename _Dummy = void,
             typename enable_if<
               _TCC<_Dummy>::template
                 _ConstructibleTuple<_Elements...>()
               && !_TCC<_Dummy>::template
                 _ImplicitlyConvertibleTuple<_Elements...>(),
             bool>::type=false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
                     const _Elements&... __elements)
: _Inherited(__tag, __a, __elements...) { }

    template<typename _Alloc, typename... _UElements, typename
      enable_if<_TMC<_UElements...>::template
                  _MoveConstructibleTuple<_UElements...>()
                && _TMC<_UElements...>::template
                  _ImplicitlyMoveConvertibleTuple<_UElements...>(),
      bool>::type=true>
tuple(allocator_arg_t __tag, const _Alloc& __a,
     _UElements&&... __elements)
: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
     	{ }

    template<typename _Alloc, typename... _UElements, typename
      enable_if<_TMC<_UElements...>::template
                  _MoveConstructibleTuple<_UElements...>()
                && !_TMC<_UElements...>::template
                  _ImplicitlyMoveConvertibleTuple<_UElements...>(),
      bool>::type=false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
     _UElements&&... __elements)
: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
      { }

    template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }

    template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }

    template<typename _Alloc, typename _Dummy = void,
      typename... _UElements, typename
      enable_if<_TMCT<_UElements...>::template
                  _ConstructibleTuple<_UElements...>()
                && _TMCT<_UElements...>::template
                  _ImplicitlyConvertibleTuple<_UElements...>()
                && _TNTC<_Dummy>::template
                  _NonNestedTuple<tuple<_UElements...>&&>(),
      bool>::type=true>
tuple(allocator_arg_t __tag, const _Alloc& __a,
     const tuple<_UElements...>& __in)
: _Inherited(__tag, __a,
            static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
{ }

    template<typename _Alloc, typename _Dummy = void,
      typename... _UElements, typename
      enable_if<_TMCT<_UElements...>::template
                  _ConstructibleTuple<_UElements...>()
                && !_TMCT<_UElements...>::template
                  _ImplicitlyConvertibleTuple<_UElements...>()
                && _TNTC<_Dummy>::template
                  _NonNestedTuple<tuple<_UElements...>&&>(),
      bool>::type=false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
     const tuple<_UElements...>& __in)
: _Inherited(__tag, __a,
            static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
{ }

    template<typename _Alloc, typename _Dummy = void,
      typename... _UElements, typename
      enable_if<_TMCT<_UElements...>::template
                  _MoveConstructibleTuple<_UElements...>()
                && _TMCT<_UElements...>::template
                  _ImplicitlyMoveConvertibleTuple<_UElements...>()
                && _TNTC<_Dummy>::template
                  _NonNestedTuple<tuple<_UElements...>&&>(),
      bool>::type=true>
tuple(allocator_arg_t __tag, const _Alloc& __a,
     tuple<_UElements...>&& __in)
: _Inherited(__tag, __a,
            static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
{ }

    template<typename _Alloc, typename _Dummy = void,
      typename... _UElements, typename
      enable_if<_TMCT<_UElements...>::template
                  _MoveConstructibleTuple<_UElements...>()
                && !_TMCT<_UElements...>::template
                  _ImplicitlyMoveConvertibleTuple<_UElements...>()
                && _TNTC<_Dummy>::template
                  _NonNestedTuple<tuple<_UElements...>&&>(),
      bool>::type=false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
     tuple<_UElements...>&& __in)
: _Inherited(__tag, __a,
            static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
{ }

    tuple&
    operator=(const tuple& __in)
    {
static_cast<_Inherited&>(*this) = __in;
return *this;
    }

    tuple&
    operator=(tuple&& __in)
    noexcept(is_nothrow_move_assignable<_Inherited>::value)
    {
static_cast<_Inherited&>(*this) = std::move(__in);
return *this;
    }

    template<typename... _UElements>
typename
      enable_if<sizeof...(_UElements)
	 == sizeof...(_Elements), tuple&>::type
      operator=(const tuple<_UElements...>& __in)
      {
 static_cast<_Inherited&>(*this) = __in;
 return *this;
}

    template<typename... _UElements>
typename
      enable_if<sizeof...(_UElements)
	 == sizeof...(_Elements), tuple&>::type
      operator=(tuple<_UElements...>&& __in)
      {
 static_cast<_Inherited&>(*this) = std::move(__in);
 return *this;
}

    void
    swap(tuple& __in)
    noexcept(noexcept(__in._M_swap(__in)))
    { _Inherited::_M_swap(__in); }
  };

875#if __cpp_deduction_guides >= 201606
template<typename... _UTypes>
  tuple(_UTypes...) -> tuple<_UTypes...>;
template<typename _T1, typename _T2>
  tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>;
template<typename _Alloc, typename... _UTypes>
  tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>;
template<typename _Alloc, typename _T1, typename _T2>
  tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>;
template<typename _Alloc, typename... _UTypes>
  tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>;
886#endif

// Explicit specialization, zero-element tuple.
template<>
  class tuple<>
  {
  public:
    void swap(tuple&) noexcept { /* no-op */ }
    // We need the default since we're going to define no-op
    // allocator constructors.
    tuple() = default;
    // No-op allocator constructors.
    template<typename _Alloc>
tuple(allocator_arg_t, const _Alloc&) { }
    template<typename _Alloc>
tuple(allocator_arg_t, const _Alloc&, const tuple&) { }
  };

/// Partial specialization, 2-element tuple.
/// Includes construction and assignment from a pair.
template<typename _T1, typename _T2>
  class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
  {
    typedef _Tuple_impl<0, _T1, _T2> _Inherited;

  public:
    template <typename _U1 = _T1,
              typename _U2 = _T2,
              typename enable_if<__and_<
                                   __is_implicitly_default_constructible<_U1>,
                                   __is_implicitly_default_constructible<_U2>>
                                 ::value, bool>::type = true>

    constexpr tuple()
    : _Inherited() { }

    template <typename _U1 = _T1,
              typename _U2 = _T2,
              typename enable_if<
                __and_<
                  is_default_constructible<_U1>,
                  is_default_constructible<_U2>,
                  __not_<
                    __and_<__is_implicitly_default_constructible<_U1>,
                           __is_implicitly_default_constructible<_U2>>>>
                ::value, bool>::type = false>

    explicit constexpr tuple()
    : _Inherited() { }

    // Shortcut for the cases where constructors taking _T1, _T2
    // need to be constrained.
    template<typename _Dummy> using _TCC =
      _TC<is_same<_Dummy, void>::value, _T1, _T2>;

    template<typename _Dummy = void, typename
             enable_if<_TCC<_Dummy>::template
                         _ConstructibleTuple<_T1, _T2>()
                       && _TCC<_Dummy>::template
                         _ImplicitlyConvertibleTuple<_T1, _T2>(),
bool>::type = true>
      constexpr tuple(const _T1& __a1, const _T2& __a2)
      : _Inherited(__a1, __a2) { }

    template<typename _Dummy = void, typename
             enable_if<_TCC<_Dummy>::template
                         _ConstructibleTuple<_T1, _T2>()
                       && !_TCC<_Dummy>::template
                         _ImplicitlyConvertibleTuple<_T1, _T2>(),
bool>::type = false>
      explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
      : _Inherited(__a1, __a2) { }

    // Shortcut for the cases where constructors taking _U1, _U2
    // need to be constrained.
    using _TMC = _TC<true, _T1, _T2>;

    template<typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _MoveConstructibleTuple<_U1, _U2>()
                && _TMC::template
                  _ImplicitlyMoveConvertibleTuple<_U1, _U2>()
         && !is_same<typename decay<_U1>::type,
	      allocator_arg_t>::value,
bool>::type = true>
      constexpr tuple(_U1&& __a1, _U2&& __a2)
: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
4
←
Calling constructor for '_Tuple_impl<0, (lambda at /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp:457:17), llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>>'→
16
←
Returning from constructor for '_Tuple_impl<0, (lambda at /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp:457:17), llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>>'→
17
←
Returning without writing to 'this->_M_head_impl.StorageUnion.OutOfLineStorage.StoragePtr'→

    template<typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _MoveConstructibleTuple<_U1, _U2>()
                && !_TMC::template
                  _ImplicitlyMoveConvertibleTuple<_U1, _U2>()
         && !is_same<typename decay<_U1>::type,
	      allocator_arg_t>::value,
bool>::type = false>
      explicit constexpr tuple(_U1&& __a1, _U2&& __a2)
: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }

    constexpr tuple(const tuple&) = default;

    constexpr tuple(tuple&&) = default;

    template<typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _ConstructibleTuple<_U1, _U2>()
                && _TMC::template
                  _ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = true>
      constexpr tuple(const tuple<_U1, _U2>& __in)
: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }

    template<typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _ConstructibleTuple<_U1, _U2>()
                && !_TMC::template
                  _ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = false>
      explicit constexpr tuple(const tuple<_U1, _U2>& __in)
: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }

    template<typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _MoveConstructibleTuple<_U1, _U2>()
                && _TMC::template
                  _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = true>
      constexpr tuple(tuple<_U1, _U2>&& __in)
: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }

    template<typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _MoveConstructibleTuple<_U1, _U2>()
                && !_TMC::template
                  _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = false>
      explicit constexpr tuple(tuple<_U1, _U2>&& __in)
: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }

    template<typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _ConstructibleTuple<_U1, _U2>()
                && _TMC::template
                  _ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = true>
      constexpr tuple(const pair<_U1, _U2>& __in)
: _Inherited(__in.first, __in.second) { }

    template<typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _ConstructibleTuple<_U1, _U2>()
                && !_TMC::template
                  _ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = false>
      explicit constexpr tuple(const pair<_U1, _U2>& __in)
: _Inherited(__in.first, __in.second) { }

    template<typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _MoveConstructibleTuple<_U1, _U2>()
                && _TMC::template
                  _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = true>
      constexpr tuple(pair<_U1, _U2>&& __in)
: _Inherited(std::forward<_U1>(__in.first),
     std::forward<_U2>(__in.second)) { }

    template<typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _MoveConstructibleTuple<_U1, _U2>()
                && !_TMC::template
                  _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = false>
      explicit constexpr tuple(pair<_U1, _U2>&& __in)
: _Inherited(std::forward<_U1>(__in.first),
     std::forward<_U2>(__in.second)) { }

    // Allocator-extended constructors.

    template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a)
: _Inherited(__tag, __a) { }

    template<typename _Alloc, typename _Dummy = void,
             typename enable_if<
               _TCC<_Dummy>::template
                 _ConstructibleTuple<_T1, _T2>()
               && _TCC<_Dummy>::template
                 _ImplicitlyConvertibleTuple<_T1, _T2>(),
             bool>::type=true>

tuple(allocator_arg_t __tag, const _Alloc& __a,
     const _T1& __a1, const _T2& __a2)
: _Inherited(__tag, __a, __a1, __a2) { }

    template<typename _Alloc, typename _Dummy = void,
             typename enable_if<
               _TCC<_Dummy>::template
                 _ConstructibleTuple<_T1, _T2>()
               && !_TCC<_Dummy>::template
                 _ImplicitlyConvertibleTuple<_T1, _T2>(),
             bool>::type=false>

explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
     const _T1& __a1, const _T2& __a2)
: _Inherited(__tag, __a, __a1, __a2) { }

    template<typename _Alloc, typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _MoveConstructibleTuple<_U1, _U2>()
                && _TMC::template
                  _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = true>
tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
: _Inherited(__tag, __a, std::forward<_U1>(__a1),
            std::forward<_U2>(__a2)) { }

    template<typename _Alloc, typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _MoveConstructibleTuple<_U1, _U2>()
                && !_TMC::template
                  _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
                     _U1&& __a1, _U2&& __a2)
: _Inherited(__tag, __a, std::forward<_U1>(__a1),
            std::forward<_U2>(__a2)) { }

    template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }

    template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }

    template<typename _Alloc, typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _ConstructibleTuple<_U1, _U2>()
                && _TMC::template
                  _ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = true>
tuple(allocator_arg_t __tag, const _Alloc& __a,
     const tuple<_U1, _U2>& __in)
: _Inherited(__tag, __a,
            static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
{ }

    template<typename _Alloc, typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _ConstructibleTuple<_U1, _U2>()
                && !_TMC::template
                  _ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
     const tuple<_U1, _U2>& __in)
: _Inherited(__tag, __a,
            static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
{ }

    template<typename _Alloc, typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _MoveConstructibleTuple<_U1, _U2>()
                && _TMC::template
                  _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = true>
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
{ }

    template<typename _Alloc, typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _MoveConstructibleTuple<_U1, _U2>()
                && !_TMC::template
                  _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
                     tuple<_U1, _U2>&& __in)
: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
{ }

    template<typename _Alloc, typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _ConstructibleTuple<_U1, _U2>()
                && _TMC::template
                  _ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = true>
      tuple(allocator_arg_t __tag, const _Alloc& __a,
     const pair<_U1, _U2>& __in)
: _Inherited(__tag, __a, __in.first, __in.second) { }

    template<typename _Alloc, typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _ConstructibleTuple<_U1, _U2>()
                && !_TMC::template
                  _ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = false>
      explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
     const pair<_U1, _U2>& __in)
: _Inherited(__tag, __a, __in.first, __in.second) { }

    template<typename _Alloc, typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _MoveConstructibleTuple<_U1, _U2>()
                && _TMC::template
                  _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = true>
      tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
: _Inherited(__tag, __a, std::forward<_U1>(__in.first),
     std::forward<_U2>(__in.second)) { }

    template<typename _Alloc, typename _U1, typename _U2, typename
      enable_if<_TMC::template
                  _MoveConstructibleTuple<_U1, _U2>()
                && !_TMC::template
                  _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = false>
      explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
                     pair<_U1, _U2>&& __in)
: _Inherited(__tag, __a, std::forward<_U1>(__in.first),
     std::forward<_U2>(__in.second)) { }

    tuple&
    operator=(const tuple& __in)
    {
static_cast<_Inherited&>(*this) = __in;
return *this;
    }

    tuple&
    operator=(tuple&& __in)
    noexcept(is_nothrow_move_assignable<_Inherited>::value)
    {
static_cast<_Inherited&>(*this) = std::move(__in);
return *this;
    }

    template<typename _U1, typename _U2>
      tuple&
      operator=(const tuple<_U1, _U2>& __in)
      {
 static_cast<_Inherited&>(*this) = __in;
 return *this;
}

    template<typename _U1, typename _U2>
      tuple&
      operator=(tuple<_U1, _U2>&& __in)
      {
 static_cast<_Inherited&>(*this) = std::move(__in);
 return *this;
}

    template<typename _U1, typename _U2>
      tuple&
      operator=(const pair<_U1, _U2>& __in)
      {
 this->_M_head(*this) = __in.first;
 this->_M_tail(*this)._M_head(*this) = __in.second;
 return *this;
}

    template<typename _U1, typename _U2>
      tuple&
      operator=(pair<_U1, _U2>&& __in)
      {
 this->_M_head(*this) = std::forward<_U1>(__in.first);
 this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
 return *this;
}

    void
    swap(tuple& __in)
    noexcept(noexcept(__in._M_swap(__in)))
    { _Inherited::_M_swap(__in); }
  };


/// class tuple_size
template<typename... _Elements>
  struct tuple_size<tuple<_Elements...>>
  : public integral_constant<std::size_t, sizeof...(_Elements)> { };

1269#if __cplusplus201103L > 201402L
template <typename _Tp>
  inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
1272#endif

/**
 * Recursive case for tuple_element: strip off the first element in
 * the tuple and retrieve the (i-1)th element of the remaining tuple.
 */
template<std::size_t __i, typename _Head, typename... _Tail>
  struct tuple_element<__i, tuple<_Head, _Tail...> >
  : tuple_element<__i - 1, tuple<_Tail...> > { };

/**
 * Basis case for tuple_element: The first element is the one we're seeking.
 */
template<typename _Head, typename... _Tail>
  struct tuple_element<0, tuple<_Head, _Tail...> >
  {
    typedef _Head type;
  };

/**
 * Error case for tuple_element: invalid index.
 */
template<size_t __i>
  struct tuple_element<__i, tuple<>>
  {
    static_assert(__i < tuple_size<tuple<>>::value,
 "tuple index is in range");
  };

template<std::size_t __i, typename _Head, typename... _Tail>
  constexpr _Head&
  __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
  { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }

template<std::size_t __i, typename _Head, typename... _Tail>
  constexpr const _Head&
  __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
  { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }

/// Return a reference to the ith element of a tuple.
template<std::size_t __i, typename... _Elements>
  constexpr __tuple_element_t<__i, tuple<_Elements...>>&
  get(tuple<_Elements...>& __t) noexcept
  { return std::__get_helper<__i>(__t); }

/// Return a const reference to the ith element of a const tuple.
template<std::size_t __i, typename... _Elements>
  constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
  get(const tuple<_Elements...>& __t) noexcept
  { return std::__get_helper<__i>(__t); }

/// Return an rvalue reference to the ith element of a tuple rvalue.
template<std::size_t __i, typename... _Elements>
  constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
  get(tuple<_Elements...>&& __t) noexcept
  {
    typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
    return std::forward<__element_type&&>(std::get<__i>(__t));
  }

/// Return a const rvalue reference to the ith element of a const tuple rvalue.
template<std::size_t __i, typename... _Elements>
  constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
  get(const tuple<_Elements...>&& __t) noexcept
  {
    typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
    return std::forward<const __element_type&&>(std::get<__i>(__t));
  }

1341#if __cplusplus201103L > 201103L

1343#define __cpp_lib_tuples_by_type 201304

template<typename _Head, size_t __i, typename... _Tail>
  constexpr _Head&
  __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
  { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }

template<typename _Head, size_t __i, typename... _Tail>
  constexpr const _Head&
  __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
  { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }

/// Return a reference to the unique element of type _Tp of a tuple.
template <typename _Tp, typename... _Types>
  constexpr _Tp&
  get(tuple<_Types...>& __t) noexcept
  { return std::__get_helper2<_Tp>(__t); }

/// Return a reference to the unique element of type _Tp of a tuple rvalue.
template <typename _Tp, typename... _Types>
  constexpr _Tp&&
  get(tuple<_Types...>&& __t) noexcept
  { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }

/// Return a const reference to the unique element of type _Tp of a tuple.
template <typename _Tp, typename... _Types>
  constexpr const _Tp&
  get(const tuple<_Types...>& __t) noexcept
  { return std::__get_helper2<_Tp>(__t); }

/// Return a const reference to the unique element of type _Tp of
/// a const tuple rvalue.
template <typename _Tp, typename... _Types>
  constexpr const _Tp&&
  get(const tuple<_Types...>&& __t) noexcept
  { return std::forward<const _Tp&&>(std::__get_helper2<_Tp>(__t)); }
1379#endif

// This class performs the comparison operations on tuples
template<typename _Tp, typename _Up, size_t __i, size_t __size>
  struct __tuple_compare
  {
    static constexpr bool
    __eq(const _Tp& __t, const _Up& __u)
    {
return bool(std::get<__i>(__t) == std::get<__i>(__u))
 && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
    }

    static constexpr bool
    __less(const _Tp& __t, const _Up& __u)
    {
return bool(std::get<__i>(__t) < std::get<__i>(__u))
 || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
     && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
    }
  };

template<typename _Tp, typename _Up, size_t __size>
  struct __tuple_compare<_Tp, _Up, __size, __size>
  {
    static constexpr bool
    __eq(const _Tp&, const _Up&) { return true; }

    static constexpr bool
    __less(const _Tp&, const _Up&) { return false; }
  };

template<typename... _TElements, typename... _UElements>
  constexpr bool
  operator==(const tuple<_TElements...>& __t,
      const tuple<_UElements...>& __u)
  {
    static_assert(sizeof...(_TElements) == sizeof...(_UElements),
 "tuple objects can only be compared if they have equal sizes.");
    using __compare = __tuple_compare<tuple<_TElements...>,
			tuple<_UElements...>,
			0, sizeof...(_TElements)>;
    return __compare::__eq(__t, __u);
  }

template<typename... _TElements, typename... _UElements>
  constexpr bool
  operator<(const tuple<_TElements...>& __t,
     const tuple<_UElements...>& __u)
  {
    static_assert(sizeof...(_TElements) == sizeof...(_UElements),
 "tuple objects can only be compared if they have equal sizes.");
    using __compare = __tuple_compare<tuple<_TElements...>,
			tuple<_UElements...>,
			0, sizeof...(_TElements)>;
    return __compare::__less(__t, __u);
  }

template<typename... _TElements, typename... _UElements>
  constexpr bool
  operator!=(const tuple<_TElements...>& __t,
      const tuple<_UElements...>& __u)
  { return !(__t == __u); }

template<typename... _TElements, typename... _UElements>
  constexpr bool
  operator>(const tuple<_TElements...>& __t,
     const tuple<_UElements...>& __u)
  { return __u < __t; }

template<typename... _TElements, typename... _UElements>
  constexpr bool
  operator<=(const tuple<_TElements...>& __t,
      const tuple<_UElements...>& __u)
  { return !(__u < __t); }

template<typename... _TElements, typename... _UElements>
  constexpr bool
  operator>=(const tuple<_TElements...>& __t,
      const tuple<_UElements...>& __u)
  { return !(__t < __u); }

// NB: DR 705.
template<typename... _Elements>
  constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
  make_tuple(_Elements&&... __args)
  {
    typedef tuple<typename __decay_and_strip<_Elements>::__type...>
__result_type;
    return __result_type(std::forward<_Elements>(__args)...);
3
←
Calling constructor for 'tuple<(lambda at /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp:457:17), llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>>'→
18
←
Returning from constructor for 'tuple<(lambda at /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/tools/extra/clangd/ClangdServer.cpp:457:17), llvm::unique_function<void (llvm::Expected<std::vector<clang::clangd::SymbolInformation, std::allocator<clang::clangd::SymbolInformation> > >)>>'→
  }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2275. Why is forward_as_tuple not constexpr?
template<typename... _Elements>
  constexpr tuple<_Elements&&...>
  forward_as_tuple(_Elements&&... __args) noexcept
  { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }

template<size_t, typename, typename, size_t>
  struct __make_tuple_impl;

template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
  struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
  : __make_tuple_impl<_Idx + 1,
	tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
	_Tuple, _Nm>
  { };

template<std::size_t _Nm, typename _Tuple, typename... _Tp>
  struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
  {
    typedef tuple<_Tp...> __type;
  };

template<typename _Tuple>
  struct __do_make_tuple
  : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
  { };

// Returns the std::tuple equivalent of a tuple-like type.
template<typename _Tuple>
  struct __make_tuple
  : public __do_make_tuple<typename std::remove_cv
          <typename std::remove_reference<_Tuple>::type>::type>
  { };

// Combines several std::tuple's into a single one.
template<typename...>
  struct __combine_tuples;

template<>
  struct __combine_tuples<>
  {
    typedef tuple<> __type;
  };

template<typename... _Ts>
  struct __combine_tuples<tuple<_Ts...>>
  {
    typedef tuple<_Ts...> __type;
  };

template<typename... _T1s, typename... _T2s, typename... _Rem>
  struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
  {
    typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
			_Rem...>::__type __type;
  };

// Computes the result type of tuple_cat given a set of tuple-like types.
template<typename... _Tpls>
  struct __tuple_cat_result
  {
    typedef typename __combine_tuples
      <typename __make_tuple<_Tpls>::__type...>::__type __type;
  };

// Helper to determine the index set for the first tuple-like
// type of a given set.
template<typename...>
  struct __make_1st_indices;

template<>
  struct __make_1st_indices<>
  {
    typedef std::_Index_tuple<> __type;
  };

template<typename _Tp, typename... _Tpls>
  struct __make_1st_indices<_Tp, _Tpls...>
  {
    typedef typename std::_Build_index_tuple<std::tuple_size<
typename std::remove_reference<_Tp>::type>::value>::__type __type;
  };

// Performs the actual concatenation by step-wise expanding tuple-like
// objects into the elements,  which are finally forwarded into the
// result tuple.
template<typename _Ret, typename _Indices, typename... _Tpls>
  struct __tuple_concater;

template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
  struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
  {
    template<typename... _Us>
      static constexpr _Ret
      _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
      {
 typedef typename __make_1st_indices<_Tpls...>::__type __idx;
 typedef __tuple_concater<_Ret, __idx, _Tpls...>      __next;
 return __next::_S_do(std::forward<_Tpls>(__tps)...,
	       std::forward<_Us>(__us)...,
	       std::get<_Is>(std::forward<_Tp>(__tp))...);
}
  };

template<typename _Ret>
  struct __tuple_concater<_Ret, std::_Index_tuple<>>
  {
    template<typename... _Us>
static constexpr _Ret
_S_do(_Us&&... __us)
      {
 return _Ret(std::forward<_Us>(__us)...);
}
  };

/// tuple_cat
template<typename... _Tpls, typename = typename
         enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
  constexpr auto
  tuple_cat(_Tpls&&... __tpls)
  -> typename __tuple_cat_result<_Tpls...>::__type
  {
    typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
    typedef typename __make_1st_indices<_Tpls...>::__type __idx;
    typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
    return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
  }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2301. Why is tie not constexpr?
/// tie
template<typename... _Elements>
  constexpr tuple<_Elements&...>
  tie(_Elements&... __args) noexcept
  { return tuple<_Elements&...>(__args...); }

/// swap
template<typename... _Elements>
  inline
1611#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
  // Constrained free swap overload, see p0185r1
  typename enable_if<__and_<__is_swappable<_Elements>...>::value
    >::type
1615#else
  void
1617#endif
  swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
  noexcept(noexcept(__x.swap(__y)))
  { __x.swap(__y); }

1622#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
template<typename... _Elements>
  typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
  swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;
1626#endif

// A class (and instance) which can be used in 'tie' when an element
// of a tuple is not required.
// _GLIBCXX14_CONSTEXPR
// 2933. PR for LWG 2773 could be clearer
struct _Swallow_assign
{
  template<class _Tp>
    _GLIBCXX14_CONSTEXPR const _Swallow_assign&
    operator=(const _Tp&) const
    { return *this; }
};

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2773. Making std::ignore constexpr
_GLIBCXX17_INLINE constexpr _Swallow_assign ignore{};

/// Partial specialization for tuples
template<typename... _Types, typename _Alloc>
  struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };

// See stl_pair.h...
template<class _T1, class _T2>
  template<typename... _Args1, typename... _Args2>
    inline
    pair<_T1, _T2>::
    pair(piecewise_construct_t,
  tuple<_Args1...> __first, tuple<_Args2...> __second)
    : pair(__first, __second,
    typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
    typename _Build_index_tuple<sizeof...(_Args2)>::__type())
    { }

template<class _T1, class _T2>
  template<typename... _Args1, std::size_t... _Indexes1,
           typename... _Args2, std::size_t... _Indexes2>
    inline
    pair<_T1, _T2>::
    pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
  _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
    : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
      second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
    { }

1671#if __cplusplus201103L > 201402L
1672# define __cpp_lib_apply 201603

template <typename _Fn, typename _Tuple, size_t... _Idx>
  constexpr decltype(auto)
  __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>)
  {
    return std::__invoke(std::forward<_Fn>(__f),
	   std::get<_Idx>(std::forward<_Tuple>(__t))...);
  }

template <typename _Fn, typename _Tuple>
  constexpr decltype(auto)
  apply(_Fn&& __f, _Tuple&& __t)
  {
    using _Indices = make_index_sequence<tuple_size_v<decay_t<_Tuple>>>;
    return std::__apply_impl(std::forward<_Fn>(__f),
	       std::forward<_Tuple>(__t),
	       _Indices{});
  }

1692#define __cpp_lib_make_from_tuple  201606

template <typename _Tp, typename _Tuple, size_t... _Idx>
  constexpr _Tp
  __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>)
  { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); }

template <typename _Tp, typename _Tuple>
  constexpr _Tp
  make_from_tuple(_Tuple&& __t)
  {
    return __make_from_tuple_impl<_Tp>(
      std::forward<_Tuple>(__t),
make_index_sequence<tuple_size_v<decay_t<_Tuple>>>{});
  }
1707#endif // C++17

/// @}

1711_GLIBCXX_END_NAMESPACE_VERSION
1712} // namespace std

1714#endif // C++11

1716#endif // _GLIBCXX_TUPLE

←

/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/FunctionExtras.h

1//===- FunctionExtras.h - Function type erasure utilities -------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9/// \file
10/// This file provides a collection of function (or more generally, callable)
11/// type erasure utilities supplementing those provided by the standard library
12/// in `<function>`.
13///
14/// It provides `unique_function`, which works like `std::function` but supports
15/// move-only callable objects.
16///
17/// Future plans:
18/// - Add a `function` that provides const, volatile, and ref-qualified support,
19///   which doesn't work with `std::function`.
20/// - Provide support for specifying multiple signatures to type erase callable
21///   objects with an overload set, such as those produced by generic lambdas.
22/// - Expand to include a copyable utility that directly replaces std::function
23///   but brings the above improvements.
24///
25/// Note that LLVM's utilities are greatly simplified by not supporting
26/// allocators.
27///
28/// If the standard library ever begins to provide comparable facilities we can
29/// consider switching to those.
30///
31//===----------------------------------------------------------------------===//

33#ifndef LLVM_ADT_FUNCTION_EXTRAS_H
34#define LLVM_ADT_FUNCTION_EXTRAS_H

36#include "llvm/ADT/PointerIntPair.h"
37#include "llvm/ADT/PointerUnion.h"
38#include "llvm/Support/type_traits.h"
39#include <memory>

41namespace llvm {

43template <typename FunctionT> class unique_function;

45template <typename ReturnT, typename... ParamTs>
46class unique_function<ReturnT(ParamTs...)> {
static constexpr size_t InlineStorageSize = sizeof(void *) * 3;

// MSVC has a bug and ICEs if we give it a particular dependent value
// expression as part of the `std::conditional` below. To work around this,
// we build that into a template struct's constexpr bool.
template <typename T> struct IsSizeLessThanThresholdT {
  static constexpr bool value = sizeof(T) <= (2 * sizeof(void *));
};

// Provide a type function to map parameters that won't observe extra copies
// or moves and which are small enough to likely pass in register to values
// and all other types to l-value reference types. We use this to compute the
// types used in our erased call utility to minimize copies and moves unless
// doing so would force things unnecessarily into memory.
//
// The heuristic used is related to common ABI register passing conventions.
// It doesn't have to be exact though, and in one way it is more strict
// because we want to still be able to observe either moves *or* copies.
template <typename T>
using AdjustedParamT = typename std::conditional<
    !std::is_reference<T>::value &&
        llvm::is_trivially_copy_constructible<T>::value &&
        llvm::is_trivially_move_constructible<T>::value &&
        IsSizeLessThanThresholdT<T>::value,
    T, T &>::type;

// The type of the erased function pointer we use as a callback to dispatch to
// the stored callable when it is trivial to move and destroy.
using CallPtrT = ReturnT (*)(void *CallableAddr,
                             AdjustedParamT<ParamTs>... Params);
using MovePtrT = void (*)(void *LHSCallableAddr, void *RHSCallableAddr);
using DestroyPtrT = void (*)(void *CallableAddr);

/// A struct to hold a single trivial callback with sufficient alignment for
/// our bitpacking.
struct alignas(8) TrivialCallback {
  CallPtrT CallPtr;
};

/// A struct we use to aggregate three callbacks when we need full set of
/// operations.
struct alignas(8) NonTrivialCallbacks {
  CallPtrT CallPtr;
  MovePtrT MovePtr;
  DestroyPtrT DestroyPtr;
};

// Create a pointer union between either a pointer to a static trivial call
// pointer in a struct or a pointer to a static struct of the call, move, and
// destroy pointers.
using CallbackPointerUnionT =
    PointerUnion<TrivialCallback *, NonTrivialCallbacks *>;

// The main storage buffer. This will either have a pointer to out-of-line
// storage or an inline buffer storing the callable.
union StorageUnionT {
  // For out-of-line storage we keep a pointer to the underlying storage and
  // the size. This is enough to deallocate the memory.
  struct OutOfLineStorageT {
    void *StoragePtr;
    size_t Size;
    size_t Alignment;
  } OutOfLineStorage;
  static_assert(
      sizeof(OutOfLineStorageT) <= InlineStorageSize,
      "Should always use all of the out-of-line storage for inline storage!");

  // For in-line storage, we just provide an aligned character buffer. We
  // provide three pointers worth of storage here.
  typename std::aligned_storage<InlineStorageSize, alignof(void *)>::type
      InlineStorage;
} StorageUnion;

// A compressed pointer to either our dispatching callback or our table of
// dispatching callbacks and the flag for whether the callable itself is
// stored inline or not.
PointerIntPair<CallbackPointerUnionT, 1, bool> CallbackAndInlineFlag;

bool isInlineStorage() const { return CallbackAndInlineFlag.getInt(); }

bool isTrivialCallback() const {
  return CallbackAndInlineFlag.getPointer().template is<TrivialCallback *>();
}

CallPtrT getTrivialCallback() const {
  return CallbackAndInlineFlag.getPointer().template get<TrivialCallback *>()->CallPtr;
}

NonTrivialCallbacks *getNonTrivialCallbacks() const {
  return CallbackAndInlineFlag.getPointer()
      .template get<NonTrivialCallbacks *>();
}

void *getInlineStorage() { return &StorageUnion.InlineStorage; }

void *getOutOfLineStorage() {
  return StorageUnion.OutOfLineStorage.StoragePtr;
30
←
Undefined or garbage value returned to caller
}
size_t getOutOfLineStorageSize() const {
  return StorageUnion.OutOfLineStorage.Size;
}
size_t getOutOfLineStorageAlignment() const {
  return StorageUnion.OutOfLineStorage.Alignment;
}

void setOutOfLineStorage(void *Ptr, size_t Size, size_t Alignment) {
  StorageUnion.OutOfLineStorage = {Ptr, Size, Alignment};
}

template <typename CallableT>
static ReturnT CallImpl(void *CallableAddr, AdjustedParamT<ParamTs>... Params) {
  return (*reinterpret_cast<CallableT *>(CallableAddr))(
      std::forward<ParamTs>(Params)...);
}

template <typename CallableT>
static void MoveImpl(void *LHSCallableAddr, void *RHSCallableAddr) noexcept {
  new (LHSCallableAddr)
      CallableT(std::move(*reinterpret_cast<CallableT *>(RHSCallableAddr)));
}

template <typename CallableT>
static void DestroyImpl(void *CallableAddr) noexcept {
  reinterpret_cast<CallableT *>(CallableAddr)->~CallableT();
}

173public:
unique_function() = default;
unique_function(std::nullptr_t /*null_callable*/) {}

~unique_function() {
  if (!CallbackAndInlineFlag.getPointer())
25
←
Taking false branch→
    return;

  // Cache this value so we don't re-check it after type-erased operations.
  bool IsInlineStorage = isInlineStorage();

  if (!isTrivialCallback())
26
←
Taking false branch→
    getNonTrivialCallbacks()->DestroyPtr(
        IsInlineStorage ? getInlineStorage() : getOutOfLineStorage());

  if (!IsInlineStorage)
27
←
Assuming 'IsInlineStorage' is 0→
28
←
Taking true branch→
    deallocate_buffer(getOutOfLineStorage(), getOutOfLineStorageSize(),
29
←
Calling 'unique_function::getOutOfLineStorage'→
                      getOutOfLineStorageAlignment());
}

unique_function(unique_function &&RHS) noexcept {
  // Copy the callback and inline flag.
  CallbackAndInlineFlag = RHS.CallbackAndInlineFlag;

  // If the RHS is empty, just copying the above is sufficient.
  if (!RHS)
8
←
Taking true branch→
    return;
9
←
Returning without writing to 'this->StorageUnion.OutOfLineStorage.StoragePtr'→

  if (!isInlineStorage()) {
    // The out-of-line case is easiest to move.
    StorageUnion.OutOfLineStorage = RHS.StorageUnion.OutOfLineStorage;
  } else if (isTrivialCallback()) {
    // Move is trivial, just memcpy the bytes across.
    memcpy(getInlineStorage(), RHS.getInlineStorage(), InlineStorageSize);
  } else {
    // Non-trivial move, so dispatch to a type-erased implementation.
    getNonTrivialCallbacks()->MovePtr(getInlineStorage(),
                                      RHS.getInlineStorage());
  }

  // Clear the old callback and inline flag to get back to as-if-null.
  RHS.CallbackAndInlineFlag = {};

216#ifndef NDEBUG
  // In debug builds, we also scribble across the rest of the storage.
  memset(RHS.getInlineStorage(), 0xAD, InlineStorageSize);
219#endif
}

unique_function &operator=(unique_function &&RHS) noexcept {
  if (this == &RHS)
    return *this;

  // Because we don't try to provide any exception safety guarantees we can
  // implement move assignment very simply by first destroying the current
  // object and then move-constructing over top of it.
  this->~unique_function();
  new (this) unique_function(std::move(RHS));
  return *this;
}

template <typename CallableT> unique_function(CallableT Callable) {
  bool IsInlineStorage = true;
  void *CallableAddr = getInlineStorage();
  if (sizeof(CallableT) > InlineStorageSize ||
      alignof(CallableT) > alignof(decltype(StorageUnion.InlineStorage))) {
    IsInlineStorage = false;
    // Allocate out-of-line storage. FIXME: Use an explicit alignment
    // parameter in C++17 mode.
    auto Size = sizeof(CallableT);
    auto Alignment = alignof(CallableT);
    CallableAddr = allocate_buffer(Size, Alignment);
    setOutOfLineStorage(CallableAddr, Size, Alignment);
  }

  // Now move into the storage.
  new (CallableAddr) CallableT(std::move(Callable));

  // See if we can create a trivial callback. We need the callable to be
  // trivially moved and trivially destroyed so that we don't have to store
  // type erased callbacks for those operations.
  //
  // FIXME: We should use constexpr if here and below to avoid instantiating
  // the non-trivial static objects when unnecessary. While the linker should
  // remove them, it is still wasteful.
  if (llvm::is_trivially_move_constructible<CallableT>::value &&
      std::is_trivially_destructible<CallableT>::value) {
    // We need to create a nicely aligned object. We use a static variable
    // for this because it is a trivial struct.
    static TrivialCallback Callback = { &CallImpl<CallableT> };

    CallbackAndInlineFlag = {&Callback, IsInlineStorage};
    return;
  }

  // Otherwise, we need to point at an object that contains all the different
  // type erased behaviors needed. Create a static instance of the struct type
  // here and then use a pointer to that.
  static NonTrivialCallbacks Callbacks = {
      &CallImpl<CallableT>, &MoveImpl<CallableT>, &DestroyImpl<CallableT>};

  CallbackAndInlineFlag = {&Callbacks, IsInlineStorage};
}

ReturnT operator()(ParamTs... Params) {
  void *CallableAddr =
      isInlineStorage() ? getInlineStorage() : getOutOfLineStorage();

  return (isTrivialCallback()
              ? getTrivialCallback()
              : getNonTrivialCallbacks()->CallPtr)(CallableAddr, Params...);
}

explicit operator bool() const {
  return (bool)CallbackAndInlineFlag.getPointer();
}
289};

291} // end namespace llvm

293#endif // LLVM_ADT_FUNCTION_H