//===- CIndex.cpp - Clang-C Source Indexing Library -----------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file implements the main API hooks in the Clang-C Source Indexing

// library.

//

//===----------------------------------------------------------------------===//

#include "CIndexDiagnostic.h"

#include "CIndexer.h"

#include "CLog.h"

#include "CXCursor.h"

#include "CXSourceLocation.h"

#include "CXString.h"

#include "CXTranslationUnit.h"

#include "CXType.h"

#include "CursorVisitor.h"

#include "clang-c/FatalErrorHandler.h"

#include "clang/AST/Attr.h"

#include "clang/AST/DeclObjCCommon.h"

#include "clang/AST/Mangle.h"

#include "clang/AST/OpenMPClause.h"

#include "clang/AST/StmtVisitor.h"

#include "clang/Basic/Diagnostic.h"

#include "clang/Basic/DiagnosticCategories.h"

#include "clang/Basic/DiagnosticIDs.h"

#include "clang/Basic/Stack.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/Basic/Version.h"

#include "clang/Frontend/ASTUnit.h"

#include "clang/Frontend/CompilerInstance.h"

#include "clang/Index/CommentToXML.h"

#include "clang/Lex/HeaderSearch.h"

#include "clang/Lex/Lexer.h"

#include "clang/Lex/PreprocessingRecord.h"

#include "clang/Lex/Preprocessor.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/StringSwitch.h"

#include "llvm/Config/llvm-config.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/CrashRecoveryContext.h"

#include "llvm/Support/Format.h"

#include "llvm/Support/ManagedStatic.h"

#include "llvm/Support/MemoryBuffer.h"

#include "llvm/Support/Program.h"

#include "llvm/Support/SaveAndRestore.h"

#include "llvm/Support/Signals.h"

#include "llvm/Support/TargetSelect.h"

#include "llvm/Support/Threading.h"

#include "llvm/Support/Timer.h"

#include "llvm/Support/raw_ostream.h"

#include "llvm/Support/thread.h"

#include <mutex>

#include <optional>

#if LLVM_ENABLE_THREADS != 0 && defined(__APPLE__)

#define USE_DARWIN_THREADS

#endif

#ifdef USE_DARWIN_THREADS

#include <pthread.h>

#endif

using namespace clang;

using namespace clang::cxcursor;

using namespace clang::cxtu;

using namespace clang::cxindex;

CXTranslationUnit cxtu::MakeCXTranslationUnit(CIndexer *CIdx,

                                              std::unique_ptr<ASTUnit> AU) {

  if (!AU)

    return nullptr;

  assert(CIdx);

  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;

}

bool cxtu::isASTReadError(ASTUnit *AU) {

  for (ASTUnit::stored_diag_iterator D = AU->stored_diag_begin(),

                                     DEnd = AU->stored_diag_end();

       D != DEnd; 
++D5.17k
) {

    if (D->getLevel() >= DiagnosticsEngine::Error &&

        DiagnosticIDs::getCategoryNumberForDiag(D->getID()) ==

            diag::DiagCat_AST_Deserialization_Issue)

      return true;

  }

  return false;

}

cxtu::CXTUOwner::~CXTUOwner() {

  if (TU)

    clang_disposeTranslationUnit(TU);

}

/// Compare two source ranges to determine their relative position in

/// the translation unit.

static RangeComparisonResult RangeCompare(SourceManager &SM, SourceRange R1,

                                          SourceRange R2) {

  assert(R1.isValid() && "First range is invalid?");

  assert(R2.isValid() && "Second range is invalid?");

  if (R1.getEnd() != R2.getBegin() &&

      
SM.isBeforeInTranslationUnit(R1.getEnd(), R2.getBegin())36.0k
)

    return RangeBefore;

  if (R2.getEnd() != R1.getBegin() &&

      
SM.isBeforeInTranslationUnit(R2.getEnd(), R1.getBegin())19.3k
)

    return RangeAfter;

  return RangeOverlap;

}

/// Determine if a source location falls within, before, or after a

///   a given source range.

static RangeComparisonResult LocationCompare(SourceManager &SM,

                                             SourceLocation L, SourceRange R) {

  assert(R.isValid() && "First range is invalid?");

  assert(L.isValid() && "Second range is invalid?");

  if (L == R.getBegin() || 
L == R.getEnd()23.6M
)

    return RangeOverlap;

  if (SM.isBeforeInTranslationUnit(L, R.getBegin()))

    return RangeBefore;

  if (SM.isBeforeInTranslationUnit(R.getEnd(), L))

    return RangeAfter;

  return RangeOverlap;

}

/// Translate a Clang source range into a CIndex source range.

///

/// Clang internally represents ranges where the end location points to the

/// start of the token at the end. However, for external clients it is more

/// useful to have a CXSourceRange be a proper half-open interval. This routine

/// does the appropriate translation.

CXSourceRange 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()386k
 &&

      
!SM.isMacroArgExpansion(EndLoc)1.47k
) {

    CharSourceRange Expansion = SM.getExpansionRange(EndLoc);

    EndLoc = Expansion.getEnd();

    IsTokenRange = Expansion.isTokenRange();

  }

  if (IsTokenRange && 
EndLoc.isValid()386k
) {

    unsigned Length =

        Lexer::MeasureTokenLength(SM.getSpellingLoc(EndLoc), SM, LangOpts);

    EndLoc = EndLoc.getLocWithOffset(Length);

  }

  CXSourceRange Result = {

      {&SM, &LangOpts}, R.getBegin().getRawEncoding(), EndLoc.getRawEncoding()};

  return Result;

}

CharSourceRange cxloc::translateCXRangeToCharRange(CXSourceRange R) {

  return CharSourceRange::getCharRange(

      SourceLocation::getFromRawEncoding(R.begin_int_data),

      SourceLocation::getFromRawEncoding(R.end_int_data));

}

//===----------------------------------------------------------------------===//

// Cursor visitor.

//===----------------------------------------------------------------------===//

static SourceRange getRawCursorExtent(CXCursor C);

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

RangeComparisonResult CursorVisitor::CompareRegionOfInterest(SourceRange R) {

  return RangeCompare(AU->getSourceManager(), R, RegionOfInterest);

}

/// Visit the given cursor and, if requested by the visitor,

/// its children.

///

/// \param Cursor the cursor to visit.

///

/// \param CheckedRegionOfInterest if true, then the caller already checked

/// that this cursor is within the region of interest.

///

/// \returns true if the visitation should be aborted, false if it

/// should continue.

bool 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");

      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)2.15k
)

      return false;

  }

  // If we have a range of interest, and this cursor doesn't intersect with it,

  // we're done.

  if (RegionOfInterest.isValid() && 
!CheckedRegionOfInterest11.4k
) {

    SourceRange Range = getRawCursorExtent(Cursor);

    if (Range.isInvalid() || 
CompareRegionOfInterest(Range)9.37k
)

      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!");

}

static 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);

}

bool 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);

  if (Begin.second > End.second)

    return false;

  FileID File = Begin.first;

  unsigned Offset = Begin.second;

  unsigned Length = End.second - Begin.second;

  if (!VisitDeclsOnly && 
!VisitPreprocessorLast9.56k
)

    if (visitPreprocessedEntitiesInRegion())

      return true; // visitation break.

  if (visitDeclsFromFileRegion(File, Offset, Length))

    return true; // visitation break.

  if (!VisitDeclsOnly && 
VisitPreprocessorLast9.55k
)

    return visitPreprocessedEntitiesInRegion();

  return false;

}

static bool isInLexicalContext(Decl *D, DeclContext *DC) {

  if (!DC)

    return false;

  
for (DeclContext *DeclDC = D->getLexicalDeclContext(); 1.16k
DeclDC;

       
DeclDC = DeclDC->getLexicalParent()1.12k
) {

    if (DeclDC == DC)

      return true;

  }

  return false;

}

bool 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()9.57k
) {

    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());

  bool VisitedAtLeastOnce = false;

  DeclContext *CurDC = nullptr;

  SmallVectorImpl<Decl *>::iterator DIt = Decls.begin();

  for (SmallVectorImpl<Decl *>::iterator DE = Decls.end(); DIt != DE; 
++DIt9.01k
) {

    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);

    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()1.08k

                        : 
(*(DIt - 1))->getLexicalDeclContext()7.35k
;

  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;

}

bool 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()188
;

  if (OnlyLocalDecls)

    return visitPreprocessedEntities(PPRec.local_begin(), PPRec.local_end(),

                                     PPRec);

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

}

template <typename InputIterator>

bool CursorVisitor::visitPreprocessedEntities(InputIterator First,

                                              InputIterator Last,

                                              PreprocessingRecord &PPRec,

                                              FileID FID) {

  for (; First != Last; 
++First88.8k
) {

    if (!FID.isInvalid() && 
!PPRec.isEntityInFileID(First, FID)8.75k
)

      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;

}

/// Visit the children of the given cursor.

///

/// \returns true if the visitation should be aborted, false if it

/// should continue.

bool CursorVisitor::VisitChildren(CXCursor Cursor) {

  if (clang_isReference(Cursor.kind) &&

      
Cursor.kind != CXCursor_CXXBaseSpecifier2.08k
) {

    // 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; 
++I414
) {

      if (VisitOrder[I]) {

        if (!CXXUnit->isMainFileAST() && 
CXXUnit->getOnlyLocalDecls()190
 &&

            
RegionOfInterest.isInvalid()47
) {

          for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(),

                                           TLEnd = CXXUnit->top_level_end();

               TL != TLEnd; 
++TL185
) {

            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()72.0k
) {

    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;

}

bool 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;

}

std::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;

}

bool 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; 
++I7.42k
) {

    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;

}

std::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;

}

bool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) {

  llvm_unreachable("Translation units are visited directly by Visit()");

}

bool CursorVisitor::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {

  if (VisitTemplateParameters(D->getTemplateParameters()))

    return true;

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

}

bool CursorVisitor::VisitTypeAliasDecl(TypeAliasDecl *D) {

  if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo())

    return Visit(TSInfo->getTypeLoc());

  return false;

}

bool CursorVisitor::VisitTypedefDecl(TypedefDecl *D) {

  if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo())

    return Visit(TSInfo->getTypeLoc());

  return false;

}

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

bool 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; 
++I32
)

        if (VisitTemplateArgumentLoc(TSTLoc.getArgLoc(I)))

          return true;

    }

  }

  return ShouldVisitBody && 
VisitCXXRecordDecl(D)12
;

}

bool 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; 
++I23
)

    if (VisitTemplateArgumentLoc(TemplateArgs[I]))

      return true;

  return VisitCXXRecordDecl(D);

}

bool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {

  if (const auto *TC = D->getTypeConstraint()) {

    if (VisitTypeConstraint(*TC))

      return true;

  }

  // Visit the default argument.

  if (D->hasDefaultArgument() && 
!D->defaultArgumentWasInherited()10
)

    if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo())

      if (Visit(DefArg->getTypeLoc()))

        return true;

  return false;

}

bool CursorVisitor::VisitEnumConstantDecl(EnumConstantDecl *D) {

  if (Expr *Init = D->getInitExpr())

    return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));

  return false;

}

bool CursorVisitor::VisitDeclaratorDecl(DeclaratorDecl *DD) {

  unsigned NumParamList = DD->getNumTemplateParameterLists();

  for (unsigned i = 0; i < NumParamList; 
i++1
) {

    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;

}

static 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;

}

/// Compare two base or member initializers based on their source order.

static int CompareCXXCtorInitializers(CXXCtorInitializer *const *X,

                                      CXXCtorInitializer *const *Y) {

  return (*X)->getSourceOrder() - (*Y)->getSourceOrder();

}

bool CursorVisitor::VisitFunctionDecl(FunctionDecl *ND) {

  unsigned NumParamList = ND->getNumTemplateParameterLists();

  for (unsigned i = 0; i < NumParamList; 
i++20
) {

    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) && 
!HasTrailingRT1.92k
 &&

         
Visit(FTL.getReturnLoc())1.92k
) ||

        (!FTL && 
Visit(TL)0
))

      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())3
)

      return true;

    // FIXME: Attributes?

  }

  if (auto *E = ND->getTrailingRequiresClause()) {

    if (Visit(E))

      return true;

  }

  if (ND->doesThisDeclarationHaveABody() && 
!ND->isLateTemplateParsed()829
) {

    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; 
++I36
) {

        CXXCtorInitializer *Init = WrittenInits[I];

        if (Init->isAnyMemberInitializer()) {

          if (Visit(MakeCursorMemberRef(Init->getAnyMember(),

                                        Init->getMemberLocation(), TU)))

            return true;

        } else 
if (TypeSourceInfo *14
TInfo14
 = 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;

}

bool 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;

}

bool CursorVisitor::VisitVarDecl(VarDecl *D) {

  if (VisitDeclaratorDecl(D))

    return true;

  if (Expr *Init = D->getInit())

    return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));

  return false;

}

bool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {

  if (VisitDeclaratorDecl(D))

    return true;

  if (D->hasDefaultArgument() && 
!D->defaultArgumentWasInherited()2
)

    if (Expr *DefArg = D->getDefaultArgument())

      return Visit(MakeCXCursor(DefArg, StmtParent, TU, RegionOfInterest));

  return false;

}

bool 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);

}

bool 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);

}

bool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {

  if (VisitTemplateParameters(D->getTemplateParameters()))

    return true;

  if (D->hasDefaultArgument() && 
!D->defaultArgumentWasInherited()2
 &&

      
VisitTemplateArgumentLoc(D->getDefaultArgument())2
)

    return true;

  return false;

}

bool 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;

}

bool 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))70
;

}

template <typename DeclIt>

static 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;