/build/source/clang/tools/libclang/CIndex.cpp

Bug Summary

File:	build/source/clang/tools/libclang/CIndex.cpp
Warning:	line 4005, column 3 Branch condition evaluates to a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name CIndex.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-17/lib/clang/17 -D CLANG_REPOSITORY_STRING="++20230510111145+7df43bdb42ae-1~exp1~20230510111303.1288" -D _CINDEX_LIB_ -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/clang/tools/libclang -I /build/source/clang/tools/libclang -I /build/source/clang/include -I tools/clang/include -I include -I /build/source/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-17/lib/clang/17/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1683717183 -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-05-10-133810-16478-1 -x c++ /build/source/clang/tools/libclang/CIndex.cpp
1//===- CIndex.cpp - Clang-C Source Indexing Library -----------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the main API hooks in the Clang-C Source Indexing
10// library.
11//
12//===----------------------------------------------------------------------===//

14#include "CIndexDiagnostic.h"
15#include "CIndexer.h"
16#include "CLog.h"
17#include "CXCursor.h"
18#include "CXSourceLocation.h"
19#include "CXString.h"
20#include "CXTranslationUnit.h"
21#include "CXType.h"
22#include "CursorVisitor.h"
23#include "clang-c/FatalErrorHandler.h"
24#include "clang/AST/Attr.h"
25#include "clang/AST/DeclObjCCommon.h"
26#include "clang/AST/Mangle.h"
27#include "clang/AST/OpenMPClause.h"
28#include "clang/AST/StmtVisitor.h"
29#include "clang/Basic/Diagnostic.h"
30#include "clang/Basic/DiagnosticCategories.h"
31#include "clang/Basic/DiagnosticIDs.h"
32#include "clang/Basic/Stack.h"
33#include "clang/Basic/TargetInfo.h"
34#include "clang/Basic/Version.h"
35#include "clang/Frontend/ASTUnit.h"
36#include "clang/Frontend/CompilerInstance.h"
37#include "clang/Index/CommentToXML.h"
38#include "clang/Lex/HeaderSearch.h"
39#include "clang/Lex/Lexer.h"
40#include "clang/Lex/PreprocessingRecord.h"
41#include "clang/Lex/Preprocessor.h"
42#include "llvm/ADT/STLExtras.h"
43#include "llvm/ADT/StringSwitch.h"
44#include "llvm/Config/llvm-config.h"
45#include "llvm/Support/Compiler.h"
46#include "llvm/Support/CrashRecoveryContext.h"
47#include "llvm/Support/Format.h"
48#include "llvm/Support/ManagedStatic.h"
49#include "llvm/Support/MemoryBuffer.h"
50#include "llvm/Support/Program.h"
51#include "llvm/Support/SaveAndRestore.h"
52#include "llvm/Support/Signals.h"
53#include "llvm/Support/TargetSelect.h"
54#include "llvm/Support/Threading.h"
55#include "llvm/Support/Timer.h"
56#include "llvm/Support/raw_ostream.h"
57#include "llvm/Support/thread.h"
58#include <mutex>
59#include <optional>

61#if LLVM_ENABLE_THREADS1 != 0 && defined(__APPLE__)
62#define USE_DARWIN_THREADS
63#endif

65#ifdef USE_DARWIN_THREADS
66#include <pthread.h>
67#endif

69using namespace clang;
70using namespace clang::cxcursor;
71using namespace clang::cxtu;
72using namespace clang::cxindex;

74CXTranslationUnit cxtu::MakeCXTranslationUnit(CIndexer *CIdx,
                                            std::unique_ptr<ASTUnit> AU) {
if (!AU)
  return nullptr;
assert(CIdx)(static_cast <bool> (CIdx) ? void (0) : __assert_fail (
"CIdx", "clang/tools/libclang/CIndex.cpp", 78, __extension__ __PRETTY_FUNCTION__
));
CXTranslationUnit D = new CXTranslationUnitImpl();
D->CIdx = CIdx;
D->TheASTUnit = AU.release();
D->StringPool = new cxstring::CXStringPool();
D->Diagnostics = nullptr;
D->OverridenCursorsPool = createOverridenCXCursorsPool();
D->CommentToXML = nullptr;
D->ParsingOptions = 0;
D->Arguments = {};
return D;
89}

91bool cxtu::isASTReadError(ASTUnit *AU) {
for (ASTUnit::stored_diag_iterator D = AU->stored_diag_begin(),
                                   DEnd = AU->stored_diag_end();
     D != DEnd; ++D) {
  if (D->getLevel() >= DiagnosticsEngine::Error &&
      DiagnosticIDs::getCategoryNumberForDiag(D->getID()) ==
          diag::DiagCat_AST_Deserialization_Issue)
    return true;
}
return false;
101}

103cxtu::CXTUOwner::~CXTUOwner() {
if (TU)
  clang_disposeTranslationUnit(TU);
106}

108/// Compare two source ranges to determine their relative position in
109/// the translation unit.
110static RangeComparisonResult RangeCompare(SourceManager &SM, SourceRange R1,
                                        SourceRange R2) {
assert(R1.isValid() && "First range is invalid?")(static_cast <bool> (R1.isValid() && "First range is invalid?"
) ? void (0) : __assert_fail ("R1.isValid() && \"First range is invalid?\""
, "clang/tools/libclang/CIndex.cpp", 112, __extension__ __PRETTY_FUNCTION__
));
assert(R2.isValid() && "Second range is invalid?")(static_cast <bool> (R2.isValid() && "Second range is invalid?"
) ? void (0) : __assert_fail ("R2.isValid() && \"Second range is invalid?\""
, "clang/tools/libclang/CIndex.cpp", 113, __extension__ __PRETTY_FUNCTION__
));
if (R1.getEnd() != R2.getBegin() &&
    SM.isBeforeInTranslationUnit(R1.getEnd(), R2.getBegin()))
  return RangeBefore;
if (R2.getEnd() != R1.getBegin() &&
    SM.isBeforeInTranslationUnit(R2.getEnd(), R1.getBegin()))
  return RangeAfter;
return RangeOverlap;
121}

123/// Determine if a source location falls within, before, or after a
124///   a given source range.
125static RangeComparisonResult LocationCompare(SourceManager &SM,
                                           SourceLocation L, SourceRange R) {
assert(R.isValid() && "First range is invalid?")(static_cast <bool> (R.isValid() && "First range is invalid?"
) ? void (0) : __assert_fail ("R.isValid() && \"First range is invalid?\""
, "clang/tools/libclang/CIndex.cpp", 127, __extension__ __PRETTY_FUNCTION__
));
assert(L.isValid() && "Second range is invalid?")(static_cast <bool> (L.isValid() && "Second range is invalid?"
) ? void (0) : __assert_fail ("L.isValid() && \"Second range is invalid?\""
, "clang/tools/libclang/CIndex.cpp", 128, __extension__ __PRETTY_FUNCTION__
));
if (L == R.getBegin() || L == R.getEnd())
  return RangeOverlap;
if (SM.isBeforeInTranslationUnit(L, R.getBegin()))
  return RangeBefore;
if (SM.isBeforeInTranslationUnit(R.getEnd(), L))
  return RangeAfter;
return RangeOverlap;
136}

138/// Translate a Clang source range into a CIndex source range.
139///
140/// Clang internally represents ranges where the end location points to the
141/// start of the token at the end. However, for external clients it is more
142/// useful to have a CXSourceRange be a proper half-open interval. This routine
143/// does the appropriate translation.
144CXSourceRange cxloc::translateSourceRange(const SourceManager &SM,
                                        const LangOptions &LangOpts,
                                        const CharSourceRange &R) {
// We want the last character in this location, so we will adjust the
// location accordingly.
SourceLocation EndLoc = R.getEnd();
bool IsTokenRange = R.isTokenRange();
if (EndLoc.isValid() && EndLoc.isMacroID() &&
    !SM.isMacroArgExpansion(EndLoc)) {
  CharSourceRange Expansion = SM.getExpansionRange(EndLoc);
  EndLoc = Expansion.getEnd();
  IsTokenRange = Expansion.isTokenRange();
}
if (IsTokenRange && EndLoc.isValid()) {
  unsigned Length =
      Lexer::MeasureTokenLength(SM.getSpellingLoc(EndLoc), SM, LangOpts);
  EndLoc = EndLoc.getLocWithOffset(Length);
}

CXSourceRange Result = {
    {&SM, &LangOpts}, R.getBegin().getRawEncoding(), EndLoc.getRawEncoding()};
return Result;
166}

168CharSourceRange cxloc::translateCXRangeToCharRange(CXSourceRange R) {
return CharSourceRange::getCharRange(
    SourceLocation::getFromRawEncoding(R.begin_int_data),
    SourceLocation::getFromRawEncoding(R.end_int_data));
172}

174//===----------------------------------------------------------------------===//
175// Cursor visitor.
176//===----------------------------------------------------------------------===//

178static SourceRange getRawCursorExtent(CXCursor C);
179static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr);

181RangeComparisonResult CursorVisitor::CompareRegionOfInterest(SourceRange R) {
return RangeCompare(AU->getSourceManager(), R, RegionOfInterest);
183}

185/// Visit the given cursor and, if requested by the visitor,
186/// its children.
187///
188/// \param Cursor the cursor to visit.
189///
190/// \param CheckedRegionOfInterest if true, then the caller already checked
191/// that this cursor is within the region of interest.
192///
193/// \returns true if the visitation should be aborted, false if it
194/// should continue.
195bool CursorVisitor::Visit(CXCursor Cursor, bool CheckedRegionOfInterest) {
if (clang_isInvalid(Cursor.kind))
  return false;

if (clang_isDeclaration(Cursor.kind)) {
  const Decl *D = getCursorDecl(Cursor);
  if (!D) {
    assert(0 && "Invalid declaration cursor")(static_cast <bool> (0 && "Invalid declaration cursor"
) ? void (0) : __assert_fail ("0 && \"Invalid declaration cursor\""
, "clang/tools/libclang/CIndex.cpp", 202, __extension__ __PRETTY_FUNCTION__
));
    return true; // abort.
  }

  // Ignore implicit declarations, unless it's an objc method because
  // currently we should report implicit methods for properties when indexing.
  if (D->isImplicit() && !isa<ObjCMethodDecl>(D))
    return false;
}

// If we have a range of interest, and this cursor doesn't intersect with it,
// we're done.
if (RegionOfInterest.isValid() && !CheckedRegionOfInterest) {
  SourceRange Range = getRawCursorExtent(Cursor);
  if (Range.isInvalid() || CompareRegionOfInterest(Range))
    return false;
}

switch (Visitor(Cursor, Parent, ClientData)) {
case CXChildVisit_Break:
  return true;

case CXChildVisit_Continue:
  return false;

case CXChildVisit_Recurse: {
  bool ret = VisitChildren(Cursor);
  if (PostChildrenVisitor)
    if (PostChildrenVisitor(Cursor, ClientData))
      return true;
  return ret;
}
}

llvm_unreachable("Invalid CXChildVisitResult!")::llvm::llvm_unreachable_internal("Invalid CXChildVisitResult!"
, "clang/tools/libclang/CIndex.cpp", 236);
237}

239static bool visitPreprocessedEntitiesInRange(SourceRange R,
                                           PreprocessingRecord &PPRec,
                                           CursorVisitor &Visitor) {
SourceManager &SM = Visitor.getASTUnit()->getSourceManager();
FileID FID;

if (!Visitor.shouldVisitIncludedEntities()) {
  // If the begin/end of the range lie in the same FileID, do the optimization
  // where we skip preprocessed entities that do not come from the same
  // FileID.
  FID = SM.getFileID(SM.getFileLoc(R.getBegin()));
  if (FID != SM.getFileID(SM.getFileLoc(R.getEnd())))
    FID = FileID();
}

const auto &Entities = PPRec.getPreprocessedEntitiesInRange(R);
return Visitor.visitPreprocessedEntities(Entities.begin(), Entities.end(),
                                         PPRec, FID);
257}

259bool CursorVisitor::visitFileRegion() {
if (RegionOfInterest.isInvalid())
  return false;

ASTUnit *Unit = cxtu::getASTUnit(TU);
SourceManager &SM = Unit->getSourceManager();

std::pair<FileID, unsigned> Begin = SM.getDecomposedLoc(
                                SM.getFileLoc(RegionOfInterest.getBegin())),
                            End = SM.getDecomposedLoc(
                                SM.getFileLoc(RegionOfInterest.getEnd()));

if (End.first != Begin.first) {
  // If the end does not reside in the same file, try to recover by
  // picking the end of the file of begin location.
  End.first = Begin.first;
  End.second = SM.getFileIDSize(Begin.first);
}

assert(Begin.first == End.first)(static_cast <bool> (Begin.first == End.first) ? void (
0) : __assert_fail ("Begin.first == End.first", "clang/tools/libclang/CIndex.cpp"
, 278, __extension__ __PRETTY_FUNCTION__));
if (Begin.second > End.second)
  return false;

FileID File = Begin.first;
unsigned Offset = Begin.second;
unsigned Length = End.second - Begin.second;

if (!VisitDeclsOnly && !VisitPreprocessorLast)
  if (visitPreprocessedEntitiesInRegion())
    return true; // visitation break.

if (visitDeclsFromFileRegion(File, Offset, Length))
  return true; // visitation break.

if (!VisitDeclsOnly && VisitPreprocessorLast)
  return visitPreprocessedEntitiesInRegion();

return false;
297}

299static bool isInLexicalContext(Decl *D, DeclContext *DC) {
if (!DC)
  return false;

for (DeclContext *DeclDC = D->getLexicalDeclContext(); DeclDC;
     DeclDC = DeclDC->getLexicalParent()) {
  if (DeclDC == DC)
    return true;
}
return false;
309}

311bool CursorVisitor::visitDeclsFromFileRegion(FileID File, unsigned Offset,
                                           unsigned Length) {
ASTUnit *Unit = cxtu::getASTUnit(TU);
SourceManager &SM = Unit->getSourceManager();
SourceRange Range = RegionOfInterest;

SmallVector<Decl *, 16> Decls;
Unit->findFileRegionDecls(File, Offset, Length, Decls);

// If we didn't find any file level decls for the file, try looking at the
// file that it was included from.
while (Decls.empty() || Decls.front()->isTopLevelDeclInObjCContainer()) {
  bool Invalid = false;
  const SrcMgr::SLocEntry &SLEntry = SM.getSLocEntry(File, &Invalid);
  if (Invalid)
    return false;

  SourceLocation Outer;
  if (SLEntry.isFile())
    Outer = SLEntry.getFile().getIncludeLoc();
  else
    Outer = SLEntry.getExpansion().getExpansionLocStart();
  if (Outer.isInvalid())
    return false;

  std::tie(File, Offset) = SM.getDecomposedExpansionLoc(Outer);
  Length = 0;
  Unit->findFileRegionDecls(File, Offset, Length, Decls);
}

assert(!Decls.empty())(static_cast <bool> (!Decls.empty()) ? void (0) : __assert_fail
 ("!Decls.empty()", "clang/tools/libclang/CIndex.cpp", 341, __extension__
 __PRETTY_FUNCTION__));

bool VisitedAtLeastOnce = false;
DeclContext *CurDC = nullptr;
SmallVectorImpl<Decl *>::iterator DIt = Decls.begin();
for (SmallVectorImpl<Decl *>::iterator DE = Decls.end(); DIt != DE; ++DIt) {
  Decl *D = *DIt;
  if (D->getSourceRange().isInvalid())
    continue;

  if (isInLexicalContext(D, CurDC))
    continue;

  CurDC = dyn_cast<DeclContext>(D);

  if (TagDecl *TD = dyn_cast<TagDecl>(D))
    if (!TD->isFreeStanding())
      continue;

  RangeComparisonResult CompRes =
      RangeCompare(SM, D->getSourceRange(), Range);
  if (CompRes == RangeBefore)
    continue;
  if (CompRes == RangeAfter)
    break;

  assert(CompRes == RangeOverlap)(static_cast <bool> (CompRes == RangeOverlap) ? void (0
) : __assert_fail ("CompRes == RangeOverlap", "clang/tools/libclang/CIndex.cpp"
, 367, __extension__ __PRETTY_FUNCTION__));
  VisitedAtLeastOnce = true;

  if (isa<ObjCContainerDecl>(D)) {
    FileDI_current = &DIt;
    FileDE_current = DE;
  } else {
    FileDI_current = nullptr;
  }

  if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true))
    return true; // visitation break.
}

if (VisitedAtLeastOnce)
  return false;

// No Decls overlapped with the range. Move up the lexical context until there
// is a context that contains the range or we reach the translation unit
// level.
DeclContext *DC = DIt == Decls.begin()
                      ? (*DIt)->getLexicalDeclContext()
                      : (*(DIt - 1))->getLexicalDeclContext();

while (DC && !DC->isTranslationUnit()) {
  Decl *D = cast<Decl>(DC);
  SourceRange CurDeclRange = D->getSourceRange();
  if (CurDeclRange.isInvalid())
    break;

  if (RangeCompare(SM, CurDeclRange, Range) == RangeOverlap) {
    if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true))
      return true; // visitation break.
  }

  DC = D->getLexicalDeclContext();
}

return false;
406}

408bool CursorVisitor::visitPreprocessedEntitiesInRegion() {
if (!AU->getPreprocessor().getPreprocessingRecord())
  return false;

PreprocessingRecord &PPRec = *AU->getPreprocessor().getPreprocessingRecord();
SourceManager &SM = AU->getSourceManager();

if (RegionOfInterest.isValid()) {
  SourceRange MappedRange = AU->mapRangeToPreamble(RegionOfInterest);
  SourceLocation B = MappedRange.getBegin();
  SourceLocation E = MappedRange.getEnd();

  if (AU->isInPreambleFileID(B)) {
    if (SM.isLoadedSourceLocation(E))
      return visitPreprocessedEntitiesInRange(SourceRange(B, E), PPRec,
                                              *this);

    // Beginning of range lies in the preamble but it also extends beyond
    // it into the main file. Split the range into 2 parts, one covering
    // the preamble and another covering the main file. This allows subsequent
    // calls to visitPreprocessedEntitiesInRange to accept a source range that
    // lies in the same FileID, allowing it to skip preprocessed entities that
    // do not come from the same FileID.
    bool breaked = visitPreprocessedEntitiesInRange(
        SourceRange(B, AU->getEndOfPreambleFileID()), PPRec, *this);
    if (breaked)
      return true;
    return visitPreprocessedEntitiesInRange(
        SourceRange(AU->getStartOfMainFileID(), E), PPRec, *this);
  }

  return visitPreprocessedEntitiesInRange(SourceRange(B, E), PPRec, *this);
}

bool OnlyLocalDecls = !AU->isMainFileAST() && AU->getOnlyLocalDecls();

if (OnlyLocalDecls)
  return visitPreprocessedEntities(PPRec.local_begin(), PPRec.local_end(),
                                   PPRec);

return visitPreprocessedEntities(PPRec.begin(), PPRec.end(), PPRec);
449}

451template <typename InputIterator>
452bool CursorVisitor::visitPreprocessedEntities(InputIterator First,
                                            InputIterator Last,
                                            PreprocessingRecord &PPRec,
                                            FileID FID) {
for (; First != Last; ++First) {
  if (!FID.isInvalid() && !PPRec.isEntityInFileID(First, FID))
    continue;

  PreprocessedEntity *PPE = *First;
  if (!PPE)
    continue;

  if (MacroExpansion *ME = dyn_cast<MacroExpansion>(PPE)) {
    if (Visit(MakeMacroExpansionCursor(ME, TU)))
      return true;

    continue;
  }

  if (MacroDefinitionRecord *MD = dyn_cast<MacroDefinitionRecord>(PPE)) {
    if (Visit(MakeMacroDefinitionCursor(MD, TU)))
      return true;

    continue;
  }

  if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) {
    if (Visit(MakeInclusionDirectiveCursor(ID, TU)))
      return true;

    continue;
  }
}

return false;
487}

489/// Visit the children of the given cursor.
490///
491/// \returns true if the visitation should be aborted, false if it
492/// should continue.
493bool CursorVisitor::VisitChildren(CXCursor Cursor) {
if (clang_isReference(Cursor.kind) &&
    Cursor.kind != CXCursor_CXXBaseSpecifier) {
  // By definition, references have no children.
  return false;
}

// Set the Parent field to Cursor, then back to its old value once we're
// done.
SetParentRAII SetParent(Parent, StmtParent, Cursor);

if (clang_isDeclaration(Cursor.kind)) {
  Decl *D = const_cast<Decl *>(getCursorDecl(Cursor));
  if (!D)
    return false;

  return VisitAttributes(D) || Visit(D);
}

if (clang_isStatement(Cursor.kind)) {
  if (const Stmt *S = getCursorStmt(Cursor))
    return Visit(S);

  return false;
}

if (clang_isExpression(Cursor.kind)) {
  if (const Expr *E = getCursorExpr(Cursor))
    return Visit(E);

  return false;
}

if (clang_isTranslationUnit(Cursor.kind)) {
  CXTranslationUnit TU = getCursorTU(Cursor);
  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);

  int VisitOrder[2] = {VisitPreprocessorLast, !VisitPreprocessorLast};
  for (unsigned I = 0; I != 2; ++I) {
    if (VisitOrder[I]) {
      if (!CXXUnit->isMainFileAST() && CXXUnit->getOnlyLocalDecls() &&
          RegionOfInterest.isInvalid()) {
        for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(),
                                         TLEnd = CXXUnit->top_level_end();
             TL != TLEnd; ++TL) {
          const std::optional<bool> V = handleDeclForVisitation(*TL);
          if (!V)
            continue;
          return *V;
        }
      } else if (VisitDeclContext(
                     CXXUnit->getASTContext().getTranslationUnitDecl()))
        return true;
      continue;
    }

    // Walk the preprocessing record.
    if (CXXUnit->getPreprocessor().getPreprocessingRecord())
      visitPreprocessedEntitiesInRegion();
  }

  return false;
}

if (Cursor.kind == CXCursor_CXXBaseSpecifier) {
  if (const CXXBaseSpecifier *Base = getCursorCXXBaseSpecifier(Cursor)) {
    if (TypeSourceInfo *BaseTSInfo = Base->getTypeSourceInfo()) {
      return Visit(BaseTSInfo->getTypeLoc());
    }
  }
}

if (Cursor.kind == CXCursor_IBOutletCollectionAttr) {
  const IBOutletCollectionAttr *A =
      cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(Cursor));
  if (const ObjCObjectType *ObjT = A->getInterface()->getAs<ObjCObjectType>())
    return Visit(cxcursor::MakeCursorObjCClassRef(
        ObjT->getInterface(),
        A->getInterfaceLoc()->getTypeLoc().getBeginLoc(), TU));
}

// If pointing inside a macro definition, check if the token is an identifier
// that was ever defined as a macro. In such a case, create a "pseudo" macro
// expansion cursor for that token.
SourceLocation BeginLoc = RegionOfInterest.getBegin();
if (Cursor.kind == CXCursor_MacroDefinition &&
    BeginLoc == RegionOfInterest.getEnd()) {
  SourceLocation Loc = AU->mapLocationToPreamble(BeginLoc);
  const MacroInfo *MI =
      getMacroInfo(cxcursor::getCursorMacroDefinition(Cursor), TU);
  if (MacroDefinitionRecord *MacroDef =
          checkForMacroInMacroDefinition(MI, Loc, TU))
    return Visit(cxcursor::MakeMacroExpansionCursor(MacroDef, BeginLoc, TU));
}

// Nothing to visit at the moment.
return false;
590}

592bool CursorVisitor::VisitBlockDecl(BlockDecl *B) {
if (TypeSourceInfo *TSInfo = B->getSignatureAsWritten())
  if (Visit(TSInfo->getTypeLoc()))
    return true;

if (Stmt *Body = B->getBody())
  return Visit(MakeCXCursor(Body, StmtParent, TU, RegionOfInterest));

return false;
601}

603std::optional<bool> CursorVisitor::shouldVisitCursor(CXCursor Cursor) {
if (RegionOfInterest.isValid()) {
  SourceRange Range = getFullCursorExtent(Cursor, AU->getSourceManager());
  if (Range.isInvalid())
    return std::nullopt;

  switch (CompareRegionOfInterest(Range)) {
  case RangeBefore:
    // This declaration comes before the region of interest; skip it.
    return std::nullopt;

  case RangeAfter:
    // This declaration comes after the region of interest; we're done.
    return false;

  case RangeOverlap:
    // This declaration overlaps the region of interest; visit it.
    break;
  }
}
return true;
624}

626bool CursorVisitor::VisitDeclContext(DeclContext *DC) {
DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end();

// FIXME: Eventually remove.  This part of a hack to support proper
// iteration over all Decls contained lexically within an ObjC container.
SaveAndRestore DI_saved(DI_current, &I);
SaveAndRestore DE_saved(DE_current, E);

for (; I != E; ++I) {
  Decl *D = *I;
  if (D->getLexicalDeclContext() != DC)
    continue;
  // Filter out synthesized property accessor redeclarations.
  if (isa<ObjCImplDecl>(DC))
    if (auto *OMD = dyn_cast<ObjCMethodDecl>(D))
      if (OMD->isSynthesizedAccessorStub())
        continue;
  const std::optional<bool> V = handleDeclForVisitation(D);
  if (!V)
    continue;
  return *V;
}
return false;
649}

651std::optional<bool> CursorVisitor::handleDeclForVisitation(const Decl *D) {
CXCursor Cursor = MakeCXCursor(D, TU, RegionOfInterest);

// Ignore synthesized ivars here, otherwise if we have something like:
//   @synthesize prop = _prop;
// and '_prop' is not declared, we will encounter a '_prop' ivar before
// encountering the 'prop' synthesize declaration and we will think that
// we passed the region-of-interest.
if (auto *ivarD = dyn_cast<ObjCIvarDecl>(D)) {
  if (ivarD->getSynthesize())
    return std::nullopt;
}

// FIXME: ObjCClassRef/ObjCProtocolRef for forward class/protocol
// declarations is a mismatch with the compiler semantics.
if (Cursor.kind == CXCursor_ObjCInterfaceDecl) {
  auto *ID = cast<ObjCInterfaceDecl>(D);
  if (!ID->isThisDeclarationADefinition())
    Cursor = MakeCursorObjCClassRef(ID, ID->getLocation(), TU);

} else if (Cursor.kind == CXCursor_ObjCProtocolDecl) {
  auto *PD = cast<ObjCProtocolDecl>(D);
  if (!PD->isThisDeclarationADefinition())
    Cursor = MakeCursorObjCProtocolRef(PD, PD->getLocation(), TU);
}

const std::optional<bool> V = shouldVisitCursor(Cursor);
if (!V)
  return std::nullopt;
if (!*V)
  return false;
if (Visit(Cursor, true))
  return true;
return std::nullopt;
685}

687bool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
llvm_unreachable("Translation units are visited directly by Visit()")::llvm::llvm_unreachable_internal("Translation units are visited directly by Visit()"
, "clang/tools/libclang/CIndex.cpp", 688);
689}

691bool CursorVisitor::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
if (VisitTemplateParameters(D->getTemplateParameters()))
  return true;

return Visit(MakeCXCursor(D->getTemplatedDecl(), TU, RegionOfInterest));
696}

698bool CursorVisitor::VisitTypeAliasDecl(TypeAliasDecl *D) {
if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo())
  return Visit(TSInfo->getTypeLoc());

return false;
703}

705bool CursorVisitor::VisitTypedefDecl(TypedefDecl *D) {
if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo())
  return Visit(TSInfo->getTypeLoc());

return false;
710}

712bool CursorVisitor::VisitTagDecl(TagDecl *D) { return VisitDeclContext(D); }

714bool CursorVisitor::VisitClassTemplateSpecializationDecl(
  ClassTemplateSpecializationDecl *D) {
bool ShouldVisitBody = false;
switch (D->getSpecializationKind()) {
case TSK_Undeclared:
case TSK_ImplicitInstantiation:
  // Nothing to visit
  return false;

case TSK_ExplicitInstantiationDeclaration:
case TSK_ExplicitInstantiationDefinition:
  break;

case TSK_ExplicitSpecialization:
  ShouldVisitBody = true;
  break;
}

// Visit the template arguments used in the specialization.
if (TypeSourceInfo *SpecType = D->getTypeAsWritten()) {
  TypeLoc TL = SpecType->getTypeLoc();
  if (TemplateSpecializationTypeLoc TSTLoc =
          TL.getAs<TemplateSpecializationTypeLoc>()) {
    for (unsigned I = 0, N = TSTLoc.getNumArgs(); I != N; ++I)
      if (VisitTemplateArgumentLoc(TSTLoc.getArgLoc(I)))
        return true;
  }
}

return ShouldVisitBody && VisitCXXRecordDecl(D);
744}

746bool CursorVisitor::VisitClassTemplatePartialSpecializationDecl(
  ClassTemplatePartialSpecializationDecl *D) {
// FIXME: Visit the "outer" template parameter lists on the TagDecl
// before visiting these template parameters.
if (VisitTemplateParameters(D->getTemplateParameters()))
  return true;

// Visit the partial specialization arguments.
const ASTTemplateArgumentListInfo *Info = D->getTemplateArgsAsWritten();
const TemplateArgumentLoc *TemplateArgs = Info->getTemplateArgs();
for (unsigned I = 0, N = Info->NumTemplateArgs; I != N; ++I)
  if (VisitTemplateArgumentLoc(TemplateArgs[I]))
    return true;

return VisitCXXRecordDecl(D);
761}

763bool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
if (const auto *TC = D->getTypeConstraint()) {
  if (VisitTypeConstraint(*TC))
    return true;
}

// Visit the default argument.
if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
  if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo())
    if (Visit(DefArg->getTypeLoc()))
      return true;

return false;
776}

778bool CursorVisitor::VisitEnumConstantDecl(EnumConstantDecl *D) {
if (Expr *Init = D->getInitExpr())
  return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));
return false;
782}

784bool CursorVisitor::VisitDeclaratorDecl(DeclaratorDecl *DD) {
unsigned NumParamList = DD->getNumTemplateParameterLists();
for (unsigned i = 0; i < NumParamList; i++) {
  TemplateParameterList *Params = DD->getTemplateParameterList(i);
  if (VisitTemplateParameters(Params))
    return true;
}

if (TypeSourceInfo *TSInfo = DD->getTypeSourceInfo())
  if (Visit(TSInfo->getTypeLoc()))
    return true;

// Visit the nested-name-specifier, if present.
if (NestedNameSpecifierLoc QualifierLoc = DD->getQualifierLoc())
  if (VisitNestedNameSpecifierLoc(QualifierLoc))
    return true;

return false;
802}

804static bool HasTrailingReturnType(FunctionDecl *ND) {
const QualType Ty = ND->getType();
if (const FunctionType *AFT = Ty->getAs<FunctionType>()) {
  if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(AFT))
    return FT->hasTrailingReturn();
}

return false;
812}

814/// Compare two base or member initializers based on their source order.
815static int CompareCXXCtorInitializers(CXXCtorInitializer *const *X,
                                    CXXCtorInitializer *const *Y) {
return (*X)->getSourceOrder() - (*Y)->getSourceOrder();
818}

820bool CursorVisitor::VisitFunctionDecl(FunctionDecl *ND) {
unsigned NumParamList = ND->getNumTemplateParameterLists();
for (unsigned i = 0; i < NumParamList; i++) {
  TemplateParameterList *Params = ND->getTemplateParameterList(i);
  if (VisitTemplateParameters(Params))
    return true;
}

if (TypeSourceInfo *TSInfo = ND->getTypeSourceInfo()) {
  // Visit the function declaration's syntactic components in the order
  // written. This requires a bit of work.
  TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
  FunctionTypeLoc FTL = TL.getAs<FunctionTypeLoc>();
  const bool HasTrailingRT = HasTrailingReturnType(ND);

  // If we have a function declared directly (without the use of a typedef),
  // visit just the return type. Otherwise, just visit the function's type
  // now.
  if ((FTL && !isa<CXXConversionDecl>(ND) && !HasTrailingRT &&
       Visit(FTL.getReturnLoc())) ||
      (!FTL && Visit(TL)))
    return true;

  // Visit the nested-name-specifier, if present.
  if (NestedNameSpecifierLoc QualifierLoc = ND->getQualifierLoc())
    if (VisitNestedNameSpecifierLoc(QualifierLoc))
      return true;

  // Visit the declaration name.
  if (!isa<CXXDestructorDecl>(ND))
    if (VisitDeclarationNameInfo(ND->getNameInfo()))
      return true;

  // FIXME: Visit explicitly-specified template arguments!

  // Visit the function parameters, if we have a function type.
  if (FTL && VisitFunctionTypeLoc(FTL, true))
    return true;

  // Visit the function's trailing return type.
  if (FTL && HasTrailingRT && Visit(FTL.getReturnLoc()))
    return true;

  // FIXME: Attributes?
}

if (auto *E = ND->getTrailingRequiresClause()) {
  if (Visit(E))
    return true;
}

if (ND->doesThisDeclarationHaveABody() && !ND->isLateTemplateParsed()) {
  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ND)) {
    // Find the initializers that were written in the source.
    SmallVector<CXXCtorInitializer *, 4> WrittenInits;
    for (auto *I : Constructor->inits()) {
      if (!I->isWritten())
        continue;

      WrittenInits.push_back(I);
    }

    // Sort the initializers in source order
    llvm::array_pod_sort(WrittenInits.begin(), WrittenInits.end(),
                         &CompareCXXCtorInitializers);

    // Visit the initializers in source order
    for (unsigned I = 0, N = WrittenInits.size(); I != N; ++I) {
      CXXCtorInitializer *Init = WrittenInits[I];
      if (Init->isAnyMemberInitializer()) {
        if (Visit(MakeCursorMemberRef(Init->getAnyMember(),
                                      Init->getMemberLocation(), TU)))
          return true;
      } else if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo()) {
        if (Visit(TInfo->getTypeLoc()))
          return true;
      }

      // Visit the initializer value.
      if (Expr *Initializer = Init->getInit())
        if (Visit(MakeCXCursor(Initializer, ND, TU, RegionOfInterest)))
          return true;
    }
  }

  if (Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest)))
    return true;
}

return false;
910}

912bool CursorVisitor::VisitFieldDecl(FieldDecl *D) {
if (VisitDeclaratorDecl(D))
  return true;

if (Expr *BitWidth = D->getBitWidth())
  return Visit(MakeCXCursor(BitWidth, StmtParent, TU, RegionOfInterest));

if (Expr *Init = D->getInClassInitializer())
  return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));

return false;
923}

925bool CursorVisitor::VisitVarDecl(VarDecl *D) {
if (VisitDeclaratorDecl(D))
  return true;

if (Expr *Init = D->getInit())
  return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));

return false;
933}

935bool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
if (VisitDeclaratorDecl(D))
  return true;

if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
  if (Expr *DefArg = D->getDefaultArgument())
    return Visit(MakeCXCursor(DefArg, StmtParent, TU, RegionOfInterest));

return false;
944}

946bool CursorVisitor::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
// FIXME: Visit the "outer" template parameter lists on the FunctionDecl
// before visiting these template parameters.
if (VisitTemplateParameters(D->getTemplateParameters()))
  return true;

auto *FD = D->getTemplatedDecl();
return VisitAttributes(FD) || VisitFunctionDecl(FD);
954}

956bool CursorVisitor::VisitClassTemplateDecl(ClassTemplateDecl *D) {
// FIXME: Visit the "outer" template parameter lists on the TagDecl
// before visiting these template parameters.
if (VisitTemplateParameters(D->getTemplateParameters()))
  return true;

auto *CD = D->getTemplatedDecl();
return VisitAttributes(CD) || VisitCXXRecordDecl(CD);
964}

966bool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
if (VisitTemplateParameters(D->getTemplateParameters()))
  return true;

if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited() &&
    VisitTemplateArgumentLoc(D->getDefaultArgument()))
  return true;

return false;
975}

977bool CursorVisitor::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
// Visit the bound, if it's explicit.
if (D->hasExplicitBound()) {
  if (auto TInfo = D->getTypeSourceInfo()) {
    if (Visit(TInfo->getTypeLoc()))
      return true;
  }
}

return false;
987}

989bool CursorVisitor::VisitObjCMethodDecl(ObjCMethodDecl *ND) {
if (TypeSourceInfo *TSInfo = ND->getReturnTypeSourceInfo())
  if (Visit(TSInfo->getTypeLoc()))
    return true;

for (const auto *P : ND->parameters()) {
  if (Visit(MakeCXCursor(P, TU, RegionOfInterest)))
    return true;
}

return ND->isThisDeclarationADefinition() &&
       Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest));
1001}

1003template <typename DeclIt>
1004static void addRangedDeclsInContainer(DeclIt *DI_current, DeclIt DE_current,
                                    SourceManager &SM, SourceLocation EndLoc,
                                    SmallVectorImpl<Decl *> &Decls) {
DeclIt next = *DI_current;
while (++next != DE_current) {
  Decl *D_next = *next;
  if (!D_next)
    break;
  SourceLocation L = D_next->getBeginLoc();
  if (!L.isValid())
    break;
  if (SM.isBeforeInTranslationUnit(L, EndLoc)) {
    *DI_current = next;
    Decls.push_back(D_next);
    continue;
  }
  break;
}
1022}

1024bool CursorVisitor::VisitObjCContainerDecl(ObjCContainerDecl *D) {
// FIXME: Eventually convert back to just 'VisitDeclContext()'.  Essentially
// an @implementation can lexically contain Decls that are not properly
// nested in the AST.  When we identify such cases, we need to retrofit
// this nesting here.
if (!DI_current && !FileDI_current)
  return VisitDeclContext(D);

// Scan the Decls that immediately come after the container
// in the current DeclContext.  If any fall within the
// container's lexical region, stash them into a vector
// for later processing.
SmallVector<Decl *, 24> DeclsInContainer;
SourceLocation EndLoc = D->getSourceRange().getEnd();
SourceManager &SM = AU->getSourceManager();
if (EndLoc.isValid()) {
  if (DI_current) {
    addRangedDeclsInContainer(DI_current, DE_current, SM, EndLoc,
                              DeclsInContainer);
  } else {
    addRangedDeclsInContainer(FileDI_current, FileDE_current, SM, EndLoc,
                              DeclsInContainer);
  }
}

// The common case.
if (DeclsInContainer.empty())
  return VisitDeclContext(D);

// Get all the Decls in the DeclContext, and sort them with the
// additional ones we've collected.  Then visit them.
for (auto *SubDecl : D->decls()) {
  if (!SubDecl || SubDecl->getLexicalDeclContext() != D ||
      SubDecl->getBeginLoc().isInvalid())
    continue;
  DeclsInContainer.push_back(SubDecl);
}

// Now sort the Decls so that they appear in lexical order.
llvm::sort(DeclsInContainer, [&SM](Decl *A, Decl *B) {
  SourceLocation L_A = A->getBeginLoc();
  SourceLocation L_B = B->getBeginLoc();
  return L_A != L_B
             ? SM.isBeforeInTranslationUnit(L_A, L_B)
             : SM.isBeforeInTranslationUnit(A->getEndLoc(), B->getEndLoc());
});

// Now visit the decls.
for (SmallVectorImpl<Decl *>::iterator I = DeclsInContainer.begin(),
                                       E = DeclsInContainer.end();
     I != E; ++I) {
  CXCursor Cursor = MakeCXCursor(*I, TU, RegionOfInterest);
  const std::optional<bool> &V = shouldVisitCursor(Cursor);
  if (!V)
    continue;
  if (!*V)
    return false;
  if (Visit(Cursor, true))
    return true;
}
return false;
1085}

1087bool CursorVisitor::VisitObjCCategoryDecl(ObjCCategoryDecl *ND) {
if (Visit(MakeCursorObjCClassRef(ND->getClassInterface(), ND->getLocation(),
                                 TU)))
  return true;

if (VisitObjCTypeParamList(ND->getTypeParamList()))
  return true;

ObjCCategoryDecl::protocol_loc_iterator PL = ND->protocol_loc_begin();
for (ObjCCategoryDecl::protocol_iterator I = ND->protocol_begin(),
                                         E = ND->protocol_end();
     I != E; ++I, ++PL)
  if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
    return true;

return VisitObjCContainerDecl(ND);
1103}

1105bool CursorVisitor::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) {
if (!PID->isThisDeclarationADefinition())
  return Visit(MakeCursorObjCProtocolRef(PID, PID->getLocation(), TU));

ObjCProtocolDecl::protocol_loc_iterator PL = PID->protocol_loc_begin();
for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(),
                                         E = PID->protocol_end();
     I != E; ++I, ++PL)
  if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
    return true;

return VisitObjCContainerDecl(PID);
1117}

1119bool CursorVisitor::VisitObjCPropertyDecl(ObjCPropertyDecl *PD) {
if (PD->getTypeSourceInfo() && Visit(PD->getTypeSourceInfo()->getTypeLoc()))
  return true;

// FIXME: This implements a workaround with @property declarations also being
// installed in the DeclContext for the @interface.  Eventually this code
// should be removed.
ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(PD->getDeclContext());
if (!CDecl || !CDecl->IsClassExtension())
  return false;

ObjCInterfaceDecl *ID = CDecl->getClassInterface();
if (!ID)
  return false;

IdentifierInfo *PropertyId = PD->getIdentifier();
ObjCPropertyDecl *prevDecl = ObjCPropertyDecl::findPropertyDecl(
    cast<DeclContext>(ID), PropertyId, PD->getQueryKind());

if (!prevDecl)
  return false;

// Visit synthesized methods since they will be skipped when visiting
// the @interface.
if (ObjCMethodDecl *MD = prevDecl->getGetterMethodDecl())
  if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl)
    if (Visit(MakeCXCursor(MD, TU, RegionOfInterest)))
      return true;

if (ObjCMethodDecl *MD = prevDecl->getSetterMethodDecl())
  if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl)
    if (Visit(MakeCXCursor(MD, TU, RegionOfInterest)))
      return true;

return false;
1154}

1156bool CursorVisitor::VisitObjCTypeParamList(ObjCTypeParamList *typeParamList) {
if (!typeParamList)
  return false;

for (auto *typeParam : *typeParamList) {
  // Visit the type parameter.
  if (Visit(MakeCXCursor(typeParam, TU, RegionOfInterest)))
    return true;
}

return false;
1167}

1169bool CursorVisitor::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
if (!D->isThisDeclarationADefinition()) {
  // Forward declaration is treated like a reference.
  return Visit(MakeCursorObjCClassRef(D, D->getLocation(), TU));
}

// Objective-C type parameters.
if (VisitObjCTypeParamList(D->getTypeParamListAsWritten()))
  return true;

// Issue callbacks for super class.
if (D->getSuperClass() && Visit(MakeCursorObjCSuperClassRef(
                              D->getSuperClass(), D->getSuperClassLoc(), TU)))
  return true;

if (TypeSourceInfo *SuperClassTInfo = D->getSuperClassTInfo())
  if (Visit(SuperClassTInfo->getTypeLoc()))
    return true;

ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin();
for (ObjCInterfaceDecl::protocol_iterator I = D->protocol_begin(),
                                          E = D->protocol_end();
     I != E; ++I, ++PL)
  if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
    return true;

return VisitObjCContainerDecl(D);
1196}

1198bool CursorVisitor::VisitObjCImplDecl(ObjCImplDecl *D) {
return VisitObjCContainerDecl(D);
1200}

1202bool CursorVisitor::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
// 'ID' could be null when dealing with invalid code.
if (ObjCInterfaceDecl *ID = D->getClassInterface())
  if (Visit(MakeCursorObjCClassRef(ID, D->getLocation(), TU)))
    return true;

return VisitObjCImplDecl(D);
1209}

1211bool CursorVisitor::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
1212#if 0
// Issue callbacks for super class.
// FIXME: No source location information!
if (D->getSuperClass() &&
    Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(),
                                      D->getSuperClassLoc(),
                                      TU)))
  return true;
1220#endif

return VisitObjCImplDecl(D);
1223}

1225bool CursorVisitor::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PD) {
if (ObjCIvarDecl *Ivar = PD->getPropertyIvarDecl())
  if (PD->isIvarNameSpecified())
    return Visit(MakeCursorMemberRef(Ivar, PD->getPropertyIvarDeclLoc(), TU));

return false;
1231}

1233bool CursorVisitor::VisitNamespaceDecl(NamespaceDecl *D) {
return VisitDeclContext(D);
1235}

1237bool CursorVisitor::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
// Visit nested-name-specifier.
if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
  if (VisitNestedNameSpecifierLoc(QualifierLoc))
    return true;

return Visit(MakeCursorNamespaceRef(D->getAliasedNamespace(),
                                    D->getTargetNameLoc(), TU));
1245}

1247bool CursorVisitor::VisitUsingDecl(UsingDecl *D) {
// Visit nested-name-specifier.
if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) {
  if (VisitNestedNameSpecifierLoc(QualifierLoc))
    return true;
}

if (Visit(MakeCursorOverloadedDeclRef(D, D->getLocation(), TU)))
  return true;

return VisitDeclarationNameInfo(D->getNameInfo());
1258}

1260bool CursorVisitor::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
// Visit nested-name-specifier.
if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
  if (VisitNestedNameSpecifierLoc(QualifierLoc))
    return true;

return Visit(MakeCursorNamespaceRef(D->getNominatedNamespaceAsWritten(),
                                    D->getIdentLocation(), TU));
1268}

1270bool CursorVisitor::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
// Visit nested-name-specifier.
if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) {
  if (VisitNestedNameSpecifierLoc(QualifierLoc))
    return true;
}

return VisitDeclarationNameInfo(D->getNameInfo());
1278}

1280bool CursorVisitor::VisitUnresolvedUsingTypenameDecl(
  UnresolvedUsingTypenameDecl *D) {
// Visit nested-name-specifier.
if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
  if (VisitNestedNameSpecifierLoc(QualifierLoc))
    return true;

return false;
1288}

1290bool CursorVisitor::VisitStaticAssertDecl(StaticAssertDecl *D) {
if (Visit(MakeCXCursor(D->getAssertExpr(), StmtParent, TU, RegionOfInterest)))
  return true;
if (StringLiteral *Message = D->getMessage())
  if (Visit(MakeCXCursor(Message, StmtParent, TU, RegionOfInterest)))
    return true;
return false;
1297}

1299bool CursorVisitor::VisitFriendDecl(FriendDecl *D) {
if (NamedDecl *FriendD = D->getFriendDecl()) {
  if (Visit(MakeCXCursor(FriendD, TU, RegionOfInterest)))
    return true;
} else if (TypeSourceInfo *TI = D->getFriendType()) {
  if (Visit(TI->getTypeLoc()))
    return true;
}
return false;
1308}

1310bool CursorVisitor::VisitDecompositionDecl(DecompositionDecl *D) {
for (auto *B : D->bindings()) {
  if (Visit(MakeCXCursor(B, TU, RegionOfInterest)))
    return true;
}
return VisitVarDecl(D);
1316}

1318bool CursorVisitor::VisitConceptDecl(ConceptDecl *D) {
if (VisitTemplateParameters(D->getTemplateParameters()))
  return true;

if (auto *E = D->getConstraintExpr()) {
  if (Visit(MakeCXCursor(E, D, TU, RegionOfInterest)))
    return true;
}
return false;
1327}

1329bool CursorVisitor::VisitTypeConstraint(const TypeConstraint &TC) {
if (TC.getNestedNameSpecifierLoc()) {
  if (VisitNestedNameSpecifierLoc(TC.getNestedNameSpecifierLoc()))
    return true;
}
if (TC.getNamedConcept()) {
  if (Visit(MakeCursorTemplateRef(TC.getNamedConcept(),
                                  TC.getConceptNameLoc(), TU)))
    return true;
}
if (auto Args = TC.getTemplateArgsAsWritten()) {
  for (const auto &Arg : Args->arguments()) {
    if (VisitTemplateArgumentLoc(Arg))
      return true;
  }
}
return false;
1346}

1348bool CursorVisitor::VisitConceptRequirement(const concepts::Requirement &R) {
using namespace concepts;
switch (R.getKind()) {
case Requirement::RK_Type: {
  const TypeRequirement &TR = cast<TypeRequirement>(R);
  if (!TR.isSubstitutionFailure()) {
    if (Visit(TR.getType()->getTypeLoc()))
      return true;
  }
  break;
}
case Requirement::RK_Simple:
case Requirement::RK_Compound: {
  const ExprRequirement &ER = cast<ExprRequirement>(R);
  if (!ER.isExprSubstitutionFailure()) {
    if (Visit(ER.getExpr()))
      return true;
  }
  if (ER.getKind() == Requirement::RK_Compound) {
    const auto &RTR = ER.getReturnTypeRequirement();
    if (RTR.isTypeConstraint()) {
      if (const auto *Cons = RTR.getTypeConstraint())
        VisitTypeConstraint(*Cons);
    }
  }
  break;
}
case Requirement::RK_Nested: {
  const NestedRequirement &NR = cast<NestedRequirement>(R);
  if (!NR.hasInvalidConstraint()) {
    if (Visit(NR.getConstraintExpr()))
      return true;
  }
  break;
}
}
return false;
1385}

1387bool CursorVisitor::VisitDeclarationNameInfo(DeclarationNameInfo Name) {
switch (Name.getName().getNameKind()) {
case clang::DeclarationName::Identifier:
case clang::DeclarationName::CXXLiteralOperatorName:
case clang::DeclarationName::CXXDeductionGuideName:
case clang::DeclarationName::CXXOperatorName:
case clang::DeclarationName::CXXUsingDirective:
  return false;

case clang::DeclarationName::CXXConstructorName:
case clang::DeclarationName::CXXDestructorName:
case clang::DeclarationName::CXXConversionFunctionName:
  if (TypeSourceInfo *TSInfo = Name.getNamedTypeInfo())
    return Visit(TSInfo->getTypeLoc());
  return false;

case clang::DeclarationName::ObjCZeroArgSelector:
case clang::DeclarationName::ObjCOneArgSelector:
case clang::DeclarationName::ObjCMultiArgSelector:
  // FIXME: Per-identifier location info?
  return false;
}

llvm_unreachable("Invalid DeclarationName::Kind!")::llvm::llvm_unreachable_internal("Invalid DeclarationName::Kind!"
, "clang/tools/libclang/CIndex.cpp", 1410);
1411}

1413bool CursorVisitor::VisitNestedNameSpecifier(NestedNameSpecifier *NNS,
                                           SourceRange Range) {
// FIXME: This whole routine is a hack to work around the lack of proper
// source information in nested-name-specifiers (PR5791). Since we do have
// a beginning source location, we can visit the first component of the
// nested-name-specifier, if it's a single-token component.
if (!NNS)
  return false;

// Get the first component in the nested-name-specifier.
while (NestedNameSpecifier *Prefix = NNS->getPrefix())
  NNS = Prefix;

switch (NNS->getKind()) {
case NestedNameSpecifier::Namespace:
  return Visit(
      MakeCursorNamespaceRef(NNS->getAsNamespace(), Range.getBegin(), TU));

case NestedNameSpecifier::NamespaceAlias:
  return Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(),
                                      Range.getBegin(), TU));

case NestedNameSpecifier::TypeSpec: {
  // If the type has a form where we know that the beginning of the source
  // range matches up with a reference cursor. Visit the appropriate reference
  // cursor.
  const Type *T = NNS->getAsType();
  if (const TypedefType *Typedef = dyn_cast<TypedefType>(T))
    return Visit(MakeCursorTypeRef(Typedef->getDecl(), Range.getBegin(), TU));
  if (const TagType *Tag = dyn_cast<TagType>(T))
    return Visit(MakeCursorTypeRef(Tag->getDecl(), Range.getBegin(), TU));
  if (const TemplateSpecializationType *TST =
          dyn_cast<TemplateSpecializationType>(T))
    return VisitTemplateName(TST->getTemplateName(), Range.getBegin());
  break;
}

case NestedNameSpecifier::TypeSpecWithTemplate:
case NestedNameSpecifier::Global:
case NestedNameSpecifier::Identifier:
case NestedNameSpecifier::Super:
  break;
}

return false;
1458}

1460bool CursorVisitor::VisitNestedNameSpecifierLoc(
  NestedNameSpecifierLoc Qualifier) {
SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;
for (; Qualifier; Qualifier = Qualifier.getPrefix())
  Qualifiers.push_back(Qualifier);

while (!Qualifiers.empty()) {
  NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
  NestedNameSpecifier *NNS = Q.getNestedNameSpecifier();
  switch (NNS->getKind()) {
  case NestedNameSpecifier::Namespace:
    if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(),
                                     Q.getLocalBeginLoc(), TU)))
      return true;

    break;

  case NestedNameSpecifier::NamespaceAlias:
    if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(),
                                     Q.getLocalBeginLoc(), TU)))
      return true;

    break;

  case NestedNameSpecifier::TypeSpec:
  case NestedNameSpecifier::TypeSpecWithTemplate:
    if (Visit(Q.getTypeLoc()))
      return true;

    break;

  case NestedNameSpecifier::Global:
  case NestedNameSpecifier::Identifier:
  case NestedNameSpecifier::Super:
    break;
  }
}

return false;
1499}

1501bool CursorVisitor::VisitTemplateParameters(
  const TemplateParameterList *Params) {
if (!Params)
  return false;

for (TemplateParameterList::const_iterator P = Params->begin(),
                                           PEnd = Params->end();
     P != PEnd; ++P) {
  if (Visit(MakeCXCursor(*P, TU, RegionOfInterest)))
    return true;
}

if (const auto *E = Params->getRequiresClause()) {
  if (Visit(MakeCXCursor(E, nullptr, TU, RegionOfInterest)))
    return true;
}

return false;
1519}

1521bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) {
switch (Name.getKind()) {
case TemplateName::Template:
case TemplateName::UsingTemplate:
case TemplateName::QualifiedTemplate: // FIXME: Visit nested-name-specifier.
  return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU));

case TemplateName::OverloadedTemplate:
  // Visit the overloaded template set.
  if (Visit(MakeCursorOverloadedDeclRef(Name, Loc, TU)))
    return true;

  return false;

case TemplateName::AssumedTemplate:
  // FIXME: Visit DeclarationName?
  return false;

case TemplateName::DependentTemplate:
  // FIXME: Visit nested-name-specifier.
  return false;

case TemplateName::SubstTemplateTemplateParm:
  return Visit(MakeCursorTemplateRef(
      Name.getAsSubstTemplateTemplateParm()->getParameter(), Loc, TU));

case TemplateName::SubstTemplateTemplateParmPack:
  return Visit(MakeCursorTemplateRef(
      Name.getAsSubstTemplateTemplateParmPack()->getParameterPack(), Loc,
      TU));
}

llvm_unreachable("Invalid TemplateName::Kind!")::llvm::llvm_unreachable_internal("Invalid TemplateName::Kind!"
, "clang/tools/libclang/CIndex.cpp", 1553);
1554}

1556bool CursorVisitor::VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL) {
switch (TAL.getArgument().getKind()) {
case TemplateArgument::Null:
case TemplateArgument::Integral:
case TemplateArgument::Pack:
  return false;

case TemplateArgument::Type:
  if (TypeSourceInfo *TSInfo = TAL.getTypeSourceInfo())
    return Visit(TSInfo->getTypeLoc());
  return false;

case TemplateArgument::Declaration:
  if (Expr *E = TAL.getSourceDeclExpression())
    return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
  return false;

case TemplateArgument::NullPtr:
  if (Expr *E = TAL.getSourceNullPtrExpression())
    return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
  return false;

case TemplateArgument::Expression:
  if (Expr *E = TAL.getSourceExpression())
    return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
  return false;

case TemplateArgument::Template:
case TemplateArgument::TemplateExpansion:
  if (VisitNestedNameSpecifierLoc(TAL.getTemplateQualifierLoc()))
    return true;

  return VisitTemplateName(TAL.getArgument().getAsTemplateOrTemplatePattern(),
                           TAL.getTemplateNameLoc());
}

llvm_unreachable("Invalid TemplateArgument::Kind!")::llvm::llvm_unreachable_internal("Invalid TemplateArgument::Kind!"
, "clang/tools/libclang/CIndex.cpp", 1592);
1593}

1595bool CursorVisitor::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
return VisitDeclContext(D);
1597}

1599bool CursorVisitor::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
return Visit(TL.getUnqualifiedLoc());
1601}

1603bool CursorVisitor::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
ASTContext &Context = AU->getASTContext();

// Some builtin types (such as Objective-C's "id", "sel", and
// "Class") have associated declarations. Create cursors for those.
QualType VisitType;
switch (TL.getTypePtr()->getKind()) {

case BuiltinType::Void:
case BuiltinType::NullPtr:
case BuiltinType::Dependent:
1614#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
case BuiltinType::Id:
1616#include "clang/Basic/OpenCLImageTypes.def"
1617#define EXT_OPAQUE_TYPE(ExtTYpe, Id, Ext) case BuiltinType::Id:
1618#include "clang/Basic/OpenCLExtensionTypes.def"
case BuiltinType::OCLSampler:
case BuiltinType::OCLEvent:
case BuiltinType::OCLClkEvent:
case BuiltinType::OCLQueue:
case BuiltinType::OCLReserveID:
1624#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
1625#include "clang/Basic/AArch64SVEACLETypes.def"
1626#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
1627#include "clang/Basic/PPCTypes.def"
1628#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
1629#include "clang/Basic/RISCVVTypes.def"
1630#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
1631#include "clang/Basic/WebAssemblyReferenceTypes.def"
1632#define BUILTIN_TYPE(Id, SingletonId)
1633#define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
1634#define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
1635#define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
1636#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
1637#include "clang/AST/BuiltinTypes.def"
  break;

case BuiltinType::ObjCId:
  VisitType = Context.getObjCIdType();
  break;

case BuiltinType::ObjCClass:
  VisitType = Context.getObjCClassType();
  break;

case BuiltinType::ObjCSel:
  VisitType = Context.getObjCSelType();
  break;
}

if (!VisitType.isNull()) {
  if (const TypedefType *Typedef = VisitType->getAs<TypedefType>())
    return Visit(
        MakeCursorTypeRef(Typedef->getDecl(), TL.getBuiltinLoc(), TU));
}

return false;
1660}

1662bool CursorVisitor::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
return Visit(MakeCursorTypeRef(TL.getTypedefNameDecl(), TL.getNameLoc(), TU));
1664}

1666bool CursorVisitor::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1668}

1670bool CursorVisitor::VisitTagTypeLoc(TagTypeLoc TL) {
if (TL.isDefinition())
  return Visit(MakeCXCursor(TL.getDecl(), TU, RegionOfInterest));

return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1675}

1677bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
if (const auto *TC = TL.getDecl()->getTypeConstraint()) {
  if (VisitTypeConstraint(*TC))
    return true;
}

return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1684}

1686bool CursorVisitor::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
return Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU));
1688}

1690bool CursorVisitor::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
if (Visit(MakeCursorTypeRef(TL.getDecl(), TL.getBeginLoc(), TU)))
  return true;
for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {
  if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I),
                                      TU)))
    return true;
}

return false;
1700}

1702bool CursorVisitor::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
if (TL.hasBaseTypeAsWritten() && Visit(TL.getBaseLoc()))
  return true;

for (unsigned I = 0, N = TL.getNumTypeArgs(); I != N; ++I) {
  if (Visit(TL.getTypeArgTInfo(I)->getTypeLoc()))
    return true;
}

for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {
  if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I),
                                      TU)))
    return true;
}

return false;
1718}

1720bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
return Visit(TL.getPointeeLoc());
1722}

1724bool CursorVisitor::VisitParenTypeLoc(ParenTypeLoc TL) {
return Visit(TL.getInnerLoc());
1726}

1728bool CursorVisitor::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
return Visit(TL.getInnerLoc());
1730}

1732bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) {
return Visit(TL.getPointeeLoc());
1734}

1736bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
return Visit(TL.getPointeeLoc());
1738}

1740bool CursorVisitor::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
return Visit(TL.getPointeeLoc());
1742}

1744bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
return Visit(TL.getPointeeLoc());
1746}

1748bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
return Visit(TL.getPointeeLoc());
1750}

1752bool CursorVisitor::VisitUsingTypeLoc(UsingTypeLoc TL) {
auto *underlyingDecl = TL.getUnderlyingType()->getAsTagDecl();
if (underlyingDecl) {
  return Visit(MakeCursorTypeRef(underlyingDecl, TL.getNameLoc(), TU));
}
return false;
1758}

1760bool CursorVisitor::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
return Visit(TL.getModifiedLoc());
1762}

1764bool CursorVisitor::VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) {
return Visit(TL.getWrappedLoc());
1766}

1768bool CursorVisitor::VisitFunctionTypeLoc(FunctionTypeLoc TL,
                                       bool SkipResultType) {
if (!SkipResultType && Visit(TL.getReturnLoc()))
  return true;

for (unsigned I = 0, N = TL.getNumParams(); I != N; ++I)
  if (Decl *D = TL.getParam(I))
    if (Visit(MakeCXCursor(D, TU, RegionOfInterest)))
      return true;

return false;
1779}

1781bool CursorVisitor::VisitArrayTypeLoc(ArrayTypeLoc TL) {
if (Visit(TL.getElementLoc()))
  return true;

if (Expr *Size = TL.getSizeExpr())
  return Visit(MakeCXCursor(Size, StmtParent, TU, RegionOfInterest));

return false;
1789}

1791bool CursorVisitor::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
return Visit(TL.getOriginalLoc());
1793}

1795bool CursorVisitor::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
return Visit(TL.getOriginalLoc());
1797}

1799bool CursorVisitor::VisitDeducedTemplateSpecializationTypeLoc(
  DeducedTemplateSpecializationTypeLoc TL) {
if (VisitTemplateName(TL.getTypePtr()->getTemplateName(),
                      TL.getTemplateNameLoc()))
  return true;

return false;
1806}

1808bool CursorVisitor::VisitTemplateSpecializationTypeLoc(
  TemplateSpecializationTypeLoc TL) {
// Visit the template name.
if (VisitTemplateName(TL.getTypePtr()->getTemplateName(),
                      TL.getTemplateNameLoc()))
  return true;

// Visit the template arguments.
for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
  if (VisitTemplateArgumentLoc(TL.getArgLoc(I)))
    return true;

return false;
1821}

1823bool CursorVisitor::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
return Visit(MakeCXCursor(TL.getUnderlyingExpr(), StmtParent, TU));
1825}

1827bool CursorVisitor::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
if (TypeSourceInfo *TSInfo = TL.getUnmodifiedTInfo())
  return Visit(TSInfo->getTypeLoc());

return false;
1832}

1834bool CursorVisitor::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo())
  return Visit(TSInfo->getTypeLoc());

return false;
1839}

1841bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
return VisitNestedNameSpecifierLoc(TL.getQualifierLoc());
1843}

1845bool CursorVisitor::VisitDependentTemplateSpecializationTypeLoc(
  DependentTemplateSpecializationTypeLoc TL) {
// Visit the nested-name-specifier, if there is one.
if (TL.getQualifierLoc() && VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
  return true;

// Visit the template arguments.
for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
  if (VisitTemplateArgumentLoc(TL.getArgLoc(I)))
    return true;

return false;
1857}

1859bool CursorVisitor::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
  return true;

return Visit(TL.getNamedTypeLoc());
1864}

1866bool CursorVisitor::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
return Visit(TL.getPatternLoc());
1868}

1870bool CursorVisitor::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
if (Expr *E = TL.getUnderlyingExpr())
  return Visit(MakeCXCursor(E, StmtParent, TU));

return false;
1875}

1877bool CursorVisitor::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1879}

1881bool CursorVisitor::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
return Visit(TL.getValueLoc());
1883}

1885bool CursorVisitor::VisitPipeTypeLoc(PipeTypeLoc TL) {
return Visit(TL.getValueLoc());
1887}

1889#define DEFAULT_TYPELOC_IMPL(CLASS, PARENT)bool CursorVisitor::VisitCLASSTypeLoc(CLASSTypeLoc TL) { return
 VisitPARENTLoc(TL); }                                    \
bool CursorVisitor::Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) {               \
  return Visit##PARENT##Loc(TL);                                             \
}

1894DEFAULT_TYPELOC_IMPL(Complex, Type)bool CursorVisitor::VisitComplexTypeLoc(ComplexTypeLoc TL) { return
 VisitTypeLoc(TL); }
1895DEFAULT_TYPELOC_IMPL(ConstantArray, ArrayType)bool CursorVisitor::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc
 TL) { return VisitArrayTypeLoc(TL); }
1896DEFAULT_TYPELOC_IMPL(IncompleteArray, ArrayType)bool CursorVisitor::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc
 TL) { return VisitArrayTypeLoc(TL); }
1897DEFAULT_TYPELOC_IMPL(VariableArray, ArrayType)bool CursorVisitor::VisitVariableArrayTypeLoc(VariableArrayTypeLoc
 TL) { return VisitArrayTypeLoc(TL); }
1898DEFAULT_TYPELOC_IMPL(DependentSizedArray, ArrayType)bool CursorVisitor::VisitDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc
 TL) { return VisitArrayTypeLoc(TL); }
1899DEFAULT_TYPELOC_IMPL(DependentAddressSpace, Type)bool CursorVisitor::VisitDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc
 TL) { return VisitTypeLoc(TL); }
1900DEFAULT_TYPELOC_IMPL(DependentVector, Type)bool CursorVisitor::VisitDependentVectorTypeLoc(DependentVectorTypeLoc
 TL) { return VisitTypeLoc(TL); }
1901DEFAULT_TYPELOC_IMPL(DependentSizedExtVector, Type)bool CursorVisitor::VisitDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc
 TL) { return VisitTypeLoc(TL); }
1902DEFAULT_TYPELOC_IMPL(Vector, Type)bool CursorVisitor::VisitVectorTypeLoc(VectorTypeLoc TL) { return
 VisitTypeLoc(TL); }
1903DEFAULT_TYPELOC_IMPL(ExtVector, VectorType)bool CursorVisitor::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL
) { return VisitVectorTypeLoc(TL); }
1904DEFAULT_TYPELOC_IMPL(ConstantMatrix, MatrixType)bool CursorVisitor::VisitConstantMatrixTypeLoc(ConstantMatrixTypeLoc
 TL) { return VisitMatrixTypeLoc(TL); }
1905DEFAULT_TYPELOC_IMPL(DependentSizedMatrix, MatrixType)bool CursorVisitor::VisitDependentSizedMatrixTypeLoc(DependentSizedMatrixTypeLoc
 TL) { return VisitMatrixTypeLoc(TL); }
1906DEFAULT_TYPELOC_IMPL(FunctionProto, FunctionType)bool CursorVisitor::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc
 TL) { return VisitFunctionTypeLoc(TL); }
1907DEFAULT_TYPELOC_IMPL(FunctionNoProto, FunctionType)bool CursorVisitor::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc
 TL) { return VisitFunctionTypeLoc(TL); }
1908DEFAULT_TYPELOC_IMPL(Record, TagType)bool CursorVisitor::VisitRecordTypeLoc(RecordTypeLoc TL) { return
 VisitTagTypeLoc(TL); }
1909DEFAULT_TYPELOC_IMPL(Enum, TagType)bool CursorVisitor::VisitEnumTypeLoc(EnumTypeLoc TL) { return
 VisitTagTypeLoc(TL); }
1910DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParm, Type)bool CursorVisitor::VisitSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc
 TL) { return VisitTypeLoc(TL); }
1911DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParmPack, Type)bool CursorVisitor::VisitSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc
 TL) { return VisitTypeLoc(TL); }
1912DEFAULT_TYPELOC_IMPL(Auto, Type)bool CursorVisitor::VisitAutoTypeLoc(AutoTypeLoc TL) { return
 VisitTypeLoc(TL); }
1913DEFAULT_TYPELOC_IMPL(BitInt, Type)bool CursorVisitor::VisitBitIntTypeLoc(BitIntTypeLoc TL) { return
 VisitTypeLoc(TL); }
1914DEFAULT_TYPELOC_IMPL(DependentBitInt, Type)bool CursorVisitor::VisitDependentBitIntTypeLoc(DependentBitIntTypeLoc
 TL) { return VisitTypeLoc(TL); }

1916bool CursorVisitor::VisitCXXRecordDecl(CXXRecordDecl *D) {
// Visit the nested-name-specifier, if present.
if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
  if (VisitNestedNameSpecifierLoc(QualifierLoc))
    return true;

if (D->isCompleteDefinition()) {
  for (const auto &I : D->bases()) {
    if (Visit(cxcursor::MakeCursorCXXBaseSpecifier(&I, TU)))
      return true;
  }
}

return VisitTagDecl(D);
1930}

1932bool CursorVisitor::VisitAttributes(Decl *D) {
for (const auto *I : D->attrs())
  if ((TU->ParsingOptions & CXTranslationUnit_VisitImplicitAttributes ||
       !I->isImplicit()) &&
      Visit(MakeCXCursor(I, D, TU)))
    return true;

return false;
1940}

1942//===----------------------------------------------------------------------===//
1943// Data-recursive visitor methods.
1944//===----------------------------------------------------------------------===//

1946namespace {
1947#define DEF_JOB(NAME, DATA, KIND)                                              \
class NAME : public VisitorJob {                                             \
public:                                                                      \
  NAME(const DATA *d, CXCursor parent)                                       \
      : VisitorJob(parent, VisitorJob::KIND, d) {}                           \
  static bool classof(const VisitorJob *VJ) {                                \
    return VJ->getKind() == KIND;                                            \
  }                                                                          \
  const DATA *get() const { return static_cast<const DATA *>(data[0]); }     \
};

1958DEF_JOB(StmtVisit, Stmt, StmtVisitKind)
1959DEF_JOB(MemberExprParts, MemberExpr, MemberExprPartsKind)
1960DEF_JOB(DeclRefExprParts, DeclRefExpr, DeclRefExprPartsKind)
1961DEF_JOB(OverloadExprParts, OverloadExpr, OverloadExprPartsKind)
1962DEF_JOB(SizeOfPackExprParts, SizeOfPackExpr, SizeOfPackExprPartsKind)
1963DEF_JOB(LambdaExprParts, LambdaExpr, LambdaExprPartsKind)
1964DEF_JOB(ConceptSpecializationExprVisit, ConceptSpecializationExpr,
      ConceptSpecializationExprVisitKind)
1966DEF_JOB(RequiresExprVisit, RequiresExpr, RequiresExprVisitKind)
1967DEF_JOB(PostChildrenVisit, void, PostChildrenVisitKind)
1968#undef DEF_JOB

1970class ExplicitTemplateArgsVisit : public VisitorJob {
1971public:
ExplicitTemplateArgsVisit(const TemplateArgumentLoc *Begin,
                          const TemplateArgumentLoc *End, CXCursor parent)
    : VisitorJob(parent, VisitorJob::ExplicitTemplateArgsVisitKind, Begin,
                 End) {}
static bool classof(const VisitorJob *VJ) {
  return VJ->getKind() == ExplicitTemplateArgsVisitKind;
}
const TemplateArgumentLoc *begin() const {
  return static_cast<const TemplateArgumentLoc *>(data[0]);
}
const TemplateArgumentLoc *end() {
  return static_cast<const TemplateArgumentLoc *>(data[1]);
}
1985};
1986class DeclVisit : public VisitorJob {
1987public:
DeclVisit(const Decl *D, CXCursor parent, bool isFirst)
    : VisitorJob(parent, VisitorJob::DeclVisitKind, D,
                 isFirst ? (void *)1 : (void *)nullptr) {}
static bool classof(const VisitorJob *VJ) {
  return VJ->getKind() == DeclVisitKind;
}
const Decl *get() const { return static_cast<const Decl *>(data[0]); }
bool isFirst() const { return data[1] != nullptr; }
1996};
1997class TypeLocVisit : public VisitorJob {
1998public:
TypeLocVisit(TypeLoc tl, CXCursor parent)
    : VisitorJob(parent, VisitorJob::TypeLocVisitKind,
                 tl.getType().getAsOpaquePtr(), tl.getOpaqueData()) {}

static bool classof(const VisitorJob *VJ) {
  return VJ->getKind() == TypeLocVisitKind;
}

TypeLoc get() const {
  QualType T = QualType::getFromOpaquePtr(data[0]);
  return TypeLoc(T, const_cast<void *>(data[1]));
}
2011};

2013class LabelRefVisit : public VisitorJob {
2014public:
LabelRefVisit(LabelDecl *LD, SourceLocation labelLoc, CXCursor parent)
    : VisitorJob(parent, VisitorJob::LabelRefVisitKind, LD,
                 labelLoc.getPtrEncoding()) {}

static bool classof(const VisitorJob *VJ) {
  return VJ->getKind() == VisitorJob::LabelRefVisitKind;
}
const LabelDecl *get() const {
  return static_cast<const LabelDecl *>(data[0]);
}
SourceLocation getLoc() const {
  return SourceLocation::getFromPtrEncoding(data[1]);
}
2028};

2030class NestedNameSpecifierLocVisit : public VisitorJob {
2031public:
NestedNameSpecifierLocVisit(NestedNameSpecifierLoc Qualifier, CXCursor parent)
    : VisitorJob(parent, VisitorJob::NestedNameSpecifierLocVisitKind,
                 Qualifier.getNestedNameSpecifier(),
                 Qualifier.getOpaqueData()) {}

static bool classof(const VisitorJob *VJ) {
  return VJ->getKind() == VisitorJob::NestedNameSpecifierLocVisitKind;
}

NestedNameSpecifierLoc get() const {
  return NestedNameSpecifierLoc(
      const_cast<NestedNameSpecifier *>(
          static_cast<const NestedNameSpecifier *>(data[0])),
      const_cast<void *>(data[1]));
}
2047};

2049class DeclarationNameInfoVisit : public VisitorJob {
2050public:
DeclarationNameInfoVisit(const Stmt *S, CXCursor parent)
    : VisitorJob(parent, VisitorJob::DeclarationNameInfoVisitKind, S) {}
static bool classof(const VisitorJob *VJ) {
  return VJ->getKind() == VisitorJob::DeclarationNameInfoVisitKind;
}
DeclarationNameInfo get() const {
  const Stmt *S = static_cast<const Stmt *>(data[0]);
  switch (S->getStmtClass()) {
  default:
    llvm_unreachable("Unhandled Stmt")::llvm::llvm_unreachable_internal("Unhandled Stmt", "clang/tools/libclang/CIndex.cpp"
, 2060);
  case clang::Stmt::MSDependentExistsStmtClass:
    return cast<MSDependentExistsStmt>(S)->getNameInfo();
  case Stmt::CXXDependentScopeMemberExprClass:
    return cast<CXXDependentScopeMemberExpr>(S)->getMemberNameInfo();
  case Stmt::DependentScopeDeclRefExprClass:
    return cast<DependentScopeDeclRefExpr>(S)->getNameInfo();
  case Stmt::OMPCriticalDirectiveClass:
    return cast<OMPCriticalDirective>(S)->getDirectiveName();
  }
}
2071};
2072class MemberRefVisit : public VisitorJob {
2073public:
MemberRefVisit(const FieldDecl *D, SourceLocation L, CXCursor parent)
    : VisitorJob(parent, VisitorJob::MemberRefVisitKind, D,
                 L.getPtrEncoding()) {}
static bool classof(const VisitorJob *VJ) {
  return VJ->getKind() == VisitorJob::MemberRefVisitKind;
}
const FieldDecl *get() const {
  return static_cast<const FieldDecl *>(data[0]);
}
SourceLocation getLoc() const {
  return SourceLocation::getFromRawEncoding(
      (SourceLocation::UIntTy)(uintptr_t)data[1]);
}
2087};
2088class EnqueueVisitor : public ConstStmtVisitor<EnqueueVisitor, void> {
friend class OMPClauseEnqueue;
VisitorWorkList &WL;
CXCursor Parent;

2093public:
EnqueueVisitor(VisitorWorkList &wl, CXCursor parent)
    : WL(wl), Parent(parent) {}

void VisitAddrLabelExpr(const AddrLabelExpr *E);
void VisitBlockExpr(const BlockExpr *B);
void VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
void VisitCompoundStmt(const CompoundStmt *S);
void VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) { /* Do nothing. */
}
void VisitMSDependentExistsStmt(const MSDependentExistsStmt *S);
void VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E);
void VisitCXXNewExpr(const CXXNewExpr *E);
void VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E);
void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *E);
void VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E);
void VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *E);
void VisitCXXTypeidExpr(const CXXTypeidExpr *E);
void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *E);
void VisitCXXUuidofExpr(const CXXUuidofExpr *E);
void VisitCXXCatchStmt(const CXXCatchStmt *S);
void VisitCXXForRangeStmt(const CXXForRangeStmt *S);
void VisitDeclRefExpr(const DeclRefExpr *D);
void VisitDeclStmt(const DeclStmt *S);
void VisitDependentScopeDeclRefExpr(const DependentScopeDeclRefExpr *E);
void VisitDesignatedInitExpr(const DesignatedInitExpr *E);
void VisitExplicitCastExpr(const ExplicitCastExpr *E);
void VisitForStmt(const ForStmt *FS);
void VisitGotoStmt(const GotoStmt *GS);
void VisitIfStmt(const IfStmt *If);
void VisitInitListExpr(const InitListExpr *IE);
void VisitMemberExpr(const MemberExpr *M);
void VisitOffsetOfExpr(const OffsetOfExpr *E);
void VisitObjCEncodeExpr(const ObjCEncodeExpr *E);
void VisitObjCMessageExpr(const ObjCMessageExpr *M);
void VisitOverloadExpr(const OverloadExpr *E);
void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
void VisitStmt(const Stmt *S);
void VisitSwitchStmt(const SwitchStmt *S);
void VisitWhileStmt(const WhileStmt *W);
void VisitTypeTraitExpr(const TypeTraitExpr *E);
void VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E);
void VisitExpressionTraitExpr(const ExpressionTraitExpr *E);
void VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U);
void VisitVAArgExpr(const VAArgExpr *E);
void VisitSizeOfPackExpr(const SizeOfPackExpr *E);
void VisitPseudoObjectExpr(const PseudoObjectExpr *E);
void VisitOpaqueValueExpr(const OpaqueValueExpr *E);
void VisitLambdaExpr(const LambdaExpr *E);
void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E);
void VisitRequiresExpr(const RequiresExpr *E);
void VisitCXXParenListInitExpr(const CXXParenListInitExpr *E);
void VisitOMPExecutableDirective(const OMPExecutableDirective *D);
void VisitOMPLoopBasedDirective(const OMPLoopBasedDirective *D);
void VisitOMPLoopDirective(const OMPLoopDirective *D);
void VisitOMPParallelDirective(const OMPParallelDirective *D);
void VisitOMPSimdDirective(const OMPSimdDirective *D);
void
VisitOMPLoopTransformationDirective(const OMPLoopTransformationDirective *D);
void VisitOMPTileDirective(const OMPTileDirective *D);
void VisitOMPUnrollDirective(const OMPUnrollDirective *D);
void VisitOMPForDirective(const OMPForDirective *D);
void VisitOMPForSimdDirective(const OMPForSimdDirective *D);
void VisitOMPSectionsDirective(const OMPSectionsDirective *D);
void VisitOMPSectionDirective(const OMPSectionDirective *D);
void VisitOMPSingleDirective(const OMPSingleDirective *D);
void VisitOMPMasterDirective(const OMPMasterDirective *D);
void VisitOMPCriticalDirective(const OMPCriticalDirective *D);
void VisitOMPParallelForDirective(const OMPParallelForDirective *D);
void VisitOMPParallelForSimdDirective(const OMPParallelForSimdDirective *D);
void VisitOMPParallelMasterDirective(const OMPParallelMasterDirective *D);
void VisitOMPParallelMaskedDirective(const OMPParallelMaskedDirective *D);
void VisitOMPParallelSectionsDirective(const OMPParallelSectionsDirective *D);
void VisitOMPTaskDirective(const OMPTaskDirective *D);
void VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *D);
void VisitOMPBarrierDirective(const OMPBarrierDirective *D);
void VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D);
void VisitOMPErrorDirective(const OMPErrorDirective *D);
void VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *D);
void
VisitOMPCancellationPointDirective(const OMPCancellationPointDirective *D);
void VisitOMPCancelDirective(const OMPCancelDirective *D);
void VisitOMPFlushDirective(const OMPFlushDirective *D);
void VisitOMPDepobjDirective(const OMPDepobjDirective *D);
void VisitOMPScanDirective(const OMPScanDirective *D);
void VisitOMPOrderedDirective(const OMPOrderedDirective *D);
void VisitOMPAtomicDirective(const OMPAtomicDirective *D);
void VisitOMPTargetDirective(const OMPTargetDirective *D);
void VisitOMPTargetDataDirective(const OMPTargetDataDirective *D);
void VisitOMPTargetEnterDataDirective(const OMPTargetEnterDataDirective *D);
void VisitOMPTargetExitDataDirective(const OMPTargetExitDataDirective *D);
void VisitOMPTargetParallelDirective(const OMPTargetParallelDirective *D);
void
VisitOMPTargetParallelForDirective(const OMPTargetParallelForDirective *D);
void VisitOMPTeamsDirective(const OMPTeamsDirective *D);
void VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D);
void VisitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective *D);
void VisitOMPMasterTaskLoopDirective(const OMPMasterTaskLoopDirective *D);
void VisitOMPMaskedTaskLoopDirective(const OMPMaskedTaskLoopDirective *D);
void
VisitOMPMasterTaskLoopSimdDirective(const OMPMasterTaskLoopSimdDirective *D);
void VisitOMPMaskedTaskLoopSimdDirective(
    const OMPMaskedTaskLoopSimdDirective *D);
void VisitOMPParallelMasterTaskLoopDirective(
    const OMPParallelMasterTaskLoopDirective *D);
void VisitOMPParallelMaskedTaskLoopDirective(
    const OMPParallelMaskedTaskLoopDirective *D);
void VisitOMPParallelMasterTaskLoopSimdDirective(
    const OMPParallelMasterTaskLoopSimdDirective *D);
void VisitOMPParallelMaskedTaskLoopSimdDirective(
    const OMPParallelMaskedTaskLoopSimdDirective *D);
void VisitOMPDistributeDirective(const OMPDistributeDirective *D);
void VisitOMPDistributeParallelForDirective(
    const OMPDistributeParallelForDirective *D);
void VisitOMPDistributeParallelForSimdDirective(
    const OMPDistributeParallelForSimdDirective *D);
void VisitOMPDistributeSimdDirective(const OMPDistributeSimdDirective *D);
void VisitOMPTargetParallelForSimdDirective(
    const OMPTargetParallelForSimdDirective *D);
void VisitOMPTargetSimdDirective(const OMPTargetSimdDirective *D);
void VisitOMPTeamsDistributeDirective(const OMPTeamsDistributeDirective *D);
void VisitOMPTeamsDistributeSimdDirective(
    const OMPTeamsDistributeSimdDirective *D);
void VisitOMPTeamsDistributeParallelForSimdDirective(
    const OMPTeamsDistributeParallelForSimdDirective *D);
void VisitOMPTeamsDistributeParallelForDirective(
    const OMPTeamsDistributeParallelForDirective *D);
void VisitOMPTargetTeamsDirective(const OMPTargetTeamsDirective *D);
void VisitOMPTargetTeamsDistributeDirective(
    const OMPTargetTeamsDistributeDirective *D);
void VisitOMPTargetTeamsDistributeParallelForDirective(
    const OMPTargetTeamsDistributeParallelForDirective *D);
void VisitOMPTargetTeamsDistributeParallelForSimdDirective(
    const OMPTargetTeamsDistributeParallelForSimdDirective *D);
void VisitOMPTargetTeamsDistributeSimdDirective(
    const OMPTargetTeamsDistributeSimdDirective *D);

2230private:
void AddDeclarationNameInfo(const Stmt *S);
void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier);
void AddExplicitTemplateArgs(const TemplateArgumentLoc *A,
                             unsigned NumTemplateArgs);
void AddMemberRef(const FieldDecl *D, SourceLocation L);
void AddStmt(const Stmt *S);
void AddDecl(const Decl *D, bool isFirst = true);
void AddTypeLoc(TypeSourceInfo *TI);
void EnqueueChildren(const Stmt *S);
void EnqueueChildren(const OMPClause *S);
2241};
2242} // namespace

2244void EnqueueVisitor::AddDeclarationNameInfo(const Stmt *S) {
// 'S' should always be non-null, since it comes from the
// statement we are visiting.
WL.push_back(DeclarationNameInfoVisit(S, Parent));
2248}

2250void EnqueueVisitor::AddNestedNameSpecifierLoc(
  NestedNameSpecifierLoc Qualifier) {
if (Qualifier)
  WL.push_back(NestedNameSpecifierLocVisit(Qualifier, Parent));
2254}

2256void EnqueueVisitor::AddStmt(const Stmt *S) {
if (S)
  WL.push_back(StmtVisit(S, Parent));
2259}
2260void EnqueueVisitor::AddDecl(const Decl *D, bool isFirst) {
if (D)
  WL.push_back(DeclVisit(D, Parent, isFirst));
2263}
2264void EnqueueVisitor::AddExplicitTemplateArgs(const TemplateArgumentLoc *A,
                                           unsigned NumTemplateArgs) {
WL.push_back(ExplicitTemplateArgsVisit(A, A + NumTemplateArgs, Parent));
2267}
2268void EnqueueVisitor::AddMemberRef(const FieldDecl *D, SourceLocation L) {
if (D)
  WL.push_back(MemberRefVisit(D, L, Parent));
2271}
2272void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) {
if (TI)
  WL.push_back(TypeLocVisit(TI->getTypeLoc(), Parent));
2275}
2276void EnqueueVisitor::EnqueueChildren(const Stmt *S) {
unsigned size = WL.size();
for (const Stmt *SubStmt : S->children()) {
  AddStmt(SubStmt);
}
if (size == WL.size())
  return;
// Now reverse the entries we just added.  This will match the DFS
// ordering performed by the worklist.
VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
std::reverse(I, E);
2287}
2288namespace {
2289class OMPClauseEnqueue : public ConstOMPClauseVisitor<OMPClauseEnqueue> {
EnqueueVisitor *Visitor;
/// Process clauses with list of variables.
template <typename T> void VisitOMPClauseList(T *Node);

2294public:
OMPClauseEnqueue(EnqueueVisitor *Visitor) : Visitor(Visitor) {}
2296#define GEN_CLANG_CLAUSE_CLASS
2297#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C);
2298#include "llvm/Frontend/OpenMP/OMP.inc"
void VisitOMPClauseWithPreInit(const OMPClauseWithPreInit *C);
void VisitOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C);
2301};

2303void OMPClauseEnqueue::VisitOMPClauseWithPreInit(
  const OMPClauseWithPreInit *C) {
Visitor->AddStmt(C->getPreInitStmt());
2306}

2308void OMPClauseEnqueue::VisitOMPClauseWithPostUpdate(
  const OMPClauseWithPostUpdate *C) {
VisitOMPClauseWithPreInit(C);
Visitor->AddStmt(C->getPostUpdateExpr());
2312}

2314void OMPClauseEnqueue::VisitOMPIfClause(const OMPIfClause *C) {
VisitOMPClauseWithPreInit(C);
Visitor->AddStmt(C->getCondition());
2317}

2319void OMPClauseEnqueue::VisitOMPFinalClause(const OMPFinalClause *C) {
Visitor->AddStmt(C->getCondition());
2321}

2323void OMPClauseEnqueue::VisitOMPNumThreadsClause(const OMPNumThreadsClause *C) {
VisitOMPClauseWithPreInit(C);
Visitor->AddStmt(C->getNumThreads());
2326}

2328void OMPClauseEnqueue::VisitOMPSafelenClause(const OMPSafelenClause *C) {
Visitor->AddStmt(C->getSafelen());
2330}

2332void OMPClauseEnqueue::VisitOMPSimdlenClause(const OMPSimdlenClause *C) {
Visitor->AddStmt(C->getSimdlen());
2334}

2336void OMPClauseEnqueue::VisitOMPSizesClause(const OMPSizesClause *C) {
for (auto E : C->getSizesRefs())
  Visitor->AddStmt(E);
2339}

2341void OMPClauseEnqueue::VisitOMPFullClause(const OMPFullClause *C) {}

2343void OMPClauseEnqueue::VisitOMPPartialClause(const OMPPartialClause *C) {
Visitor->AddStmt(C->getFactor());
2345}

2347void OMPClauseEnqueue::VisitOMPAllocatorClause(const OMPAllocatorClause *C) {
Visitor->AddStmt(C->getAllocator());
2349}

2351void OMPClauseEnqueue::VisitOMPCollapseClause(const OMPCollapseClause *C) {
Visitor->AddStmt(C->getNumForLoops());
2353}

2355void OMPClauseEnqueue::VisitOMPDefaultClause(const OMPDefaultClause *C) {}

2357void OMPClauseEnqueue::VisitOMPProcBindClause(const OMPProcBindClause *C) {}

2359void OMPClauseEnqueue::VisitOMPScheduleClause(const OMPScheduleClause *C) {
VisitOMPClauseWithPreInit(C);
Visitor->AddStmt(C->getChunkSize());
2362}

2364void OMPClauseEnqueue::VisitOMPOrderedClause(const OMPOrderedClause *C) {
Visitor->AddStmt(C->getNumForLoops());
2366}

2368void OMPClauseEnqueue::VisitOMPDetachClause(const OMPDetachClause *C) {
Visitor->AddStmt(C->getEventHandler());
2370}

2372void OMPClauseEnqueue::VisitOMPNowaitClause(const OMPNowaitClause *) {}

2374void OMPClauseEnqueue::VisitOMPUntiedClause(const OMPUntiedClause *) {}

2376void OMPClauseEnqueue::VisitOMPMergeableClause(const OMPMergeableClause *) {}

2378void OMPClauseEnqueue::VisitOMPReadClause(const OMPReadClause *) {}

2380void OMPClauseEnqueue::VisitOMPWriteClause(const OMPWriteClause *) {}

2382void OMPClauseEnqueue::VisitOMPUpdateClause(const OMPUpdateClause *) {}

2384void OMPClauseEnqueue::VisitOMPCaptureClause(const OMPCaptureClause *) {}

2386void OMPClauseEnqueue::VisitOMPCompareClause(const OMPCompareClause *) {}

2388void OMPClauseEnqueue::VisitOMPSeqCstClause(const OMPSeqCstClause *) {}

2390void OMPClauseEnqueue::VisitOMPAcqRelClause(const OMPAcqRelClause *) {}

2392void OMPClauseEnqueue::VisitOMPAcquireClause(const OMPAcquireClause *) {}

2394void OMPClauseEnqueue::VisitOMPReleaseClause(const OMPReleaseClause *) {}

2396void OMPClauseEnqueue::VisitOMPRelaxedClause(const OMPRelaxedClause *) {}

2398void OMPClauseEnqueue::VisitOMPThreadsClause(const OMPThreadsClause *) {}

2400void OMPClauseEnqueue::VisitOMPSIMDClause(const OMPSIMDClause *) {}

2402void OMPClauseEnqueue::VisitOMPNogroupClause(const OMPNogroupClause *) {}

2404void OMPClauseEnqueue::VisitOMPInitClause(const OMPInitClause *C) {
VisitOMPClauseList(C);
2406}

2408void OMPClauseEnqueue::VisitOMPUseClause(const OMPUseClause *C) {
Visitor->AddStmt(C->getInteropVar());
2410}

2412void OMPClauseEnqueue::VisitOMPDestroyClause(const OMPDestroyClause *C) {
if (C->getInteropVar())
  Visitor->AddStmt(C->getInteropVar());
2415}

2417void OMPClauseEnqueue::VisitOMPNovariantsClause(const OMPNovariantsClause *C) {
Visitor->AddStmt(C->getCondition());
2419}

2421void OMPClauseEnqueue::VisitOMPNocontextClause(const OMPNocontextClause *C) {
Visitor->AddStmt(C->getCondition());
2423}

2425void OMPClauseEnqueue::VisitOMPFilterClause(const OMPFilterClause *C) {
VisitOMPClauseWithPreInit(C);
Visitor->AddStmt(C->getThreadID());
2428}

2430void OMPClauseEnqueue::VisitOMPAlignClause(const OMPAlignClause *C) {
Visitor->AddStmt(C->getAlignment());
2432}

2434void OMPClauseEnqueue::VisitOMPUnifiedAddressClause(
  const OMPUnifiedAddressClause *) {}

2437void OMPClauseEnqueue::VisitOMPUnifiedSharedMemoryClause(
  const OMPUnifiedSharedMemoryClause *) {}

2440void OMPClauseEnqueue::VisitOMPReverseOffloadClause(
  const OMPReverseOffloadClause *) {}

2443void OMPClauseEnqueue::VisitOMPDynamicAllocatorsClause(
  const OMPDynamicAllocatorsClause *) {}

2446void OMPClauseEnqueue::VisitOMPAtomicDefaultMemOrderClause(
  const OMPAtomicDefaultMemOrderClause *) {}

2449void OMPClauseEnqueue::VisitOMPAtClause(const OMPAtClause *) {}

2451void OMPClauseEnqueue::VisitOMPSeverityClause(const OMPSeverityClause *) {}

2453void OMPClauseEnqueue::VisitOMPMessageClause(const OMPMessageClause *) {}

2455void OMPClauseEnqueue::VisitOMPDeviceClause(const OMPDeviceClause *C) {
Visitor->AddStmt(C->getDevice());
2457}

2459void OMPClauseEnqueue::VisitOMPNumTeamsClause(const OMPNumTeamsClause *C) {
VisitOMPClauseWithPreInit(C);
Visitor->AddStmt(C->getNumTeams());
2462}

2464void OMPClauseEnqueue::VisitOMPThreadLimitClause(
  const OMPThreadLimitClause *C) {
VisitOMPClauseWithPreInit(C);
Visitor->AddStmt(C->getThreadLimit());
2468}

2470void OMPClauseEnqueue::VisitOMPPriorityClause(const OMPPriorityClause *C) {
Visitor->AddStmt(C->getPriority());
2472}

2474void OMPClauseEnqueue::VisitOMPGrainsizeClause(const OMPGrainsizeClause *C) {
Visitor->AddStmt(C->getGrainsize());
2476}

2478void OMPClauseEnqueue::VisitOMPNumTasksClause(const OMPNumTasksClause *C) {
Visitor->AddStmt(C->getNumTasks());
2480}

2482void OMPClauseEnqueue::VisitOMPHintClause(const OMPHintClause *C) {
Visitor->AddStmt(C->getHint());
2484}

2486template <typename T> void OMPClauseEnqueue::VisitOMPClauseList(T *Node) {
for (const auto *I : Node->varlists()) {
  Visitor->AddStmt(I);
}
2490}

2492void OMPClauseEnqueue::VisitOMPInclusiveClause(const OMPInclusiveClause *C) {
VisitOMPClauseList(C);
2494}
2495void OMPClauseEnqueue::VisitOMPExclusiveClause(const OMPExclusiveClause *C) {
VisitOMPClauseList(C);
2497}
2498void OMPClauseEnqueue::VisitOMPAllocateClause(const OMPAllocateClause *C) {
VisitOMPClauseList(C);
Visitor->AddStmt(C->getAllocator());
2501}
2502void OMPClauseEnqueue::VisitOMPPrivateClause(const OMPPrivateClause *C) {
VisitOMPClauseList(C);
for (const auto *E : C->private_copies()) {
  Visitor->AddStmt(E);
}
2507}
2508void OMPClauseEnqueue::VisitOMPFirstprivateClause(
  const OMPFirstprivateClause *C) {
VisitOMPClauseList(C);
VisitOMPClauseWithPreInit(C);
for (const auto *E : C->private_copies()) {
  Visitor->AddStmt(E);
}
for (const auto *E : C->inits()) {
  Visitor->AddStmt(E);
}
2518}
2519void OMPClauseEnqueue::VisitOMPLastprivateClause(
  const OMPLastprivateClause *C) {
VisitOMPClauseList(C);
VisitOMPClauseWithPostUpdate(C);
for (auto *E : C->private_copies()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->source_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->destination_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->assignment_ops()) {
  Visitor->AddStmt(E);
}
2535}
2536void OMPClauseEnqueue::VisitOMPSharedClause(const OMPSharedClause *C) {
VisitOMPClauseList(C);
2538}
2539void OMPClauseEnqueue::VisitOMPReductionClause(const OMPReductionClause *C) {
VisitOMPClauseList(C);
VisitOMPClauseWithPostUpdate(C);
for (auto *E : C->privates()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->lhs_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->rhs_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->reduction_ops()) {
  Visitor->AddStmt(E);
}
if (C->getModifier() == clang::OMPC_REDUCTION_inscan) {
  for (auto *E : C->copy_ops()) {
    Visitor->AddStmt(E);
  }
  for (auto *E : C->copy_array_temps()) {
    Visitor->AddStmt(E);
  }
  for (auto *E : C->copy_array_elems()) {
    Visitor->AddStmt(E);
  }
}
2565}
2566void OMPClauseEnqueue::VisitOMPTaskReductionClause(
  const OMPTaskReductionClause *C) {
VisitOMPClauseList(C);
VisitOMPClauseWithPostUpdate(C);
for (auto *E : C->privates()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->lhs_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->rhs_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->reduction_ops()) {
  Visitor->AddStmt(E);
}
2582}
2583void OMPClauseEnqueue::VisitOMPInReductionClause(
  const OMPInReductionClause *C) {
VisitOMPClauseList(C);
VisitOMPClauseWithPostUpdate(C);
for (auto *E : C->privates()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->lhs_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->rhs_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->reduction_ops()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->taskgroup_descriptors())
  Visitor->AddStmt(E);
2601}
2602void OMPClauseEnqueue::VisitOMPLinearClause(const OMPLinearClause *C) {
VisitOMPClauseList(C);
VisitOMPClauseWithPostUpdate(C);
for (const auto *E : C->privates()) {
  Visitor->AddStmt(E);
}
for (const auto *E : C->inits()) {
  Visitor->AddStmt(E);
}
for (const auto *E : C->updates()) {
  Visitor->AddStmt(E);
}
for (const auto *E : C->finals()) {
  Visitor->AddStmt(E);
}
Visitor->AddStmt(C->getStep());
Visitor->AddStmt(C->getCalcStep());
2619}
2620void OMPClauseEnqueue::VisitOMPAlignedClause(const OMPAlignedClause *C) {
VisitOMPClauseList(C);
Visitor->AddStmt(C->getAlignment());
2623}
2624void OMPClauseEnqueue::VisitOMPCopyinClause(const OMPCopyinClause *C) {
VisitOMPClauseList(C);
for (auto *E : C->source_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->destination_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->assignment_ops()) {
  Visitor->AddStmt(E);
}
2635}
2636void OMPClauseEnqueue::VisitOMPCopyprivateClause(
  const OMPCopyprivateClause *C) {
VisitOMPClauseList(C);
for (auto *E : C->source_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->destination_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->assignment_ops()) {
  Visitor->AddStmt(E);
}
2648}
2649void OMPClauseEnqueue::VisitOMPFlushClause(const OMPFlushClause *C) {
VisitOMPClauseList(C);
2651}
2652void OMPClauseEnqueue::VisitOMPDepobjClause(const OMPDepobjClause *C) {
Visitor->AddStmt(C->getDepobj());
2654}
2655void OMPClauseEnqueue::VisitOMPDependClause(const OMPDependClause *C) {
VisitOMPClauseList(C);
2657}
2658void OMPClauseEnqueue::VisitOMPMapClause(const OMPMapClause *C) {
VisitOMPClauseList(C);
2660}
2661void OMPClauseEnqueue::VisitOMPDistScheduleClause(
  const OMPDistScheduleClause *C) {
VisitOMPClauseWithPreInit(C);
Visitor->AddStmt(C->getChunkSize());
2665}
2666void OMPClauseEnqueue::VisitOMPDefaultmapClause(
  const OMPDefaultmapClause * /*C*/) {}
2668void OMPClauseEnqueue::VisitOMPToClause(const OMPToClause *C) {
VisitOMPClauseList(C);
2670}
2671void OMPClauseEnqueue::VisitOMPFromClause(const OMPFromClause *C) {
VisitOMPClauseList(C);
2673}
2674void OMPClauseEnqueue::VisitOMPUseDevicePtrClause(
  const OMPUseDevicePtrClause *C) {
VisitOMPClauseList(C);
2677}
2678void OMPClauseEnqueue::VisitOMPUseDeviceAddrClause(
  const OMPUseDeviceAddrClause *C) {
VisitOMPClauseList(C);
2681}
2682void OMPClauseEnqueue::VisitOMPIsDevicePtrClause(
  const OMPIsDevicePtrClause *C) {
VisitOMPClauseList(C);
2685}
2686void OMPClauseEnqueue::VisitOMPHasDeviceAddrClause(
  const OMPHasDeviceAddrClause *C) {
VisitOMPClauseList(C);
2689}
2690void OMPClauseEnqueue::VisitOMPNontemporalClause(
  const OMPNontemporalClause *C) {
VisitOMPClauseList(C);
for (const auto *E : C->private_refs())
  Visitor->AddStmt(E);
2695}
2696void OMPClauseEnqueue::VisitOMPOrderClause(const OMPOrderClause *C) {}
2697void OMPClauseEnqueue::VisitOMPUsesAllocatorsClause(
  const OMPUsesAllocatorsClause *C) {
for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) {
  const OMPUsesAllocatorsClause::Data &D = C->getAllocatorData(I);
  Visitor->AddStmt(D.Allocator);
  Visitor->AddStmt(D.AllocatorTraits);
}
2704}
2705void OMPClauseEnqueue::VisitOMPAffinityClause(const OMPAffinityClause *C) {
Visitor->AddStmt(C->getModifier());
for (const Expr *E : C->varlists())
  Visitor->AddStmt(E);
2709}
2710void OMPClauseEnqueue::VisitOMPBindClause(const OMPBindClause *C) {}
2711void OMPClauseEnqueue::VisitOMPXDynCGroupMemClause(
  const OMPXDynCGroupMemClause *C) {
VisitOMPClauseWithPreInit(C);
Visitor->AddStmt(C->getSize());
2715}

2717} // namespace

2719void EnqueueVisitor::EnqueueChildren(const OMPClause *S) {
unsigned size = WL.size();
OMPClauseEnqueue Visitor(this);
Visitor.Visit(S);
if (size == WL.size())
  return;
// Now reverse the entries we just added.  This will match the DFS
// ordering performed by the worklist.
VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
std::reverse(I, E);
2729}
2730void EnqueueVisitor::VisitAddrLabelExpr(const AddrLabelExpr *E) {
WL.push_back(LabelRefVisit(E->getLabel(), E->getLabelLoc(), Parent));
2732}
2733void EnqueueVisitor::VisitBlockExpr(const BlockExpr *B) {
AddDecl(B->getBlockDecl());
2735}
2736void EnqueueVisitor::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
EnqueueChildren(E);
AddTypeLoc(E->getTypeSourceInfo());
2739}
2740void EnqueueVisitor::VisitCompoundStmt(const CompoundStmt *S) {
for (auto &I : llvm::reverse(S->body()))
  AddStmt(I);
2743}
2744void EnqueueVisitor::VisitMSDependentExistsStmt(
  const MSDependentExistsStmt *S) {
AddStmt(S->getSubStmt());
AddDeclarationNameInfo(S);
if (NestedNameSpecifierLoc QualifierLoc = S->getQualifierLoc())
  AddNestedNameSpecifierLoc(QualifierLoc);
2750}

2752void EnqueueVisitor::VisitCXXDependentScopeMemberExpr(
  const CXXDependentScopeMemberExpr *E) {
if (E->hasExplicitTemplateArgs())
  AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs());
AddDeclarationNameInfo(E);
if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
  AddNestedNameSpecifierLoc(QualifierLoc);
if (!E->isImplicitAccess())
  AddStmt(E->getBase());
2761}
2762void EnqueueVisitor::VisitCXXNewExpr(const CXXNewExpr *E) {
// Enqueue the initializer , if any.
AddStmt(E->getInitializer());
// Enqueue the array size, if any.
AddStmt(E->getArraySize().value_or(nullptr));
// Enqueue the allocated type.
AddTypeLoc(E->getAllocatedTypeSourceInfo());
// Enqueue the placement arguments.
for (unsigned I = E->getNumPlacementArgs(); I > 0; --I)
  AddStmt(E->getPlacementArg(I - 1));
2772}
2773void EnqueueVisitor::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *CE) {
for (unsigned I = CE->getNumArgs(); I > 1 /* Yes, this is 1 */; --I)
  AddStmt(CE->getArg(I - 1));
AddStmt(CE->getCallee());
AddStmt(CE->getArg(0));
2778}
2779void EnqueueVisitor::VisitCXXPseudoDestructorExpr(
  const CXXPseudoDestructorExpr *E) {
// Visit the name of the type being destroyed.
AddTypeLoc(E->getDestroyedTypeInfo());
// Visit the scope type that looks disturbingly like the nested-name-specifier
// but isn't.
AddTypeLoc(E->getScopeTypeInfo());
// Visit the nested-name-specifier.
if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
  AddNestedNameSpecifierLoc(QualifierLoc);
// Visit base expression.
AddStmt(E->getBase());
2791}
2792void EnqueueVisitor::VisitCXXScalarValueInitExpr(
  const CXXScalarValueInitExpr *E) {
AddTypeLoc(E->getTypeSourceInfo());
2795}
2796void EnqueueVisitor::VisitCXXTemporaryObjectExpr(
  const CXXTemporaryObjectExpr *E) {
EnqueueChildren(E);
AddTypeLoc(E->getTypeSourceInfo());
2800}
2801void EnqueueVisitor::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
EnqueueChildren(E);
if (E->isTypeOperand())
  AddTypeLoc(E->getTypeOperandSourceInfo());
2805}

2807void EnqueueVisitor::VisitCXXUnresolvedConstructExpr(
  const CXXUnresolvedConstructExpr *E) {
EnqueueChildren(E);
AddTypeLoc(E->getTypeSourceInfo());
2811}
2812void EnqueueVisitor::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
EnqueueChildren(E);
if (E->isTypeOperand())
  AddTypeLoc(E->getTypeOperandSourceInfo());
2816}

2818void EnqueueVisitor::VisitCXXCatchStmt(const CXXCatchStmt *S) {
EnqueueChildren(S);
AddDecl(S->getExceptionDecl());
2821}

2823void EnqueueVisitor::VisitCXXForRangeStmt(const CXXForRangeStmt *S) {
AddStmt(S->getBody());
AddStmt(S->getRangeInit());
AddDecl(S->getLoopVariable());
2827}

2829void EnqueueVisitor::VisitDeclRefExpr(const DeclRefExpr *DR) {
if (DR->hasExplicitTemplateArgs())
  AddExplicitTemplateArgs(DR->getTemplateArgs(), DR->getNumTemplateArgs());
WL.push_back(DeclRefExprParts(DR, Parent));
2833}
2834void EnqueueVisitor::VisitDependentScopeDeclRefExpr(
  const DependentScopeDeclRefExpr *E) {
if (E->hasExplicitTemplateArgs())
  AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs());
AddDeclarationNameInfo(E);
AddNestedNameSpecifierLoc(E->getQualifierLoc());
2840}
2841void EnqueueVisitor::VisitDeclStmt(const DeclStmt *S) {
unsigned size = WL.size();
bool isFirst = true;
for (const auto *D : S->decls()) {
  AddDecl(D, isFirst);
  isFirst = false;
}
if (size == WL.size())
  return;
// Now reverse the entries we just added.  This will match the DFS
// ordering performed by the worklist.
VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
std::reverse(I, E);
2854}
2855void EnqueueVisitor::VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
AddStmt(E->getInit());
for (const DesignatedInitExpr::Designator &D :
     llvm::reverse(E->designators())) {
  if (D.isFieldDesignator()) {
    if (const FieldDecl *Field = D.getFieldDecl())
      AddMemberRef(Field, D.getFieldLoc());
    continue;
  }
  if (D.isArrayDesignator()) {
    AddStmt(E->getArrayIndex(D));
    continue;
  }
  assert(D.isArrayRangeDesignator() && "Unknown designator kind")(static_cast <bool> (D.isArrayRangeDesignator() &&
 "Unknown designator kind") ? void (0) : __assert_fail ("D.isArrayRangeDesignator() && \"Unknown designator kind\""
, "clang/tools/libclang/CIndex.cpp", 2868, __extension__ __PRETTY_FUNCTION__
));
  AddStmt(E->getArrayRangeEnd(D));
  AddStmt(E->getArrayRangeStart(D));
}
2872}
2873void EnqueueVisitor::VisitExplicitCastExpr(const ExplicitCastExpr *E) {
EnqueueChildren(E);
AddTypeLoc(E->getTypeInfoAsWritten());
2876}
2877void EnqueueVisitor::VisitForStmt(const ForStmt *FS) {
AddStmt(FS->getBody());
AddStmt(FS->getInc());
AddStmt(FS->getCond());
AddDecl(FS->getConditionVariable());
AddStmt(FS->getInit());
2883}
2884void EnqueueVisitor::VisitGotoStmt(const GotoStmt *GS) {
WL.push_back(LabelRefVisit(GS->getLabel(), GS->getLabelLoc(), Parent));
2886}
2887void EnqueueVisitor::VisitIfStmt(const IfStmt *If) {
AddStmt(If->getElse());
AddStmt(If->getThen());
AddStmt(If->getCond());
AddStmt(If->getInit());
AddDecl(If->getConditionVariable());
2893}
2894void EnqueueVisitor::VisitInitListExpr(const InitListExpr *IE) {
// We care about the syntactic form of the initializer list, only.
if (InitListExpr *Syntactic = IE->getSyntacticForm())
  IE = Syntactic;
EnqueueChildren(IE);
2899}
2900void EnqueueVisitor::VisitMemberExpr(const MemberExpr *M) {
WL.push_back(MemberExprParts(M, Parent));

// If the base of the member access expression is an implicit 'this', don't
// visit it.
// FIXME: If we ever want to show these implicit accesses, this will be
// unfortunate. However, clang_getCursor() relies on this behavior.
if (M->isImplicitAccess())
  return;

// Ignore base anonymous struct/union fields, otherwise they will shadow the
// real field that we are interested in.
if (auto *SubME = dyn_cast<MemberExpr>(M->getBase())) {
  if (auto *FD = dyn_cast_or_null<FieldDecl>(SubME->getMemberDecl())) {
    if (FD->isAnonymousStructOrUnion()) {
      AddStmt(SubME->getBase());
      return;
    }
  }
}

AddStmt(M->getBase());
2922}
2923void EnqueueVisitor::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
AddTypeLoc(E->getEncodedTypeSourceInfo());
2925}
2926void EnqueueVisitor::VisitObjCMessageExpr(const ObjCMessageExpr *M) {
EnqueueChildren(M);
AddTypeLoc(M->getClassReceiverTypeInfo());
2929}
2930void EnqueueVisitor::VisitOffsetOfExpr(const OffsetOfExpr *E) {
// Visit the components of the offsetof expression.
for (unsigned N = E->getNumComponents(), I = N; I > 0; --I) {
  const OffsetOfNode &Node = E->getComponent(I - 1);
  switch (Node.getKind()) {
  case OffsetOfNode::Array:
    AddStmt(E->getIndexExpr(Node.getArrayExprIndex()));
    break;
  case OffsetOfNode::Field:
    AddMemberRef(Node.getField(), Node.getSourceRange().getEnd());
    break;
  case OffsetOfNode::Identifier:
  case OffsetOfNode::Base:
    continue;
  }
}
// Visit the type into which we're computing the offset.
AddTypeLoc(E->getTypeSourceInfo());
2948}
2949void EnqueueVisitor::VisitOverloadExpr(const OverloadExpr *E) {
if (E->hasExplicitTemplateArgs())
  AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs());
WL.push_back(OverloadExprParts(E, Parent));
2953}
2954void EnqueueVisitor::VisitUnaryExprOrTypeTraitExpr(
  const UnaryExprOrTypeTraitExpr *E) {
EnqueueChildren(E);
if (E->isArgumentType())
  AddTypeLoc(E->getArgumentTypeInfo());
2959}
2960void EnqueueVisitor::VisitStmt(const Stmt *S) { EnqueueChildren(S); }
2961void EnqueueVisitor::VisitSwitchStmt(const SwitchStmt *S) {
AddStmt(S->getBody());
AddStmt(S->getCond());
AddDecl(S->getConditionVariable());
2965}

2967void EnqueueVisitor::VisitWhileStmt(const WhileStmt *W) {
AddStmt(W->getBody());
AddStmt(W->getCond());
AddDecl(W->getConditionVariable());
2971}

2973void EnqueueVisitor::VisitTypeTraitExpr(const TypeTraitExpr *E) {
for (unsigned I = E->getNumArgs(); I > 0; --I)
  AddTypeLoc(E->getArg(I - 1));
2976}

2978void EnqueueVisitor::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
AddTypeLoc(E->getQueriedTypeSourceInfo());
2980}

2982void EnqueueVisitor::VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
EnqueueChildren(E);
2984}

2986void EnqueueVisitor::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U) {
VisitOverloadExpr(U);
if (!U->isImplicitAccess())
  AddStmt(U->getBase());
2990}
2991void EnqueueVisitor::VisitVAArgExpr(const VAArgExpr *E) {
AddStmt(E->getSubExpr());
AddTypeLoc(E->getWrittenTypeInfo());
2994}
2995void EnqueueVisitor::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
WL.push_back(SizeOfPackExprParts(E, Parent));
2997}
2998void EnqueueVisitor::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
// If the opaque value has a source expression, just transparently
// visit that.  This is useful for (e.g.) pseudo-object expressions.
if (Expr *SourceExpr = E->getSourceExpr())
  return Visit(SourceExpr);
3003}
3004void EnqueueVisitor::VisitLambdaExpr(const LambdaExpr *E) {
AddStmt(E->getBody());
WL.push_back(LambdaExprParts(E, Parent));
3007}
3008void EnqueueVisitor::VisitConceptSpecializationExpr(
  const ConceptSpecializationExpr *E) {
WL.push_back(ConceptSpecializationExprVisit(E, Parent));
3011}
3012void EnqueueVisitor::VisitRequiresExpr(const RequiresExpr *E) {
WL.push_back(RequiresExprVisit(E, Parent));
for (ParmVarDecl *VD : E->getLocalParameters())
  AddDecl(VD);
3016}
3017void EnqueueVisitor::VisitCXXParenListInitExpr(const CXXParenListInitExpr *E) {
EnqueueChildren(E);
3019}
3020void EnqueueVisitor::VisitPseudoObjectExpr(const PseudoObjectExpr *E) {
// Treat the expression like its syntactic form.
Visit(E->getSyntacticForm());
3023}

3025void EnqueueVisitor::VisitOMPExecutableDirective(
  const OMPExecutableDirective *D) {
EnqueueChildren(D);
for (ArrayRef<OMPClause *>::iterator I = D->clauses().begin(),
                                     E = D->clauses().end();
     I != E; ++I)
  EnqueueChildren(*I);
3032}

3034void EnqueueVisitor::VisitOMPLoopBasedDirective(
  const OMPLoopBasedDirective *D) {
VisitOMPExecutableDirective(D);
3037}

3039void EnqueueVisitor::VisitOMPLoopDirective(const OMPLoopDirective *D) {
VisitOMPLoopBasedDirective(D);
3041}

3043void EnqueueVisitor::VisitOMPParallelDirective(const OMPParallelDirective *D) {
VisitOMPExecutableDirective(D);
3045}

3047void EnqueueVisitor::VisitOMPSimdDirective(const OMPSimdDirective *D) {
VisitOMPLoopDirective(D);
3049}

3051void EnqueueVisitor::VisitOMPLoopTransformationDirective(
  const OMPLoopTransformationDirective *D) {
VisitOMPLoopBasedDirective(D);
3054}

3056void EnqueueVisitor::VisitOMPTileDirective(const OMPTileDirective *D) {
VisitOMPLoopTransformationDirective(D);
3058}

3060void EnqueueVisitor::VisitOMPUnrollDirective(const OMPUnrollDirective *D) {
VisitOMPLoopTransformationDirective(D);
3062}

3064void EnqueueVisitor::VisitOMPForDirective(const OMPForDirective *D) {
VisitOMPLoopDirective(D);
3066}

3068void EnqueueVisitor::VisitOMPForSimdDirective(const OMPForSimdDirective *D) {
VisitOMPLoopDirective(D);
3070}

3072void EnqueueVisitor::VisitOMPSectionsDirective(const OMPSectionsDirective *D) {
VisitOMPExecutableDirective(D);
3074}

3076void EnqueueVisitor::VisitOMPSectionDirective(const OMPSectionDirective *D) {
VisitOMPExecutableDirective(D);
3078}

3080void EnqueueVisitor::VisitOMPSingleDirective(const OMPSingleDirective *D) {
VisitOMPExecutableDirective(D);
3082}

3084void EnqueueVisitor::VisitOMPMasterDirective(const OMPMasterDirective *D) {
VisitOMPExecutableDirective(D);
3086}

3088void EnqueueVisitor::VisitOMPCriticalDirective(const OMPCriticalDirective *D) {
VisitOMPExecutableDirective(D);
AddDeclarationNameInfo(D);
3091}

3093void EnqueueVisitor::VisitOMPParallelForDirective(
  const OMPParallelForDirective *D) {
VisitOMPLoopDirective(D);
3096}

3098void EnqueueVisitor::VisitOMPParallelForSimdDirective(
  const OMPParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
3101}

3103void EnqueueVisitor::VisitOMPParallelMasterDirective(
  const OMPParallelMasterDirective *D) {
VisitOMPExecutableDirective(D);
3106}

3108void EnqueueVisitor::VisitOMPParallelMaskedDirective(
  const OMPParallelMaskedDirective *D) {
VisitOMPExecutableDirective(D);
3111}

3113void EnqueueVisitor::VisitOMPParallelSectionsDirective(
  const OMPParallelSectionsDirective *D) {
VisitOMPExecutableDirective(D);
3116}

3118void EnqueueVisitor::VisitOMPTaskDirective(const OMPTaskDirective *D) {
VisitOMPExecutableDirective(D);
3120}

3122void EnqueueVisitor::VisitOMPTaskyieldDirective(
  const OMPTaskyieldDirective *D) {
VisitOMPExecutableDirective(D);
3125}

3127void EnqueueVisitor::VisitOMPBarrierDirective(const OMPBarrierDirective *D) {
VisitOMPExecutableDirective(D);
3129}

3131void EnqueueVisitor::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D) {
VisitOMPExecutableDirective(D);
3133}

3135void EnqueueVisitor::VisitOMPErrorDirective(const OMPErrorDirective *D) {
VisitOMPExecutableDirective(D);
3137}

3139void EnqueueVisitor::VisitOMPTaskgroupDirective(
  const OMPTaskgroupDirective *D) {
VisitOMPExecutableDirective(D);
if (const Expr *E = D->getReductionRef())
  VisitStmt(E);
3144}

3146void EnqueueVisitor::VisitOMPFlushDirective(const OMPFlushDirective *D) {
VisitOMPExecutableDirective(D);
3148}

3150void EnqueueVisitor::VisitOMPDepobjDirective(const OMPDepobjDirective *D) {
VisitOMPExecutableDirective(D);
3152}

3154void EnqueueVisitor::VisitOMPScanDirective(const OMPScanDirective *D) {
VisitOMPExecutableDirective(D);
3156}

3158void EnqueueVisitor::VisitOMPOrderedDirective(const OMPOrderedDirective *D) {
VisitOMPExecutableDirective(D);
3160}

3162void EnqueueVisitor::VisitOMPAtomicDirective(const OMPAtomicDirective *D) {
VisitOMPExecutableDirective(D);
3164}

3166void EnqueueVisitor::VisitOMPTargetDirective(const OMPTargetDirective *D) {
VisitOMPExecutableDirective(D);
3168}

3170void EnqueueVisitor::VisitOMPTargetDataDirective(
  const OMPTargetDataDirective *D) {
VisitOMPExecutableDirective(D);
3173}

3175void EnqueueVisitor::VisitOMPTargetEnterDataDirective(
  const OMPTargetEnterDataDirective *D) {
VisitOMPExecutableDirective(D);
3178}

3180void EnqueueVisitor::VisitOMPTargetExitDataDirective(
  const OMPTargetExitDataDirective *D) {
VisitOMPExecutableDirective(D);
3183}

3185void EnqueueVisitor::VisitOMPTargetParallelDirective(
  const OMPTargetParallelDirective *D) {
VisitOMPExecutableDirective(D);
3188}

3190void EnqueueVisitor::VisitOMPTargetParallelForDirective(
  const OMPTargetParallelForDirective *D) {
VisitOMPLoopDirective(D);
3193}

3195void EnqueueVisitor::VisitOMPTeamsDirective(const OMPTeamsDirective *D) {
VisitOMPExecutableDirective(D);
3197}

3199void EnqueueVisitor::VisitOMPCancellationPointDirective(
  const OMPCancellationPointDirective *D) {
VisitOMPExecutableDirective(D);
3202}

3204void EnqueueVisitor::VisitOMPCancelDirective(const OMPCancelDirective *D) {
VisitOMPExecutableDirective(D);
3206}

3208void EnqueueVisitor::VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D) {
VisitOMPLoopDirective(D);
3210}

3212void EnqueueVisitor::VisitOMPTaskLoopSimdDirective(
  const OMPTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
3215}

3217void EnqueueVisitor::VisitOMPMasterTaskLoopDirective(
  const OMPMasterTaskLoopDirective *D) {
VisitOMPLoopDirective(D);
3220}

3222void EnqueueVisitor::VisitOMPMaskedTaskLoopDirective(
  const OMPMaskedTaskLoopDirective *D) {
VisitOMPLoopDirective(D);
3225}

3227void EnqueueVisitor::VisitOMPMasterTaskLoopSimdDirective(
  const OMPMasterTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
3230}

3232void EnqueueVisitor::VisitOMPMaskedTaskLoopSimdDirective(
  const OMPMaskedTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
3235}

3237void EnqueueVisitor::VisitOMPParallelMasterTaskLoopDirective(
  const OMPParallelMasterTaskLoopDirective *D) {
VisitOMPLoopDirective(D);
3240}

3242void EnqueueVisitor::VisitOMPParallelMaskedTaskLoopDirective(
  const OMPParallelMaskedTaskLoopDirective *D) {
VisitOMPLoopDirective(D);
3245}

3247void EnqueueVisitor::VisitOMPParallelMasterTaskLoopSimdDirective(
  const OMPParallelMasterTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
3250}

3252void EnqueueVisitor::VisitOMPParallelMaskedTaskLoopSimdDirective(
  const OMPParallelMaskedTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
3255}

3257void EnqueueVisitor::VisitOMPDistributeDirective(
  const OMPDistributeDirective *D) {
VisitOMPLoopDirective(D);
3260}

3262void EnqueueVisitor::VisitOMPDistributeParallelForDirective(
  const OMPDistributeParallelForDirective *D) {
VisitOMPLoopDirective(D);
3265}

3267void EnqueueVisitor::VisitOMPDistributeParallelForSimdDirective(
  const OMPDistributeParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
3270}

3272void EnqueueVisitor::VisitOMPDistributeSimdDirective(
  const OMPDistributeSimdDirective *D) {
VisitOMPLoopDirective(D);
3275}

3277void EnqueueVisitor::VisitOMPTargetParallelForSimdDirective(
  const OMPTargetParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
3280}

3282void EnqueueVisitor::VisitOMPTargetSimdDirective(
  const OMPTargetSimdDirective *D) {
VisitOMPLoopDirective(D);
3285}

3287void EnqueueVisitor::VisitOMPTeamsDistributeDirective(
  const OMPTeamsDistributeDirective *D) {
VisitOMPLoopDirective(D);
3290}

3292void EnqueueVisitor::VisitOMPTeamsDistributeSimdDirective(
  const OMPTeamsDistributeSimdDirective *D) {
VisitOMPLoopDirective(D);
3295}

3297void EnqueueVisitor::VisitOMPTeamsDistributeParallelForSimdDirective(
  const OMPTeamsDistributeParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
3300}

3302void EnqueueVisitor::VisitOMPTeamsDistributeParallelForDirective(
  const OMPTeamsDistributeParallelForDirective *D) {
VisitOMPLoopDirective(D);
3305}

3307void EnqueueVisitor::VisitOMPTargetTeamsDirective(
  const OMPTargetTeamsDirective *D) {
VisitOMPExecutableDirective(D);
3310}

3312void EnqueueVisitor::VisitOMPTargetTeamsDistributeDirective(
  const OMPTargetTeamsDistributeDirective *D) {
VisitOMPLoopDirective(D);
3315}

3317void EnqueueVisitor::VisitOMPTargetTeamsDistributeParallelForDirective(
  const OMPTargetTeamsDistributeParallelForDirective *D) {
VisitOMPLoopDirective(D);
3320}

3322void EnqueueVisitor::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
  const OMPTargetTeamsDistributeParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
3325}

3327void EnqueueVisitor::VisitOMPTargetTeamsDistributeSimdDirective(
  const OMPTargetTeamsDistributeSimdDirective *D) {
VisitOMPLoopDirective(D);
3330}

3332void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) {
EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU, RegionOfInterest))
    .Visit(S);
3335}

3337bool CursorVisitor::IsInRegionOfInterest(CXCursor C) {
if (RegionOfInterest.isValid()) {
  SourceRange Range = getRawCursorExtent(C);
  if (Range.isInvalid() || CompareRegionOfInterest(Range))
    return false;
}
return true;
3344}

3346bool CursorVisitor::RunVisitorWorkList(VisitorWorkList &WL) {
while (!WL.empty()) {
  // Dequeue the worklist item.
  VisitorJob LI = WL.pop_back_val();

  // Set the Parent field, then back to its old value once we're done.
  SetParentRAII SetParent(Parent, StmtParent, LI.getParent());

  switch (LI.getKind()) {
  case VisitorJob::DeclVisitKind: {
    const Decl *D = cast<DeclVisit>(&LI)->get();
    if (!D)
      continue;

    // For now, perform default visitation for Decls.
    if (Visit(MakeCXCursor(D, TU, RegionOfInterest,
                           cast<DeclVisit>(&LI)->isFirst())))
      return true;

    continue;
  }
  case VisitorJob::ExplicitTemplateArgsVisitKind: {
    for (const TemplateArgumentLoc &Arg :
         *cast<ExplicitTemplateArgsVisit>(&LI)) {
      if (VisitTemplateArgumentLoc(Arg))
        return true;
    }
    continue;
  }
  case VisitorJob::TypeLocVisitKind: {
    // Perform default visitation for TypeLocs.
    if (Visit(cast<TypeLocVisit>(&LI)->get()))
      return true;
    continue;
  }
  case VisitorJob::LabelRefVisitKind: {
    const LabelDecl *LS = cast<LabelRefVisit>(&LI)->get();
    if (LabelStmt *stmt = LS->getStmt()) {
      if (Visit(MakeCursorLabelRef(stmt, cast<LabelRefVisit>(&LI)->getLoc(),
                                   TU))) {
        return true;
      }
    }
    continue;
  }

  case VisitorJob::NestedNameSpecifierLocVisitKind: {
    NestedNameSpecifierLocVisit *V = cast<NestedNameSpecifierLocVisit>(&LI);
    if (VisitNestedNameSpecifierLoc(V->get()))
      return true;
    continue;
  }

  case VisitorJob::DeclarationNameInfoVisitKind: {
    if (VisitDeclarationNameInfo(cast<DeclarationNameInfoVisit>(&LI)->get()))
      return true;
    continue;
  }
  case VisitorJob::MemberRefVisitKind: {
    MemberRefVisit *V = cast<MemberRefVisit>(&LI);
    if (Visit(MakeCursorMemberRef(V->get(), V->getLoc(), TU)))
      return true;
    continue;
  }
  case VisitorJob::StmtVisitKind: {
    const Stmt *S = cast<StmtVisit>(&LI)->get();
    if (!S)
      continue;

    // Update the current cursor.
    CXCursor Cursor = MakeCXCursor(S, StmtParent, TU, RegionOfInterest);
    if (!IsInRegionOfInterest(Cursor))
      continue;
    switch (Visitor(Cursor, Parent, ClientData)) {
    case CXChildVisit_Break:
      return true;
    case CXChildVisit_Continue:
      break;
    case CXChildVisit_Recurse:
      if (PostChildrenVisitor)
        WL.push_back(PostChildrenVisit(nullptr, Cursor));
      EnqueueWorkList(WL, S);
      break;
    }
    continue;
  }
  case VisitorJob::MemberExprPartsKind: {
    // Handle the other pieces in the MemberExpr besides the base.
    const MemberExpr *M = cast<MemberExprParts>(&LI)->get();

    // Visit the nested-name-specifier
    if (NestedNameSpecifierLoc QualifierLoc = M->getQualifierLoc())
      if (VisitNestedNameSpecifierLoc(QualifierLoc))
        return true;

    // Visit the declaration name.
    if (VisitDeclarationNameInfo(M->getMemberNameInfo()))
      return true;

    // Visit the explicitly-specified template arguments, if any.
    if (M->hasExplicitTemplateArgs()) {
      for (const TemplateArgumentLoc *Arg = M->getTemplateArgs(),
                                     *ArgEnd = Arg + M->getNumTemplateArgs();
           Arg != ArgEnd; ++Arg) {
        if (VisitTemplateArgumentLoc(*Arg))
          return true;
      }
    }
    continue;
  }
  case VisitorJob::DeclRefExprPartsKind: {
    const DeclRefExpr *DR = cast<DeclRefExprParts>(&LI)->get();
    // Visit nested-name-specifier, if present.
    if (NestedNameSpecifierLoc QualifierLoc = DR->getQualifierLoc())
      if (VisitNestedNameSpecifierLoc(QualifierLoc))
        return true;
    // Visit declaration name.
    if (VisitDeclarationNameInfo(DR->getNameInfo()))
      return true;
    continue;
  }
  case VisitorJob::OverloadExprPartsKind: {
    const OverloadExpr *O = cast<OverloadExprParts>(&LI)->get();
    // Visit the nested-name-specifier.
    if (NestedNameSpecifierLoc QualifierLoc = O->getQualifierLoc())
      if (VisitNestedNameSpecifierLoc(QualifierLoc))
        return true;
    // Visit the declaration name.
    if (VisitDeclarationNameInfo(O->getNameInfo()))
      return true;
    // Visit the overloaded declaration reference.
    if (Visit(MakeCursorOverloadedDeclRef(O, TU)))
      return true;
    continue;
  }
  case VisitorJob::SizeOfPackExprPartsKind: {
    const SizeOfPackExpr *E = cast<SizeOfPackExprParts>(&LI)->get();
    NamedDecl *Pack = E->getPack();
    if (isa<TemplateTypeParmDecl>(Pack)) {
      if (Visit(MakeCursorTypeRef(cast<TemplateTypeParmDecl>(Pack),
                                  E->getPackLoc(), TU)))
        return true;

      continue;
    }

    if (isa<TemplateTemplateParmDecl>(Pack)) {
      if (Visit(MakeCursorTemplateRef(cast<TemplateTemplateParmDecl>(Pack),
                                      E->getPackLoc(), TU)))
        return true;

      continue;
    }

    // Non-type template parameter packs and function parameter packs are
    // treated like DeclRefExpr cursors.
    continue;
  }

  case VisitorJob::LambdaExprPartsKind: {
    // Visit non-init captures.
    const LambdaExpr *E = cast<LambdaExprParts>(&LI)->get();
    for (LambdaExpr::capture_iterator C = E->explicit_capture_begin(),
                                      CEnd = E->explicit_capture_end();
         C != CEnd; ++C) {
      if (!C->capturesVariable())
        continue;
      // TODO: handle structured bindings here ?
      if (!isa<VarDecl>(C->getCapturedVar()))
        continue;
      if (Visit(MakeCursorVariableRef(cast<VarDecl>(C->getCapturedVar()),
                                      C->getLocation(), TU)))
        return true;
    }
    // Visit init captures
    for (auto InitExpr : E->capture_inits()) {
      if (InitExpr && Visit(InitExpr))
        return true;
    }

    TypeLoc TL = E->getCallOperator()->getTypeSourceInfo()->getTypeLoc();
    // Visit parameters and return type, if present.
    if (FunctionTypeLoc Proto = TL.getAs<FunctionProtoTypeLoc>()) {
      if (E->hasExplicitParameters()) {
        // Visit parameters.
        for (unsigned I = 0, N = Proto.getNumParams(); I != N; ++I)
          if (Visit(MakeCXCursor(Proto.getParam(I), TU)))
            return true;
      }
      if (E->hasExplicitResultType()) {
        // Visit result type.
        if (Visit(Proto.getReturnLoc()))
          return true;
      }
    }
    break;
  }

  case VisitorJob::ConceptSpecializationExprVisitKind: {
    const ConceptSpecializationExpr *E =
        cast<ConceptSpecializationExprVisit>(&LI)->get();
    if (NestedNameSpecifierLoc QualifierLoc =
            E->getNestedNameSpecifierLoc()) {
      if (VisitNestedNameSpecifierLoc(QualifierLoc))
        return true;
    }

    if (E->getNamedConcept() &&
        Visit(MakeCursorTemplateRef(E->getNamedConcept(),
                                    E->getConceptNameLoc(), TU)))
      return true;

    if (auto Args = E->getTemplateArgsAsWritten()) {
      for (const auto &Arg : Args->arguments()) {
        if (VisitTemplateArgumentLoc(Arg))
          return true;
      }
    }
    break;
  }

  case VisitorJob::RequiresExprVisitKind: {
    const RequiresExpr *E = cast<RequiresExprVisit>(&LI)->get();
    for (const concepts::Requirement *R : E->getRequirements())
      VisitConceptRequirement(*R);
    break;
  }

  case VisitorJob::PostChildrenVisitKind:
    if (PostChildrenVisitor(Parent, ClientData))
      return true;
    break;
  }
}
return false;
3581}

3583bool CursorVisitor::Visit(const Stmt *S) {
VisitorWorkList *WL = nullptr;
if (!WorkListFreeList.empty()) {
  WL = WorkListFreeList.back();
  WL->clear();
  WorkListFreeList.pop_back();
} else {
  WL = new VisitorWorkList();
  WorkListCache.push_back(WL);
}
EnqueueWorkList(*WL, S);
bool result = RunVisitorWorkList(*WL);
WorkListFreeList.push_back(WL);
return result;
3597}

3599namespace {
3600typedef SmallVector<SourceRange, 4> RefNamePieces;
3601RefNamePieces buildPieces(unsigned NameFlags, bool IsMemberRefExpr,
                        const DeclarationNameInfo &NI, SourceRange QLoc,
                        const SourceRange *TemplateArgsLoc = nullptr) {
const bool WantQualifier = NameFlags & CXNameRange_WantQualifier;
const bool WantTemplateArgs = NameFlags & CXNameRange_WantTemplateArgs;
const bool WantSinglePiece = NameFlags & CXNameRange_WantSinglePiece;

const DeclarationName::NameKind Kind = NI.getName().getNameKind();

RefNamePieces Pieces;

if (WantQualifier && QLoc.isValid())
  Pieces.push_back(QLoc);

if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr)
  Pieces.push_back(NI.getLoc());

if (WantTemplateArgs && TemplateArgsLoc && TemplateArgsLoc->isValid())
  Pieces.push_back(*TemplateArgsLoc);

if (Kind == DeclarationName::CXXOperatorName) {
  Pieces.push_back(NI.getInfo().getCXXOperatorNameBeginLoc());
  Pieces.push_back(NI.getInfo().getCXXOperatorNameEndLoc());
}

if (WantSinglePiece) {
  SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd());
  Pieces.clear();
  Pieces.push_back(R);
}

return Pieces;
3633}
3634} // namespace

3636//===----------------------------------------------------------------------===//
3637// Misc. API hooks.
3638//===----------------------------------------------------------------------===//

3640namespace {
3641struct RegisterFatalErrorHandler {
RegisterFatalErrorHandler() {
  clang_install_aborting_llvm_fatal_error_handler();
}
3645};
3646} // namespace

3648static llvm::ManagedStatic<RegisterFatalErrorHandler>
  RegisterFatalErrorHandlerOnce;

3651static CIndexer *clang_createIndex_Impl(
  int excludeDeclarationsFromPCH, int displayDiagnostics,
  unsigned char threadBackgroundPriorityForIndexing = CXChoice_Default,
  unsigned char threadBackgroundPriorityForEditing = CXChoice_Default) {
// We use crash recovery to make some of our APIs more reliable, implicitly
// enable it.
if (!getenv("LIBCLANG_DISABLE_CRASH_RECOVERY"))
  llvm::CrashRecoveryContext::Enable();

// Look through the managed static to trigger construction of the managed
// static which registers our fatal error handler. This ensures it is only
// registered once.
(void)*RegisterFatalErrorHandlerOnce;

// Initialize targets for clang module support.
llvm::InitializeAllTargets();
llvm::InitializeAllTargetMCs();
llvm::InitializeAllAsmPrinters();
llvm::InitializeAllAsmParsers();

CIndexer *CIdxr = new CIndexer();

if (excludeDeclarationsFromPCH)
  CIdxr->setOnlyLocalDecls();
if (displayDiagnostics)
  CIdxr->setDisplayDiagnostics();

unsigned GlobalOptions = CIdxr->getCXGlobalOptFlags();
const auto updateGlobalOption =
    [&GlobalOptions](unsigned char Policy, CXGlobalOptFlags Flag,
                     const char *EnvironmentVariableName) {
      switch (Policy) {
      case CXChoice_Enabled:
        GlobalOptions |= Flag;
        break;
      case CXChoice_Disabled:
        GlobalOptions &= ~Flag;
        break;
      case CXChoice_Default:
      default: // Fall back to default behavior if Policy is unsupported.
        if (getenv(EnvironmentVariableName))
          GlobalOptions |= Flag;
      }
    };
updateGlobalOption(threadBackgroundPriorityForIndexing,
                   CXGlobalOpt_ThreadBackgroundPriorityForIndexing,
                   "LIBCLANG_BGPRIO_INDEX");
updateGlobalOption(threadBackgroundPriorityForEditing,
                   CXGlobalOpt_ThreadBackgroundPriorityForEditing,
                   "LIBCLANG_BGPRIO_EDIT");
CIdxr->setCXGlobalOptFlags(GlobalOptions);

return CIdxr;
3704}

3706CXIndex clang_createIndex(int excludeDeclarationsFromPCH,
                        int displayDiagnostics) {
return clang_createIndex_Impl(excludeDeclarationsFromPCH, displayDiagnostics);
3709}

3711void clang_disposeIndex(CXIndex CIdx) {
if (CIdx)
  delete static_cast<CIndexer *>(CIdx);
3714}

3716CXIndex clang_createIndexWithOptions(const CXIndexOptions *options) {
// Adding new options to struct CXIndexOptions:
// 1. If no other new option has been added in the same libclang version,
// sizeof(CXIndexOptions) must increase for versioning purposes.
// 2. Options should be added at the end of the struct in order to seamlessly
// support older struct versions. If options->Size < sizeof(CXIndexOptions),
// don't attempt to read the missing options and rely on the default values of
// recently added options being reasonable. For example:
// if (options->Size >= offsetof(CXIndexOptions, RecentlyAddedMember))
//   do_something(options->RecentlyAddedMember);

// An exception: if a new option is small enough, it can be squeezed into the
// /*Reserved*/ bits in CXIndexOptions. Since the default value of each option
// is guaranteed to be 0 and the callers are advised to zero out the struct,
// programs built against older libclang versions would implicitly set the new
// options to default values, which should keep the behavior of previous
// libclang versions and thus be backward-compatible.

// If options->Size > sizeof(CXIndexOptions), the user may have set an option
// we can't handle, in which case we return nullptr to report failure.
// Replace `!=` with `>` here to support older struct versions. `!=` has the
// advantage of catching more usage bugs and no disadvantages while there is a
// single supported struct version (the initial version).
if (options->Size != sizeof(CXIndexOptions))
  return nullptr;
CIndexer *const CIdxr = clang_createIndex_Impl(
    options->ExcludeDeclarationsFromPCH, options->DisplayDiagnostics,
    options->ThreadBackgroundPriorityForIndexing,
    options->ThreadBackgroundPriorityForEditing);
CIdxr->setStorePreamblesInMemory(options->StorePreamblesInMemory);
CIdxr->setPreambleStoragePath(options->PreambleStoragePath);
CIdxr->setInvocationEmissionPath(options->InvocationEmissionPath);
return CIdxr;
3749}

3751void clang_CXIndex_setGlobalOptions(CXIndex CIdx, unsigned options) {
if (CIdx)
  static_cast<CIndexer *>(CIdx)->setCXGlobalOptFlags(options);
3754}

3756unsigned clang_CXIndex_getGlobalOptions(CXIndex CIdx) {
if (CIdx)
  return static_cast<CIndexer *>(CIdx)->getCXGlobalOptFlags();
return 0;
3760}

3762void clang_CXIndex_setInvocationEmissionPathOption(CXIndex CIdx,
                                                 const char *Path) {
if (CIdx)
  static_cast<CIndexer *>(CIdx)->setInvocationEmissionPath(Path ? Path : "");
3766}

3768void clang_toggleCrashRecovery(unsigned isEnabled) {
if (isEnabled)
  llvm::CrashRecoveryContext::Enable();
else
  llvm::CrashRecoveryContext::Disable();
3773}

3775CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx,
                                            const char *ast_filename) {
CXTranslationUnit TU;
enum CXErrorCode Result =
    clang_createTranslationUnit2(CIdx, ast_filename, &TU);
(void)Result;
assert((TU && Result == CXError_Success) ||(static_cast <bool> ((TU && Result == CXError_Success
) || (!TU && Result != CXError_Success)) ? void (0) :
 __assert_fail ("(TU && Result == CXError_Success) || (!TU && Result != CXError_Success)"
, "clang/tools/libclang/CIndex.cpp", 3782, __extension__ __PRETTY_FUNCTION__
))
       (!TU && Result != CXError_Success))(static_cast <bool> ((TU && Result == CXError_Success
) || (!TU && Result != CXError_Success)) ? void (0) :
 __assert_fail ("(TU && Result == CXError_Success) || (!TU && Result != CXError_Success)"
, "clang/tools/libclang/CIndex.cpp", 3782, __extension__ __PRETTY_FUNCTION__
));
return TU;
3784}

3786enum CXErrorCode clang_createTranslationUnit2(CXIndex CIdx,
                                            const char *ast_filename,
                                            CXTranslationUnit *out_TU) {
if (out_TU)
  *out_TU = nullptr;

if (!CIdx || !ast_filename || !out_TU)
  return CXError_InvalidArguments;

LOG_FUNC_SECTIONif (clang::cxindex::LogRef Log = clang::cxindex::Logger::make
(__func__)) { *Log << ast_filename; }

CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
FileSystemOptions FileSystemOpts;

IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
    CompilerInstance::createDiagnostics(new DiagnosticOptions());
std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile(
    ast_filename, CXXIdx->getPCHContainerOperations()->getRawReader(),
    ASTUnit::LoadEverything, Diags, FileSystemOpts, /*UseDebugInfo=*/false,
    CXXIdx->getOnlyLocalDecls(), CaptureDiagsKind::All,
    /*AllowASTWithCompilerErrors=*/true,
    /*UserFilesAreVolatile=*/true);
*out_TU = MakeCXTranslationUnit(CXXIdx, std::move(AU));
return *out_TU ? CXError_Success : CXError_Failure;
3810}

3812unsigned clang_defaultEditingTranslationUnitOptions() {
return CXTranslationUnit_PrecompiledPreamble |
       CXTranslationUnit_CacheCompletionResults;
3815}

3817CXTranslationUnit clang_createTranslationUnitFromSourceFile(
  CXIndex CIdx, const char *source_filename, int num_command_line_args,
  const char *const *command_line_args, unsigned num_unsaved_files,
  struct CXUnsavedFile *unsaved_files) {
unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord;
return clang_parseTranslationUnit(CIdx, source_filename, command_line_args,
1
Calling 'clang_parseTranslationUnit'→
                                  num_command_line_args, unsaved_files,
                                  num_unsaved_files, Options);
3825}

3827static CXErrorCode
3828clang_parseTranslationUnit_Impl(CXIndex CIdx, const char *source_filename,
                              const char *const *command_line_args,
                              int num_command_line_args,
                              ArrayRef<CXUnsavedFile> unsaved_files,
                              unsigned options, CXTranslationUnit *out_TU) {
// Set up the initial return values.
if (out_TU)
  *out_TU = nullptr;

// Check arguments.
if (!CIdx || !out_TU)
  return CXError_InvalidArguments;

CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);

if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
  setThreadBackgroundPriority();

bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble;
bool CreatePreambleOnFirstParse =
    options & CXTranslationUnit_CreatePreambleOnFirstParse;
// FIXME: Add a flag for modules.
TranslationUnitKind TUKind = (options & (CXTranslationUnit_Incomplete |
                                         CXTranslationUnit_SingleFileParse))
                                 ? TU_Prefix
                                 : TU_Complete;
bool CacheCodeCompletionResults =
    options & CXTranslationUnit_CacheCompletionResults;
bool IncludeBriefCommentsInCodeCompletion =
    options & CXTranslationUnit_IncludeBriefCommentsInCodeCompletion;
bool SingleFileParse = options & CXTranslationUnit_SingleFileParse;
bool ForSerialization = options & CXTranslationUnit_ForSerialization;
bool RetainExcludedCB =
    options & CXTranslationUnit_RetainExcludedConditionalBlocks;
SkipFunctionBodiesScope SkipFunctionBodies = SkipFunctionBodiesScope::None;
if (options & CXTranslationUnit_SkipFunctionBodies) {
  SkipFunctionBodies =
      (options & CXTranslationUnit_LimitSkipFunctionBodiesToPreamble)
          ? SkipFunctionBodiesScope::Preamble
          : SkipFunctionBodiesScope::PreambleAndMainFile;
}

// Configure the diagnostics.
std::unique_ptr<DiagnosticOptions> DiagOpts = CreateAndPopulateDiagOpts(
    llvm::ArrayRef(command_line_args, num_command_line_args));
IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
    CompilerInstance::createDiagnostics(DiagOpts.release()));

if (options & CXTranslationUnit_KeepGoing)
  Diags->setFatalsAsError(true);

CaptureDiagsKind CaptureDiagnostics = CaptureDiagsKind::All;
if (options & CXTranslationUnit_IgnoreNonErrorsFromIncludedFiles)
  CaptureDiagnostics = CaptureDiagsKind::AllWithoutNonErrorsFromIncludes;

// Recover resources if we crash before exiting this function.
llvm::CrashRecoveryContextCleanupRegistrar<
    DiagnosticsEngine,
    llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
    DiagCleanup(Diags.get());

std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles(
    new std::vector<ASTUnit::RemappedFile>());

// Recover resources if we crash before exiting this function.
llvm::CrashRecoveryContextCleanupRegistrar<std::vector<ASTUnit::RemappedFile>>
    RemappedCleanup(RemappedFiles.get());

for (auto &UF : unsaved_files) {
  std::unique_ptr<llvm::MemoryBuffer> MB =
      llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
  RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release()));
}

std::unique_ptr<std::vector<const char *>> Args(
    new std::vector<const char *>());

// Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char *>>
    ArgsCleanup(Args.get());

// Since the Clang C library is primarily used by batch tools dealing with
// (often very broken) source code, where spell-checking can have a
// significant negative impact on performance (particularly when
// precompiled headers are involved), we disable it by default.
// Only do this if we haven't found a spell-checking-related argument.
bool FoundSpellCheckingArgument = false;
for (int I = 0; I != num_command_line_args; ++I) {
  if (strcmp(command_line_args[I], "-fno-spell-checking") == 0 ||
      strcmp(command_line_args[I], "-fspell-checking") == 0) {
    FoundSpellCheckingArgument = true;
    break;
  }
}
Args->insert(Args->end(), command_line_args,
             command_line_args + num_command_line_args);

if (!FoundSpellCheckingArgument)
  Args->insert(Args->begin() + 1, "-fno-spell-checking");

// The 'source_filename' argument is optional.  If the caller does not
// specify it then it is assumed that the source file is specified
// in the actual argument list.
// Put the source file after command_line_args otherwise if '-x' flag is
// present it will be unused.
if (source_filename)
  Args->push_back(source_filename);

// Do we need the detailed preprocessing record?
if (options & CXTranslationUnit_DetailedPreprocessingRecord) {
  Args->push_back("-Xclang");
  Args->push_back("-detailed-preprocessing-record");
}

// Suppress any editor placeholder diagnostics.
Args->push_back("-fallow-editor-placeholders");

unsigned NumErrors = Diags->getClient()->getNumErrors();
std::unique_ptr<ASTUnit> ErrUnit;
// Unless the user specified that they want the preamble on the first parse
// set it up to be created on the first reparse. This makes the first parse
// faster, trading for a slower (first) reparse.
unsigned PrecompilePreambleAfterNParses =
    !PrecompilePreamble ? 0 : 2 - CreatePreambleOnFirstParse;

LibclangInvocationReporter InvocationReporter(
    *CXXIdx, LibclangInvocationReporter::OperationKind::ParseOperation,
    options, llvm::ArrayRef(*Args), /*InvocationArgs=*/std::nullopt,
    unsaved_files);
std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCommandLine(
    Args->data(), Args->data() + Args->size(),
    CXXIdx->getPCHContainerOperations(), Diags,
    CXXIdx->getClangResourcesPath(), CXXIdx->getStorePreamblesInMemory(),
    CXXIdx->getPreambleStoragePath(), CXXIdx->getOnlyLocalDecls(),
    CaptureDiagnostics, *RemappedFiles.get(),
    /*RemappedFilesKeepOriginalName=*/true, PrecompilePreambleAfterNParses,
    TUKind, CacheCodeCompletionResults, IncludeBriefCommentsInCodeCompletion,
    /*AllowPCHWithCompilerErrors=*/true, SkipFunctionBodies, SingleFileParse,
    /*UserFilesAreVolatile=*/true, ForSerialization, RetainExcludedCB,
    CXXIdx->getPCHContainerOperations()->getRawReader().getFormats().front(),
    &ErrUnit));

// Early failures in LoadFromCommandLine may return with ErrUnit unset.
if (!Unit && !ErrUnit)
  return CXError_ASTReadError;

if (NumErrors != Diags->getClient()->getNumErrors()) {
  // Make sure to check that 'Unit' is non-NULL.
  if (CXXIdx->getDisplayDiagnostics())
    printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get());
}

if (isASTReadError(Unit ? Unit.get() : ErrUnit.get()))
  return CXError_ASTReadError;

*out_TU = MakeCXTranslationUnit(CXXIdx, std::move(Unit));
if (CXTranslationUnitImpl *TU = *out_TU) {
  TU->ParsingOptions = options;
  TU->Arguments.reserve(Args->size());
  for (const char *Arg : *Args)
    TU->Arguments.push_back(Arg);
  return CXError_Success;
}
return CXError_Failure;
3992}

3994CXTranslationUnit
3995clang_parseTranslationUnit(CXIndex CIdx, const char *source_filename,
                         const char *const *command_line_args,
                         int num_command_line_args,
                         struct CXUnsavedFile *unsaved_files,
                         unsigned num_unsaved_files, unsigned options) {
CXTranslationUnit TU;
2
←
'TU' declared without an initial value→
enum CXErrorCode Result = clang_parseTranslationUnit2(
3
←
Calling 'clang_parseTranslationUnit2'→
12
←
Returning from 'clang_parseTranslationUnit2'→
    CIdx, source_filename, command_line_args, num_command_line_args,
    unsaved_files, num_unsaved_files, options, &TU);
(void)Result;
assert((TU && Result == CXError_Success) ||(static_cast <bool> ((TU && Result == CXError_Success
) || (!TU && Result != CXError_Success)) ? void (0) :
 __assert_fail ("(TU && Result == CXError_Success) || (!TU && Result != CXError_Success)"
, "clang/tools/libclang/CIndex.cpp", 4006, __extension__ __PRETTY_FUNCTION__
))
13
←
Branch condition evaluates to a garbage value
       (!TU && Result != CXError_Success))(static_cast <bool> ((TU && Result == CXError_Success
) || (!TU && Result != CXError_Success)) ? void (0) :
 __assert_fail ("(TU && Result == CXError_Success) || (!TU && Result != CXError_Success)"
, "clang/tools/libclang/CIndex.cpp", 4006, __extension__ __PRETTY_FUNCTION__
));
return TU;
4008}

4010enum CXErrorCode clang_parseTranslationUnit2(
  CXIndex CIdx, const char *source_filename,
  const char *const *command_line_args, int num_command_line_args,
  struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files,
  unsigned options, CXTranslationUnit *out_TU) {
noteBottomOfStack();
SmallVector<const char *, 4> Args;
Args.push_back("clang");
Args.append(command_line_args, command_line_args + num_command_line_args);
return clang_parseTranslationUnit2FullArgv(
4
←
Calling 'clang_parseTranslationUnit2FullArgv'→
10
←
Returning from 'clang_parseTranslationUnit2FullArgv'→
11
←
Returning without writing to '*out_TU'→
    CIdx, source_filename, Args.data(), Args.size(), unsaved_files,
    num_unsaved_files, options, out_TU);
4022}

4024enum CXErrorCode clang_parseTranslationUnit2FullArgv(
  CXIndex CIdx, const char *source_filename,
  const char *const *command_line_args, int num_command_line_args,
  struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files,
  unsigned options, CXTranslationUnit *out_TU) {
LOG_FUNC_SECTIONif (clang::cxindex::LogRef Log = clang::cxindex::Logger::make
(__func__)) {
5
←
Taking false branch→
  *Log << source_filename << ": ";
  for (int i = 0; i != num_command_line_args; ++i)
    *Log << command_line_args[i] << " ";
}

if (num_unsaved_files && !unsaved_files)
6
←
Assuming 'num_unsaved_files' is not equal to 0→
7
←
Assuming 'unsaved_files' is null→
8
←
Taking true branch→
  return CXError_InvalidArguments;
9
←
Returning without writing to '*out_TU'→

CXErrorCode result = CXError_Failure;
auto ParseTranslationUnitImpl = [=, &result] {
  noteBottomOfStack();
  result = clang_parseTranslationUnit_Impl(
      CIdx, source_filename, command_line_args, num_command_line_args,
      llvm::ArrayRef(unsaved_files, num_unsaved_files), options, out_TU);
};

llvm::CrashRecoveryContext CRC;

if (!RunSafely(CRC, ParseTranslationUnitImpl)) {
  fprintf(stderrstderr, "libclang: crash detected during parsing: {\n");
  fprintf(stderrstderr, "  'source_filename' : '%s'\n", source_filename);
  fprintf(stderrstderr, "  'command_line_args' : [");
  for (int i = 0; i != num_command_line_args; ++i) {
    if (i)
      fprintf(stderrstderr, ", ");
    fprintf(stderrstderr, "'%s'", command_line_args[i]);
  }
  fprintf(stderrstderr, "],\n");
  fprintf(stderrstderr, "  'unsaved_files' : [");
  for (unsigned i = 0; i != num_unsaved_files; ++i) {
    if (i)
      fprintf(stderrstderr, ", ");
    fprintf(stderrstderr, "('%s', '...', %ld)", unsaved_files[i].Filename,
            unsaved_files[i].Length);
  }
  fprintf(stderrstderr, "],\n");
  fprintf(stderrstderr, "  'options' : %d,\n", options);
  fprintf(stderrstderr, "}\n");

  return CXError_Crashed;
} else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
  if (CXTranslationUnit *TU = out_TU)
    PrintLibclangResourceUsage(*TU);
}

return result;
4076}

4078CXString clang_Type_getObjCEncoding(CXType CT) {
CXTranslationUnit tu = static_cast<CXTranslationUnit>(CT.data[1]);
ASTContext &Ctx = getASTUnit(tu)->getASTContext();
std::string encoding;
Ctx.getObjCEncodingForType(QualType::getFromOpaquePtr(CT.data[0]), encoding);

return cxstring::createDup(encoding);
4085}

4087static const IdentifierInfo *getMacroIdentifier(CXCursor C) {
if (C.kind == CXCursor_MacroDefinition) {
  if (const MacroDefinitionRecord *MDR = getCursorMacroDefinition(C))
    return MDR->getName();
} else if (C.kind == CXCursor_MacroExpansion) {
  MacroExpansionCursor ME = getCursorMacroExpansion(C);
  return ME.getName();
}
return nullptr;
4096}

4098unsigned clang_Cursor_isMacroFunctionLike(CXCursor C) {
const IdentifierInfo *II = getMacroIdentifier(C);
if (!II) {
  return false;
}
ASTUnit *ASTU = getCursorASTUnit(C);
Preprocessor &PP = ASTU->getPreprocessor();
if (const MacroInfo *MI = PP.getMacroInfo(II))
  return MI->isFunctionLike();
return false;
4108}

4110unsigned clang_Cursor_isMacroBuiltin(CXCursor C) {
const IdentifierInfo *II = getMacroIdentifier(C);
if (!II) {
  return false;
}
ASTUnit *ASTU = getCursorASTUnit(C);
Preprocessor &PP = ASTU->getPreprocessor();
if (const MacroInfo *MI = PP.getMacroInfo(II))
  return MI->isBuiltinMacro();
return false;
4120}

4122unsigned clang_Cursor_isFunctionInlined(CXCursor C) {
const Decl *D = getCursorDecl(C);
const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
if (!FD) {
  return false;
}
return FD->isInlined();
4129}

4131static StringLiteral *getCFSTR_value(CallExpr *callExpr) {
if (callExpr->getNumArgs() != 1) {
  return nullptr;
}

StringLiteral *S = nullptr;
auto *arg = callExpr->getArg(0);
if (arg->getStmtClass() == Stmt::ImplicitCastExprClass) {
  ImplicitCastExpr *I = static_cast<ImplicitCastExpr *>(arg);
  auto *subExpr = I->getSubExprAsWritten();

  if (subExpr->getStmtClass() != Stmt::StringLiteralClass) {
    return nullptr;
  }

  S = static_cast<StringLiteral *>(I->getSubExprAsWritten());
} else if (arg->getStmtClass() == Stmt::StringLiteralClass) {
  S = static_cast<StringLiteral *>(callExpr->getArg(0));
} else {
  return nullptr;
}
return S;
4153}

4155struct ExprEvalResult {
CXEvalResultKind EvalType;
union {
  unsigned long long unsignedVal;
  long long intVal;
  double floatVal;
  char *stringVal;
} EvalData;
bool IsUnsignedInt;
~ExprEvalResult() {
  if (EvalType != CXEval_UnExposed && EvalType != CXEval_Float &&
      EvalType != CXEval_Int) {
    delete[] EvalData.stringVal;
  }
}
4170};

4172void clang_EvalResult_dispose(CXEvalResult E) {
delete static_cast<ExprEvalResult *>(E);
4174}

4176CXEvalResultKind clang_EvalResult_getKind(CXEvalResult E) {
if (!E) {
  return CXEval_UnExposed;
}
return ((ExprEvalResult *)E)->EvalType;
4181}

4183int clang_EvalResult_getAsInt(CXEvalResult E) {
return clang_EvalResult_getAsLongLong(E);
4185}

4187long long clang_EvalResult_getAsLongLong(CXEvalResult E) {
if (!E) {
  return 0;
}
ExprEvalResult *Result = (ExprEvalResult *)E;
if (Result->IsUnsignedInt)
  return Result->EvalData.unsignedVal;
return Result->EvalData.intVal;
4195}

4197unsigned clang_EvalResult_isUnsignedInt(CXEvalResult E) {
return ((ExprEvalResult *)E)->IsUnsignedInt;
4199}

4201unsigned long long clang_EvalResult_getAsUnsigned(CXEvalResult E) {
if (!E) {
  return 0;
}

ExprEvalResult *Result = (ExprEvalResult *)E;
if (Result->IsUnsignedInt)
  return Result->EvalData.unsignedVal;
return Result->EvalData.intVal;
4210}

4212double clang_EvalResult_getAsDouble(CXEvalResult E) {
if (!E) {
  return 0;
}
return ((ExprEvalResult *)E)->EvalData.floatVal;
4217}

4219const char *clang_EvalResult_getAsStr(CXEvalResult E) {
if (!E) {
  return nullptr;
}
return ((ExprEvalResult *)E)->EvalData.stringVal;
4224}

4226static const ExprEvalResult *evaluateExpr(Expr *expr, CXCursor C) {
Expr::EvalResult ER;
ASTContext &ctx = getCursorContext(C);
if (!expr)
  return nullptr;

expr = expr->IgnoreParens();
if (expr->isValueDependent())
  return nullptr;
if (!expr->EvaluateAsRValue(ER, ctx))
  return nullptr;

QualType rettype;
CallExpr *callExpr;
auto result = std::make_unique<ExprEvalResult>();
result->EvalType = CXEval_UnExposed;
result->IsUnsignedInt = false;

if (ER.Val.isInt()) {
  result->EvalType = CXEval_Int;

  auto &val = ER.Val.getInt();
  if (val.isUnsigned()) {
    result->IsUnsignedInt = true;
    result->EvalData.unsignedVal = val.getZExtValue();
  } else {
    result->EvalData.intVal = val.getExtValue();
  }

  return result.release();
}

if (ER.Val.isFloat()) {
  llvm::SmallVector<char, 100> Buffer;
  ER.Val.getFloat().toString(Buffer);
  std::string floatStr(Buffer.data(), Buffer.size());
  result->EvalType = CXEval_Float;
  bool ignored;
  llvm::APFloat apFloat = ER.Val.getFloat();
  apFloat.convert(llvm::APFloat::IEEEdouble(),
                  llvm::APFloat::rmNearestTiesToEven, &ignored);
  result->EvalData.floatVal = apFloat.convertToDouble();
  return result.release();
}

if (expr->getStmtClass() == Stmt::ImplicitCastExprClass) {
  const auto *I = cast<ImplicitCastExpr>(expr);
  auto *subExpr = I->getSubExprAsWritten();
  if (subExpr->getStmtClass() == Stmt::StringLiteralClass ||
      subExpr->getStmtClass() == Stmt::ObjCStringLiteralClass) {
    const StringLiteral *StrE = nullptr;
    const ObjCStringLiteral *ObjCExpr;
    ObjCExpr = dyn_cast<ObjCStringLiteral>(subExpr);

    if (ObjCExpr) {
      StrE = ObjCExpr->getString();
      result->EvalType = CXEval_ObjCStrLiteral;
    } else {
      StrE = cast<StringLiteral>(I->getSubExprAsWritten());
      result->EvalType = CXEval_StrLiteral;
    }

    std::string strRef(StrE->getString().str());
    result->EvalData.stringVal = new char[strRef.size() + 1];
    strncpy((char *)result->EvalData.stringVal, strRef.c_str(),
            strRef.size());
    result->EvalData.stringVal[strRef.size()] = '\0';
    return result.release();
  }
} else if (expr->getStmtClass() == Stmt::ObjCStringLiteralClass ||
           expr->getStmtClass() == Stmt::StringLiteralClass) {
  const StringLiteral *StrE = nullptr;
  const ObjCStringLiteral *ObjCExpr;
  ObjCExpr = dyn_cast<ObjCStringLiteral>(expr);

  if (ObjCExpr) {
    StrE = ObjCExpr->getString();
    result->EvalType = CXEval_ObjCStrLiteral;
  } else {
    StrE = cast<StringLiteral>(expr);
    result->EvalType = CXEval_StrLiteral;
  }

  std::string strRef(StrE->getString().str());
  result->EvalData.stringVal = new char[strRef.size() + 1];
  strncpy((char *)result->EvalData.stringVal, strRef.c_str(), strRef.size());
  result->EvalData.stringVal[strRef.size()] = '\0';
  return result.release();
}

if (expr->getStmtClass() == Stmt::CStyleCastExprClass) {
  CStyleCastExpr *CC = static_cast<CStyleCastExpr *>(expr);

  rettype = CC->getType();
  if (rettype.getAsString() == "CFStringRef" &&
      CC->getSubExpr()->getStmtClass() == Stmt::CallExprClass) {

    callExpr = static_cast<CallExpr *>(CC->getSubExpr());
    StringLiteral *S = getCFSTR_value(callExpr);
    if (S) {
      std::string strLiteral(S->getString().str());
      result->EvalType = CXEval_CFStr;

      result->EvalData.stringVal = new char[strLiteral.size() + 1];
      strncpy((char *)result->EvalData.stringVal, strLiteral.c_str(),
              strLiteral.size());
      result->EvalData.stringVal[strLiteral.size()] = '\0';
      return result.release();
    }
  }

} else if (expr->getStmtClass() == Stmt::CallExprClass) {
  callExpr = static_cast<CallExpr *>(expr);
  rettype = callExpr->getCallReturnType(ctx);

  if (rettype->isVectorType() || callExpr->getNumArgs() > 1)
    return nullptr;

  if (rettype->isIntegralType(ctx) || rettype->isRealFloatingType()) {
    if (callExpr->getNumArgs() == 1 &&
        !callExpr->getArg(0)->getType()->isIntegralType(ctx))
      return nullptr;
  } else if (rettype.getAsString() == "CFStringRef") {

    StringLiteral *S = getCFSTR_value(callExpr);
    if (S) {
      std::string strLiteral(S->getString().str());
      result->EvalType = CXEval_CFStr;
      result->EvalData.stringVal = new char[strLiteral.size() + 1];
      strncpy((char *)result->EvalData.stringVal, strLiteral.c_str(),
              strLiteral.size());
      result->EvalData.stringVal[strLiteral.size()] = '\0';
      return result.release();
    }
  }
} else if (expr->getStmtClass() == Stmt::DeclRefExprClass) {
  DeclRefExpr *D = static_cast<DeclRefExpr *>(expr);
  ValueDecl *V = D->getDecl();
  if (V->getKind() == Decl::Function) {
    std::string strName = V->getNameAsString();
    result->EvalType = CXEval_Other;
    result->EvalData.stringVal = new char[strName.size() + 1];
    strncpy(result->EvalData.stringVal, strName.c_str(), strName.size());
    result->EvalData.stringVal[strName.size()] = '\0';
    return result.release();
  }
}

return nullptr;
4375}

4377static const Expr *evaluateDeclExpr(const Decl *D) {
if (!D)
  return nullptr;
if (auto *Var = dyn_cast<VarDecl>(D))
  return Var->getInit();
else if (auto *Field = dyn_cast<FieldDecl>(D))
  return Field->getInClassInitializer();
return nullptr;
4385}

4387static const Expr *evaluateCompoundStmtExpr(const CompoundStmt *CS) {
assert(CS && "invalid compound statement")(static_cast <bool> (CS && "invalid compound statement"
) ? void (0) : __assert_fail ("CS && \"invalid compound statement\""
, "clang/tools/libclang/CIndex.cpp", 4388, __extension__ __PRETTY_FUNCTION__
));
for (auto *bodyIterator : CS->body()) {
  if (const auto *E = dyn_cast<Expr>(bodyIterator))
    return E;
}
return nullptr;
4394}

4396CXEvalResult clang_Cursor_Evaluate(CXCursor C) {
const Expr *E = nullptr;
if (clang_getCursorKind(C) == CXCursor_CompoundStmt)
  E = evaluateCompoundStmtExpr(cast<CompoundStmt>(getCursorStmt(C)));
else if (clang_isDeclaration(C.kind))
  E = evaluateDeclExpr(getCursorDecl(C));
else if (clang_isExpression(C.kind))
  E = getCursorExpr(C);
if (E)
  return const_cast<CXEvalResult>(
      reinterpret_cast<const void *>(evaluateExpr(const_cast<Expr *>(E), C)));
return nullptr;
4408}

4410unsigned clang_Cursor_hasAttrs(CXCursor C) {
const Decl *D = getCursorDecl(C);
if (!D) {
  return 0;
}

if (D->hasAttrs()) {
  return 1;
}

return 0;
4421}
4422unsigned clang_defaultSaveOptions(CXTranslationUnit TU) {
return CXSaveTranslationUnit_None;
4424}

4426static CXSaveError clang_saveTranslationUnit_Impl(CXTranslationUnit TU,
                                                const char *FileName,
                                                unsigned options) {
CIndexer *CXXIdx = TU->CIdx;
if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
  setThreadBackgroundPriority();

bool hadError = cxtu::getASTUnit(TU)->Save(FileName);
return hadError ? CXSaveError_Unknown : CXSaveError_None;
4435}

4437int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName,
                            unsigned options) {
LOG_FUNC_SECTIONif (clang::cxindex::LogRef Log = clang::cxindex::Logger::make
(__func__)) { *Log << TU << ' ' << FileName; }

if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return CXSaveError_InvalidTU;
}

ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
ASTUnit::ConcurrencyCheck Check(*CXXUnit);
if (!CXXUnit->hasSema())
  return CXSaveError_InvalidTU;

CXSaveError result;
auto SaveTranslationUnitImpl = [=, &result]() {
  result = clang_saveTranslationUnit_Impl(TU, FileName, options);
};

if (!CXXUnit->getDiagnostics().hasUnrecoverableErrorOccurred()) {
  SaveTranslationUnitImpl();

  if (getenv("LIBCLANG_RESOURCE_USAGE"))
    PrintLibclangResourceUsage(TU);

  return result;
}

// We have an AST that has invalid nodes due to compiler errors.
// Use a crash recovery thread for protection.

llvm::CrashRecoveryContext CRC;

if (!RunSafely(CRC, SaveTranslationUnitImpl)) {
  fprintf(stderrstderr, "libclang: crash detected during AST saving: {\n");
  fprintf(stderrstderr, "  'filename' : '%s'\n", FileName);
  fprintf(stderrstderr, "  'options' : %d,\n", options);
  fprintf(stderrstderr, "}\n");

  return CXSaveError_Unknown;

} else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
  PrintLibclangResourceUsage(TU);
}

return result;
4483}

4485void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) {
if (CTUnit) {
  // If the translation unit has been marked as unsafe to free, just discard
  // it.
  ASTUnit *Unit = cxtu::getASTUnit(CTUnit);
  if (Unit && Unit->isUnsafeToFree())
    return;

  delete cxtu::getASTUnit(CTUnit);
  delete CTUnit->StringPool;
  delete static_cast<CXDiagnosticSetImpl *>(CTUnit->Diagnostics);
  disposeOverridenCXCursorsPool(CTUnit->OverridenCursorsPool);
  delete CTUnit->CommentToXML;
  delete CTUnit;
}
4500}

4502unsigned clang_suspendTranslationUnit(CXTranslationUnit CTUnit) {
if (CTUnit) {
  ASTUnit *Unit = cxtu::getASTUnit(CTUnit);

  if (Unit && Unit->isUnsafeToFree())
    return false;

  Unit->ResetForParse();
  return true;
}

return false;
4514}

4516unsigned clang_defaultReparseOptions(CXTranslationUnit TU) {
return CXReparse_None;
4518}

4520static CXErrorCode
4521clang_reparseTranslationUnit_Impl(CXTranslationUnit TU,
                                ArrayRef<CXUnsavedFile> unsaved_files,
                                unsigned options) {
// Check arguments.
if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return CXError_InvalidArguments;
}

// Reset the associated diagnostics.
delete static_cast<CXDiagnosticSetImpl *>(TU->Diagnostics);
TU->Diagnostics = nullptr;

CIndexer *CXXIdx = TU->CIdx;
if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
  setThreadBackgroundPriority();

ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
ASTUnit::ConcurrencyCheck Check(*CXXUnit);

std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles(
    new std::vector<ASTUnit::RemappedFile>());

// Recover resources if we crash before exiting this function.
llvm::CrashRecoveryContextCleanupRegistrar<std::vector<ASTUnit::RemappedFile>>
    RemappedCleanup(RemappedFiles.get());

for (auto &UF : unsaved_files) {
  std::unique_ptr<llvm::MemoryBuffer> MB =
      llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
  RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release()));
}

if (!CXXUnit->Reparse(CXXIdx->getPCHContainerOperations(),
                      *RemappedFiles.get()))
  return CXError_Success;
if (isASTReadError(CXXUnit))
  return CXError_ASTReadError;
return CXError_Failure;
4560}

4562int clang_reparseTranslationUnit(CXTranslationUnit TU,
                               unsigned num_unsaved_files,
                               struct CXUnsavedFile *unsaved_files,
                               unsigned options) {
LOG_FUNC_SECTIONif (clang::cxindex::LogRef Log = clang::cxindex::Logger::make
(__func__)) { *Log << TU; }

if (num_unsaved_files && !unsaved_files)
  return CXError_InvalidArguments;

CXErrorCode result;
auto ReparseTranslationUnitImpl = [=, &result]() {
  result = clang_reparseTranslationUnit_Impl(
      TU, llvm::ArrayRef(unsaved_files, num_unsaved_files), options);
};

llvm::CrashRecoveryContext CRC;

if (!RunSafely(CRC, ReparseTranslationUnitImpl)) {
  fprintf(stderrstderr, "libclang: crash detected during reparsing\n");
  cxtu::getASTUnit(TU)->setUnsafeToFree(true);
  return CXError_Crashed;
} else if (getenv("LIBCLANG_RESOURCE_USAGE"))
  PrintLibclangResourceUsage(TU);

return result;
4587}

4589CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) {
if (isNotUsableTU(CTUnit)) {
  LOG_BAD_TU(CTUnit)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 CTUnit; } } while(false);
  return cxstring::createEmpty();
}

ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit);
return cxstring::createDup(CXXUnit->getOriginalSourceFileName());
4597}

4599CXCursor clang_getTranslationUnitCursor(CXTranslationUnit TU) {
if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return clang_getNullCursor();
}

ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
return MakeCXCursor(CXXUnit->getASTContext().getTranslationUnitDecl(), TU);
4607}

4609CXTargetInfo clang_getTranslationUnitTargetInfo(CXTranslationUnit CTUnit) {
if (isNotUsableTU(CTUnit)) {
  LOG_BAD_TU(CTUnit)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 CTUnit; } } while(false);
  return nullptr;
}

CXTargetInfoImpl *impl = new CXTargetInfoImpl();
impl->TranslationUnit = CTUnit;
return impl;
4618}

4620CXString clang_TargetInfo_getTriple(CXTargetInfo TargetInfo) {
if (!TargetInfo)
  return cxstring::createEmpty();

CXTranslationUnit CTUnit = TargetInfo->TranslationUnit;
assert(!isNotUsableTU(CTUnit) &&(static_cast <bool> (!isNotUsableTU(CTUnit) && "Unexpected unusable translation unit in TargetInfo"
) ? void (0) : __assert_fail ("!isNotUsableTU(CTUnit) && \"Unexpected unusable translation unit in TargetInfo\""
, "clang/tools/libclang/CIndex.cpp", 4626, __extension__ __PRETTY_FUNCTION__
))
       "Unexpected unusable translation unit in TargetInfo")(static_cast <bool> (!isNotUsableTU(CTUnit) && "Unexpected unusable translation unit in TargetInfo"
) ? void (0) : __assert_fail ("!isNotUsableTU(CTUnit) && \"Unexpected unusable translation unit in TargetInfo\""
, "clang/tools/libclang/CIndex.cpp", 4626, __extension__ __PRETTY_FUNCTION__
));

ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit);
std::string Triple =
    CXXUnit->getASTContext().getTargetInfo().getTriple().normalize();
return cxstring::createDup(Triple);
4632}

4634int clang_TargetInfo_getPointerWidth(CXTargetInfo TargetInfo) {
if (!TargetInfo)
  return -1;

CXTranslationUnit CTUnit = TargetInfo->TranslationUnit;
assert(!isNotUsableTU(CTUnit) &&(static_cast <bool> (!isNotUsableTU(CTUnit) && "Unexpected unusable translation unit in TargetInfo"
) ? void (0) : __assert_fail ("!isNotUsableTU(CTUnit) && \"Unexpected unusable translation unit in TargetInfo\""
, "clang/tools/libclang/CIndex.cpp", 4640, __extension__ __PRETTY_FUNCTION__
))
       "Unexpected unusable translation unit in TargetInfo")(static_cast <bool> (!isNotUsableTU(CTUnit) && "Unexpected unusable translation unit in TargetInfo"
) ? void (0) : __assert_fail ("!isNotUsableTU(CTUnit) && \"Unexpected unusable translation unit in TargetInfo\""
, "clang/tools/libclang/CIndex.cpp", 4640, __extension__ __PRETTY_FUNCTION__
));

ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit);
return CXXUnit->getASTContext().getTargetInfo().getMaxPointerWidth();
4644}

4646void clang_TargetInfo_dispose(CXTargetInfo TargetInfo) {
if (!TargetInfo)
  return;

delete TargetInfo;
4651}

4653//===----------------------------------------------------------------------===//
4654// CXFile Operations.
4655//===----------------------------------------------------------------------===//

4657CXString clang_getFileName(CXFile SFile) {
if (!SFile)
  return cxstring::createNull();

FileEntry *FEnt = static_cast<FileEntry *>(SFile);
return cxstring::createRef(FEnt->getName());
4663}

4665time_t clang_getFileTime(CXFile SFile) {
if (!SFile)
  return 0;

FileEntry *FEnt = static_cast<FileEntry *>(SFile);
return FEnt->getModificationTime();
4671}

4673CXFile clang_getFile(CXTranslationUnit TU, const char *file_name) {
if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return nullptr;
}

ASTUnit *CXXUnit = cxtu::getASTUnit(TU);

FileManager &FMgr = CXXUnit->getFileManager();
auto File = FMgr.getFile(file_name);
if (!File)
  return nullptr;
return const_cast<FileEntry *>(*File);
4686}

4688const char *clang_getFileContents(CXTranslationUnit TU, CXFile file,
                                size_t *size) {
if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return nullptr;
}

const SourceManager &SM = cxtu::getASTUnit(TU)->getSourceManager();
FileID fid = SM.translateFile(static_cast<FileEntry *>(file));
std::optional<llvm::MemoryBufferRef> buf = SM.getBufferOrNone(fid);
if (!buf) {
  if (size)
    *size = 0;
  return nullptr;
}
if (size)
  *size = buf->getBufferSize();
return buf->getBufferStart();
4706}

4708unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit TU, CXFile file) {
if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return 0;
}

if (!file)
  return 0;

ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
FileEntry *FEnt = static_cast<FileEntry *>(file);
return CXXUnit->getPreprocessor()
    .getHeaderSearchInfo()
    .isFileMultipleIncludeGuarded(FEnt);
4722}

4724int clang_getFileUniqueID(CXFile file, CXFileUniqueID *outID) {
if (!file || !outID)
  return 1;

FileEntry *FEnt = static_cast<FileEntry *>(file);
const llvm::sys::fs::UniqueID &ID = FEnt->getUniqueID();
outID->data[0] = ID.getDevice();
outID->data[1] = ID.getFile();
outID->data[2] = FEnt->getModificationTime();
return 0;
4734}

4736int clang_File_isEqual(CXFile file1, CXFile file2) {
if (file1 == file2)
  return true;

if (!file1 || !file2)
  return false;

FileEntry *FEnt1 = static_cast<FileEntry *>(file1);
FileEntry *FEnt2 = static_cast<FileEntry *>(file2);
return FEnt1->getUniqueID() == FEnt2->getUniqueID();
4746}

4748CXString clang_File_tryGetRealPathName(CXFile SFile) {
if (!SFile)
  return cxstring::createNull();

FileEntry *FEnt = static_cast<FileEntry *>(SFile);
return cxstring::createRef(FEnt->tryGetRealPathName());
4754}

4756//===----------------------------------------------------------------------===//
4757// CXCursor Operations.
4758//===----------------------------------------------------------------------===//

4760static const Decl *getDeclFromExpr(const Stmt *E) {
if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
  return getDeclFromExpr(CE->getSubExpr());

if (const DeclRefExpr *RefExpr = dyn_cast<DeclRefExpr>(E))
  return RefExpr->getDecl();
if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
  return ME->getMemberDecl();
if (const ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(E))
  return RE->getDecl();
if (const ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(E)) {
  if (PRE->isExplicitProperty())
    return PRE->getExplicitProperty();
  // It could be messaging both getter and setter as in:
  // ++myobj.myprop;
  // in which case prefer to associate the setter since it is less obvious
  // from inspecting the source that the setter is going to get called.
  if (PRE->isMessagingSetter())
    return PRE->getImplicitPropertySetter();
  return PRE->getImplicitPropertyGetter();
}
if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
  return getDeclFromExpr(POE->getSyntacticForm());
if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E))
  if (Expr *Src = OVE->getSourceExpr())
    return getDeclFromExpr(Src);

if (const CallExpr *CE = dyn_cast<CallExpr>(E))
  return getDeclFromExpr(CE->getCallee());
if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E))
  if (!CE->isElidable())
    return CE->getConstructor();
if (const CXXInheritedCtorInitExpr *CE =
        dyn_cast<CXXInheritedCtorInitExpr>(E))
  return CE->getConstructor();
if (const ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E))
  return OME->getMethodDecl();

if (const ObjCProtocolExpr *PE = dyn_cast<ObjCProtocolExpr>(E))
  return PE->getProtocol();
if (const SubstNonTypeTemplateParmPackExpr *NTTP =
        dyn_cast<SubstNonTypeTemplateParmPackExpr>(E))
  return NTTP->getParameterPack();
if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
  if (isa<NonTypeTemplateParmDecl>(SizeOfPack->getPack()) ||
      isa<ParmVarDecl>(SizeOfPack->getPack()))
    return SizeOfPack->getPack();

return nullptr;
4809}

4811static SourceLocation getLocationFromExpr(const Expr *E) {
if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
  return getLocationFromExpr(CE->getSubExpr());

if (const ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E))
  return /*FIXME:*/ Msg->getLeftLoc();
if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
  return DRE->getLocation();
if (const MemberExpr *Member = dyn_cast<MemberExpr>(E))
  return Member->getMemberLoc();
if (const ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E))
  return Ivar->getLocation();
if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
  return SizeOfPack->getPackLoc();
if (const ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E))
  return PropRef->getLocation();

return E->getBeginLoc();
4829}

4831extern "C" {

4833unsigned clang_visitChildren(CXCursor parent, CXCursorVisitor visitor,
                           CXClientData client_data) {
CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data,
                        /*VisitPreprocessorLast=*/false);
return CursorVis.VisitChildren(parent);
4838}

4840#ifndef __has_feature
4841#define0 __has_feature(x)0 0
4842#endif
4843#if __has_feature(blocks)0
4844typedef enum CXChildVisitResult (^CXCursorVisitorBlock)(CXCursor cursor,
                                                      CXCursor parent);

4847static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
                                            CXClientData client_data) {
CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
return block(cursor, parent);
4851}
4852#else
4853// If we are compiled with a compiler that doesn't have native blocks support,
4854// define and call the block manually, so the
4855typedef struct _CXChildVisitResult {
void *isa;
int flags;
int reserved;
enum CXChildVisitResult (*invoke)(struct _CXChildVisitResult *, CXCursor,
                                  CXCursor);
4861} * CXCursorVisitorBlock;

4863static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
                                            CXClientData client_data) {
CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
return block->invoke(block, cursor, parent);
4867}
4868#endif

4870unsigned clang_visitChildrenWithBlock(CXCursor parent,
                                    CXCursorVisitorBlock block) {
return clang_visitChildren(parent, visitWithBlock, block);
4873}

4875static CXString getDeclSpelling(const Decl *D) {
if (!D)
  return cxstring::createEmpty();

const NamedDecl *ND = dyn_cast<NamedDecl>(D);
if (!ND) {
  if (const ObjCPropertyImplDecl *PropImpl =
          dyn_cast<ObjCPropertyImplDecl>(D))
    if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl())
      return cxstring::createDup(Property->getIdentifier()->getName());

  if (const ImportDecl *ImportD = dyn_cast<ImportDecl>(D))
    if (Module *Mod = ImportD->getImportedModule())
      return cxstring::createDup(Mod->getFullModuleName());

  return cxstring::createEmpty();
}

if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
  return cxstring::createDup(OMD->getSelector().getAsString());

if (const ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND))
  // No, this isn't the same as the code below. getIdentifier() is non-virtual
  // and returns different names. NamedDecl returns the class name and
  // ObjCCategoryImplDecl returns the category name.
  return cxstring::createRef(CIMP->getIdentifier()->getNameStart());

if (isa<UsingDirectiveDecl>(D))
  return cxstring::createEmpty();

SmallString<1024> S;
llvm::raw_svector_ostream os(S);
ND->printName(os);

return cxstring::createDup(os.str());
4910}

4912CXString clang_getCursorSpelling(CXCursor C) {
if (clang_isTranslationUnit(C.kind))
  return clang_getTranslationUnitSpelling(getCursorTU(C));

if (clang_isReference(C.kind)) {
  switch (C.kind) {
  case CXCursor_ObjCSuperClassRef: {
    const ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first;
    return cxstring::createRef(Super->getIdentifier()->getNameStart());
  }
  case CXCursor_ObjCClassRef: {
    const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first;
    return cxstring::createRef(Class->getIdentifier()->getNameStart());
  }
  case CXCursor_ObjCProtocolRef: {
    const ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first;
    assert(OID && "getCursorSpelling(): Missing protocol decl")(static_cast <bool> (OID && "getCursorSpelling(): Missing protocol decl"
) ? void (0) : __assert_fail ("OID && \"getCursorSpelling(): Missing protocol decl\""
, "clang/tools/libclang/CIndex.cpp", 4928, __extension__ __PRETTY_FUNCTION__
));
    return cxstring::createRef(OID->getIdentifier()->getNameStart());
  }
  case CXCursor_CXXBaseSpecifier: {
    const CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C);
    return cxstring::createDup(B->getType().getAsString());
  }
  case CXCursor_TypeRef: {
    const TypeDecl *Type = getCursorTypeRef(C).first;
    assert(Type && "Missing type decl")(static_cast <bool> (Type && "Missing type decl"
) ? void (0) : __assert_fail ("Type && \"Missing type decl\""
, "clang/tools/libclang/CIndex.cpp", 4937, __extension__ __PRETTY_FUNCTION__
));

    return cxstring::createDup(
        getCursorContext(C).getTypeDeclType(Type).getAsString());
  }
  case CXCursor_TemplateRef: {
    const TemplateDecl *Template = getCursorTemplateRef(C).first;
    assert(Template && "Missing template decl")(static_cast <bool> (Template && "Missing template decl"
) ? void (0) : __assert_fail ("Template && \"Missing template decl\""
, "clang/tools/libclang/CIndex.cpp", 4944, __extension__ __PRETTY_FUNCTION__
));

    return cxstring::createDup(Template->getNameAsString());
  }

  case CXCursor_NamespaceRef: {
    const NamedDecl *NS = getCursorNamespaceRef(C).first;
    assert(NS && "Missing namespace decl")(static_cast <bool> (NS && "Missing namespace decl"
) ? void (0) : __assert_fail ("NS && \"Missing namespace decl\""
, "clang/tools/libclang/CIndex.cpp", 4951, __extension__ __PRETTY_FUNCTION__
));

    return cxstring::createDup(NS->getNameAsString());
  }

  case CXCursor_MemberRef: {
    const FieldDecl *Field = getCursorMemberRef(C).first;
    assert(Field && "Missing member decl")(static_cast <bool> (Field && "Missing member decl"
) ? void (0) : __assert_fail ("Field && \"Missing member decl\""
, "clang/tools/libclang/CIndex.cpp", 4958, __extension__ __PRETTY_FUNCTION__
));

    return cxstring::createDup(Field->getNameAsString());
  }

  case CXCursor_LabelRef: {
    const LabelStmt *Label = getCursorLabelRef(C).first;
    assert(Label && "Missing label")(static_cast <bool> (Label && "Missing label") ?
 void (0) : __assert_fail ("Label && \"Missing label\""
, "clang/tools/libclang/CIndex.cpp", 4965, __extension__ __PRETTY_FUNCTION__
));

    return cxstring::createRef(Label->getName());
  }

  case CXCursor_OverloadedDeclRef: {
    OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first;
    if (const Decl *D = Storage.dyn_cast<const Decl *>()) {
      if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
        return cxstring::createDup(ND->getNameAsString());
      return cxstring::createEmpty();
    }
    if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
      return cxstring::createDup(E->getName().getAsString());
    OverloadedTemplateStorage *Ovl =
        Storage.get<OverloadedTemplateStorage *>();
    if (Ovl->size() == 0)
      return cxstring::createEmpty();
    return cxstring::createDup((*Ovl->begin())->getNameAsString());
  }

  case CXCursor_VariableRef: {
    const VarDecl *Var = getCursorVariableRef(C).first;
    assert(Var && "Missing variable decl")(static_cast <bool> (Var && "Missing variable decl"
) ? void (0) : __assert_fail ("Var && \"Missing variable decl\""
, "clang/tools/libclang/CIndex.cpp", 4988, __extension__ __PRETTY_FUNCTION__
));

    return cxstring::createDup(Var->getNameAsString());
  }

  default:
    return cxstring::createRef("<not implemented>");
  }
}

if (clang_isExpression(C.kind)) {
  const Expr *E = getCursorExpr(C);

  if (C.kind == CXCursor_ObjCStringLiteral ||
      C.kind == CXCursor_StringLiteral) {
    const StringLiteral *SLit;
    if (const ObjCStringLiteral *OSL = dyn_cast<ObjCStringLiteral>(E)) {
      SLit = OSL->getString();
    } else {
      SLit = cast<StringLiteral>(E);
    }
    SmallString<256> Buf;
    llvm::raw_svector_ostream OS(Buf);
    SLit->outputString(OS);
    return cxstring::createDup(OS.str());
  }

  const Decl *D = getDeclFromExpr(getCursorExpr(C));
  if (D)
    return getDeclSpelling(D);
  return cxstring::createEmpty();
}

if (clang_isStatement(C.kind)) {
  const Stmt *S = getCursorStmt(C);
  if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
    return cxstring::createRef(Label->getName());

  return cxstring::createEmpty();
}

if (C.kind == CXCursor_MacroExpansion)
  return cxstring::createRef(
      getCursorMacroExpansion(C).getName()->getNameStart());

if (C.kind == CXCursor_MacroDefinition)
  return cxstring::createRef(
      getCursorMacroDefinition(C)->getName()->getNameStart());

if (C.kind == CXCursor_InclusionDirective)
  return cxstring::createDup(getCursorInclusionDirective(C)->getFileName());

if (clang_isDeclaration(C.kind))
  return getDeclSpelling(getCursorDecl(C));

if (C.kind == CXCursor_AnnotateAttr) {
  const AnnotateAttr *AA = cast<AnnotateAttr>(cxcursor::getCursorAttr(C));
  return cxstring::createDup(AA->getAnnotation());
}

if (C.kind == CXCursor_AsmLabelAttr) {
  const AsmLabelAttr *AA = cast<AsmLabelAttr>(cxcursor::getCursorAttr(C));
  return cxstring::createDup(AA->getLabel());
}

if (C.kind == CXCursor_PackedAttr) {
  return cxstring::createRef("packed");
}

if (C.kind == CXCursor_VisibilityAttr) {
  const VisibilityAttr *AA = cast<VisibilityAttr>(cxcursor::getCursorAttr(C));
  switch (AA->getVisibility()) {
  case VisibilityAttr::VisibilityType::Default:
    return cxstring::createRef("default");
  case VisibilityAttr::VisibilityType::Hidden:
    return cxstring::createRef("hidden");
  case VisibilityAttr::VisibilityType::Protected:
    return cxstring::createRef("protected");
  }
  llvm_unreachable("unknown visibility type")::llvm::llvm_unreachable_internal("unknown visibility type", "clang/tools/libclang/CIndex.cpp"
, 5067);
}

return cxstring::createEmpty();
5071}

5073CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor C, unsigned pieceIndex,
                                              unsigned options) {
if (clang_Cursor_isNull(C))
  return clang_getNullRange();

ASTContext &Ctx = getCursorContext(C);

if (clang_isStatement(C.kind)) {
  const Stmt *S = getCursorStmt(C);
  if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) {
    if (pieceIndex > 0)
      return clang_getNullRange();
    return cxloc::translateSourceRange(Ctx, Label->getIdentLoc());
  }

  return clang_getNullRange();
}

if (C.kind == CXCursor_ObjCMessageExpr) {
  if (const ObjCMessageExpr *ME =
          dyn_cast_or_null<ObjCMessageExpr>(getCursorExpr(C))) {
    if (pieceIndex >= ME->getNumSelectorLocs())
      return clang_getNullRange();
    return cxloc::translateSourceRange(Ctx, ME->getSelectorLoc(pieceIndex));
  }
}

if (C.kind == CXCursor_ObjCInstanceMethodDecl ||
    C.kind == CXCursor_ObjCClassMethodDecl) {
  if (const ObjCMethodDecl *MD =
          dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(C))) {
    if (pieceIndex >= MD->getNumSelectorLocs())
      return clang_getNullRange();
    return cxloc::translateSourceRange(Ctx, MD->getSelectorLoc(pieceIndex));
  }
}

if (C.kind == CXCursor_ObjCCategoryDecl ||
    C.kind == CXCursor_ObjCCategoryImplDecl) {
  if (pieceIndex > 0)
    return clang_getNullRange();
  if (const ObjCCategoryDecl *CD =
          dyn_cast_or_null<ObjCCategoryDecl>(getCursorDecl(C)))
    return cxloc::translateSourceRange(Ctx, CD->getCategoryNameLoc());
  if (const ObjCCategoryImplDecl *CID =
          dyn_cast_or_null<ObjCCategoryImplDecl>(getCursorDecl(C)))
    return cxloc::translateSourceRange(Ctx, CID->getCategoryNameLoc());
}

if (C.kind == CXCursor_ModuleImportDecl) {
  if (pieceIndex > 0)
    return clang_getNullRange();
  if (const ImportDecl *ImportD =
          dyn_cast_or_null<ImportDecl>(getCursorDecl(C))) {
    ArrayRef<SourceLocation> Locs = ImportD->getIdentifierLocs();
    if (!Locs.empty())
      return cxloc::translateSourceRange(
          Ctx, SourceRange(Locs.front(), Locs.back()));
  }
  return clang_getNullRange();
}

if (C.kind == CXCursor_CXXMethod || C.kind == CXCursor_Destructor ||
    C.kind == CXCursor_ConversionFunction ||
    C.kind == CXCursor_FunctionDecl) {
  if (pieceIndex > 0)
    return clang_getNullRange();
  if (const FunctionDecl *FD =
          dyn_cast_or_null<FunctionDecl>(getCursorDecl(C))) {
    DeclarationNameInfo FunctionName = FD->getNameInfo();
    return cxloc::translateSourceRange(Ctx, FunctionName.getSourceRange());
  }
  return clang_getNullRange();
}

// FIXME: A CXCursor_InclusionDirective should give the location of the
// filename, but we don't keep track of this.

// FIXME: A CXCursor_AnnotateAttr should give the location of the annotation
// but we don't keep track of this.

// FIXME: A CXCursor_AsmLabelAttr should give the location of the label
// but we don't keep track of this.

// Default handling, give the location of the cursor.

if (pieceIndex > 0)
  return clang_getNullRange();

CXSourceLocation CXLoc = clang_getCursorLocation(C);
SourceLocation Loc = cxloc::translateSourceLocation(CXLoc);
return cxloc::translateSourceRange(Ctx, Loc);
5165}

5167CXString clang_Cursor_getMangling(CXCursor C) {
if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind))
  return cxstring::createEmpty();

// Mangling only works for functions and variables.
const Decl *D = getCursorDecl(C);
if (!D || !(isa<FunctionDecl>(D) || isa<VarDecl>(D)))
  return cxstring::createEmpty();

ASTContext &Ctx = D->getASTContext();
ASTNameGenerator ASTNameGen(Ctx);
return cxstring::createDup(ASTNameGen.getName(D));
5179}

5181CXStringSet *clang_Cursor_getCXXManglings(CXCursor C) {
if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind))
  return nullptr;

const Decl *D = getCursorDecl(C);
if (!(isa<CXXRecordDecl>(D) || isa<CXXMethodDecl>(D)))
  return nullptr;

ASTContext &Ctx = D->getASTContext();
ASTNameGenerator ASTNameGen(Ctx);
std::vector<std::string> Manglings = ASTNameGen.getAllManglings(D);
return cxstring::createSet(Manglings);
5193}

5195CXStringSet *clang_Cursor_getObjCManglings(CXCursor C) {
if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind))
  return nullptr;

const Decl *D = getCursorDecl(C);
if (!(isa<ObjCInterfaceDecl>(D) || isa<ObjCImplementationDecl>(D)))
  return nullptr;

ASTContext &Ctx = D->getASTContext();
ASTNameGenerator ASTNameGen(Ctx);
std::vector<std::string> Manglings = ASTNameGen.getAllManglings(D);
return cxstring::createSet(Manglings);
5207}

5209CXPrintingPolicy clang_getCursorPrintingPolicy(CXCursor C) {
if (clang_Cursor_isNull(C))
  return nullptr;
return new PrintingPolicy(getCursorContext(C).getPrintingPolicy());
5213}

5215void clang_PrintingPolicy_dispose(CXPrintingPolicy Policy) {
if (Policy)
  delete static_cast<PrintingPolicy *>(Policy);
5218}

5220unsigned
5221clang_PrintingPolicy_getProperty(CXPrintingPolicy Policy,
                               enum CXPrintingPolicyProperty Property) {
if (!Policy)
  return 0;

PrintingPolicy *P = static_cast<PrintingPolicy *>(Policy);
switch (Property) {
case CXPrintingPolicy_Indentation:
  return P->Indentation;
case CXPrintingPolicy_SuppressSpecifiers:
  return P->SuppressSpecifiers;
case CXPrintingPolicy_SuppressTagKeyword:
  return P->SuppressTagKeyword;
case CXPrintingPolicy_IncludeTagDefinition:
  return P->IncludeTagDefinition;
case CXPrintingPolicy_SuppressScope:
  return P->SuppressScope;
case CXPrintingPolicy_SuppressUnwrittenScope:
  return P->SuppressUnwrittenScope;
case CXPrintingPolicy_SuppressInitializers:
  return P->SuppressInitializers;
case CXPrintingPolicy_ConstantArraySizeAsWritten:
  return P->ConstantArraySizeAsWritten;
case CXPrintingPolicy_AnonymousTagLocations:
  return P->AnonymousTagLocations;
case CXPrintingPolicy_SuppressStrongLifetime:
  return P->SuppressStrongLifetime;
case CXPrintingPolicy_SuppressLifetimeQualifiers:
  return P->SuppressLifetimeQualifiers;
case CXPrintingPolicy_SuppressTemplateArgsInCXXConstructors:
  return P->SuppressTemplateArgsInCXXConstructors;
case CXPrintingPolicy_Bool:
  return P->Bool;
case CXPrintingPolicy_Restrict:
  return P->Restrict;
case CXPrintingPolicy_Alignof:
  return P->Alignof;
case CXPrintingPolicy_UnderscoreAlignof:
  return P->UnderscoreAlignof;
case CXPrintingPolicy_UseVoidForZeroParams:
  return P->UseVoidForZeroParams;
case CXPrintingPolicy_TerseOutput:
  return P->TerseOutput;
case CXPrintingPolicy_PolishForDeclaration:
  return P->PolishForDeclaration;
case CXPrintingPolicy_Half:
  return P->Half;
case CXPrintingPolicy_MSWChar:
  return P->MSWChar;
case CXPrintingPolicy_IncludeNewlines:
  return P->IncludeNewlines;
case CXPrintingPolicy_MSVCFormatting:
  return P->MSVCFormatting;
case CXPrintingPolicy_ConstantsAsWritten:
  return P->ConstantsAsWritten;
case CXPrintingPolicy_SuppressImplicitBase:
  return P->SuppressImplicitBase;
case CXPrintingPolicy_FullyQualifiedName:
  return P->FullyQualifiedName;
}

assert(false && "Invalid CXPrintingPolicyProperty")(static_cast <bool> (false && "Invalid CXPrintingPolicyProperty"
) ? void (0) : __assert_fail ("false && \"Invalid CXPrintingPolicyProperty\""
, "clang/tools/libclang/CIndex.cpp", 5282, __extension__ __PRETTY_FUNCTION__
));
return 0;
5284}

5286void clang_PrintingPolicy_setProperty(CXPrintingPolicy Policy,
                                    enum CXPrintingPolicyProperty Property,
                                    unsigned Value) {
if (!Policy)
  return;

PrintingPolicy *P = static_cast<PrintingPolicy *>(Policy);
switch (Property) {
case CXPrintingPolicy_Indentation:
  P->Indentation = Value;
  return;
case CXPrintingPolicy_SuppressSpecifiers:
  P->SuppressSpecifiers = Value;
  return;
case CXPrintingPolicy_SuppressTagKeyword:
  P->SuppressTagKeyword = Value;
  return;
case CXPrintingPolicy_IncludeTagDefinition:
  P->IncludeTagDefinition = Value;
  return;
case CXPrintingPolicy_SuppressScope:
  P->SuppressScope = Value;
  return;
case CXPrintingPolicy_SuppressUnwrittenScope:
  P->SuppressUnwrittenScope = Value;
  return;
case CXPrintingPolicy_SuppressInitializers:
  P->SuppressInitializers = Value;
  return;
case CXPrintingPolicy_ConstantArraySizeAsWritten:
  P->ConstantArraySizeAsWritten = Value;
  return;
case CXPrintingPolicy_AnonymousTagLocations:
  P->AnonymousTagLocations = Value;
  return;
case CXPrintingPolicy_SuppressStrongLifetime:
  P->SuppressStrongLifetime = Value;
  return;
case CXPrintingPolicy_SuppressLifetimeQualifiers:
  P->SuppressLifetimeQualifiers = Value;
  return;
case CXPrintingPolicy_SuppressTemplateArgsInCXXConstructors:
  P->SuppressTemplateArgsInCXXConstructors = Value;
  return;
case CXPrintingPolicy_Bool:
  P->Bool = Value;
  return;
case CXPrintingPolicy_Restrict:
  P->Restrict = Value;
  return;
case CXPrintingPolicy_Alignof:
  P->Alignof = Value;
  return;
case CXPrintingPolicy_UnderscoreAlignof:
  P->UnderscoreAlignof = Value;
  return;
case CXPrintingPolicy_UseVoidForZeroParams:
  P->UseVoidForZeroParams = Value;
  return;
case CXPrintingPolicy_TerseOutput:
  P->TerseOutput = Value;
  return;
case CXPrintingPolicy_PolishForDeclaration:
  P->PolishForDeclaration = Value;
  return;
case CXPrintingPolicy_Half:
  P->Half = Value;
  return;
case CXPrintingPolicy_MSWChar:
  P->MSWChar = Value;
  return;
case CXPrintingPolicy_IncludeNewlines:
  P->IncludeNewlines = Value;
  return;
case CXPrintingPolicy_MSVCFormatting:
  P->MSVCFormatting = Value;
  return;
case CXPrintingPolicy_ConstantsAsWritten:
  P->ConstantsAsWritten = Value;
  return;
case CXPrintingPolicy_SuppressImplicitBase:
  P->SuppressImplicitBase = Value;
  return;
case CXPrintingPolicy_FullyQualifiedName:
  P->FullyQualifiedName = Value;
  return;
}

assert(false && "Invalid CXPrintingPolicyProperty")(static_cast <bool> (false && "Invalid CXPrintingPolicyProperty"
) ? void (0) : __assert_fail ("false && \"Invalid CXPrintingPolicyProperty\""
, "clang/tools/libclang/CIndex.cpp", 5374, __extension__ __PRETTY_FUNCTION__
));
5375}

5377CXString clang_getCursorPrettyPrinted(CXCursor C, CXPrintingPolicy cxPolicy) {
if (clang_Cursor_isNull(C))
  return cxstring::createEmpty();

if (clang_isDeclaration(C.kind)) {
  const Decl *D = getCursorDecl(C);
  if (!D)
    return cxstring::createEmpty();

  SmallString<128> Str;
  llvm::raw_svector_ostream OS(Str);
  PrintingPolicy *UserPolicy = static_cast<PrintingPolicy *>(cxPolicy);
  D->print(OS, UserPolicy ? *UserPolicy
                          : getCursorContext(C).getPrintingPolicy());

  return cxstring::createDup(OS.str());
}

return cxstring::createEmpty();
5396}

5398CXString clang_getCursorDisplayName(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return clang_getCursorSpelling(C);

const Decl *D = getCursorDecl(C);
if (!D)
  return cxstring::createEmpty();

PrintingPolicy Policy = getCursorContext(C).getPrintingPolicy();
if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
  D = FunTmpl->getTemplatedDecl();

if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
  SmallString<64> Str;
  llvm::raw_svector_ostream OS(Str);
  OS << *Function;
  if (Function->getPrimaryTemplate())
    OS << "<>";
  OS << "(";
  for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) {
    if (I)
      OS << ", ";
    OS << Function->getParamDecl(I)->getType().getAsString(Policy);
  }

  if (Function->isVariadic()) {
    if (Function->getNumParams())
      OS << ", ";
    OS << "...";
  }
  OS << ")";
  return cxstring::createDup(OS.str());
}

if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) {
  SmallString<64> Str;
  llvm::raw_svector_ostream OS(Str);
  OS << *ClassTemplate;
  OS << "<";
  TemplateParameterList *Params = ClassTemplate->getTemplateParameters();
  for (unsigned I = 0, N = Params->size(); I != N; ++I) {
    if (I)
      OS << ", ";

    NamedDecl *Param = Params->getParam(I);
    if (Param->getIdentifier()) {
      OS << Param->getIdentifier()->getName();
      continue;
    }

    // There is no parameter name, which makes this tricky. Try to come up
    // with something useful that isn't too long.
    if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
      if (const auto *TC = TTP->getTypeConstraint()) {
        TC->getConceptNameInfo().printName(OS, Policy);
        if (TC->hasExplicitTemplateArgs())
          OS << "<...>";
      } else
        OS << (TTP->wasDeclaredWithTypename() ? "typename" : "class");
    else if (NonTypeTemplateParmDecl *NTTP =
                 dyn_cast<NonTypeTemplateParmDecl>(Param))
      OS << NTTP->getType().getAsString(Policy);
    else
      OS << "template<...> class";
  }

  OS << ">";
  return cxstring::createDup(OS.str());
}

if (const ClassTemplateSpecializationDecl *ClassSpec =
        dyn_cast<ClassTemplateSpecializationDecl>(D)) {
  // If the type was explicitly written, use that.
  if (TypeSourceInfo *TSInfo = ClassSpec->getTypeAsWritten())
    return cxstring::createDup(TSInfo->getType().getAsString(Policy));

  SmallString<128> Str;
  llvm::raw_svector_ostream OS(Str);
  OS << *ClassSpec;
  printTemplateArgumentList(
      OS, ClassSpec->getTemplateArgs().asArray(), Policy,
      ClassSpec->getSpecializedTemplate()->getTemplateParameters());
  return cxstring::createDup(OS.str());
}

return clang_getCursorSpelling(C);
5484}

5486CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
switch (Kind) {
case CXCursor_FunctionDecl:
  return cxstring::createRef("FunctionDecl");
case CXCursor_TypedefDecl:
  return cxstring::createRef("TypedefDecl");
case CXCursor_EnumDecl:
  return cxstring::createRef("EnumDecl");
case CXCursor_EnumConstantDecl:
  return cxstring::createRef("EnumConstantDecl");
case CXCursor_StructDecl:
  return cxstring::createRef("StructDecl");
case CXCursor_UnionDecl:
  return cxstring::createRef("UnionDecl");
case CXCursor_ClassDecl:
  return cxstring::createRef("ClassDecl");
case CXCursor_FieldDecl:
  return cxstring::createRef("FieldDecl");
case CXCursor_VarDecl:
  return cxstring::createRef("VarDecl");
case CXCursor_ParmDecl:
  return cxstring::createRef("ParmDecl");
case CXCursor_ObjCInterfaceDecl:
  return cxstring::createRef("ObjCInterfaceDecl");
case CXCursor_ObjCCategoryDecl:
  return cxstring::createRef("ObjCCategoryDecl");
case CXCursor_ObjCProtocolDecl:
  return cxstring::createRef("ObjCProtocolDecl");
case CXCursor_ObjCPropertyDecl:
  return cxstring::createRef("ObjCPropertyDecl");
case CXCursor_ObjCIvarDecl:
  return cxstring::createRef("ObjCIvarDecl");
case CXCursor_ObjCInstanceMethodDecl:
  return cxstring::createRef("ObjCInstanceMethodDecl");
case CXCursor_ObjCClassMethodDecl:
  return cxstring::createRef("ObjCClassMethodDecl");
case CXCursor_ObjCImplementationDecl:
  return cxstring::createRef("ObjCImplementationDecl");
case CXCursor_ObjCCategoryImplDecl:
  return cxstring::createRef("ObjCCategoryImplDecl");
case CXCursor_CXXMethod:
  return cxstring::createRef("CXXMethod");
case CXCursor_UnexposedDecl:
  return cxstring::createRef("UnexposedDecl");
case CXCursor_ObjCSuperClassRef:
  return cxstring::createRef("ObjCSuperClassRef");
case CXCursor_ObjCProtocolRef:
  return cxstring::createRef("ObjCProtocolRef");
case CXCursor_ObjCClassRef:
  return cxstring::createRef("ObjCClassRef");
case CXCursor_TypeRef:
  return cxstring::createRef("TypeRef");
case CXCursor_TemplateRef:
  return cxstring::createRef("TemplateRef");
case CXCursor_NamespaceRef:
  return cxstring::createRef("NamespaceRef");
case CXCursor_MemberRef:
  return cxstring::createRef("MemberRef");
case CXCursor_LabelRef:
  return cxstring::createRef("LabelRef");
case CXCursor_OverloadedDeclRef:
  return cxstring::createRef("OverloadedDeclRef");
case CXCursor_VariableRef:
  return cxstring::createRef("VariableRef");
case CXCursor_IntegerLiteral:
  return cxstring::createRef("IntegerLiteral");
case CXCursor_FixedPointLiteral:
  return cxstring::createRef("FixedPointLiteral");
case CXCursor_FloatingLiteral:
  return cxstring::createRef("FloatingLiteral");
case CXCursor_ImaginaryLiteral:
  return cxstring::createRef("ImaginaryLiteral");
case CXCursor_StringLiteral:
  return cxstring::createRef("StringLiteral");
case CXCursor_CharacterLiteral:
  return cxstring::createRef("CharacterLiteral");
case CXCursor_ParenExpr:
  return cxstring::createRef("ParenExpr");
case CXCursor_UnaryOperator:
  return cxstring::createRef("UnaryOperator");
case CXCursor_ArraySubscriptExpr:
  return cxstring::createRef("ArraySubscriptExpr");
case CXCursor_OMPArraySectionExpr:
  return cxstring::createRef("OMPArraySectionExpr");
case CXCursor_OMPArrayShapingExpr:
  return cxstring::createRef("OMPArrayShapingExpr");
case CXCursor_OMPIteratorExpr:
  return cxstring::createRef("OMPIteratorExpr");
case CXCursor_BinaryOperator:
  return cxstring::createRef("BinaryOperator");
case CXCursor_CompoundAssignOperator:
  return cxstring::createRef("CompoundAssignOperator");
case CXCursor_ConditionalOperator:
  return cxstring::createRef("ConditionalOperator");
case CXCursor_CStyleCastExpr:
  return cxstring::createRef("CStyleCastExpr");
case CXCursor_CompoundLiteralExpr:
  return cxstring::createRef("CompoundLiteralExpr");
case CXCursor_InitListExpr:
  return cxstring::createRef("InitListExpr");
case CXCursor_AddrLabelExpr:
  return cxstring::createRef("AddrLabelExpr");
case CXCursor_StmtExpr:
  return cxstring::createRef("StmtExpr");
case CXCursor_GenericSelectionExpr:
  return cxstring::createRef("GenericSelectionExpr");
case CXCursor_GNUNullExpr:
  return cxstring::createRef("GNUNullExpr");
case CXCursor_CXXStaticCastExpr:
  return cxstring::createRef("CXXStaticCastExpr");
case CXCursor_CXXDynamicCastExpr:
  return cxstring::createRef("CXXDynamicCastExpr");
case CXCursor_CXXReinterpretCastExpr:
  return cxstring::createRef("CXXReinterpretCastExpr");
case CXCursor_CXXConstCastExpr:
  return cxstring::createRef("CXXConstCastExpr");
case CXCursor_CXXFunctionalCastExpr:
  return cxstring::createRef("CXXFunctionalCastExpr");
case CXCursor_CXXAddrspaceCastExpr:
  return cxstring::createRef("CXXAddrspaceCastExpr");
case CXCursor_CXXTypeidExpr:
  return cxstring::createRef("CXXTypeidExpr");
case CXCursor_CXXBoolLiteralExpr:
  return cxstring::createRef("CXXBoolLiteralExpr");
case CXCursor_CXXNullPtrLiteralExpr:
  return cxstring::createRef("CXXNullPtrLiteralExpr");
case CXCursor_CXXThisExpr:
  return cxstring::createRef("CXXThisExpr");
case CXCursor_CXXThrowExpr:
  return cxstring::createRef("CXXThrowExpr");
case CXCursor_CXXNewExpr:
  return cxstring::createRef("CXXNewExpr");
case CXCursor_CXXDeleteExpr:
  return cxstring::createRef("CXXDeleteExpr");
case CXCursor_UnaryExpr:
  return cxstring::createRef("UnaryExpr");
case CXCursor_ObjCStringLiteral:
  return cxstring::createRef("ObjCStringLiteral");
case CXCursor_ObjCBoolLiteralExpr:
  return cxstring::createRef("ObjCBoolLiteralExpr");
case CXCursor_ObjCAvailabilityCheckExpr:
  return cxstring::createRef("ObjCAvailabilityCheckExpr");
case CXCursor_ObjCSelfExpr:
  return cxstring::createRef("ObjCSelfExpr");
case CXCursor_ObjCEncodeExpr:
  return cxstring::createRef("ObjCEncodeExpr");
case CXCursor_ObjCSelectorExpr:
  return cxstring::createRef("ObjCSelectorExpr");
case CXCursor_ObjCProtocolExpr:
  return cxstring::createRef("ObjCProtocolExpr");
case CXCursor_ObjCBridgedCastExpr:
  return cxstring::createRef("ObjCBridgedCastExpr");
case CXCursor_BlockExpr:
  return cxstring::createRef("BlockExpr");
case CXCursor_PackExpansionExpr:
  return cxstring::createRef("PackExpansionExpr");
case CXCursor_SizeOfPackExpr:
  return cxstring::createRef("SizeOfPackExpr");
case CXCursor_LambdaExpr:
  return cxstring::createRef("LambdaExpr");
case CXCursor_UnexposedExpr:
  return cxstring::createRef("UnexposedExpr");
case CXCursor_DeclRefExpr:
  return cxstring::createRef("DeclRefExpr");
case CXCursor_MemberRefExpr:
  return cxstring::createRef("MemberRefExpr");
case CXCursor_CallExpr:
  return cxstring::createRef("CallExpr");
case CXCursor_ObjCMessageExpr:
  return cxstring::createRef("ObjCMessageExpr");
case CXCursor_BuiltinBitCastExpr:
  return cxstring::createRef("BuiltinBitCastExpr");
case CXCursor_ConceptSpecializationExpr:
  return cxstring::createRef("ConceptSpecializationExpr");
case CXCursor_RequiresExpr:
  return cxstring::createRef("RequiresExpr");
case CXCursor_CXXParenListInitExpr:
  return cxstring::createRef("CXXParenListInitExpr");
case CXCursor_UnexposedStmt:
  return cxstring::createRef("UnexposedStmt");
case CXCursor_DeclStmt:
  return cxstring::createRef("DeclStmt");
case CXCursor_LabelStmt:
  return cxstring::createRef("LabelStmt");
case CXCursor_CompoundStmt:
  return cxstring::createRef("CompoundStmt");
case CXCursor_CaseStmt:
  return cxstring::createRef("CaseStmt");
case CXCursor_DefaultStmt:
  return cxstring::createRef("DefaultStmt");
case CXCursor_IfStmt:
  return cxstring::createRef("IfStmt");
case CXCursor_SwitchStmt:
  return cxstring::createRef("SwitchStmt");
case CXCursor_WhileStmt:
  return cxstring::createRef("WhileStmt");
case CXCursor_DoStmt:
  return cxstring::createRef("DoStmt");
case CXCursor_ForStmt:
  return cxstring::createRef("ForStmt");
case CXCursor_GotoStmt:
  return cxstring::createRef("GotoStmt");
case CXCursor_IndirectGotoStmt:
  return cxstring::createRef("IndirectGotoStmt");
case CXCursor_ContinueStmt:
  return cxstring::createRef("ContinueStmt");
case CXCursor_BreakStmt:
  return cxstring::createRef("BreakStmt");
case CXCursor_ReturnStmt:
  return cxstring::createRef("ReturnStmt");
case CXCursor_GCCAsmStmt:
  return cxstring::createRef("GCCAsmStmt");
case CXCursor_MSAsmStmt:
  return cxstring::createRef("MSAsmStmt");
case CXCursor_ObjCAtTryStmt:
  return cxstring::createRef("ObjCAtTryStmt");
case CXCursor_ObjCAtCatchStmt:
  return cxstring::createRef("ObjCAtCatchStmt");
case CXCursor_ObjCAtFinallyStmt:
  return cxstring::createRef("ObjCAtFinallyStmt");
case CXCursor_ObjCAtThrowStmt:
  return cxstring::createRef("ObjCAtThrowStmt");
case CXCursor_ObjCAtSynchronizedStmt:
  return cxstring::createRef("ObjCAtSynchronizedStmt");
case CXCursor_ObjCAutoreleasePoolStmt:
  return cxstring::createRef("ObjCAutoreleasePoolStmt");
case CXCursor_ObjCForCollectionStmt:
  return cxstring::createRef("ObjCForCollectionStmt");
case CXCursor_CXXCatchStmt:
  return cxstring::createRef("CXXCatchStmt");
case CXCursor_CXXTryStmt:
  return cxstring::createRef("CXXTryStmt");
case CXCursor_CXXForRangeStmt:
  return cxstring::createRef("CXXForRangeStmt");
case CXCursor_SEHTryStmt:
  return cxstring::createRef("SEHTryStmt");
case CXCursor_SEHExceptStmt:
  return cxstring::createRef("SEHExceptStmt");
case CXCursor_SEHFinallyStmt:
  return cxstring::createRef("SEHFinallyStmt");
case CXCursor_SEHLeaveStmt:
  return cxstring::createRef("SEHLeaveStmt");
case CXCursor_NullStmt:
  return cxstring::createRef("NullStmt");
case CXCursor_InvalidFile:
  return cxstring::createRef("InvalidFile");
case CXCursor_InvalidCode:
  return cxstring::createRef("InvalidCode");
case CXCursor_NoDeclFound:
  return cxstring::createRef("NoDeclFound");
case CXCursor_NotImplemented:
  return cxstring::createRef("NotImplemented");
case CXCursor_TranslationUnit:
  return cxstring::createRef("TranslationUnit");
case CXCursor_UnexposedAttr:
  return cxstring::createRef("UnexposedAttr");
case CXCursor_IBActionAttr:
  return cxstring::createRef("attribute(ibaction)");
case CXCursor_IBOutletAttr:
  return cxstring::createRef("attribute(iboutlet)");
case CXCursor_IBOutletCollectionAttr:
  return cxstring::createRef("attribute(iboutletcollection)");
case CXCursor_CXXFinalAttr:
  return cxstring::createRef("attribute(final)");
case CXCursor_CXXOverrideAttr:
  return cxstring::createRef("attribute(override)");
case CXCursor_AnnotateAttr:
  return cxstring::createRef("attribute(annotate)");
case CXCursor_AsmLabelAttr:
  return cxstring::createRef("asm label");
case CXCursor_PackedAttr:
  return cxstring::createRef("attribute(packed)");
case CXCursor_PureAttr:
  return cxstring::createRef("attribute(pure)");
case CXCursor_ConstAttr:
  return cxstring::createRef("attribute(const)");
case CXCursor_NoDuplicateAttr:
  return cxstring::createRef("attribute(noduplicate)");
case CXCursor_CUDAConstantAttr:
  return cxstring::createRef("attribute(constant)");
case CXCursor_CUDADeviceAttr:
  return cxstring::createRef("attribute(device)");
case CXCursor_CUDAGlobalAttr:
  return cxstring::createRef("attribute(global)");
case CXCursor_CUDAHostAttr:
  return cxstring::createRef("attribute(host)");
case CXCursor_CUDASharedAttr:
  return cxstring::createRef("attribute(shared)");
case CXCursor_VisibilityAttr:
  return cxstring::createRef("attribute(visibility)");
case CXCursor_DLLExport:
  return cxstring::createRef("attribute(dllexport)");
case CXCursor_DLLImport:
  return cxstring::createRef("attribute(dllimport)");
case CXCursor_NSReturnsRetained:
  return cxstring::createRef("attribute(ns_returns_retained)");
case CXCursor_NSReturnsNotRetained:
  return cxstring::createRef("attribute(ns_returns_not_retained)");
case CXCursor_NSReturnsAutoreleased:
  return cxstring::createRef("attribute(ns_returns_autoreleased)");
case CXCursor_NSConsumesSelf:
  return cxstring::createRef("attribute(ns_consumes_self)");
case CXCursor_NSConsumed:
  return cxstring::createRef("attribute(ns_consumed)");
case CXCursor_ObjCException:
  return cxstring::createRef("attribute(objc_exception)");
case CXCursor_ObjCNSObject:
  return cxstring::createRef("attribute(NSObject)");
case CXCursor_ObjCIndependentClass:
  return cxstring::createRef("attribute(objc_independent_class)");
case CXCursor_ObjCPreciseLifetime:
  return cxstring::createRef("attribute(objc_precise_lifetime)");
case CXCursor_ObjCReturnsInnerPointer:
  return cxstring::createRef("attribute(objc_returns_inner_pointer)");
case CXCursor_ObjCRequiresSuper:
  return cxstring::createRef("attribute(objc_requires_super)");
case CXCursor_ObjCRootClass:
  return cxstring::createRef("attribute(objc_root_class)");
case CXCursor_ObjCSubclassingRestricted:
  return cxstring::createRef("attribute(objc_subclassing_restricted)");
case CXCursor_ObjCExplicitProtocolImpl:
  return cxstring::createRef(
      "attribute(objc_protocol_requires_explicit_implementation)");
case CXCursor_ObjCDesignatedInitializer:
  return cxstring::createRef("attribute(objc_designated_initializer)");
case CXCursor_ObjCRuntimeVisible:
  return cxstring::createRef("attribute(objc_runtime_visible)");
case CXCursor_ObjCBoxable:
  return cxstring::createRef("attribute(objc_boxable)");
case CXCursor_FlagEnum:
  return cxstring::createRef("attribute(flag_enum)");
case CXCursor_PreprocessingDirective:
  return cxstring::createRef("preprocessing directive");
case CXCursor_MacroDefinition:
  return cxstring::createRef("macro definition");
case CXCursor_MacroExpansion:
  return cxstring::createRef("macro expansion");
case CXCursor_InclusionDirective:
  return cxstring::createRef("inclusion directive");
case CXCursor_Namespace:
  return cxstring::createRef("Namespace");
case CXCursor_LinkageSpec:
  return cxstring::createRef("LinkageSpec");
case CXCursor_CXXBaseSpecifier:
  return cxstring::createRef("C++ base class specifier");
case CXCursor_Constructor:
  return cxstring::createRef("CXXConstructor");
case CXCursor_Destructor:
  return cxstring::createRef("CXXDestructor");
case CXCursor_ConversionFunction:
  return cxstring::createRef("CXXConversion");
case CXCursor_TemplateTypeParameter:
  return cxstring::createRef("TemplateTypeParameter");
case CXCursor_NonTypeTemplateParameter:
  return cxstring::createRef("NonTypeTemplateParameter");
case CXCursor_TemplateTemplateParameter:
  return cxstring::createRef("TemplateTemplateParameter");
case CXCursor_FunctionTemplate:
  return cxstring::createRef("FunctionTemplate");
case CXCursor_ClassTemplate:
  return cxstring::createRef("ClassTemplate");
case CXCursor_ClassTemplatePartialSpecialization:
  return cxstring::createRef("ClassTemplatePartialSpecialization");
case CXCursor_NamespaceAlias:
  return cxstring::createRef("NamespaceAlias");
case CXCursor_UsingDirective:
  return cxstring::createRef("UsingDirective");
case CXCursor_UsingDeclaration:
  return cxstring::createRef("UsingDeclaration");
case CXCursor_TypeAliasDecl:
  return cxstring::createRef("TypeAliasDecl");
case CXCursor_ObjCSynthesizeDecl:
  return cxstring::createRef("ObjCSynthesizeDecl");
case CXCursor_ObjCDynamicDecl:
  return cxstring::createRef("ObjCDynamicDecl");
case CXCursor_CXXAccessSpecifier:
  return cxstring::createRef("CXXAccessSpecifier");
case CXCursor_ModuleImportDecl:
  return cxstring::createRef("ModuleImport");
case CXCursor_OMPCanonicalLoop:
  return cxstring::createRef("OMPCanonicalLoop");
case CXCursor_OMPMetaDirective:
  return cxstring::createRef("OMPMetaDirective");
case CXCursor_OMPParallelDirective:
  return cxstring::createRef("OMPParallelDirective");
case CXCursor_OMPSimdDirective:
  return cxstring::createRef("OMPSimdDirective");
case CXCursor_OMPTileDirective:
  return cxstring::createRef("OMPTileDirective");
case CXCursor_OMPUnrollDirective:
  return cxstring::createRef("OMPUnrollDirective");
case CXCursor_OMPForDirective:
  return cxstring::createRef("OMPForDirective");
case CXCursor_OMPForSimdDirective:
  return cxstring::createRef("OMPForSimdDirective");
case CXCursor_OMPSectionsDirective:
  return cxstring::createRef("OMPSectionsDirective");
case CXCursor_OMPSectionDirective:
  return cxstring::createRef("OMPSectionDirective");
case CXCursor_OMPSingleDirective:
  return cxstring::createRef("OMPSingleDirective");
case CXCursor_OMPMasterDirective:
  return cxstring::createRef("OMPMasterDirective");
case CXCursor_OMPCriticalDirective:
  return cxstring::createRef("OMPCriticalDirective");
case CXCursor_OMPParallelForDirective:
  return cxstring::createRef("OMPParallelForDirective");
case CXCursor_OMPParallelForSimdDirective:
  return cxstring::createRef("OMPParallelForSimdDirective");
case CXCursor_OMPParallelMasterDirective:
  return cxstring::createRef("OMPParallelMasterDirective");
case CXCursor_OMPParallelMaskedDirective:
  return cxstring::createRef("OMPParallelMaskedDirective");
case CXCursor_OMPParallelSectionsDirective:
  return cxstring::createRef("OMPParallelSectionsDirective");
case CXCursor_OMPTaskDirective:
  return cxstring::createRef("OMPTaskDirective");
case CXCursor_OMPTaskyieldDirective:
  return cxstring::createRef("OMPTaskyieldDirective");
case CXCursor_OMPBarrierDirective:
  return cxstring::createRef("OMPBarrierDirective");
case CXCursor_OMPTaskwaitDirective:
  return cxstring::createRef("OMPTaskwaitDirective");
case CXCursor_OMPErrorDirective:
  return cxstring::createRef("OMPErrorDirective");
case CXCursor_OMPTaskgroupDirective:
  return cxstring::createRef("OMPTaskgroupDirective");
case CXCursor_OMPFlushDirective:
  return cxstring::createRef("OMPFlushDirective");
case CXCursor_OMPDepobjDirective:
  return cxstring::createRef("OMPDepobjDirective");
case CXCursor_OMPScanDirective:
  return cxstring::createRef("OMPScanDirective");
case CXCursor_OMPOrderedDirective:
  return cxstring::createRef("OMPOrderedDirective");
case CXCursor_OMPAtomicDirective:
  return cxstring::createRef("OMPAtomicDirective");
case CXCursor_OMPTargetDirective:
  return cxstring::createRef("OMPTargetDirective");
case CXCursor_OMPTargetDataDirective:
  return cxstring::createRef("OMPTargetDataDirective");
case CXCursor_OMPTargetEnterDataDirective:
  return cxstring::createRef("OMPTargetEnterDataDirective");
case CXCursor_OMPTargetExitDataDirective:
  return cxstring::createRef("OMPTargetExitDataDirective");
case CXCursor_OMPTargetParallelDirective:
  return cxstring::createRef("OMPTargetParallelDirective");
case CXCursor_OMPTargetParallelForDirective:
  return cxstring::createRef("OMPTargetParallelForDirective");
case CXCursor_OMPTargetUpdateDirective:
  return cxstring::createRef("OMPTargetUpdateDirective");
case CXCursor_OMPTeamsDirective:
  return cxstring::createRef("OMPTeamsDirective");
case CXCursor_OMPCancellationPointDirective:
  return cxstring::createRef("OMPCancellationPointDirective");
case CXCursor_OMPCancelDirective:
  return cxstring::createRef("OMPCancelDirective");
case CXCursor_OMPTaskLoopDirective:
  return cxstring::createRef("OMPTaskLoopDirective");
case CXCursor_OMPTaskLoopSimdDirective:
  return cxstring::createRef("OMPTaskLoopSimdDirective");
case CXCursor_OMPMasterTaskLoopDirective:
  return cxstring::createRef("OMPMasterTaskLoopDirective");
case CXCursor_OMPMaskedTaskLoopDirective:
  return cxstring::createRef("OMPMaskedTaskLoopDirective");
case CXCursor_OMPMasterTaskLoopSimdDirective:
  return cxstring::createRef("OMPMasterTaskLoopSimdDirective");
case CXCursor_OMPMaskedTaskLoopSimdDirective:
  return cxstring::createRef("OMPMaskedTaskLoopSimdDirective");
case CXCursor_OMPParallelMasterTaskLoopDirective:
  return cxstring::createRef("OMPParallelMasterTaskLoopDirective");
case CXCursor_OMPParallelMaskedTaskLoopDirective:
  return cxstring::createRef("OMPParallelMaskedTaskLoopDirective");
case CXCursor_OMPParallelMasterTaskLoopSimdDirective:
  return cxstring::createRef("OMPParallelMasterTaskLoopSimdDirective");
case CXCursor_OMPParallelMaskedTaskLoopSimdDirective:
  return cxstring::createRef("OMPParallelMaskedTaskLoopSimdDirective");
case CXCursor_OMPDistributeDirective:
  return cxstring::createRef("OMPDistributeDirective");
case CXCursor_OMPDistributeParallelForDirective:
  return cxstring::createRef("OMPDistributeParallelForDirective");
case CXCursor_OMPDistributeParallelForSimdDirective:
  return cxstring::createRef("OMPDistributeParallelForSimdDirective");
case CXCursor_OMPDistributeSimdDirective:
  return cxstring::createRef("OMPDistributeSimdDirective");
case CXCursor_OMPTargetParallelForSimdDirective:
  return cxstring::createRef("OMPTargetParallelForSimdDirective");
case CXCursor_OMPTargetSimdDirective:
  return cxstring::createRef("OMPTargetSimdDirective");
case CXCursor_OMPTeamsDistributeDirective:
  return cxstring::createRef("OMPTeamsDistributeDirective");
case CXCursor_OMPTeamsDistributeSimdDirective:
  return cxstring::createRef("OMPTeamsDistributeSimdDirective");
case CXCursor_OMPTeamsDistributeParallelForSimdDirective:
  return cxstring::createRef("OMPTeamsDistributeParallelForSimdDirective");
case CXCursor_OMPTeamsDistributeParallelForDirective:
  return cxstring::createRef("OMPTeamsDistributeParallelForDirective");
case CXCursor_OMPTargetTeamsDirective:
  return cxstring::createRef("OMPTargetTeamsDirective");
case CXCursor_OMPTargetTeamsDistributeDirective:
  return cxstring::createRef("OMPTargetTeamsDistributeDirective");
case CXCursor_OMPTargetTeamsDistributeParallelForDirective:
  return cxstring::createRef("OMPTargetTeamsDistributeParallelForDirective");
case CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective:
  return cxstring::createRef(
      "OMPTargetTeamsDistributeParallelForSimdDirective");
case CXCursor_OMPTargetTeamsDistributeSimdDirective:
  return cxstring::createRef("OMPTargetTeamsDistributeSimdDirective");
case CXCursor_OMPInteropDirective:
  return cxstring::createRef("OMPInteropDirective");
case CXCursor_OMPDispatchDirective:
  return cxstring::createRef("OMPDispatchDirective");
case CXCursor_OMPMaskedDirective:
  return cxstring::createRef("OMPMaskedDirective");
case CXCursor_OMPGenericLoopDirective:
  return cxstring::createRef("OMPGenericLoopDirective");
case CXCursor_OMPTeamsGenericLoopDirective:
  return cxstring::createRef("OMPTeamsGenericLoopDirective");
case CXCursor_OMPTargetTeamsGenericLoopDirective:
  return cxstring::createRef("OMPTargetTeamsGenericLoopDirective");
case CXCursor_OMPParallelGenericLoopDirective:
  return cxstring::createRef("OMPParallelGenericLoopDirective");
case CXCursor_OMPTargetParallelGenericLoopDirective:
  return cxstring::createRef("OMPTargetParallelGenericLoopDirective");
case CXCursor_OverloadCandidate:
  return cxstring::createRef("OverloadCandidate");
case CXCursor_TypeAliasTemplateDecl:
  return cxstring::createRef("TypeAliasTemplateDecl");
case CXCursor_StaticAssert:
  return cxstring::createRef("StaticAssert");
case CXCursor_FriendDecl:
  return cxstring::createRef(