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//===----------------------------------------------------------------------===//
13
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>
60
61#if LLVM_ENABLE_THREADS != 0 && defined(__APPLE__)
62#define USE_DARWIN_THREADS
63#endif
64
65#ifdef USE_DARWIN_THREADS
66#include <pthread.h>
67#endif
68
69using namespace clang;
70using namespace clang::cxcursor;
71using namespace clang::cxtu;
72using namespace clang::cxindex;
73
74CXTranslationUnit cxtu::MakeCXTranslationUnit(CIndexer *CIdx,
75                                              std::unique_ptr<ASTUnit> AU) {
76  if (!AU)
77    return nullptr;
78  assert(CIdx);
79  CXTranslationUnit D = new CXTranslationUnitImpl();
80  D->CIdx = CIdx;
81  D->TheASTUnit = AU.release();
82  D->StringPool = new cxstring::CXStringPool();
83  D->Diagnostics = nullptr;
84  D->OverridenCursorsPool = createOverridenCXCursorsPool();
85  D->CommentToXML = nullptr;
86  D->ParsingOptions = 0;
87  D->Arguments = {};
88  return D;
89}
90
91bool cxtu::isASTReadError(ASTUnit *AU) {
92  for (ASTUnit::stored_diag_iterator D = AU->stored_diag_begin(),
93                                     DEnd = AU->stored_diag_end();
94       D != DEnd; ++D) {
95    if (D->getLevel() >= DiagnosticsEngine::Error &&
96        DiagnosticIDs::getCategoryNumberForDiag(D->getID()) ==
97            diag::DiagCat_AST_Deserialization_Issue)
98      return true;
99  }
100  return false;
101}
102
103cxtu::CXTUOwner::~CXTUOwner() {
104  if (TU)
105    clang_disposeTranslationUnit(TU);
106}
107
108/// Compare two source ranges to determine their relative position in
109/// the translation unit.
110static RangeComparisonResult RangeCompare(SourceManager &SM, SourceRange R1,
111                                          SourceRange R2) {
112  assert(R1.isValid() && "First range is invalid?");
113  assert(R2.isValid() && "Second range is invalid?");
114  if (R1.getEnd() != R2.getBegin() &&
115      SM.isBeforeInTranslationUnit(R1.getEnd(), R2.getBegin()))
116    return RangeBefore;
117  if (R2.getEnd() != R1.getBegin() &&
118      SM.isBeforeInTranslationUnit(R2.getEnd(), R1.getBegin()))
119    return RangeAfter;
120  return RangeOverlap;
121}
122
123/// Determine if a source location falls within, before, or after a
124///   a given source range.
125static RangeComparisonResult LocationCompare(SourceManager &SM,
126                                             SourceLocation L, SourceRange R) {
127  assert(R.isValid() && "First range is invalid?");
128  assert(L.isValid() && "Second range is invalid?");
129  if (L == R.getBegin() || L == R.getEnd())
130    return RangeOverlap;
131  if (SM.isBeforeInTranslationUnit(L, R.getBegin()))
132    return RangeBefore;
133  if (SM.isBeforeInTranslationUnit(R.getEnd(), L))
134    return RangeAfter;
135  return RangeOverlap;
136}
137
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,
145                                          const LangOptions &LangOpts,
146                                          const CharSourceRange &R) {
147  // We want the last character in this location, so we will adjust the
148  // location accordingly.
149  SourceLocation EndLoc = R.getEnd();
150  bool IsTokenRange = R.isTokenRange();
151  if (EndLoc.isValid() && EndLoc.isMacroID() &&
152      !SM.isMacroArgExpansion(EndLoc)) {
153    CharSourceRange Expansion = SM.getExpansionRange(EndLoc);
154    EndLoc = Expansion.getEnd();
155    IsTokenRange = Expansion.isTokenRange();
156  }
157  if (IsTokenRange && EndLoc.isValid()) {
158    unsigned Length =
159        Lexer::MeasureTokenLength(SM.getSpellingLoc(EndLoc), SM, LangOpts);
160    EndLoc = EndLoc.getLocWithOffset(Length);
161  }
162
163  CXSourceRange Result = {
164      {&SM, &LangOpts}, R.getBegin().getRawEncoding(), EndLoc.getRawEncoding()};
165  return Result;
166}
167
168CharSourceRange cxloc::translateCXRangeToCharRange(CXSourceRange R) {
169  return CharSourceRange::getCharRange(
170      SourceLocation::getFromRawEncoding(R.begin_int_data),
171      SourceLocation::getFromRawEncoding(R.end_int_data));
172}
173
174//===----------------------------------------------------------------------===//
175// Cursor visitor.
176//===----------------------------------------------------------------------===//
177
178static SourceRange getRawCursorExtent(CXCursor C);
179static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr);
180
181RangeComparisonResult CursorVisitor::CompareRegionOfInterest(SourceRange R) {
182  return RangeCompare(AU->getSourceManager(), R, RegionOfInterest);
183}
184
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) {
196  if (clang_isInvalid(Cursor.kind))
197    return false;
198
199  if (clang_isDeclaration(Cursor.kind)) {
200    const Decl *D = getCursorDecl(Cursor);
201    if (!D) {
202      assert(0 && "Invalid declaration cursor");
203      return true; // abort.
204    }
205
206    // Ignore implicit declarations, unless it's an objc method because
207    // currently we should report implicit methods for properties when indexing.
208    if (D->isImplicit() && !isa<ObjCMethodDecl>(D))
209      return false;
210  }
211
212  // If we have a range of interest, and this cursor doesn't intersect with it,
213  // we're done.
214  if (RegionOfInterest.isValid() && !CheckedRegionOfInterest) {
215    SourceRange Range = getRawCursorExtent(Cursor);
216    if (Range.isInvalid() || CompareRegionOfInterest(Range))
217      return false;
218  }
219
220  switch (Visitor(Cursor, Parent, ClientData)) {
221  case CXChildVisit_Break:
222    return true;
223
224  case CXChildVisit_Continue:
225    return false;
226
227  case CXChildVisit_Recurse: {
228    bool ret = VisitChildren(Cursor);
229    if (PostChildrenVisitor)
230      if (PostChildrenVisitor(Cursor, ClientData))
231        return true;
232    return ret;
233  }
234  }
235
236  llvm_unreachable("Invalid CXChildVisitResult!");
237}
238
239static bool visitPreprocessedEntitiesInRange(SourceRange R,
240                                             PreprocessingRecord &PPRec,
241                                             CursorVisitor &Visitor) {
242  SourceManager &SM = Visitor.getASTUnit()->getSourceManager();
243  FileID FID;
244
245  if (!Visitor.shouldVisitIncludedEntities()) {
246    // If the begin/end of the range lie in the same FileID, do the optimization
247    // where we skip preprocessed entities that do not come from the same
248    // FileID.
249    FID = SM.getFileID(SM.getFileLoc(R.getBegin()));
250    if (FID != SM.getFileID(SM.getFileLoc(R.getEnd())))
251      FID = FileID();
252  }
253
254  const auto &Entities = PPRec.getPreprocessedEntitiesInRange(R);
255  return Visitor.visitPreprocessedEntities(Entities.begin(), Entities.end(),
256                                           PPRec, FID);
257}
258
259bool CursorVisitor::visitFileRegion() {
260  if (RegionOfInterest.isInvalid())
261    return false;
262
263  ASTUnit *Unit = cxtu::getASTUnit(TU);
264  SourceManager &SM = Unit->getSourceManager();
265
266  std::pair<FileID, unsigned> Begin = SM.getDecomposedLoc(
267                                  SM.getFileLoc(RegionOfInterest.getBegin())),
268                              End = SM.getDecomposedLoc(
269                                  SM.getFileLoc(RegionOfInterest.getEnd()));
270
271  if (End.first != Begin.first) {
272    // If the end does not reside in the same file, try to recover by
273    // picking the end of the file of begin location.
274    End.first = Begin.first;
275    End.second = SM.getFileIDSize(Begin.first);
276  }
277
278  assert(Begin.first == End.first);
279  if (Begin.second > End.second)
280    return false;
281
282  FileID File = Begin.first;
283  unsigned Offset = Begin.second;
284  unsigned Length = End.second - Begin.second;
285
286  if (!VisitDeclsOnly && !VisitPreprocessorLast)
287    if (visitPreprocessedEntitiesInRegion())
288      return true; // visitation break.
289
290  if (visitDeclsFromFileRegion(File, Offset, Length))
291    return true; // visitation break.
292
293  if (!VisitDeclsOnly && VisitPreprocessorLast)
294    return visitPreprocessedEntitiesInRegion();
295
296  return false;
297}
298
299static bool isInLexicalContext(Decl *D, DeclContext *DC) {
300  if (!DC)
301    return false;
302
303  for (DeclContext *DeclDC = D->getLexicalDeclContext(); DeclDC;
304       DeclDC = DeclDC->getLexicalParent()) {
305    if (DeclDC == DC)
306      return true;
307  }
308  return false;
309}
310
311bool CursorVisitor::visitDeclsFromFileRegion(FileID File, unsigned Offset,
312                                             unsigned Length) {
313  ASTUnit *Unit = cxtu::getASTUnit(TU);
314  SourceManager &SM = Unit->getSourceManager();
315  SourceRange Range = RegionOfInterest;
316
317  SmallVector<Decl *, 16> Decls;
318  Unit->findFileRegionDecls(File, Offset, Length, Decls);
319
320  // If we didn't find any file level decls for the file, try looking at the
321  // file that it was included from.
322  while (Decls.empty() || Decls.front()->isTopLevelDeclInObjCContainer()) {
323    bool Invalid = false;
324    const SrcMgr::SLocEntry &SLEntry = SM.getSLocEntry(File, &Invalid);
325    if (Invalid)
326      return false;
327
328    SourceLocation Outer;
329    if (SLEntry.isFile())
330      Outer = SLEntry.getFile().getIncludeLoc();
331    else
332      Outer = SLEntry.getExpansion().getExpansionLocStart();
333    if (Outer.isInvalid())
334      return false;
335
336    std::tie(File, Offset) = SM.getDecomposedExpansionLoc(Outer);
337    Length = 0;
338    Unit->findFileRegionDecls(File, Offset, Length, Decls);
339  }
340
341  assert(!Decls.empty());
342
343  bool VisitedAtLeastOnce = false;
344  DeclContext *CurDC = nullptr;
345  SmallVectorImpl<Decl *>::iterator DIt = Decls.begin();
346  for (SmallVectorImpl<Decl *>::iterator DE = Decls.end(); DIt != DE; ++DIt) {
347    Decl *D = *DIt;
348    if (D->getSourceRange().isInvalid())
349      continue;
350
351    if (isInLexicalContext(D, CurDC))
352      continue;
353
354    CurDC = dyn_cast<DeclContext>(D);
355
356    if (TagDecl *TD = dyn_cast<TagDecl>(D))
357      if (!TD->isFreeStanding())
358        continue;
359
360    RangeComparisonResult CompRes =
361        RangeCompare(SM, D->getSourceRange(), Range);
362    if (CompRes == RangeBefore)
363      continue;
364    if (CompRes == RangeAfter)
365      break;
366
367    assert(CompRes == RangeOverlap);
368    VisitedAtLeastOnce = true;
369
370    if (isa<ObjCContainerDecl>(D)) {
371      FileDI_current = &DIt;
372      FileDE_current = DE;
373    } else {
374      FileDI_current = nullptr;
375    }
376
377    if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true))
378      return true; // visitation break.
379  }
380
381  if (VisitedAtLeastOnce)
382    return false;
383
384  // No Decls overlapped with the range. Move up the lexical context until there
385  // is a context that contains the range or we reach the translation unit
386  // level.
387  DeclContext *DC = DIt == Decls.begin()
388                        ? (*DIt)->getLexicalDeclContext()
389                        : (*(DIt - 1))->getLexicalDeclContext();
390
391  while (DC && !DC->isTranslationUnit()) {
392    Decl *D = cast<Decl>(DC);
393    SourceRange CurDeclRange = D->getSourceRange();
394    if (CurDeclRange.isInvalid())
395      break;
396
397    if (RangeCompare(SM, CurDeclRange, Range) == RangeOverlap) {
398      if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true))
399        return true; // visitation break.
400    }
401
402    DC = D->getLexicalDeclContext();
403  }
404
405  return false;
406}
407
408bool CursorVisitor::visitPreprocessedEntitiesInRegion() {
409  if (!AU->getPreprocessor().getPreprocessingRecord())
410    return false;
411
412  PreprocessingRecord &PPRec = *AU->getPreprocessor().getPreprocessingRecord();
413  SourceManager &SM = AU->getSourceManager();
414
415  if (RegionOfInterest.isValid()) {
416    SourceRange MappedRange = AU->mapRangeToPreamble(RegionOfInterest);
417    SourceLocation B = MappedRange.getBegin();
418    SourceLocation E = MappedRange.getEnd();
419
420    if (AU->isInPreambleFileID(B)) {
421      if (SM.isLoadedSourceLocation(E))
422        return visitPreprocessedEntitiesInRange(SourceRange(B, E), PPRec,
423                                                *this);
424
425      // Beginning of range lies in the preamble but it also extends beyond
426      // it into the main file. Split the range into 2 parts, one covering
427      // the preamble and another covering the main file. This allows subsequent
428      // calls to visitPreprocessedEntitiesInRange to accept a source range that
429      // lies in the same FileID, allowing it to skip preprocessed entities that
430      // do not come from the same FileID.
431      bool breaked = visitPreprocessedEntitiesInRange(
432          SourceRange(B, AU->getEndOfPreambleFileID()), PPRec, *this);
433      if (breaked)
434        return true;
435      return visitPreprocessedEntitiesInRange(
436          SourceRange(AU->getStartOfMainFileID(), E), PPRec, *this);
437    }
438
439    return visitPreprocessedEntitiesInRange(SourceRange(B, E), PPRec, *this);
440  }
441
442  bool OnlyLocalDecls = !AU->isMainFileAST() && AU->getOnlyLocalDecls();
443
444  if (OnlyLocalDecls)
445    return visitPreprocessedEntities(PPRec.local_begin(), PPRec.local_end(),
446                                     PPRec);
447
448  return visitPreprocessedEntities(PPRec.begin(), PPRec.end(), PPRec);
449}
450
451template <typename InputIterator>
452bool CursorVisitor::visitPreprocessedEntities(InputIterator First,
453                                              InputIterator Last,
454                                              PreprocessingRecord &PPRec,
455                                              FileID FID) {
456  for (; First != Last; ++First) {
457    if (!FID.isInvalid() && !PPRec.isEntityInFileID(First, FID))
458      continue;
459
460    PreprocessedEntity *PPE = *First;
461    if (!PPE)
462      continue;
463
464    if (MacroExpansion *ME = dyn_cast<MacroExpansion>(PPE)) {
465      if (Visit(MakeMacroExpansionCursor(ME, TU)))
466        return true;
467
468      continue;
469    }
470
471    if (MacroDefinitionRecord *MD = dyn_cast<MacroDefinitionRecord>(PPE)) {
472      if (Visit(MakeMacroDefinitionCursor(MD, TU)))
473        return true;
474
475      continue;
476    }
477
478    if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) {
479      if (Visit(MakeInclusionDirectiveCursor(ID, TU)))
480        return true;
481
482      continue;
483    }
484  }
485
486  return false;
487}
488
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) {
494  if (clang_isReference(Cursor.kind) &&
495      Cursor.kind != CXCursor_CXXBaseSpecifier) {
496    // By definition, references have no children.
497    return false;
498  }
499
500  // Set the Parent field to Cursor, then back to its old value once we're
501  // done.
502  SetParentRAII SetParent(Parent, StmtParent, Cursor);
503
504  if (clang_isDeclaration(Cursor.kind)) {
505    Decl *D = const_cast<Decl *>(getCursorDecl(Cursor));
506    if (!D)
507      return false;
508
509    return VisitAttributes(D) || Visit(D);
510  }
511
512  if (clang_isStatement(Cursor.kind)) {
513    if (const Stmt *S = getCursorStmt(Cursor))
514      return Visit(S);
515
516    return false;
517  }
518
519  if (clang_isExpression(Cursor.kind)) {
520    if (const Expr *E = getCursorExpr(Cursor))
521      return Visit(E);
522
523    return false;
524  }
525
526  if (clang_isTranslationUnit(Cursor.kind)) {
527    CXTranslationUnit TU = getCursorTU(Cursor);
528    ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
529
530    int VisitOrder[2] = {VisitPreprocessorLast, !VisitPreprocessorLast};
531    for (unsigned I = 0; I != 2; ++I) {
532      if (VisitOrder[I]) {
533        if (!CXXUnit->isMainFileAST() && CXXUnit->getOnlyLocalDecls() &&
534            RegionOfInterest.isInvalid()) {
535          for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(),
536                                           TLEnd = CXXUnit->top_level_end();
537               TL != TLEnd; ++TL) {
538            const std::optional<bool> V = handleDeclForVisitation(*TL);
539            if (!V)
540              continue;
541            return *V;
542          }
543        } else if (VisitDeclContext(
544                       CXXUnit->getASTContext().getTranslationUnitDecl()))
545          return true;
546        continue;
547      }
548
549      // Walk the preprocessing record.
550      if (CXXUnit->getPreprocessor().getPreprocessingRecord())
551        visitPreprocessedEntitiesInRegion();
552    }
553
554    return false;
555  }
556
557  if (Cursor.kind == CXCursor_CXXBaseSpecifier) {
558    if (const CXXBaseSpecifier *Base = getCursorCXXBaseSpecifier(Cursor)) {
559      if (TypeSourceInfo *BaseTSInfo = Base->getTypeSourceInfo()) {
560        return Visit(BaseTSInfo->getTypeLoc());
561      }
562    }
563  }
564
565  if (Cursor.kind == CXCursor_IBOutletCollectionAttr) {
566    const IBOutletCollectionAttr *A =
567        cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(Cursor));
568    if (const ObjCObjectType *ObjT = A->getInterface()->getAs<ObjCObjectType>())
569      return Visit(cxcursor::MakeCursorObjCClassRef(
570          ObjT->getInterface(),
571          A->getInterfaceLoc()->getTypeLoc().getBeginLoc(), TU));
572  }
573
574  // If pointing inside a macro definition, check if the token is an identifier
575  // that was ever defined as a macro. In such a case, create a "pseudo" macro
576  // expansion cursor for that token.
577  SourceLocation BeginLoc = RegionOfInterest.getBegin();
578  if (Cursor.kind == CXCursor_MacroDefinition &&
579      BeginLoc == RegionOfInterest.getEnd()) {
580    SourceLocation Loc = AU->mapLocationToPreamble(BeginLoc);
581    const MacroInfo *MI =
582        getMacroInfo(cxcursor::getCursorMacroDefinition(Cursor), TU);
583    if (MacroDefinitionRecord *MacroDef =
584            checkForMacroInMacroDefinition(MI, Loc, TU))
585      return Visit(cxcursor::MakeMacroExpansionCursor(MacroDef, BeginLoc, TU));
586  }
587
588  // Nothing to visit at the moment.
589  return false;
590}
591
592bool CursorVisitor::VisitBlockDecl(BlockDecl *B) {
593  if (TypeSourceInfo *TSInfo = B->getSignatureAsWritten())
594    if (Visit(TSInfo->getTypeLoc()))
595      return true;
596
597  if (Stmt *Body = B->getBody())
598    return Visit(MakeCXCursor(Body, StmtParent, TU, RegionOfInterest));
599
600  return false;
601}
602
603std::optional<bool> CursorVisitor::shouldVisitCursor(CXCursor Cursor) {
604  if (RegionOfInterest.isValid()) {
605    SourceRange Range = getFullCursorExtent(Cursor, AU->getSourceManager());
606    if (Range.isInvalid())
607      return std::nullopt;
608
609    switch (CompareRegionOfInterest(Range)) {
610    case RangeBefore:
611      // This declaration comes before the region of interest; skip it.
612      return std::nullopt;
613
614    case RangeAfter:
615      // This declaration comes after the region of interest; we're done.
616      return false;
617
618    case RangeOverlap:
619      // This declaration overlaps the region of interest; visit it.
620      break;
621    }
622  }
623  return true;
624}
625
626bool CursorVisitor::VisitDeclContext(DeclContext *DC) {
627  DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end();
628
629  // FIXME: Eventually remove.  This part of a hack to support proper
630  // iteration over all Decls contained lexically within an ObjC container.
631  SaveAndRestore DI_saved(DI_current, &I);
632  SaveAndRestore DE_saved(DE_current, E);
633
634  for (; I != E; ++I) {
635    Decl *D = *I;
636    if (D->getLexicalDeclContext() != DC)
637      continue;
638    // Filter out synthesized property accessor redeclarations.
639    if (isa<ObjCImplDecl>(DC))
640      if (auto *OMD = dyn_cast<ObjCMethodDecl>(D))
641        if (OMD->isSynthesizedAccessorStub())
642          continue;
643    const std::optional<bool> V = handleDeclForVisitation(D);
644    if (!V)
645      continue;
646    return *V;
647  }
648  return false;
649}
650
651std::optional<bool> CursorVisitor::handleDeclForVisitation(const Decl *D) {
652  CXCursor Cursor = MakeCXCursor(D, TU, RegionOfInterest);
653
654  // Ignore synthesized ivars here, otherwise if we have something like:
655  //   @synthesize prop = _prop;
656  // and '_prop' is not declared, we will encounter a '_prop' ivar before
657  // encountering the 'prop' synthesize declaration and we will think that
658  // we passed the region-of-interest.
659  if (auto *ivarD = dyn_cast<ObjCIvarDecl>(D)) {
660    if (ivarD->getSynthesize())
661      return std::nullopt;
662  }
663
664  // FIXME: ObjCClassRef/ObjCProtocolRef for forward class/protocol
665  // declarations is a mismatch with the compiler semantics.
666  if (Cursor.kind == CXCursor_ObjCInterfaceDecl) {
667    auto *ID = cast<ObjCInterfaceDecl>(D);
668    if (!ID->isThisDeclarationADefinition())
669      Cursor = MakeCursorObjCClassRef(ID, ID->getLocation(), TU);
670
671  } else if (Cursor.kind == CXCursor_ObjCProtocolDecl) {
672    auto *PD = cast<ObjCProtocolDecl>(D);
673    if (!PD->isThisDeclarationADefinition())
674      Cursor = MakeCursorObjCProtocolRef(PD, PD->getLocation(), TU);
675  }
676
677  const std::optional<bool> V = shouldVisitCursor(Cursor);
678  if (!V)
679    return std::nullopt;
680  if (!*V)
681    return false;
682  if (Visit(Cursor, true))
683    return true;
684  return std::nullopt;
685}
686
687bool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
688  llvm_unreachable("Translation units are visited directly by Visit()");
689}
690
691bool CursorVisitor::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
692  if (VisitTemplateParameters(D->getTemplateParameters()))
693    return true;
694
695  return Visit(MakeCXCursor(D->getTemplatedDecl(), TU, RegionOfInterest));
696}
697
698bool CursorVisitor::VisitTypeAliasDecl(TypeAliasDecl *D) {
699  if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo())
700    return Visit(TSInfo->getTypeLoc());
701
702  return false;
703}
704
705bool CursorVisitor::VisitTypedefDecl(TypedefDecl *D) {
706  if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo())
707    return Visit(TSInfo->getTypeLoc());
708
709  return false;
710}
711
712bool CursorVisitor::VisitTagDecl(TagDecl *D) { return VisitDeclContext(D); }
713
714bool CursorVisitor::VisitClassTemplateSpecializationDecl(
715    ClassTemplateSpecializationDecl *D) {
716  bool ShouldVisitBody = false;
717  switch (D->getSpecializationKind()) {
718  case TSK_Undeclared:
719  case TSK_ImplicitInstantiation:
720    // Nothing to visit
721    return false;
722
723  case TSK_ExplicitInstantiationDeclaration:
724  case TSK_ExplicitInstantiationDefinition:
725    break;
726
727  case TSK_ExplicitSpecialization:
728    ShouldVisitBody = true;
729    break;
730  }
731
732  // Visit the template arguments used in the specialization.
733  if (TypeSourceInfo *SpecType = D->getTypeAsWritten()) {
734    TypeLoc TL = SpecType->getTypeLoc();
735    if (TemplateSpecializationTypeLoc TSTLoc =
736            TL.getAs<TemplateSpecializationTypeLoc>()) {
737      for (unsigned I = 0, N = TSTLoc.getNumArgs(); I != N; ++I)
738        if (VisitTemplateArgumentLoc(TSTLoc.getArgLoc(I)))
739          return true;
740    }
741  }
742
743  return ShouldVisitBody && VisitCXXRecordDecl(D);
744}
745
746bool CursorVisitor::VisitClassTemplatePartialSpecializationDecl(
747    ClassTemplatePartialSpecializationDecl *D) {
748  // FIXME: Visit the "outer" template parameter lists on the TagDecl
749  // before visiting these template parameters.
750  if (VisitTemplateParameters(D->getTemplateParameters()))
751    return true;
752
753  // Visit the partial specialization arguments.
754  const ASTTemplateArgumentListInfo *Info = D->getTemplateArgsAsWritten();
755  const TemplateArgumentLoc *TemplateArgs = Info->getTemplateArgs();
756  for (unsigned I = 0, N = Info->NumTemplateArgs; I != N; ++I)
757    if (VisitTemplateArgumentLoc(TemplateArgs[I]))
758      return true;
759
760  return VisitCXXRecordDecl(D);
761}
762
763bool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
764  if (const auto *TC = D->getTypeConstraint()) {
765    if (VisitTypeConstraint(*TC))
766      return true;
767  }
768
769  // Visit the default argument.
770  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
771    if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo())
772      if (Visit(DefArg->getTypeLoc()))
773        return true;
774
775  return false;
776}
777
778bool CursorVisitor::VisitEnumConstantDecl(EnumConstantDecl *D) {
779  if (Expr *Init = D->getInitExpr())
780    return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));
781  return false;
782}
783
784bool CursorVisitor::VisitDeclaratorDecl(DeclaratorDecl *DD) {
785  unsigned NumParamList = DD->getNumTemplateParameterLists();
786  for (unsigned i = 0; i < NumParamList; i++) {
787    TemplateParameterList *Params = DD->getTemplateParameterList(i);
788    if (VisitTemplateParameters(Params))
789      return true;
790  }
791
792  if (TypeSourceInfo *TSInfo = DD->getTypeSourceInfo())
793    if (Visit(TSInfo->getTypeLoc()))
794      return true;
795
796  // Visit the nested-name-specifier, if present.
797  if (NestedNameSpecifierLoc QualifierLoc = DD->getQualifierLoc())
798    if (VisitNestedNameSpecifierLoc(QualifierLoc))
799      return true;
800
801  return false;
802}
803
804static bool HasTrailingReturnType(FunctionDecl *ND) {
805  const QualType Ty = ND->getType();
806  if (const FunctionType *AFT = Ty->getAs<FunctionType>()) {
807    if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(AFT))
808      return FT->hasTrailingReturn();
809  }
810
811  return false;
812}
813
814/// Compare two base or member initializers based on their source order.
815static int CompareCXXCtorInitializers(CXXCtorInitializer *const *X,
816                                      CXXCtorInitializer *const *Y) {
817  return (*X)->getSourceOrder() - (*Y)->getSourceOrder();
818}
819
820bool CursorVisitor::VisitFunctionDecl(FunctionDecl *ND) {
821  unsigned NumParamList = ND->getNumTemplateParameterLists();
822  for (unsigned i = 0; i < NumParamList; i++) {
823    TemplateParameterList *Params = ND->getTemplateParameterList(i);
824    if (VisitTemplateParameters(Params))
825      return true;
826  }
827
828  if (TypeSourceInfo *TSInfo = ND->getTypeSourceInfo()) {
829    // Visit the function declaration's syntactic components in the order
830    // written. This requires a bit of work.
831    TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
832    FunctionTypeLoc FTL = TL.getAs<FunctionTypeLoc>();
833    const bool HasTrailingRT = HasTrailingReturnType(ND);
834
835    // If we have a function declared directly (without the use of a typedef),
836    // visit just the return type. Otherwise, just visit the function's type
837    // now.
838    if ((FTL && !isa<CXXConversionDecl>(ND) && !HasTrailingRT &&
839         Visit(FTL.getReturnLoc())) ||
840        (!FTL && Visit(TL)))
841      return true;
842
843    // Visit the nested-name-specifier, if present.
844    if (NestedNameSpecifierLoc QualifierLoc = ND->getQualifierLoc())
845      if (VisitNestedNameSpecifierLoc(QualifierLoc))
846        return true;
847
848    // Visit the declaration name.
849    if (!isa<CXXDestructorDecl>(ND))
850      if (VisitDeclarationNameInfo(ND->getNameInfo()))
851        return true;
852
853    // FIXME: Visit explicitly-specified template arguments!
854
855    // Visit the function parameters, if we have a function type.
856    if (FTL && VisitFunctionTypeLoc(FTL, true))
857      return true;
858
859    // Visit the function's trailing return type.
860    if (FTL && HasTrailingRT && Visit(FTL.getReturnLoc()))
861      return true;
862
863    // FIXME: Attributes?
864  }
865
866  if (auto *E = ND->getTrailingRequiresClause()) {
867    if (Visit(E))
868      return true;
869  }
870
871  if (ND->doesThisDeclarationHaveABody() && !ND->isLateTemplateParsed()) {
872    if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ND)) {
873      // Find the initializers that were written in the source.
874      SmallVector<CXXCtorInitializer *, 4> WrittenInits;
875      for (auto *I : Constructor->inits()) {
876        if (!I->isWritten())
877          continue;
878
879        WrittenInits.push_back(I);
880      }
881
882      // Sort the initializers in source order
883      llvm::array_pod_sort(WrittenInits.begin(), WrittenInits.end(),
884                           &CompareCXXCtorInitializers);
885
886      // Visit the initializers in source order
887      for (unsigned I = 0, N = WrittenInits.size(); I != N; ++I) {
888        CXXCtorInitializer *Init = WrittenInits[I];
889        if (Init->isAnyMemberInitializer()) {
890          if (Visit(MakeCursorMemberRef(Init->getAnyMember(),
891                                        Init->getMemberLocation(), TU)))
892            return true;
893        } else if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo()) {
894          if (Visit(TInfo->getTypeLoc()))
895            return true;
896        }
897
898        // Visit the initializer value.
899        if (Expr *Initializer = Init->getInit())
900          if (Visit(MakeCXCursor(Initializer, ND, TU, RegionOfInterest)))
901            return true;
902      }
903    }
904
905    if (Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest)))
906      return true;
907  }
908
909  return false;
910}
911
912bool CursorVisitor::VisitFieldDecl(FieldDecl *D) {
913  if (VisitDeclaratorDecl(D))
914    return true;
915
916  if (Expr *BitWidth = D->getBitWidth())
917    return Visit(MakeCXCursor(BitWidth, StmtParent, TU, RegionOfInterest));
918
919  if (Expr *Init = D->getInClassInitializer())
920    return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));
921
922  return false;
923}
924
925bool CursorVisitor::VisitVarDecl(VarDecl *D) {
926  if (VisitDeclaratorDecl(D))
927    return true;
928
929  if (Expr *Init = D->getInit())
930    return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));
931
932  return false;
933}
934
935bool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
936  if (VisitDeclaratorDecl(D))
937    return true;
938
939  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
940    if (Expr *DefArg = D->getDefaultArgument())
941      return Visit(MakeCXCursor(DefArg, StmtParent, TU, RegionOfInterest));
942
943  return false;
944}
945
946bool CursorVisitor::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
947  // FIXME: Visit the "outer" template parameter lists on the FunctionDecl
948  // before visiting these template parameters.
949  if (VisitTemplateParameters(D->getTemplateParameters()))
950    return true;
951
952  auto *FD = D->getTemplatedDecl();
953  return VisitAttributes(FD) || VisitFunctionDecl(FD);
954}
955
956bool CursorVisitor::VisitClassTemplateDecl(ClassTemplateDecl *D) {
957  // FIXME: Visit the "outer" template parameter lists on the TagDecl
958  // before visiting these template parameters.
959  if (VisitTemplateParameters(D->getTemplateParameters()))
960    return true;
961
962  auto *CD = D->getTemplatedDecl();
963  return VisitAttributes(CD) || VisitCXXRecordDecl(CD);
964}
965
966bool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
967  if (VisitTemplateParameters(D->getTemplateParameters()))
968    return true;
969
970  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited() &&
971      VisitTemplateArgumentLoc(D->getDefaultArgument()))
972    return true;
973
974  return false;
975}
976
977bool CursorVisitor::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
978  // Visit the bound, if it's explicit.
979  if (D->hasExplicitBound()) {
980    if (auto TInfo = D->getTypeSourceInfo()) {
981      if (Visit(TInfo->getTypeLoc()))
982        return true;
983    }
984  }
985
986  return false;
987}
988
989bool CursorVisitor::VisitObjCMethodDecl(ObjCMethodDecl *ND) {
990  if (TypeSourceInfo *TSInfo = ND->getReturnTypeSourceInfo())
991    if (Visit(TSInfo->getTypeLoc()))
992      return true;
993
994  for (const auto *P : ND->parameters()) {
995    if (Visit(MakeCXCursor(P, TU, RegionOfInterest)))
996      return true;
997  }
998
999  return ND->isThisDeclarationADefinition() &&
1000         Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest));
1001}
1002
1003template <typename DeclIt>
1004static void addRangedDeclsInContainer(DeclIt *DI_current, DeclIt DE_current,
1005                                      SourceManager &SM, SourceLocation EndLoc,
1006                                      SmallVectorImpl<Decl *> &Decls) {
1007  DeclIt next = *DI_current;
1008  while (++next != DE_current) {
1009    Decl *D_next = *next;
1010    if (!D_next)
1011      break;
1012    SourceLocation L = D_next->getBeginLoc();
1013    if (!L.isValid())
1014      break;
1015    if (SM.isBeforeInTranslationUnit(L, EndLoc)) {
1016      *DI_current = next;
1017      Decls.push_back(D_next);
1018      continue;
1019    }
1020    break;
1021  }
1022}
1023
1024bool CursorVisitor::VisitObjCContainerDecl(ObjCContainerDecl *D) {
1025  // FIXME: Eventually convert back to just 'VisitDeclContext()'.  Essentially
1026  // an @implementation can lexically contain Decls that are not properly
1027  // nested in the AST.  When we identify such cases, we need to retrofit
1028  // this nesting here.
1029  if (!DI_current && !FileDI_current)
1030    return VisitDeclContext(D);
1031
1032  // Scan the Decls that immediately come after the container
1033  // in the current DeclContext.  If any fall within the
1034  // container's lexical region, stash them into a vector
1035  // for later processing.
1036  SmallVector<Decl *, 24> DeclsInContainer;
1037  SourceLocation EndLoc = D->getSourceRange().getEnd();
1038  SourceManager &SM = AU->getSourceManager();
1039  if (EndLoc.isValid()) {
1040    if (DI_current) {
1041      addRangedDeclsInContainer(DI_current, DE_current, SM, EndLoc,
1042                                DeclsInContainer);
1043    } else {
1044      addRangedDeclsInContainer(FileDI_current, FileDE_current, SM, EndLoc,
1045                                DeclsInContainer);
1046    }
1047  }
1048
1049  // The common case.
1050  if (DeclsInContainer.empty())
1051    return VisitDeclContext(D);
1052
1053  // Get all the Decls in the DeclContext, and sort them with the
1054  // additional ones we've collected.  Then visit them.
1055  for (auto *SubDecl : D->decls()) {
1056    if (!SubDecl || SubDecl->getLexicalDeclContext() != D ||
1057        SubDecl->getBeginLoc().isInvalid())
1058      continue;
1059    DeclsInContainer.push_back(SubDecl);
1060  }
1061
1062  // Now sort the Decls so that they appear in lexical order.
1063  llvm::sort(DeclsInContainer, [&SM](Decl *A, Decl *B) {
1064    SourceLocation L_A = A->getBeginLoc();
1065    SourceLocation L_B = B->getBeginLoc();
1066    return L_A != L_B
1067               ? SM.isBeforeInTranslationUnit(L_A, L_B)
1068               : SM.isBeforeInTranslationUnit(A->getEndLoc(), B->getEndLoc());
1069  });
1070
1071  // Now visit the decls.
1072  for (SmallVectorImpl<Decl *>::iterator I = DeclsInContainer.begin(),
1073                                         E = DeclsInContainer.end();
1074       I != E; ++I) {
1075    CXCursor Cursor = MakeCXCursor(*I, TU, RegionOfInterest);
1076    const std::optional<bool> &V = shouldVisitCursor(Cursor);
1077    if (!V)
1078      continue;
1079    if (!*V)
1080      return false;
1081    if (Visit(Cursor, true))
1082      return true;
1083  }
1084  return false;
1085}
1086
1087bool CursorVisitor::VisitObjCCategoryDecl(ObjCCategoryDecl *ND) {
1088  if (Visit(MakeCursorObjCClassRef(ND->getClassInterface(), ND->getLocation(),
1089                                   TU)))
1090    return true;
1091
1092  if (VisitObjCTypeParamList(ND->getTypeParamList()))
1093    return true;
1094
1095  ObjCCategoryDecl::protocol_loc_iterator PL = ND->protocol_loc_begin();
1096  for (ObjCCategoryDecl::protocol_iterator I = ND->protocol_begin(),
1097                                           E = ND->protocol_end();
1098       I != E; ++I, ++PL)
1099    if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
1100      return true;
1101
1102  return VisitObjCContainerDecl(ND);
1103}
1104
1105bool CursorVisitor::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) {
1106  if (!PID->isThisDeclarationADefinition())
1107    return Visit(MakeCursorObjCProtocolRef(PID, PID->getLocation(), TU));
1108
1109  ObjCProtocolDecl::protocol_loc_iterator PL = PID->protocol_loc_begin();
1110  for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(),
1111                                           E = PID->protocol_end();
1112       I != E; ++I, ++PL)
1113    if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
1114      return true;
1115
1116  return VisitObjCContainerDecl(PID);
1117}
1118
1119bool CursorVisitor::VisitObjCPropertyDecl(ObjCPropertyDecl *PD) {
1120  if (PD->getTypeSourceInfo() && Visit(PD->getTypeSourceInfo()->getTypeLoc()))
1121    return true;
1122
1123  // FIXME: This implements a workaround with @property declarations also being
1124  // installed in the DeclContext for the @interface.  Eventually this code
1125  // should be removed.
1126  ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(PD->getDeclContext());
1127  if (!CDecl || !CDecl->IsClassExtension())
1128    return false;
1129
1130  ObjCInterfaceDecl *ID = CDecl->getClassInterface();
1131  if (!ID)
1132    return false;
1133
1134  IdentifierInfo *PropertyId = PD->getIdentifier();
1135  ObjCPropertyDecl *prevDecl = ObjCPropertyDecl::findPropertyDecl(
1136      cast<DeclContext>(ID), PropertyId, PD->getQueryKind());
1137
1138  if (!prevDecl)
1139    return false;
1140
1141  // Visit synthesized methods since they will be skipped when visiting
1142  // the @interface.
1143  if (ObjCMethodDecl *MD = prevDecl->getGetterMethodDecl())
1144    if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl)
1145      if (Visit(MakeCXCursor(MD, TU, RegionOfInterest)))
1146        return true;
1147
1148  if (ObjCMethodDecl *MD = prevDecl->getSetterMethodDecl())
1149    if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl)
1150      if (Visit(MakeCXCursor(MD, TU, RegionOfInterest)))
1151        return true;
1152
1153  return false;
1154}
1155
1156bool CursorVisitor::VisitObjCTypeParamList(ObjCTypeParamList *typeParamList) {
1157  if (!typeParamList)
1158    return false;
1159
1160  for (auto *typeParam : *typeParamList) {
1161    // Visit the type parameter.
1162    if (Visit(MakeCXCursor(typeParam, TU, RegionOfInterest)))
1163      return true;
1164  }
1165
1166  return false;
1167}
1168
1169bool CursorVisitor::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
1170  if (!D->isThisDeclarationADefinition()) {
1171    // Forward declaration is treated like a reference.
1172    return Visit(MakeCursorObjCClassRef(D, D->getLocation(), TU));
1173  }
1174
1175  // Objective-C type parameters.
1176  if (VisitObjCTypeParamList(D->getTypeParamListAsWritten()))
1177    return true;
1178
1179  // Issue callbacks for super class.
1180  if (D->getSuperClass() && Visit(MakeCursorObjCSuperClassRef(
1181                                D->getSuperClass(), D->getSuperClassLoc(), TU)))
1182    return true;
1183
1184  if (TypeSourceInfo *SuperClassTInfo = D->getSuperClassTInfo())
1185    if (Visit(SuperClassTInfo->getTypeLoc()))
1186      return true;
1187
1188  ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin();
1189  for (ObjCInterfaceDecl::protocol_iterator I = D->protocol_begin(),
1190                                            E = D->protocol_end();
1191       I != E; ++I, ++PL)
1192    if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
1193      return true;
1194
1195  return VisitObjCContainerDecl(D);
1196}
1197
1198bool CursorVisitor::VisitObjCImplDecl(ObjCImplDecl *D) {
1199  return VisitObjCContainerDecl(D);
1200}
1201
1202bool CursorVisitor::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
1203  // 'ID' could be null when dealing with invalid code.
1204  if (ObjCInterfaceDecl *ID = D->getClassInterface())
1205    if (Visit(MakeCursorObjCClassRef(ID, D->getLocation(), TU)))
1206      return true;
1207
1208  return VisitObjCImplDecl(D);
1209}
1210
1211bool CursorVisitor::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
1212#if 0
1213  // Issue callbacks for super class.
1214  // FIXME: No source location information!
1215  if (D->getSuperClass() &&
1216      Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(),
1217                                        D->getSuperClassLoc(),
1218                                        TU)))
1219    return true;
1220#endif
1221
1222  return VisitObjCImplDecl(D);
1223}
1224
1225bool CursorVisitor::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PD) {
1226  if (ObjCIvarDecl *Ivar = PD->getPropertyIvarDecl())
1227    if (PD->isIvarNameSpecified())
1228      return Visit(MakeCursorMemberRef(Ivar, PD->getPropertyIvarDeclLoc(), TU));
1229
1230  return false;
1231}
1232
1233bool CursorVisitor::VisitNamespaceDecl(NamespaceDecl *D) {
1234  return VisitDeclContext(D);
1235}
1236
1237bool CursorVisitor::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1238  // Visit nested-name-specifier.
1239  if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1240    if (VisitNestedNameSpecifierLoc(QualifierLoc))
1241      return true;
1242
1243  return Visit(MakeCursorNamespaceRef(D->getAliasedNamespace(),
1244                                      D->getTargetNameLoc(), TU));
1245}
1246
1247bool CursorVisitor::VisitUsingDecl(UsingDecl *D) {
1248  // Visit nested-name-specifier.
1249  if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) {
1250    if (VisitNestedNameSpecifierLoc(QualifierLoc))
1251      return true;
1252  }
1253
1254  if (Visit(MakeCursorOverloadedDeclRef(D, D->getLocation(), TU)))
1255    return true;
1256
1257  return VisitDeclarationNameInfo(D->getNameInfo());
1258}
1259
1260bool CursorVisitor::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1261  // Visit nested-name-specifier.
1262  if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1263    if (VisitNestedNameSpecifierLoc(QualifierLoc))
1264      return true;
1265
1266  return Visit(MakeCursorNamespaceRef(D->getNominatedNamespaceAsWritten(),
1267                                      D->getIdentLocation(), TU));
1268}
1269
1270bool CursorVisitor::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1271  // Visit nested-name-specifier.
1272  if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) {
1273    if (VisitNestedNameSpecifierLoc(QualifierLoc))
1274      return true;
1275  }
1276
1277  return VisitDeclarationNameInfo(D->getNameInfo());
1278}
1279
1280bool CursorVisitor::VisitUnresolvedUsingTypenameDecl(
1281    UnresolvedUsingTypenameDecl *D) {
1282  // Visit nested-name-specifier.
1283  if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1284    if (VisitNestedNameSpecifierLoc(QualifierLoc))
1285      return true;
1286
1287  return false;
1288}
1289
1290bool CursorVisitor::VisitStaticAssertDecl(StaticAssertDecl *D) {
1291  if (Visit(MakeCXCursor(D->getAssertExpr(), StmtParent, TU, RegionOfInterest)))
1292    return true;
1293  if (StringLiteral *Message = D->getMessage())
1294    if (Visit(MakeCXCursor(Message, StmtParent, TU, RegionOfInterest)))
1295      return true;
1296  return false;
1297}
1298
1299bool CursorVisitor::VisitFriendDecl(FriendDecl *D) {
1300  if (NamedDecl *FriendD = D->getFriendDecl()) {
1301    if (Visit(MakeCXCursor(FriendD, TU, RegionOfInterest)))
1302      return true;
1303  } else if (TypeSourceInfo *TI = D->getFriendType()) {
1304    if (Visit(TI->getTypeLoc()))
1305      return true;
1306  }
1307  return false;
1308}
1309
1310bool CursorVisitor::VisitDecompositionDecl(DecompositionDecl *D) {
1311  for (auto *B : D->bindings()) {
1312    if (Visit(MakeCXCursor(B, TU, RegionOfInterest)))
1313      return true;
1314  }
1315  return VisitVarDecl(D);
1316}
1317
1318bool CursorVisitor::VisitConceptDecl(ConceptDecl *D) {
1319  if (VisitTemplateParameters(D->getTemplateParameters()))
1320    return true;
1321
1322  if (auto *E = D->getConstraintExpr()) {
1323    if (Visit(MakeCXCursor(E, D, TU, RegionOfInterest)))
1324      return true;
1325  }
1326  return false;
1327}
1328
1329bool CursorVisitor::VisitTypeConstraint(const TypeConstraint &TC) {
1330  if (TC.getNestedNameSpecifierLoc()) {
1331    if (VisitNestedNameSpecifierLoc(TC.getNestedNameSpecifierLoc()))
1332      return true;
1333  }
1334  if (TC.getNamedConcept()) {
1335    if (Visit(MakeCursorTemplateRef(TC.getNamedConcept(),
1336                                    TC.getConceptNameLoc(), TU)))
1337      return true;
1338  }
1339  if (auto Args = TC.getTemplateArgsAsWritten()) {
1340    for (const auto &Arg : Args->arguments()) {
1341      if (VisitTemplateArgumentLoc(Arg))
1342        return true;
1343    }
1344  }
1345  return false;
1346}
1347
1348bool CursorVisitor::VisitConceptRequirement(const concepts::Requirement &R) {
1349  using namespace concepts;
1350  switch (R.getKind()) {
1351  case Requirement::RK_Type: {
1352    const TypeRequirement &TR = cast<TypeRequirement>(R);
1353    if (!TR.isSubstitutionFailure()) {
1354      if (Visit(TR.getType()->getTypeLoc()))
1355        return true;
1356    }
1357    break;
1358  }
1359  case Requirement::RK_Simple:
1360  case Requirement::RK_Compound: {
1361    const ExprRequirement &ER = cast<ExprRequirement>(R);
1362    if (!ER.isExprSubstitutionFailure()) {
1363      if (Visit(ER.getExpr()))
1364        return true;
1365    }
1366    if (ER.getKind() == Requirement::RK_Compound) {
1367      const auto &RTR = ER.getReturnTypeRequirement();
1368      if (RTR.isTypeConstraint()) {
1369        if (const auto *Cons = RTR.getTypeConstraint())
1370          VisitTypeConstraint(*Cons);
1371      }
1372    }
1373    break;
1374  }
1375  case Requirement::RK_Nested: {
1376    const NestedRequirement &NR = cast<NestedRequirement>(R);
1377    if (!NR.hasInvalidConstraint()) {
1378      if (Visit(NR.getConstraintExpr()))
1379        return true;
1380    }
1381    break;
1382  }
1383  }
1384  return false;
1385}
1386
1387bool CursorVisitor::VisitDeclarationNameInfo(DeclarationNameInfo Name) {
1388  switch (Name.getName().getNameKind()) {
1389  case clang::DeclarationName::Identifier:
1390  case clang::DeclarationName::CXXLiteralOperatorName:
1391  case clang::DeclarationName::CXXDeductionGuideName:
1392  case clang::DeclarationName::CXXOperatorName:
1393  case clang::DeclarationName::CXXUsingDirective:
1394    return false;
1395
1396  case clang::DeclarationName::CXXConstructorName:
1397  case clang::DeclarationName::CXXDestructorName:
1398  case clang::DeclarationName::CXXConversionFunctionName:
1399    if (TypeSourceInfo *TSInfo = Name.getNamedTypeInfo())
1400      return Visit(TSInfo->getTypeLoc());
1401    return false;
1402
1403  case clang::DeclarationName::ObjCZeroArgSelector:
1404  case clang::DeclarationName::ObjCOneArgSelector:
1405  case clang::DeclarationName::ObjCMultiArgSelector:
1406    // FIXME: Per-identifier location info?
1407    return false;
1408  }
1409
1410  llvm_unreachable("Invalid DeclarationName::Kind!");
1411}
1412
1413bool CursorVisitor::VisitNestedNameSpecifier(NestedNameSpecifier *NNS,
1414                                             SourceRange Range) {
1415  // FIXME: This whole routine is a hack to work around the lack of proper
1416  // source information in nested-name-specifiers (PR5791). Since we do have
1417  // a beginning source location, we can visit the first component of the
1418  // nested-name-specifier, if it's a single-token component.
1419  if (!NNS)
1420    return false;
1421
1422  // Get the first component in the nested-name-specifier.
1423  while (NestedNameSpecifier *Prefix = NNS->getPrefix())
1424    NNS = Prefix;
1425
1426  switch (NNS->getKind()) {
1427  case NestedNameSpecifier::Namespace:
1428    return Visit(
1429        MakeCursorNamespaceRef(NNS->getAsNamespace(), Range.getBegin(), TU));
1430
1431  case NestedNameSpecifier::NamespaceAlias:
1432    return Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(),
1433                                        Range.getBegin(), TU));
1434
1435  case NestedNameSpecifier::TypeSpec: {
1436    // If the type has a form where we know that the beginning of the source
1437    // range matches up with a reference cursor. Visit the appropriate reference
1438    // cursor.
1439    const Type *T = NNS->getAsType();
1440    if (const TypedefType *Typedef = dyn_cast<TypedefType>(T))
1441      return Visit(MakeCursorTypeRef(Typedef->getDecl(), Range.getBegin(), TU));
1442    if (const TagType *Tag = dyn_cast<TagType>(T))
1443      return Visit(MakeCursorTypeRef(Tag->getDecl(), Range.getBegin(), TU));
1444    if (const TemplateSpecializationType *TST =
1445            dyn_cast<TemplateSpecializationType>(T))
1446      return VisitTemplateName(TST->getTemplateName(), Range.getBegin());
1447    break;
1448  }
1449
1450  case NestedNameSpecifier::TypeSpecWithTemplate:
1451  case NestedNameSpecifier::Global:
1452  case NestedNameSpecifier::Identifier:
1453  case NestedNameSpecifier::Super:
1454    break;
1455  }
1456
1457  return false;
1458}
1459
1460bool CursorVisitor::VisitNestedNameSpecifierLoc(
1461    NestedNameSpecifierLoc Qualifier) {
1462  SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;
1463  for (; Qualifier; Qualifier = Qualifier.getPrefix())
1464    Qualifiers.push_back(Qualifier);
1465
1466  while (!Qualifiers.empty()) {
1467    NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
1468    NestedNameSpecifier *NNS = Q.getNestedNameSpecifier();
1469    switch (NNS->getKind()) {
1470    case NestedNameSpecifier::Namespace:
1471      if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(),
1472                                       Q.getLocalBeginLoc(), TU)))
1473        return true;
1474
1475      break;
1476
1477    case NestedNameSpecifier::NamespaceAlias:
1478      if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(),
1479                                       Q.getLocalBeginLoc(), TU)))
1480        return true;
1481
1482      break;
1483
1484    case NestedNameSpecifier::TypeSpec:
1485    case NestedNameSpecifier::TypeSpecWithTemplate:
1486      if (Visit(Q.getTypeLoc()))
1487        return true;
1488
1489      break;
1490
1491    case NestedNameSpecifier::Global:
1492    case NestedNameSpecifier::Identifier:
1493    case NestedNameSpecifier::Super:
1494      break;
1495    }
1496  }
1497
1498  return false;
1499}
1500
1501bool CursorVisitor::VisitTemplateParameters(
1502    const TemplateParameterList *Params) {
1503  if (!Params)
1504    return false;
1505
1506  for (TemplateParameterList::const_iterator P = Params->begin(),
1507                                             PEnd = Params->end();
1508       P != PEnd; ++P) {
1509    if (Visit(MakeCXCursor(*P, TU, RegionOfInterest)))
1510      return true;
1511  }
1512
1513  if (const auto *E = Params->getRequiresClause()) {
1514    if (Visit(MakeCXCursor(E, nullptr, TU, RegionOfInterest)))
1515      return true;
1516  }
1517
1518  return false;
1519}
1520
1521bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) {
1522  switch (Name.getKind()) {
1523  case TemplateName::Template:
1524  case TemplateName::UsingTemplate:
1525  case TemplateName::QualifiedTemplate: // FIXME: Visit nested-name-specifier.
1526    return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU));
1527
1528  case TemplateName::OverloadedTemplate:
1529    // Visit the overloaded template set.
1530    if (Visit(MakeCursorOverloadedDeclRef(Name, Loc, TU)))
1531      return true;
1532
1533    return false;
1534
1535  case TemplateName::AssumedTemplate:
1536    // FIXME: Visit DeclarationName?
1537    return false;
1538
1539  case TemplateName::DependentTemplate:
1540    // FIXME: Visit nested-name-specifier.
1541    return false;
1542
1543  case TemplateName::SubstTemplateTemplateParm:
1544    return Visit(MakeCursorTemplateRef(
1545        Name.getAsSubstTemplateTemplateParm()->getParameter(), Loc, TU));
1546
1547  case TemplateName::SubstTemplateTemplateParmPack:
1548    return Visit(MakeCursorTemplateRef(
1549        Name.getAsSubstTemplateTemplateParmPack()->getParameterPack(), Loc,
1550        TU));
1551  }
1552
1553  llvm_unreachable("Invalid TemplateName::Kind!");
1554}
1555
1556bool CursorVisitor::VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL) {
1557  switch (TAL.getArgument().getKind()) {
1558  case TemplateArgument::Null:
1559  case TemplateArgument::Integral:
1560  case TemplateArgument::Pack:
1561    return false;
1562
1563  case TemplateArgument::Type:
1564    if (TypeSourceInfo *TSInfo = TAL.getTypeSourceInfo())
1565      return Visit(TSInfo->getTypeLoc());
1566    return false;
1567
1568  case TemplateArgument::Declaration:
1569    if (Expr *E = TAL.getSourceDeclExpression())
1570      return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
1571    return false;
1572
1573  case TemplateArgument::NullPtr:
1574    if (Expr *E = TAL.getSourceNullPtrExpression())
1575      return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
1576    return false;
1577
1578  case TemplateArgument::Expression:
1579    if (Expr *E = TAL.getSourceExpression())
1580      return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
1581    return false;
1582
1583  case TemplateArgument::Template:
1584  case TemplateArgument::TemplateExpansion:
1585    if (VisitNestedNameSpecifierLoc(TAL.getTemplateQualifierLoc()))
1586      return true;
1587
1588    return VisitTemplateName(TAL.getArgument().getAsTemplateOrTemplatePattern(),
1589                             TAL.getTemplateNameLoc());
1590  }
1591
1592  llvm_unreachable("Invalid TemplateArgument::Kind!");
1593}
1594
1595bool CursorVisitor::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1596  return VisitDeclContext(D);
1597}
1598
1599bool CursorVisitor::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
1600  return Visit(TL.getUnqualifiedLoc());
1601}
1602
1603bool CursorVisitor::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
1604  ASTContext &Context = AU->getASTContext();
1605
1606  // Some builtin types (such as Objective-C's "id", "sel", and
1607  // "Class") have associated declarations. Create cursors for those.
1608  QualType VisitType;
1609  switch (TL.getTypePtr()->getKind()) {
1610
1611  case BuiltinType::Void:
1612  case BuiltinType::NullPtr:
1613  case BuiltinType::Dependent:
1614#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
1615  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"
1619  case BuiltinType::OCLSampler:
1620  case BuiltinType::OCLEvent:
1621  case BuiltinType::OCLClkEvent:
1622  case BuiltinType::OCLQueue:
1623  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 BUILTIN_TYPE(Id, SingletonId)
1631#define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
1632#define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
1633#define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
1634#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
1635#include "clang/AST/BuiltinTypes.def"
1636    break;
1637
1638  case BuiltinType::ObjCId:
1639    VisitType = Context.getObjCIdType();
1640    break;
1641
1642  case BuiltinType::ObjCClass:
1643    VisitType = Context.getObjCClassType();
1644    break;
1645
1646  case BuiltinType::ObjCSel:
1647    VisitType = Context.getObjCSelType();
1648    break;
1649  }
1650
1651  if (!VisitType.isNull()) {
1652    if (const TypedefType *Typedef = VisitType->getAs<TypedefType>())
1653      return Visit(
1654          MakeCursorTypeRef(Typedef->getDecl(), TL.getBuiltinLoc(), TU));
1655  }
1656
1657  return false;
1658}
1659
1660bool CursorVisitor::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
1661  return Visit(MakeCursorTypeRef(TL.getTypedefNameDecl(), TL.getNameLoc(), TU));
1662}
1663
1664bool CursorVisitor::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
1665  return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1666}
1667
1668bool CursorVisitor::VisitTagTypeLoc(TagTypeLoc TL) {
1669  if (TL.isDefinition())
1670    return Visit(MakeCXCursor(TL.getDecl(), TU, RegionOfInterest));
1671
1672  return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1673}
1674
1675bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
1676  if (const auto *TC = TL.getDecl()->getTypeConstraint()) {
1677    if (VisitTypeConstraint(*TC))
1678      return true;
1679  }
1680
1681  return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1682}
1683
1684bool CursorVisitor::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
1685  return Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU));
1686}
1687
1688bool CursorVisitor::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
1689  if (Visit(MakeCursorTypeRef(TL.getDecl(), TL.getBeginLoc(), TU)))
1690    return true;
1691  for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {
1692    if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I),
1693                                        TU)))
1694      return true;
1695  }
1696
1697  return false;
1698}
1699
1700bool CursorVisitor::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
1701  if (TL.hasBaseTypeAsWritten() && Visit(TL.getBaseLoc()))
1702    return true;
1703
1704  for (unsigned I = 0, N = TL.getNumTypeArgs(); I != N; ++I) {
1705    if (Visit(TL.getTypeArgTInfo(I)->getTypeLoc()))
1706      return true;
1707  }
1708
1709  for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {
1710    if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I),
1711                                        TU)))
1712      return true;
1713  }
1714
1715  return false;
1716}
1717
1718bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
1719  return Visit(TL.getPointeeLoc());
1720}
1721
1722bool CursorVisitor::VisitParenTypeLoc(ParenTypeLoc TL) {
1723  return Visit(TL.getInnerLoc());
1724}
1725
1726bool CursorVisitor::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
1727  return Visit(TL.getInnerLoc());
1728}
1729
1730bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) {
1731  return Visit(TL.getPointeeLoc());
1732}
1733
1734bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
1735  return Visit(TL.getPointeeLoc());
1736}
1737
1738bool CursorVisitor::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
1739  return Visit(TL.getPointeeLoc());
1740}
1741
1742bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
1743  return Visit(TL.getPointeeLoc());
1744}
1745
1746bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
1747  return Visit(TL.getPointeeLoc());
1748}
1749
1750bool CursorVisitor::VisitUsingTypeLoc(UsingTypeLoc TL) {
1751  auto *underlyingDecl = TL.getUnderlyingType()->getAsTagDecl();
1752  if (underlyingDecl) {
1753    return Visit(MakeCursorTypeRef(underlyingDecl, TL.getNameLoc(), TU));
1754  }
1755  return false;
1756}
1757
1758bool CursorVisitor::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
1759  return Visit(TL.getModifiedLoc());
1760}
1761
1762bool CursorVisitor::VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) {
1763  return Visit(TL.getWrappedLoc());
1764}
1765
1766bool CursorVisitor::VisitFunctionTypeLoc(FunctionTypeLoc TL,
1767                                         bool SkipResultType) {
1768  if (!SkipResultType && Visit(TL.getReturnLoc()))
1769    return true;
1770
1771  for (unsigned I = 0, N = TL.getNumParams(); I != N; ++I)
1772    if (Decl *D = TL.getParam(I))
1773      if (Visit(MakeCXCursor(D, TU, RegionOfInterest)))
1774        return true;
1775
1776  return false;
1777}
1778
1779bool CursorVisitor::VisitArrayTypeLoc(ArrayTypeLoc TL) {
1780  if (Visit(TL.getElementLoc()))
1781    return true;
1782
1783  if (Expr *Size = TL.getSizeExpr())
1784    return Visit(MakeCXCursor(Size, StmtParent, TU, RegionOfInterest));
1785
1786  return false;
1787}
1788
1789bool CursorVisitor::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
1790  return Visit(TL.getOriginalLoc());
1791}
1792
1793bool CursorVisitor::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
1794  return Visit(TL.getOriginalLoc());
1795}
1796
1797bool CursorVisitor::VisitDeducedTemplateSpecializationTypeLoc(
1798    DeducedTemplateSpecializationTypeLoc TL) {
1799  if (VisitTemplateName(TL.getTypePtr()->getTemplateName(),
1800                        TL.getTemplateNameLoc()))
1801    return true;
1802
1803  return false;
1804}
1805
1806bool CursorVisitor::VisitTemplateSpecializationTypeLoc(
1807    TemplateSpecializationTypeLoc TL) {
1808  // Visit the template name.
1809  if (VisitTemplateName(TL.getTypePtr()->getTemplateName(),
1810                        TL.getTemplateNameLoc()))
1811    return true;
1812
1813  // Visit the template arguments.
1814  for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1815    if (VisitTemplateArgumentLoc(TL.getArgLoc(I)))
1816      return true;
1817
1818  return false;
1819}
1820
1821bool CursorVisitor::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
1822  return Visit(MakeCXCursor(TL.getUnderlyingExpr(), StmtParent, TU));
1823}
1824
1825bool CursorVisitor::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
1826  if (TypeSourceInfo *TSInfo = TL.getUnmodifiedTInfo())
1827    return Visit(TSInfo->getTypeLoc());
1828
1829  return false;
1830}
1831
1832bool CursorVisitor::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
1833  if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo())
1834    return Visit(TSInfo->getTypeLoc());
1835
1836  return false;
1837}
1838
1839bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
1840  return VisitNestedNameSpecifierLoc(TL.getQualifierLoc());
1841}
1842
1843bool CursorVisitor::VisitDependentTemplateSpecializationTypeLoc(
1844    DependentTemplateSpecializationTypeLoc TL) {
1845  // Visit the nested-name-specifier, if there is one.
1846  if (TL.getQualifierLoc() && VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
1847    return true;
1848
1849  // Visit the template arguments.
1850  for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1851    if (VisitTemplateArgumentLoc(TL.getArgLoc(I)))
1852      return true;
1853
1854  return false;
1855}
1856
1857bool CursorVisitor::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
1858  if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
1859    return true;
1860
1861  return Visit(TL.getNamedTypeLoc());
1862}
1863
1864bool CursorVisitor::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
1865  return Visit(TL.getPatternLoc());
1866}
1867
1868bool CursorVisitor::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
1869  if (Expr *E = TL.getUnderlyingExpr())
1870    return Visit(MakeCXCursor(E, StmtParent, TU));
1871
1872  return false;
1873}
1874
1875bool CursorVisitor::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
1876  return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1877}
1878
1879bool CursorVisitor::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
1880  return Visit(TL.getValueLoc());
1881}
1882
1883bool CursorVisitor::VisitPipeTypeLoc(PipeTypeLoc TL) {
1884  return Visit(TL.getValueLoc());
1885}
1886
1887#define DEFAULT_TYPELOC_IMPL(CLASS, PARENT)                                    \
1888  bool CursorVisitor::Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) {               \
1889    return Visit##PARENT##Loc(TL);                                             \
1890  }
1891
1892DEFAULT_TYPELOC_IMPL(Complex, Type)
1893DEFAULT_TYPELOC_IMPL(ConstantArray, ArrayType)
1894DEFAULT_TYPELOC_IMPL(IncompleteArray, ArrayType)
1895DEFAULT_TYPELOC_IMPL(VariableArray, ArrayType)
1896DEFAULT_TYPELOC_IMPL(DependentSizedArray, ArrayType)
1897DEFAULT_TYPELOC_IMPL(DependentAddressSpace, Type)
1898DEFAULT_TYPELOC_IMPL(DependentVector, Type)
1899DEFAULT_TYPELOC_IMPL(DependentSizedExtVector, Type)
1900DEFAULT_TYPELOC_IMPL(Vector, Type)
1901DEFAULT_TYPELOC_IMPL(ExtVector, VectorType)
1902DEFAULT_TYPELOC_IMPL(ConstantMatrix, MatrixType)
1903DEFAULT_TYPELOC_IMPL(DependentSizedMatrix, MatrixType)
1904DEFAULT_TYPELOC_IMPL(FunctionProto, FunctionType)
1905DEFAULT_TYPELOC_IMPL(FunctionNoProto, FunctionType)
1906DEFAULT_TYPELOC_IMPL(Record, TagType)
1907DEFAULT_TYPELOC_IMPL(Enum, TagType)
1908DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParm, Type)
1909DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParmPack, Type)
1910DEFAULT_TYPELOC_IMPL(Auto, Type)
1911DEFAULT_TYPELOC_IMPL(BitInt, Type)
1912DEFAULT_TYPELOC_IMPL(DependentBitInt, Type)
1913
1914bool CursorVisitor::VisitCXXRecordDecl(CXXRecordDecl *D) {
1915  // Visit the nested-name-specifier, if present.
1916  if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1917    if (VisitNestedNameSpecifierLoc(QualifierLoc))
1918      return true;
1919
1920  if (D->isCompleteDefinition()) {
1921    for (const auto &I : D->bases()) {
1922      if (Visit(cxcursor::MakeCursorCXXBaseSpecifier(&I, TU)))
1923        return true;
1924    }
1925  }
1926
1927  return VisitTagDecl(D);
1928}
1929
1930bool CursorVisitor::VisitAttributes(Decl *D) {
1931  for (const auto *I : D->attrs())
1932    if ((TU->ParsingOptions & CXTranslationUnit_VisitImplicitAttributes ||
1933         !I->isImplicit()) &&
1934        Visit(MakeCXCursor(I, D, TU)))
1935      return true;
1936
1937  return false;
1938}
1939
1940//===----------------------------------------------------------------------===//
1941// Data-recursive visitor methods.
1942//===----------------------------------------------------------------------===//
1943
1944namespace {
1945#define DEF_JOB(NAME, DATA, KIND)                                              \
1946  class NAME : public VisitorJob {                                             \
1947  public:                                                                      \
1948    NAME(const DATA *d, CXCursor parent)                                       \
1949        : VisitorJob(parent, VisitorJob::KIND, d) {}                           \
1950    static bool classof(const VisitorJob *VJ) {                                \
1951      return VJ->getKind() == KIND;                                            \
1952    }                                                                          \
1953    const DATA *get() const { return static_cast<const DATA *>(data[0]); }     \
1954  };
1955
1956DEF_JOB(StmtVisit, Stmt, StmtVisitKind)
1957DEF_JOB(MemberExprParts, MemberExpr, MemberExprPartsKind)
1958DEF_JOB(DeclRefExprParts, DeclRefExpr, DeclRefExprPartsKind)
1959DEF_JOB(OverloadExprParts, OverloadExpr, OverloadExprPartsKind)
1960DEF_JOB(SizeOfPackExprParts, SizeOfPackExpr, SizeOfPackExprPartsKind)
1961DEF_JOB(LambdaExprParts, LambdaExpr, LambdaExprPartsKind)
1962DEF_JOB(ConceptSpecializationExprVisit, ConceptSpecializationExpr,
1963        ConceptSpecializationExprVisitKind)
1964DEF_JOB(RequiresExprVisit, RequiresExpr, RequiresExprVisitKind)
1965DEF_JOB(PostChildrenVisit, void, PostChildrenVisitKind)
1966#undef DEF_JOB
1967
1968class ExplicitTemplateArgsVisit : public VisitorJob {
1969public:
1970  ExplicitTemplateArgsVisit(const TemplateArgumentLoc *Begin,
1971                            const TemplateArgumentLoc *End, CXCursor parent)
1972      : VisitorJob(parent, VisitorJob::ExplicitTemplateArgsVisitKind, Begin,
1973                   End) {}
1974  static bool classof(const VisitorJob *VJ) {
1975    return VJ->getKind() == ExplicitTemplateArgsVisitKind;
1976  }
1977  const TemplateArgumentLoc *begin() const {
1978    return static_cast<const TemplateArgumentLoc *>(data[0]);
1979  }
1980  const TemplateArgumentLoc *end() {
1981    return static_cast<const TemplateArgumentLoc *>(data[1]);
1982  }
1983};
1984class DeclVisit : public VisitorJob {
1985public:
1986  DeclVisit(const Decl *D, CXCursor parent, bool isFirst)
1987      : VisitorJob(parent, VisitorJob::DeclVisitKind, D,
1988                   isFirst ? (void *)1 : (void *)nullptr) {}
1989  static bool classof(const VisitorJob *VJ) {
1990    return VJ->getKind() == DeclVisitKind;
1991  }
1992  const Decl *get() const { return static_cast<const Decl *>(data[0]); }
1993  bool isFirst() const { return data[1] != nullptr; }
1994};
1995class TypeLocVisit : public VisitorJob {
1996public:
1997  TypeLocVisit(TypeLoc tl, CXCursor parent)
1998      : VisitorJob(parent, VisitorJob::TypeLocVisitKind,
1999                   tl.getType().getAsOpaquePtr(), tl.getOpaqueData()) {}
2000
2001  static bool classof(const VisitorJob *VJ) {
2002    return VJ->getKind() == TypeLocVisitKind;
2003  }
2004
2005  TypeLoc get() const {
2006    QualType T = QualType::getFromOpaquePtr(data[0]);
2007    return TypeLoc(T, const_cast<void *>(data[1]));
2008  }
2009};
2010
2011class LabelRefVisit : public VisitorJob {
2012public:
2013  LabelRefVisit(LabelDecl *LD, SourceLocation labelLoc, CXCursor parent)
2014      : VisitorJob(parent, VisitorJob::LabelRefVisitKind, LD,
2015                   labelLoc.getPtrEncoding()) {}
2016
2017  static bool classof(const VisitorJob *VJ) {
2018    return VJ->getKind() == VisitorJob::LabelRefVisitKind;
2019  }
2020  const LabelDecl *get() const {
2021    return static_cast<const LabelDecl *>(data[0]);
2022  }
2023  SourceLocation getLoc() const {
2024    return SourceLocation::getFromPtrEncoding(data[1]);
2025  }
2026};
2027
2028class NestedNameSpecifierLocVisit : public VisitorJob {
2029public:
2030  NestedNameSpecifierLocVisit(NestedNameSpecifierLoc Qualifier, CXCursor parent)
2031      : VisitorJob(parent, VisitorJob::NestedNameSpecifierLocVisitKind,
2032                   Qualifier.getNestedNameSpecifier(),
2033                   Qualifier.getOpaqueData()) {}
2034
2035  static bool classof(const VisitorJob *VJ) {
2036    return VJ->getKind() == VisitorJob::NestedNameSpecifierLocVisitKind;
2037  }
2038
2039  NestedNameSpecifierLoc get() const {
2040    return NestedNameSpecifierLoc(
2041        const_cast<NestedNameSpecifier *>(
2042            static_cast<const NestedNameSpecifier *>(data[0])),
2043        const_cast<void *>(data[1]));
2044  }
2045};
2046
2047class DeclarationNameInfoVisit : public VisitorJob {
2048public:
2049  DeclarationNameInfoVisit(const Stmt *S, CXCursor parent)
2050      : VisitorJob(parent, VisitorJob::DeclarationNameInfoVisitKind, S) {}
2051  static bool classof(const VisitorJob *VJ) {
2052    return VJ->getKind() == VisitorJob::DeclarationNameInfoVisitKind;
2053  }
2054  DeclarationNameInfo get() const {
2055    const Stmt *S = static_cast<const Stmt *>(data[0]);
2056    switch (S->getStmtClass()) {
2057    default:
2058      llvm_unreachable("Unhandled Stmt");
2059    case clang::Stmt::MSDependentExistsStmtClass:
2060      return cast<MSDependentExistsStmt>(S)->getNameInfo();
2061    case Stmt::CXXDependentScopeMemberExprClass:
2062      return cast<CXXDependentScopeMemberExpr>(S)->getMemberNameInfo();
2063    case Stmt::DependentScopeDeclRefExprClass:
2064      return cast<DependentScopeDeclRefExpr>(S)->getNameInfo();
2065    case Stmt::OMPCriticalDirectiveClass:
2066      return cast<OMPCriticalDirective>(S)->getDirectiveName();
2067    }
2068  }
2069};
2070class MemberRefVisit : public VisitorJob {
2071public:
2072  MemberRefVisit(const FieldDecl *D, SourceLocation L, CXCursor parent)
2073      : VisitorJob(parent, VisitorJob::MemberRefVisitKind, D,
2074                   L.getPtrEncoding()) {}
2075  static bool classof(const VisitorJob *VJ) {
2076    return VJ->getKind() == VisitorJob::MemberRefVisitKind;
2077  }
2078  const FieldDecl *get() const {
2079    return static_cast<const FieldDecl *>(data[0]);
2080  }
2081  SourceLocation getLoc() const {
2082    return SourceLocation::getFromRawEncoding(
2083        (SourceLocation::UIntTy)(uintptr_t)data[1]);
2084  }
2085};
2086class EnqueueVisitor : public ConstStmtVisitor<EnqueueVisitor, void> {
2087  friend class OMPClauseEnqueue;
2088  VisitorWorkList &WL;
2089  CXCursor Parent;
2090
2091public:
2092  EnqueueVisitor(VisitorWorkList &wl, CXCursor parent)
2093      : WL(wl), Parent(parent) {}
2094
2095  void VisitAddrLabelExpr(const AddrLabelExpr *E);
2096  void VisitBlockExpr(const BlockExpr *B);
2097  void VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
2098  void VisitCompoundStmt(const CompoundStmt *S);
2099  void VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) { /* Do nothing. */
2100  }
2101  void VisitMSDependentExistsStmt(const MSDependentExistsStmt *S);
2102  void VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E);
2103  void VisitCXXNewExpr(const CXXNewExpr *E);
2104  void VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E);
2105  void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *E);
2106  void VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E);
2107  void VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *E);
2108  void VisitCXXTypeidExpr(const CXXTypeidExpr *E);
2109  void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *E);
2110  void VisitCXXUuidofExpr(const CXXUuidofExpr *E);
2111  void VisitCXXCatchStmt(const CXXCatchStmt *S);
2112  void VisitCXXForRangeStmt(const CXXForRangeStmt *S);
2113  void VisitDeclRefExpr(const DeclRefExpr *D);
2114  void VisitDeclStmt(const DeclStmt *S);
2115  void VisitDependentScopeDeclRefExpr(const DependentScopeDeclRefExpr *E);
2116  void VisitDesignatedInitExpr(const DesignatedInitExpr *E);
2117  void VisitExplicitCastExpr(const ExplicitCastExpr *E);
2118  void VisitForStmt(const ForStmt *FS);
2119  void VisitGotoStmt(const GotoStmt *GS);
2120  void VisitIfStmt(const IfStmt *If);
2121  void VisitInitListExpr(const InitListExpr *IE);
2122  void VisitMemberExpr(const MemberExpr *M);
2123  void VisitOffsetOfExpr(const OffsetOfExpr *E);
2124  void VisitObjCEncodeExpr(const ObjCEncodeExpr *E);
2125  void VisitObjCMessageExpr(const ObjCMessageExpr *M);
2126  void VisitOverloadExpr(const OverloadExpr *E);
2127  void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
2128  void VisitStmt(const Stmt *S);
2129  void VisitSwitchStmt(const SwitchStmt *S);
2130  void VisitWhileStmt(const WhileStmt *W);
2131  void VisitTypeTraitExpr(const TypeTraitExpr *E);
2132  void VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E);
2133  void VisitExpressionTraitExpr(const ExpressionTraitExpr *E);
2134  void VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U);
2135  void VisitVAArgExpr(const VAArgExpr *E);
2136  void VisitSizeOfPackExpr(const SizeOfPackExpr *E);
2137  void VisitPseudoObjectExpr(const PseudoObjectExpr *E);
2138  void VisitOpaqueValueExpr(const OpaqueValueExpr *E);
2139  void VisitLambdaExpr(const LambdaExpr *E);
2140  void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E);
2141  void VisitRequiresExpr(const RequiresExpr *E);
2142  void VisitCXXParenListInitExpr(const CXXParenListInitExpr *E);
2143  void VisitOMPExecutableDirective(const OMPExecutableDirective *D);
2144  void VisitOMPLoopBasedDirective(const OMPLoopBasedDirective *D);
2145  void VisitOMPLoopDirective(const OMPLoopDirective *D);
2146  void VisitOMPParallelDirective(const OMPParallelDirective *D);
2147  void VisitOMPSimdDirective(const OMPSimdDirective *D);
2148  void
2149  VisitOMPLoopTransformationDirective(const OMPLoopTransformationDirective *D);
2150  void VisitOMPTileDirective(const OMPTileDirective *D);
2151  void VisitOMPUnrollDirective(const OMPUnrollDirective *D);
2152  void VisitOMPForDirective(const OMPForDirective *D);
2153  void VisitOMPForSimdDirective(const OMPForSimdDirective *D);
2154  void VisitOMPSectionsDirective(const OMPSectionsDirective *D);
2155  void VisitOMPSectionDirective(const OMPSectionDirective *D);
2156  void VisitOMPSingleDirective(const OMPSingleDirective *D);
2157  void VisitOMPMasterDirective(const OMPMasterDirective *D);
2158  void VisitOMPCriticalDirective(const OMPCriticalDirective *D);
2159  void VisitOMPParallelForDirective(const OMPParallelForDirective *D);
2160  void VisitOMPParallelForSimdDirective(const OMPParallelForSimdDirective *D);
2161  void VisitOMPParallelMasterDirective(const OMPParallelMasterDirective *D);
2162  void VisitOMPParallelMaskedDirective(const OMPParallelMaskedDirective *D);
2163  void VisitOMPParallelSectionsDirective(const OMPParallelSectionsDirective *D);
2164  void VisitOMPTaskDirective(const OMPTaskDirective *D);
2165  void VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *D);
2166  void VisitOMPBarrierDirective(const OMPBarrierDirective *D);
2167  void VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D);
2168  void VisitOMPErrorDirective(const OMPErrorDirective *D);
2169  void VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *D);
2170  void
2171  VisitOMPCancellationPointDirective(const OMPCancellationPointDirective *D);
2172  void VisitOMPCancelDirective(const OMPCancelDirective *D);
2173  void VisitOMPFlushDirective(const OMPFlushDirective *D);
2174  void VisitOMPDepobjDirective(const OMPDepobjDirective *D);
2175  void VisitOMPScanDirective(const OMPScanDirective *D);
2176  void VisitOMPOrderedDirective(const OMPOrderedDirective *D);
2177  void VisitOMPAtomicDirective(const OMPAtomicDirective *D);
2178  void VisitOMPTargetDirective(const OMPTargetDirective *D);
2179  void VisitOMPTargetDataDirective(const OMPTargetDataDirective *D);
2180  void VisitOMPTargetEnterDataDirective(const OMPTargetEnterDataDirective *D);
2181  void VisitOMPTargetExitDataDirective(const OMPTargetExitDataDirective *D);
2182  void VisitOMPTargetParallelDirective(const OMPTargetParallelDirective *D);
2183  void
2184  VisitOMPTargetParallelForDirective(const OMPTargetParallelForDirective *D);
2185  void VisitOMPTeamsDirective(const OMPTeamsDirective *D);
2186  void VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D);
2187  void VisitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective *D);
2188  void VisitOMPMasterTaskLoopDirective(const OMPMasterTaskLoopDirective *D);
2189  void VisitOMPMaskedTaskLoopDirective(const OMPMaskedTaskLoopDirective *D);
2190  void
2191  VisitOMPMasterTaskLoopSimdDirective(const OMPMasterTaskLoopSimdDirective *D);
2192  void VisitOMPMaskedTaskLoopSimdDirective(
2193      const OMPMaskedTaskLoopSimdDirective *D);
2194  void VisitOMPParallelMasterTaskLoopDirective(
2195      const OMPParallelMasterTaskLoopDirective *D);
2196  void VisitOMPParallelMaskedTaskLoopDirective(
2197      const OMPParallelMaskedTaskLoopDirective *D);
2198  void VisitOMPParallelMasterTaskLoopSimdDirective(
2199      const OMPParallelMasterTaskLoopSimdDirective *D);
2200  void VisitOMPParallelMaskedTaskLoopSimdDirective(
2201      const OMPParallelMaskedTaskLoopSimdDirective *D);
2202  void VisitOMPDistributeDirective(const OMPDistributeDirective *D);
2203  void VisitOMPDistributeParallelForDirective(
2204      const OMPDistributeParallelForDirective *D);
2205  void VisitOMPDistributeParallelForSimdDirective(
2206      const OMPDistributeParallelForSimdDirective *D);
2207  void VisitOMPDistributeSimdDirective(const OMPDistributeSimdDirective *D);
2208  void VisitOMPTargetParallelForSimdDirective(
2209      const OMPTargetParallelForSimdDirective *D);
2210  void VisitOMPTargetSimdDirective(const OMPTargetSimdDirective *D);
2211  void VisitOMPTeamsDistributeDirective(const OMPTeamsDistributeDirective *D);
2212  void VisitOMPTeamsDistributeSimdDirective(
2213      const OMPTeamsDistributeSimdDirective *D);
2214  void VisitOMPTeamsDistributeParallelForSimdDirective(
2215      const OMPTeamsDistributeParallelForSimdDirective *D);
2216  void VisitOMPTeamsDistributeParallelForDirective(
2217      const OMPTeamsDistributeParallelForDirective *D);
2218  void VisitOMPTargetTeamsDirective(const OMPTargetTeamsDirective *D);
2219  void VisitOMPTargetTeamsDistributeDirective(
2220      const OMPTargetTeamsDistributeDirective *D);
2221  void VisitOMPTargetTeamsDistributeParallelForDirective(
2222      const OMPTargetTeamsDistributeParallelForDirective *D);
2223  void VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2224      const OMPTargetTeamsDistributeParallelForSimdDirective *D);
2225  void VisitOMPTargetTeamsDistributeSimdDirective(
2226      const OMPTargetTeamsDistributeSimdDirective *D);
2227
2228private:
2229  void AddDeclarationNameInfo(const Stmt *S);
2230  void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier);
2231  void AddExplicitTemplateArgs(const TemplateArgumentLoc *A,
2232                               unsigned NumTemplateArgs);
2233  void AddMemberRef(const FieldDecl *D, SourceLocation L);
2234  void AddStmt(const Stmt *S);
2235  void AddDecl(const Decl *D, bool isFirst = true);
2236  void AddTypeLoc(TypeSourceInfo *TI);
2237  void EnqueueChildren(const Stmt *S);
2238  void EnqueueChildren(const OMPClause *S);
2239};
2240} // namespace
2241
2242void EnqueueVisitor::AddDeclarationNameInfo(const Stmt *S) {
2243  // 'S' should always be non-null, since it comes from the
2244  // statement we are visiting.
2245  WL.push_back(DeclarationNameInfoVisit(S, Parent));
2246}
2247
2248void EnqueueVisitor::AddNestedNameSpecifierLoc(
2249    NestedNameSpecifierLoc Qualifier) {
2250  if (Qualifier)
2251    WL.push_back(NestedNameSpecifierLocVisit(Qualifier, Parent));
2252}
2253
2254void EnqueueVisitor::AddStmt(const Stmt *S) {
2255  if (S)
2256    WL.push_back(StmtVisit(S, Parent));
2257}
2258void EnqueueVisitor::AddDecl(const Decl *D, bool isFirst) {
2259  if (D)
2260    WL.push_back(DeclVisit(D, Parent, isFirst));
2261}
2262void EnqueueVisitor::AddExplicitTemplateArgs(const TemplateArgumentLoc *A,
2263                                             unsigned NumTemplateArgs) {
2264  WL.push_back(ExplicitTemplateArgsVisit(A, A + NumTemplateArgs, Parent));
2265}
2266void EnqueueVisitor::AddMemberRef(const FieldDecl *D, SourceLocation L) {
2267  if (D)
2268    WL.push_back(MemberRefVisit(D, L, Parent));
2269}
2270void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) {
2271  if (TI)
2272    WL.push_back(TypeLocVisit(TI->getTypeLoc(), Parent));
2273}
2274void EnqueueVisitor::EnqueueChildren(const Stmt *S) {
2275  unsigned size = WL.size();
2276  for (const Stmt *SubStmt : S->children()) {
2277    AddStmt(SubStmt);
2278  }
2279  if (size == WL.size())
2280    return;
2281  // Now reverse the entries we just added.  This will match the DFS
2282  // ordering performed by the worklist.
2283  VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
2284  std::reverse(I, E);
2285}
2286namespace {
2287class OMPClauseEnqueue : public ConstOMPClauseVisitor<OMPClauseEnqueue> {
2288  EnqueueVisitor *Visitor;
2289  /// Process clauses with list of variables.
2290  template <typename T> void VisitOMPClauseList(T *Node);
2291
2292public:
2293  OMPClauseEnqueue(EnqueueVisitor *Visitor) : Visitor(Visitor) {}
2294#define GEN_CLANG_CLAUSE_CLASS
2295#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C);
2296#include "llvm/Frontend/OpenMP/OMP.inc"
2297  void VisitOMPClauseWithPreInit(const OMPClauseWithPreInit *C);
2298  void VisitOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C);
2299};
2300
2301void OMPClauseEnqueue::VisitOMPClauseWithPreInit(
2302    const OMPClauseWithPreInit *C) {
2303  Visitor->AddStmt(C->getPreInitStmt());
2304}
2305
2306void OMPClauseEnqueue::VisitOMPClauseWithPostUpdate(
2307    const OMPClauseWithPostUpdate *C) {
2308  VisitOMPClauseWithPreInit(C);
2309  Visitor->AddStmt(C->getPostUpdateExpr());
2310}
2311
2312void OMPClauseEnqueue::VisitOMPIfClause(const OMPIfClause *C) {
2313  VisitOMPClauseWithPreInit(C);
2314  Visitor->AddStmt(C->getCondition());
2315}
2316
2317void OMPClauseEnqueue::VisitOMPFinalClause(const OMPFinalClause *C) {
2318  Visitor->AddStmt(C->getCondition());
2319}
2320
2321void OMPClauseEnqueue::VisitOMPNumThreadsClause(const OMPNumThreadsClause *C) {
2322  VisitOMPClauseWithPreInit(C);
2323  Visitor->AddStmt(C->getNumThreads());
2324}
2325
2326void OMPClauseEnqueue::VisitOMPSafelenClause(const OMPSafelenClause *C) {
2327  Visitor->AddStmt(C->getSafelen());
2328}
2329
2330void OMPClauseEnqueue::VisitOMPSimdlenClause(const OMPSimdlenClause *C) {
2331  Visitor->AddStmt(C->getSimdlen());
2332}
2333
2334void OMPClauseEnqueue::VisitOMPSizesClause(const OMPSizesClause *C) {
2335  for (auto E : C->getSizesRefs())
2336    Visitor->AddStmt(E);
2337}
2338
2339void OMPClauseEnqueue::VisitOMPFullClause(const OMPFullClause *C) {}
2340
2341void OMPClauseEnqueue::VisitOMPPartialClause(const OMPPartialClause *C) {
2342  Visitor->AddStmt(C->getFactor());
2343}
2344
2345void OMPClauseEnqueue::VisitOMPAllocatorClause(const OMPAllocatorClause *C) {
2346  Visitor->AddStmt(C->getAllocator());
2347}
2348
2349void OMPClauseEnqueue::VisitOMPCollapseClause(const OMPCollapseClause *C) {
2350  Visitor->AddStmt(C->getNumForLoops());
2351}
2352
2353void OMPClauseEnqueue::VisitOMPDefaultClause(const OMPDefaultClause *C) {}
2354
2355void OMPClauseEnqueue::VisitOMPProcBindClause(const OMPProcBindClause *C) {}
2356
2357void OMPClauseEnqueue::VisitOMPScheduleClause(const OMPScheduleClause *C) {
2358  VisitOMPClauseWithPreInit(C);
2359  Visitor->AddStmt(C->getChunkSize());
2360}
2361
2362void OMPClauseEnqueue::VisitOMPOrderedClause(const OMPOrderedClause *C) {
2363  Visitor->AddStmt(C->getNumForLoops());
2364}
2365
2366void OMPClauseEnqueue::VisitOMPDetachClause(const OMPDetachClause *C) {
2367  Visitor->AddStmt(C->getEventHandler());
2368}
2369
2370void OMPClauseEnqueue::VisitOMPNowaitClause(const OMPNowaitClause *) {}
2371
2372void OMPClauseEnqueue::VisitOMPUntiedClause(const OMPUntiedClause *) {}
2373
2374void OMPClauseEnqueue::VisitOMPMergeableClause(const OMPMergeableClause *) {}
2375
2376void OMPClauseEnqueue::VisitOMPReadClause(const OMPReadClause *) {}
2377
2378void OMPClauseEnqueue::VisitOMPWriteClause(const OMPWriteClause *) {}
2379
2380void OMPClauseEnqueue::VisitOMPUpdateClause(const OMPUpdateClause *) {}
2381
2382void OMPClauseEnqueue::VisitOMPCaptureClause(const OMPCaptureClause *) {}
2383
2384void OMPClauseEnqueue::VisitOMPCompareClause(const OMPCompareClause *) {}
2385
2386void OMPClauseEnqueue::VisitOMPSeqCstClause(const OMPSeqCstClause *) {}
2387
2388void OMPClauseEnqueue::VisitOMPAcqRelClause(const OMPAcqRelClause *) {}
2389
2390void OMPClauseEnqueue::VisitOMPAcquireClause(const OMPAcquireClause *) {}
2391
2392void OMPClauseEnqueue::VisitOMPReleaseClause(const OMPReleaseClause *) {}
2393
2394void OMPClauseEnqueue::VisitOMPRelaxedClause(const OMPRelaxedClause *) {}
2395
2396void OMPClauseEnqueue::VisitOMPThreadsClause(const OMPThreadsClause *) {}
2397
2398void OMPClauseEnqueue::VisitOMPSIMDClause(const OMPSIMDClause *) {}
2399
2400void OMPClauseEnqueue::VisitOMPNogroupClause(const OMPNogroupClause *) {}
2401
2402void OMPClauseEnqueue::VisitOMPInitClause(const OMPInitClause *C) {
2403  VisitOMPClauseList(C);
2404}
2405
2406void OMPClauseEnqueue::VisitOMPUseClause(const OMPUseClause *C) {
2407  Visitor->AddStmt(C->getInteropVar());
2408}
2409
2410void OMPClauseEnqueue::VisitOMPDestroyClause(const OMPDestroyClause *C) {
2411  if (C->getInteropVar())
2412    Visitor->AddStmt(C->getInteropVar());
2413}
2414
2415void OMPClauseEnqueue::VisitOMPNovariantsClause(const OMPNovariantsClause *C) {
2416  Visitor->AddStmt(C->getCondition());
2417}
2418
2419void OMPClauseEnqueue::VisitOMPNocontextClause(const OMPNocontextClause *C) {
2420  Visitor->AddStmt(C->getCondition());
2421}
2422
2423void OMPClauseEnqueue::VisitOMPFilterClause(const OMPFilterClause *C) {
2424  VisitOMPClauseWithPreInit(C);
2425  Visitor->AddStmt(C->getThreadID());
2426}
2427
2428void OMPClauseEnqueue::VisitOMPAlignClause(const OMPAlignClause *C) {
2429  Visitor->AddStmt(C->getAlignment());
2430}
2431
2432void OMPClauseEnqueue::VisitOMPUnifiedAddressClause(
2433    const OMPUnifiedAddressClause *) {}
2434
2435void OMPClauseEnqueue::VisitOMPUnifiedSharedMemoryClause(
2436    const OMPUnifiedSharedMemoryClause *) {}
2437
2438void OMPClauseEnqueue::VisitOMPReverseOffloadClause(
2439    const OMPReverseOffloadClause *) {}
2440
2441void OMPClauseEnqueue::VisitOMPDynamicAllocatorsClause(
2442    const OMPDynamicAllocatorsClause *) {}
2443
2444void OMPClauseEnqueue::VisitOMPAtomicDefaultMemOrderClause(
2445    const OMPAtomicDefaultMemOrderClause *) {}
2446
2447void OMPClauseEnqueue::VisitOMPAtClause(const OMPAtClause *) {}
2448
2449void OMPClauseEnqueue::VisitOMPSeverityClause(const OMPSeverityClause *) {}
2450
2451void OMPClauseEnqueue::VisitOMPMessageClause(const OMPMessageClause *) {}
2452
2453void OMPClauseEnqueue::VisitOMPDeviceClause(const OMPDeviceClause *C) {
2454  Visitor->AddStmt(C->getDevice());
2455}
2456
2457void OMPClauseEnqueue::VisitOMPNumTeamsClause(const OMPNumTeamsClause *C) {
2458  VisitOMPClauseWithPreInit(C);
2459  Visitor->AddStmt(C->getNumTeams());
2460}
2461
2462void OMPClauseEnqueue::VisitOMPThreadLimitClause(
2463    const OMPThreadLimitClause *C) {
2464  VisitOMPClauseWithPreInit(C);
2465  Visitor->AddStmt(C->getThreadLimit());
2466}
2467
2468void OMPClauseEnqueue::VisitOMPPriorityClause(const OMPPriorityClause *C) {
2469  Visitor->AddStmt(C->getPriority());
2470}
2471
2472void OMPClauseEnqueue::VisitOMPGrainsizeClause(const OMPGrainsizeClause *C) {
2473  Visitor->AddStmt(C->getGrainsize());
2474}
2475
2476void OMPClauseEnqueue::VisitOMPNumTasksClause(const OMPNumTasksClause *C) {
2477  Visitor->AddStmt(C->getNumTasks());
2478}
2479
2480void OMPClauseEnqueue::VisitOMPHintClause(const OMPHintClause *C) {
2481  Visitor->AddStmt(C->getHint());
2482}
2483
2484template <typename T> void OMPClauseEnqueue::VisitOMPClauseList(T *Node) {
2485  for (const auto *I : Node->varlists()) {
2486    Visitor->AddStmt(I);
2487  }
2488}
2489
2490void OMPClauseEnqueue::VisitOMPInclusiveClause(const OMPInclusiveClause *C) {
2491  VisitOMPClauseList(C);
2492}
2493void OMPClauseEnqueue::VisitOMPExclusiveClause(const OMPExclusiveClause *C) {
2494  VisitOMPClauseList(C);
2495}
2496void OMPClauseEnqueue::VisitOMPAllocateClause(const OMPAllocateClause *C) {
2497  VisitOMPClauseList(C);
2498  Visitor->AddStmt(C->getAllocator());
2499}
2500void OMPClauseEnqueue::VisitOMPPrivateClause(const OMPPrivateClause *C) {
2501  VisitOMPClauseList(C);
2502  for (const auto *E : C->private_copies()) {
2503    Visitor->AddStmt(E);
2504  }
2505}
2506void OMPClauseEnqueue::VisitOMPFirstprivateClause(
2507    const OMPFirstprivateClause *C) {
2508  VisitOMPClauseList(C);
2509  VisitOMPClauseWithPreInit(C);
2510  for (const auto *E : C->private_copies()) {
2511    Visitor->AddStmt(E);
2512  }
2513  for (const auto *E : C->inits()) {
2514    Visitor->AddStmt(E);
2515  }
2516}
2517void OMPClauseEnqueue::VisitOMPLastprivateClause(
2518    const OMPLastprivateClause *C) {
2519  VisitOMPClauseList(C);
2520  VisitOMPClauseWithPostUpdate(C);
2521  for (auto *E : C->private_copies()) {
2522    Visitor->AddStmt(E);
2523  }
2524  for (auto *E : C->source_exprs()) {
2525    Visitor->AddStmt(E);
2526  }
2527  for (auto *E : C->destination_exprs()) {
2528    Visitor->AddStmt(E);
2529  }
2530  for (auto *E : C->assignment_ops()) {
2531    Visitor->AddStmt(E);
2532  }
2533}
2534void OMPClauseEnqueue::VisitOMPSharedClause(const OMPSharedClause *C) {
2535  VisitOMPClauseList(C);
2536}
2537void OMPClauseEnqueue::VisitOMPReductionClause(const OMPReductionClause *C) {
2538  VisitOMPClauseList(C);
2539  VisitOMPClauseWithPostUpdate(C);
2540  for (auto *E : C->privates()) {
2541    Visitor->AddStmt(E);
2542  }
2543  for (auto *E : C->lhs_exprs()) {
2544    Visitor->AddStmt(E);
2545  }
2546  for (auto *E : C->rhs_exprs()) {
2547    Visitor->AddStmt(E);
2548  }
2549  for (auto *E : C->reduction_ops()) {
2550    Visitor->AddStmt(E);
2551  }
2552  if (C->getModifier() == clang::OMPC_REDUCTION_inscan) {
2553    for (auto *E : C->copy_ops()) {
2554      Visitor->AddStmt(E);
2555    }
2556    for (auto *E : C->copy_array_temps()) {
2557      Visitor->AddStmt(E);
2558    }
2559    for (auto *E : C->copy_array_elems()) {
2560      Visitor->AddStmt(E);
2561    }
2562  }
2563}
2564void OMPClauseEnqueue::VisitOMPTaskReductionClause(
2565    const OMPTaskReductionClause *C) {
2566  VisitOMPClauseList(C);
2567  VisitOMPClauseWithPostUpdate(C);
2568  for (auto *E : C->privates()) {
2569    Visitor->AddStmt(E);
2570  }
2571  for (auto *E : C->lhs_exprs()) {
2572    Visitor->AddStmt(E);
2573  }
2574  for (auto *E : C->rhs_exprs()) {
2575    Visitor->AddStmt(E);
2576  }
2577  for (auto *E : C->reduction_ops()) {
2578    Visitor->AddStmt(E);
2579  }
2580}
2581void OMPClauseEnqueue::VisitOMPInReductionClause(
2582    const OMPInReductionClause *C) {
2583  VisitOMPClauseList(C);
2584  VisitOMPClauseWithPostUpdate(C);
2585  for (auto *E : C->privates()) {
2586    Visitor->AddStmt(E);
2587  }
2588  for (auto *E : C->lhs_exprs()) {
2589    Visitor->AddStmt(E);
2590  }
2591  for (auto *E : C->rhs_exprs()) {
2592    Visitor->AddStmt(E);
2593  }
2594  for (auto *E : C->reduction_ops()) {
2595    Visitor->AddStmt(E);
2596  }
2597  for (auto *E : C->taskgroup_descriptors())
2598    Visitor->AddStmt(E);
2599}
2600void OMPClauseEnqueue::VisitOMPLinearClause(const OMPLinearClause *C) {
2601  VisitOMPClauseList(C);
2602  VisitOMPClauseWithPostUpdate(C);
2603  for (const auto *E : C->privates()) {
2604    Visitor->AddStmt(E);
2605  }
2606  for (const auto *E : C->inits()) {
2607    Visitor->AddStmt(E);
2608  }
2609  for (const auto *E : C->updates()) {
2610    Visitor->AddStmt(E);
2611  }
2612  for (const auto *E : C->finals()) {
2613    Visitor->AddStmt(E);
2614  }
2615  Visitor->AddStmt(C->getStep());
2616  Visitor->AddStmt(C->getCalcStep());
2617}
2618void OMPClauseEnqueue::VisitOMPAlignedClause(const OMPAlignedClause *C) {
2619  VisitOMPClauseList(C);
2620  Visitor->AddStmt(C->getAlignment());
2621}
2622void OMPClauseEnqueue::VisitOMPCopyinClause(const OMPCopyinClause *C) {
2623  VisitOMPClauseList(C);
2624  for (auto *E : C->source_exprs()) {
2625    Visitor->AddStmt(E);
2626  }
2627  for (auto *E : C->destination_exprs()) {
2628    Visitor->AddStmt(E);
2629  }
2630  for (auto *E : C->assignment_ops()) {
2631    Visitor->AddStmt(E);
2632  }
2633}
2634void OMPClauseEnqueue::VisitOMPCopyprivateClause(
2635    const OMPCopyprivateClause *C) {
2636  VisitOMPClauseList(C);
2637  for (auto *E : C->source_exprs()) {
2638    Visitor->AddStmt(E);
2639  }
2640  for (auto *E : C->destination_exprs()) {
2641    Visitor->AddStmt(E);
2642  }
2643  for (auto *E : C->assignment_ops()) {
2644    Visitor->AddStmt(E);
2645  }
2646}
2647void OMPClauseEnqueue::VisitOMPFlushClause(const OMPFlushClause *C) {
2648  VisitOMPClauseList(C);
2649}
2650void OMPClauseEnqueue::VisitOMPDepobjClause(const OMPDepobjClause *C) {
2651  Visitor->AddStmt(C->getDepobj());
2652}
2653void OMPClauseEnqueue::VisitOMPDependClause(const OMPDependClause *C) {
2654  VisitOMPClauseList(C);
2655}
2656void OMPClauseEnqueue::VisitOMPMapClause(const OMPMapClause *C) {
2657  VisitOMPClauseList(C);
2658}
2659void OMPClauseEnqueue::VisitOMPDistScheduleClause(
2660    const OMPDistScheduleClause *C) {
2661  VisitOMPClauseWithPreInit(C);
2662  Visitor->AddStmt(C->getChunkSize());
2663}
2664void OMPClauseEnqueue::VisitOMPDefaultmapClause(
2665    const OMPDefaultmapClause * /*C*/) {}
2666void OMPClauseEnqueue::VisitOMPToClause(const OMPToClause *C) {
2667  VisitOMPClauseList(C);
2668}
2669void OMPClauseEnqueue::VisitOMPFromClause(const OMPFromClause *C) {
2670  VisitOMPClauseList(C);
2671}
2672void OMPClauseEnqueue::VisitOMPUseDevicePtrClause(
2673    const OMPUseDevicePtrClause *C) {
2674  VisitOMPClauseList(C);
2675}
2676void OMPClauseEnqueue::VisitOMPUseDeviceAddrClause(
2677    const OMPUseDeviceAddrClause *C) {
2678  VisitOMPClauseList(C);
2679}
2680void OMPClauseEnqueue::VisitOMPIsDevicePtrClause(
2681    const OMPIsDevicePtrClause *C) {
2682  VisitOMPClauseList(C);
2683}
2684void OMPClauseEnqueue::VisitOMPHasDeviceAddrClause(
2685    const OMPHasDeviceAddrClause *C) {
2686  VisitOMPClauseList(C);
2687}
2688void OMPClauseEnqueue::VisitOMPNontemporalClause(
2689    const OMPNontemporalClause *C) {
2690  VisitOMPClauseList(C);
2691  for (const auto *E : C->private_refs())
2692    Visitor->AddStmt(E);
2693}
2694void OMPClauseEnqueue::VisitOMPOrderClause(const OMPOrderClause *C) {}
2695void OMPClauseEnqueue::VisitOMPUsesAllocatorsClause(
2696    const OMPUsesAllocatorsClause *C) {
2697  for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) {
2698    const OMPUsesAllocatorsClause::Data &D = C->getAllocatorData(I);
2699    Visitor->AddStmt(D.Allocator);
2700    Visitor->AddStmt(D.AllocatorTraits);
2701  }
2702}
2703void OMPClauseEnqueue::VisitOMPAffinityClause(const OMPAffinityClause *C) {
2704  Visitor->AddStmt(C->getModifier());
2705  for (const Expr *E : C->varlists())
2706    Visitor->AddStmt(E);
2707}
2708void OMPClauseEnqueue::VisitOMPBindClause(const OMPBindClause *C) {}
2709void OMPClauseEnqueue::VisitOMPXDynCGroupMemClause(
2710    const OMPXDynCGroupMemClause *C) {
2711  VisitOMPClauseWithPreInit(C);
2712  Visitor->AddStmt(C->getSize());
2713}
2714
2715} // namespace
2716
2717void EnqueueVisitor::EnqueueChildren(const OMPClause *S) {
2718  unsigned size = WL.size();
2719  OMPClauseEnqueue Visitor(this);
2720  Visitor.Visit(S);
2721  if (size == WL.size())
2722    return;
2723  // Now reverse the entries we just added.  This will match the DFS
2724  // ordering performed by the worklist.
2725  VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
2726  std::reverse(I, E);
2727}
2728void EnqueueVisitor::VisitAddrLabelExpr(const AddrLabelExpr *E) {
2729  WL.push_back(LabelRefVisit(E->getLabel(), E->getLabelLoc(), Parent));
2730}
2731void EnqueueVisitor::VisitBlockExpr(const BlockExpr *B) {
2732  AddDecl(B->getBlockDecl());
2733}
2734void EnqueueVisitor::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
2735  EnqueueChildren(E);
2736  AddTypeLoc(E->getTypeSourceInfo());
2737}
2738void EnqueueVisitor::VisitCompoundStmt(const CompoundStmt *S) {
2739  for (auto &I : llvm::reverse(S->body()))
2740    AddStmt(I);
2741}
2742void EnqueueVisitor::VisitMSDependentExistsStmt(
2743    const MSDependentExistsStmt *S) {
2744  AddStmt(S->getSubStmt());
2745  AddDeclarationNameInfo(S);
2746  if (NestedNameSpecifierLoc QualifierLoc = S->getQualifierLoc())
2747    AddNestedNameSpecifierLoc(QualifierLoc);
2748}
2749
2750void EnqueueVisitor::VisitCXXDependentScopeMemberExpr(
2751    const CXXDependentScopeMemberExpr *E) {
2752  if (E->hasExplicitTemplateArgs())
2753    AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs());
2754  AddDeclarationNameInfo(E);
2755  if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
2756    AddNestedNameSpecifierLoc(QualifierLoc);
2757  if (!E->isImplicitAccess())
2758    AddStmt(E->getBase());
2759}
2760void EnqueueVisitor::VisitCXXNewExpr(const CXXNewExpr *E) {
2761  // Enqueue the initializer , if any.
2762  AddStmt(E->getInitializer());
2763  // Enqueue the array size, if any.
2764  AddStmt(E->getArraySize().value_or(nullptr));
2765  // Enqueue the allocated type.
2766  AddTypeLoc(E->getAllocatedTypeSourceInfo());
2767  // Enqueue the placement arguments.
2768  for (unsigned I = E->getNumPlacementArgs(); I > 0; --I)
2769    AddStmt(E->getPlacementArg(I - 1));
2770}
2771void EnqueueVisitor::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *CE) {
2772  for (unsigned I = CE->getNumArgs(); I > 1 /* Yes, this is 1 */; --I)
2773    AddStmt(CE->getArg(I - 1));
2774  AddStmt(CE->getCallee());
2775  AddStmt(CE->getArg(0));
2776}
2777void EnqueueVisitor::VisitCXXPseudoDestructorExpr(
2778    const CXXPseudoDestructorExpr *E) {
2779  // Visit the name of the type being destroyed.
2780  AddTypeLoc(E->getDestroyedTypeInfo());
2781  // Visit the scope type that looks disturbingly like the nested-name-specifier
2782  // but isn't.
2783  AddTypeLoc(E->getScopeTypeInfo());
2784  // Visit the nested-name-specifier.
2785  if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
2786    AddNestedNameSpecifierLoc(QualifierLoc);
2787  // Visit base expression.
2788  AddStmt(E->getBase());
2789}
2790void EnqueueVisitor::VisitCXXScalarValueInitExpr(
2791    const CXXScalarValueInitExpr *E) {
2792  AddTypeLoc(E->getTypeSourceInfo());
2793}
2794void EnqueueVisitor::VisitCXXTemporaryObjectExpr(
2795    const CXXTemporaryObjectExpr *E) {
2796  EnqueueChildren(E);
2797  AddTypeLoc(E->getTypeSourceInfo());
2798}
2799void EnqueueVisitor::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
2800  EnqueueChildren(E);
2801  if (E->isTypeOperand())
2802    AddTypeLoc(E->getTypeOperandSourceInfo());
2803}
2804
2805void EnqueueVisitor::VisitCXXUnresolvedConstructExpr(
2806    const CXXUnresolvedConstructExpr *E) {
2807  EnqueueChildren(E);
2808  AddTypeLoc(E->getTypeSourceInfo());
2809}
2810void EnqueueVisitor::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
2811  EnqueueChildren(E);
2812  if (E->isTypeOperand())
2813    AddTypeLoc(E->getTypeOperandSourceInfo());
2814}
2815
2816void EnqueueVisitor::VisitCXXCatchStmt(const CXXCatchStmt *S) {
2817  EnqueueChildren(S);
2818  AddDecl(S->getExceptionDecl());
2819}
2820
2821void EnqueueVisitor::VisitCXXForRangeStmt(const CXXForRangeStmt *S) {
2822  AddStmt(S->getBody());
2823  AddStmt(S->getRangeInit());
2824  AddDecl(S->getLoopVariable());
2825}
2826
2827void EnqueueVisitor::VisitDeclRefExpr(const DeclRefExpr *DR) {
2828  if (DR->hasExplicitTemplateArgs())
2829    AddExplicitTemplateArgs(DR->getTemplateArgs(), DR->getNumTemplateArgs());
2830  WL.push_back(DeclRefExprParts(DR, Parent));
2831}
2832void EnqueueVisitor::VisitDependentScopeDeclRefExpr(
2833    const DependentScopeDeclRefExpr *E) {
2834  if (E->hasExplicitTemplateArgs())
2835    AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs());
2836  AddDeclarationNameInfo(E);
2837  AddNestedNameSpecifierLoc(E->getQualifierLoc());
2838}
2839void EnqueueVisitor::VisitDeclStmt(const DeclStmt *S) {
2840  unsigned size = WL.size();
2841  bool isFirst = true;
2842  for (const auto *D : S->decls()) {
2843    AddDecl(D, isFirst);
2844    isFirst = false;
2845  }
2846  if (size == WL.size())
2847    return;
2848  // Now reverse the entries we just added.  This will match the DFS
2849  // ordering performed by the worklist.
2850  VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
2851  std::reverse(I, E);
2852}
2853void EnqueueVisitor::VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
2854  AddStmt(E->getInit());
2855  for (const DesignatedInitExpr::Designator &D :
2856       llvm::reverse(E->designators())) {
2857    if (D.isFieldDesignator()) {
2858      if (FieldDecl *Field = D.getField())
2859        AddMemberRef(Field, D.getFieldLoc());
2860      continue;
2861    }
2862    if (D.isArrayDesignator()) {
2863      AddStmt(E->getArrayIndex(D));
2864      continue;
2865    }
2866    assert(D.isArrayRangeDesignator() && "Unknown designator kind");
2867    AddStmt(E->getArrayRangeEnd(D));
2868    AddStmt(E->getArrayRangeStart(D));
2869  }
2870}
2871void EnqueueVisitor::VisitExplicitCastExpr(const ExplicitCastExpr *E) {
2872  EnqueueChildren(E);
2873  AddTypeLoc(E->getTypeInfoAsWritten());
2874}
2875void EnqueueVisitor::VisitForStmt(const ForStmt *FS) {
2876  AddStmt(FS->getBody());
2877  AddStmt(FS->getInc());
2878  AddStmt(FS->getCond());
2879  AddDecl(FS->getConditionVariable());
2880  AddStmt(FS->getInit());
2881}
2882void EnqueueVisitor::VisitGotoStmt(const GotoStmt *GS) {
2883  WL.push_back(LabelRefVisit(GS->getLabel(), GS->getLabelLoc(), Parent));
2884}
2885void EnqueueVisitor::VisitIfStmt(const IfStmt *If) {
2886  AddStmt(If->getElse());
2887  AddStmt(If->getThen());
2888  AddStmt(If->getCond());
2889  AddStmt(If->getInit());
2890  AddDecl(If->getConditionVariable());
2891}
2892void EnqueueVisitor::VisitInitListExpr(const InitListExpr *IE) {
2893  // We care about the syntactic form of the initializer list, only.
2894  if (InitListExpr *Syntactic = IE->getSyntacticForm())
2895    IE = Syntactic;
2896  EnqueueChildren(IE);
2897}
2898void EnqueueVisitor::VisitMemberExpr(const MemberExpr *M) {
2899  WL.push_back(MemberExprParts(M, Parent));
2900
2901  // If the base of the member access expression is an implicit 'this', don't
2902  // visit it.
2903  // FIXME: If we ever want to show these implicit accesses, this will be
2904  // unfortunate. However, clang_getCursor() relies on this behavior.
2905  if (M->isImplicitAccess())
2906    return;
2907
2908  // Ignore base anonymous struct/union fields, otherwise they will shadow the
2909  // real field that we are interested in.
2910  if (auto *SubME = dyn_cast<MemberExpr>(M->getBase())) {
2911    if (auto *FD = dyn_cast_or_null<FieldDecl>(SubME->getMemberDecl())) {
2912      if (FD->isAnonymousStructOrUnion()) {
2913        AddStmt(SubME->getBase());
2914        return;
2915      }
2916    }
2917  }
2918
2919  AddStmt(M->getBase());
2920}
2921void EnqueueVisitor::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
2922  AddTypeLoc(E->getEncodedTypeSourceInfo());
2923}
2924void EnqueueVisitor::VisitObjCMessageExpr(const ObjCMessageExpr *M) {
2925  EnqueueChildren(M);
2926  AddTypeLoc(M->getClassReceiverTypeInfo());
2927}
2928void EnqueueVisitor::VisitOffsetOfExpr(const OffsetOfExpr *E) {
2929  // Visit the components of the offsetof expression.
2930  for (unsigned N = E->getNumComponents(), I = N; I > 0; --I) {
2931    const OffsetOfNode &Node = E->getComponent(I - 1);
2932    switch (Node.getKind()) {
2933    case OffsetOfNode::Array:
2934      AddStmt(E->getIndexExpr(Node.getArrayExprIndex()));
2935      break;
2936    case OffsetOfNode::Field:
2937      AddMemberRef(Node.getField(), Node.getSourceRange().getEnd());
2938      break;
2939    case OffsetOfNode::Identifier:
2940    case OffsetOfNode::Base:
2941      continue;
2942    }
2943  }
2944  // Visit the type into which we're computing the offset.
2945  AddTypeLoc(E->getTypeSourceInfo());
2946}
2947void EnqueueVisitor::VisitOverloadExpr(const OverloadExpr *E) {
2948  if (E->hasExplicitTemplateArgs())
2949    AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs());
2950  WL.push_back(OverloadExprParts(E, Parent));
2951}
2952void EnqueueVisitor::VisitUnaryExprOrTypeTraitExpr(
2953    const UnaryExprOrTypeTraitExpr *E) {
2954  EnqueueChildren(E);
2955  if (E->isArgumentType())
2956    AddTypeLoc(E->getArgumentTypeInfo());
2957}
2958void EnqueueVisitor::VisitStmt(const Stmt *S) { EnqueueChildren(S); }
2959void EnqueueVisitor::VisitSwitchStmt(const SwitchStmt *S) {
2960  AddStmt(S->getBody());
2961  AddStmt(S->getCond());
2962  AddDecl(S->getConditionVariable());
2963}
2964
2965void EnqueueVisitor::VisitWhileStmt(const WhileStmt *W) {
2966  AddStmt(W->getBody());
2967  AddStmt(W->getCond());
2968  AddDecl(W->getConditionVariable());
2969}
2970
2971void EnqueueVisitor::VisitTypeTraitExpr(const TypeTraitExpr *E) {
2972  for (unsigned I = E->getNumArgs(); I > 0; --I)
2973    AddTypeLoc(E->getArg(I - 1));
2974}
2975
2976void EnqueueVisitor::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
2977  AddTypeLoc(E->getQueriedTypeSourceInfo());
2978}
2979
2980void EnqueueVisitor::VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
2981  EnqueueChildren(E);
2982}
2983
2984void EnqueueVisitor::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U) {
2985  VisitOverloadExpr(U);
2986  if (!U->isImplicitAccess())
2987    AddStmt(U->getBase());
2988}
2989void EnqueueVisitor::VisitVAArgExpr(const VAArgExpr *E) {
2990  AddStmt(E->getSubExpr());
2991  AddTypeLoc(E->getWrittenTypeInfo());
2992}
2993void EnqueueVisitor::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
2994  WL.push_back(SizeOfPackExprParts(E, Parent));
2995}
2996void EnqueueVisitor::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
2997  // If the opaque value has a source expression, just transparently
2998  // visit that.  This is useful for (e.g.) pseudo-object expressions.
2999  if (Expr *SourceExpr = E->getSourceExpr())
3000    return Visit(SourceExpr);
3001}
3002void EnqueueVisitor::VisitLambdaExpr(const LambdaExpr *E) {
3003  AddStmt(E->getBody());
3004  WL.push_back(LambdaExprParts(E, Parent));
3005}
3006void EnqueueVisitor::VisitConceptSpecializationExpr(
3007    const ConceptSpecializationExpr *E) {
3008  WL.push_back(ConceptSpecializationExprVisit(E, Parent));
3009}
3010void EnqueueVisitor::VisitRequiresExpr(const RequiresExpr *E) {
3011  WL.push_back(RequiresExprVisit(E, Parent));
3012  for (ParmVarDecl *VD : E->getLocalParameters())
3013    AddDecl(VD);
3014}
3015void EnqueueVisitor::VisitCXXParenListInitExpr(const CXXParenListInitExpr *E) {
3016  EnqueueChildren(E);
3017}
3018void EnqueueVisitor::VisitPseudoObjectExpr(const PseudoObjectExpr *E) {
3019  // Treat the expression like its syntactic form.
3020  Visit(E->getSyntacticForm());
3021}
3022
3023void EnqueueVisitor::VisitOMPExecutableDirective(
3024    const OMPExecutableDirective *D) {
3025  EnqueueChildren(D);
3026  for (ArrayRef<OMPClause *>::iterator I = D->clauses().begin(),
3027                                       E = D->clauses().end();
3028       I != E; ++I)
3029    EnqueueChildren(*I);
3030}
3031
3032void EnqueueVisitor::VisitOMPLoopBasedDirective(
3033    const OMPLoopBasedDirective *D) {
3034  VisitOMPExecutableDirective(D);
3035}
3036
3037void EnqueueVisitor::VisitOMPLoopDirective(const OMPLoopDirective *D) {
3038  VisitOMPLoopBasedDirective(D);
3039}
3040
3041void EnqueueVisitor::VisitOMPParallelDirective(const OMPParallelDirective *D) {
3042  VisitOMPExecutableDirective(D);
3043}
3044
3045void EnqueueVisitor::VisitOMPSimdDirective(const OMPSimdDirective *D) {
3046  VisitOMPLoopDirective(D);
3047}
3048
3049void EnqueueVisitor::VisitOMPLoopTransformationDirective(
3050    const OMPLoopTransformationDirective *D) {
3051  VisitOMPLoopBasedDirective(D);
3052}
3053
3054void EnqueueVisitor::VisitOMPTileDirective(const OMPTileDirective *D) {
3055  VisitOMPLoopTransformationDirective(D);
3056}
3057
3058void EnqueueVisitor::VisitOMPUnrollDirective(const OMPUnrollDirective *D) {
3059  VisitOMPLoopTransformationDirective(D);
3060}
3061
3062void EnqueueVisitor::VisitOMPForDirective(const OMPForDirective *D) {
3063  VisitOMPLoopDirective(D);
3064}
3065
3066void EnqueueVisitor::VisitOMPForSimdDirective(const OMPForSimdDirective *D) {
3067  VisitOMPLoopDirective(D);
3068}
3069
3070void EnqueueVisitor::VisitOMPSectionsDirective(const OMPSectionsDirective *D) {
3071  VisitOMPExecutableDirective(D);
3072}
3073
3074void EnqueueVisitor::VisitOMPSectionDirective(const OMPSectionDirective *D) {
3075  VisitOMPExecutableDirective(D);
3076}
3077
3078void EnqueueVisitor::VisitOMPSingleDirective(const OMPSingleDirective *D) {
3079  VisitOMPExecutableDirective(D);
3080}
3081
3082void EnqueueVisitor::VisitOMPMasterDirective(const OMPMasterDirective *D) {
3083  VisitOMPExecutableDirective(D);
3084}
3085
3086void EnqueueVisitor::VisitOMPCriticalDirective(const OMPCriticalDirective *D) {
3087  VisitOMPExecutableDirective(D);
3088  AddDeclarationNameInfo(D);
3089}
3090
3091void EnqueueVisitor::VisitOMPParallelForDirective(
3092    const OMPParallelForDirective *D) {
3093  VisitOMPLoopDirective(D);
3094}
3095
3096void EnqueueVisitor::VisitOMPParallelForSimdDirective(
3097    const OMPParallelForSimdDirective *D) {
3098  VisitOMPLoopDirective(D);
3099}
3100
3101void EnqueueVisitor::VisitOMPParallelMasterDirective(
3102    const OMPParallelMasterDirective *D) {
3103  VisitOMPExecutableDirective(D);
3104}
3105
3106void EnqueueVisitor::VisitOMPParallelMaskedDirective(
3107    const OMPParallelMaskedDirective *D) {
3108  VisitOMPExecutableDirective(D);
3109}
3110
3111void EnqueueVisitor::VisitOMPParallelSectionsDirective(
3112    const OMPParallelSectionsDirective *D) {
3113  VisitOMPExecutableDirective(D);
3114}
3115
3116void EnqueueVisitor::VisitOMPTaskDirective(const OMPTaskDirective *D) {
3117  VisitOMPExecutableDirective(D);
3118}
3119
3120void EnqueueVisitor::VisitOMPTaskyieldDirective(
3121    const OMPTaskyieldDirective *D) {
3122  VisitOMPExecutableDirective(D);
3123}
3124
3125void EnqueueVisitor::VisitOMPBarrierDirective(const OMPBarrierDirective *D) {
3126  VisitOMPExecutableDirective(D);
3127}
3128
3129void EnqueueVisitor::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D) {
3130  VisitOMPExecutableDirective(D);
3131}
3132
3133void EnqueueVisitor::VisitOMPErrorDirective(const OMPErrorDirective *D) {
3134  VisitOMPExecutableDirective(D);
3135}
3136
3137void EnqueueVisitor::VisitOMPTaskgroupDirective(
3138    const OMPTaskgroupDirective *D) {
3139  VisitOMPExecutableDirective(D);
3140  if (const Expr *E = D->getReductionRef())
3141    VisitStmt(E);
3142}
3143
3144void EnqueueVisitor::VisitOMPFlushDirective(const OMPFlushDirective *D) {
3145  VisitOMPExecutableDirective(D);
3146}
3147
3148void EnqueueVisitor::VisitOMPDepobjDirective(const OMPDepobjDirective *D) {
3149  VisitOMPExecutableDirective(D);
3150}
3151
3152void EnqueueVisitor::VisitOMPScanDirective(const OMPScanDirective *D) {
3153  VisitOMPExecutableDirective(D);
3154}
3155
3156void EnqueueVisitor::VisitOMPOrderedDirective(const OMPOrderedDirective *D) {
3157  VisitOMPExecutableDirective(D);
3158}
3159
3160void EnqueueVisitor::VisitOMPAtomicDirective(const OMPAtomicDirective *D) {
3161  VisitOMPExecutableDirective(D);
3162}
3163
3164void EnqueueVisitor::VisitOMPTargetDirective(const OMPTargetDirective *D) {
3165  VisitOMPExecutableDirective(D);
3166}
3167
3168void EnqueueVisitor::VisitOMPTargetDataDirective(
3169    const OMPTargetDataDirective *D) {
3170  VisitOMPExecutableDirective(D);
3171}
3172
3173void EnqueueVisitor::VisitOMPTargetEnterDataDirective(
3174    const OMPTargetEnterDataDirective *D) {
3175  VisitOMPExecutableDirective(D);
3176}
3177
3178void EnqueueVisitor::VisitOMPTargetExitDataDirective(
3179    const OMPTargetExitDataDirective *D) {
3180  VisitOMPExecutableDirective(D);
3181}
3182
3183void EnqueueVisitor::VisitOMPTargetParallelDirective(
3184    const OMPTargetParallelDirective *D) {
3185  VisitOMPExecutableDirective(D);
3186}
3187
3188void EnqueueVisitor::VisitOMPTargetParallelForDirective(
3189    const OMPTargetParallelForDirective *D) {
3190  VisitOMPLoopDirective(D);
3191}
3192
3193void EnqueueVisitor::VisitOMPTeamsDirective(const OMPTeamsDirective *D) {
3194  VisitOMPExecutableDirective(D);
3195}
3196
3197void EnqueueVisitor::VisitOMPCancellationPointDirective(
3198    const OMPCancellationPointDirective *D) {
3199  VisitOMPExecutableDirective(D);
3200}
3201
3202void EnqueueVisitor::VisitOMPCancelDirective(const OMPCancelDirective *D) {
3203  VisitOMPExecutableDirective(D);
3204}
3205
3206void EnqueueVisitor::VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D) {
3207  VisitOMPLoopDirective(D);
3208}
3209
3210void EnqueueVisitor::VisitOMPTaskLoopSimdDirective(
3211    const OMPTaskLoopSimdDirective *D) {
3212  VisitOMPLoopDirective(D);
3213}
3214
3215void EnqueueVisitor::VisitOMPMasterTaskLoopDirective(
3216    const OMPMasterTaskLoopDirective *D) {
3217  VisitOMPLoopDirective(D);
3218}
3219
3220void EnqueueVisitor::VisitOMPMaskedTaskLoopDirective(
3221    const OMPMaskedTaskLoopDirective *D) {
3222  VisitOMPLoopDirective(D);
3223}
3224
3225void EnqueueVisitor::VisitOMPMasterTaskLoopSimdDirective(
3226    const OMPMasterTaskLoopSimdDirective *D) {
3227  VisitOMPLoopDirective(D);
3228}
3229
3230void EnqueueVisitor::VisitOMPMaskedTaskLoopSimdDirective(
3231    const OMPMaskedTaskLoopSimdDirective *D) {
3232  VisitOMPLoopDirective(D);
3233}
3234
3235void EnqueueVisitor::VisitOMPParallelMasterTaskLoopDirective(
3236    const OMPParallelMasterTaskLoopDirective *D) {
3237  VisitOMPLoopDirective(D);
3238}
3239
3240void EnqueueVisitor::VisitOMPParallelMaskedTaskLoopDirective(
3241    const OMPParallelMaskedTaskLoopDirective *D) {
3242  VisitOMPLoopDirective(D);
3243}
3244
3245void EnqueueVisitor::VisitOMPParallelMasterTaskLoopSimdDirective(
3246    const OMPParallelMasterTaskLoopSimdDirective *D) {
3247  VisitOMPLoopDirective(D);
3248}
3249
3250void EnqueueVisitor::VisitOMPParallelMaskedTaskLoopSimdDirective(
3251    const OMPParallelMaskedTaskLoopSimdDirective *D) {
3252  VisitOMPLoopDirective(D);
3253}
3254
3255void EnqueueVisitor::VisitOMPDistributeDirective(
3256    const OMPDistributeDirective *D) {
3257  VisitOMPLoopDirective(D);
3258}
3259
3260void EnqueueVisitor::VisitOMPDistributeParallelForDirective(
3261    const OMPDistributeParallelForDirective *D) {
3262  VisitOMPLoopDirective(D);
3263}
3264
3265void EnqueueVisitor::VisitOMPDistributeParallelForSimdDirective(
3266    const OMPDistributeParallelForSimdDirective *D) {
3267  VisitOMPLoopDirective(D);
3268}
3269
3270void EnqueueVisitor::VisitOMPDistributeSimdDirective(
3271    const OMPDistributeSimdDirective *D) {
3272  VisitOMPLoopDirective(D);
3273}
3274
3275void EnqueueVisitor::VisitOMPTargetParallelForSimdDirective(
3276    const OMPTargetParallelForSimdDirective *D) {
3277  VisitOMPLoopDirective(D);
3278}
3279
3280void EnqueueVisitor::VisitOMPTargetSimdDirective(
3281    const OMPTargetSimdDirective *D) {
3282  VisitOMPLoopDirective(D);
3283}
3284
3285void EnqueueVisitor::VisitOMPTeamsDistributeDirective(
3286    const OMPTeamsDistributeDirective *D) {
3287  VisitOMPLoopDirective(D);
3288}
3289
3290void EnqueueVisitor::VisitOMPTeamsDistributeSimdDirective(
3291    const OMPTeamsDistributeSimdDirective *D) {
3292  VisitOMPLoopDirective(D);
3293}
3294
3295void EnqueueVisitor::VisitOMPTeamsDistributeParallelForSimdDirective(
3296    const OMPTeamsDistributeParallelForSimdDirective *D) {
3297  VisitOMPLoopDirective(D);
3298}
3299
3300void EnqueueVisitor::VisitOMPTeamsDistributeParallelForDirective(
3301    const OMPTeamsDistributeParallelForDirective *D) {
3302  VisitOMPLoopDirective(D);
3303}
3304
3305void EnqueueVisitor::VisitOMPTargetTeamsDirective(
3306    const OMPTargetTeamsDirective *D) {
3307  VisitOMPExecutableDirective(D);
3308}
3309
3310void EnqueueVisitor::VisitOMPTargetTeamsDistributeDirective(
3311    const OMPTargetTeamsDistributeDirective *D) {
3312  VisitOMPLoopDirective(D);
3313}
3314
3315void EnqueueVisitor::VisitOMPTargetTeamsDistributeParallelForDirective(
3316    const OMPTargetTeamsDistributeParallelForDirective *D) {
3317  VisitOMPLoopDirective(D);
3318}
3319
3320void EnqueueVisitor::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
3321    const OMPTargetTeamsDistributeParallelForSimdDirective *D) {
3322  VisitOMPLoopDirective(D);
3323}
3324
3325void EnqueueVisitor::VisitOMPTargetTeamsDistributeSimdDirective(
3326    const OMPTargetTeamsDistributeSimdDirective *D) {
3327  VisitOMPLoopDirective(D);
3328}
3329
3330void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) {
3331  EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU, RegionOfInterest))
3332      .Visit(S);
3333}
3334
3335bool CursorVisitor::IsInRegionOfInterest(CXCursor C) {
3336  if (RegionOfInterest.isValid()) {
3337    SourceRange Range = getRawCursorExtent(C);
3338    if (Range.isInvalid() || CompareRegionOfInterest(Range))
3339      return false;
3340  }
3341  return true;
3342}
3343
3344bool CursorVisitor::RunVisitorWorkList(VisitorWorkList &WL) {
3345  while (!WL.empty()) {
3346    // Dequeue the worklist item.
3347    VisitorJob LI = WL.pop_back_val();
3348
3349    // Set the Parent field, then back to its old value once we're done.
3350    SetParentRAII SetParent(Parent, StmtParent, LI.getParent());
3351
3352    switch (LI.getKind()) {
3353    case VisitorJob::DeclVisitKind: {
3354      const Decl *D = cast<DeclVisit>(&LI)->get();
3355      if (!D)
3356        continue;
3357
3358      // For now, perform default visitation for Decls.
3359      if (Visit(MakeCXCursor(D, TU, RegionOfInterest,
3360                             cast<DeclVisit>(&LI)->isFirst())))
3361        return true;
3362
3363      continue;
3364    }
3365    case VisitorJob::ExplicitTemplateArgsVisitKind: {
3366      for (const TemplateArgumentLoc &Arg :
3367           *cast<ExplicitTemplateArgsVisit>(&LI)) {
3368        if (VisitTemplateArgumentLoc(Arg))
3369          return true;
3370      }
3371      continue;
3372    }
3373    case VisitorJob::TypeLocVisitKind: {
3374      // Perform default visitation for TypeLocs.
3375      if (Visit(cast<TypeLocVisit>(&LI)->get()))
3376        return true;
3377      continue;
3378    }
3379    case VisitorJob::LabelRefVisitKind: {
3380      const LabelDecl *LS = cast<LabelRefVisit>(&LI)->get();
3381      if (LabelStmt *stmt = LS->getStmt()) {
3382        if (Visit(MakeCursorLabelRef(stmt, cast<LabelRefVisit>(&LI)->getLoc(),
3383                                     TU))) {
3384          return true;
3385        }
3386      }
3387      continue;
3388    }
3389
3390    case VisitorJob::NestedNameSpecifierLocVisitKind: {
3391      NestedNameSpecifierLocVisit *V = cast<NestedNameSpecifierLocVisit>(&LI);
3392      if (VisitNestedNameSpecifierLoc(V->get()))
3393        return true;
3394      continue;
3395    }
3396
3397    case VisitorJob::DeclarationNameInfoVisitKind: {
3398      if (VisitDeclarationNameInfo(cast<DeclarationNameInfoVisit>(&LI)->get()))
3399        return true;
3400      continue;
3401    }
3402    case VisitorJob::MemberRefVisitKind: {
3403      MemberRefVisit *V = cast<MemberRefVisit>(&LI);
3404      if (Visit(MakeCursorMemberRef(V->get(), V->getLoc(), TU)))
3405        return true;
3406      continue;
3407    }
3408    case VisitorJob::StmtVisitKind: {
3409      const Stmt *S = cast<StmtVisit>(&LI)->get();
3410      if (!S)
3411        continue;
3412
3413      // Update the current cursor.
3414      CXCursor Cursor = MakeCXCursor(S, StmtParent, TU, RegionOfInterest);
3415      if (!IsInRegionOfInterest(Cursor))
3416        continue;
3417      switch (Visitor(Cursor, Parent, ClientData)) {
3418      case CXChildVisit_Break:
3419        return true;
3420      case CXChildVisit_Continue:
3421        break;
3422      case CXChildVisit_Recurse:
3423        if (PostChildrenVisitor)
3424          WL.push_back(PostChildrenVisit(nullptr, Cursor));
3425        EnqueueWorkList(WL, S);
3426        break;
3427      }
3428      continue;
3429    }
3430    case VisitorJob::MemberExprPartsKind: {
3431      // Handle the other pieces in the MemberExpr besides the base.
3432      const MemberExpr *M = cast<MemberExprParts>(&LI)->get();
3433
3434      // Visit the nested-name-specifier
3435      if (NestedNameSpecifierLoc QualifierLoc = M->getQualifierLoc())
3436        if (VisitNestedNameSpecifierLoc(QualifierLoc))
3437          return true;
3438
3439      // Visit the declaration name.
3440      if (VisitDeclarationNameInfo(M->getMemberNameInfo()))
3441        return true;
3442
3443      // Visit the explicitly-specified template arguments, if any.
3444      if (M->hasExplicitTemplateArgs()) {
3445        for (const TemplateArgumentLoc *Arg = M->getTemplateArgs(),
3446                                       *ArgEnd = Arg + M->getNumTemplateArgs();
3447             Arg != ArgEnd; ++Arg) {
3448          if (VisitTemplateArgumentLoc(*Arg))
3449            return true;
3450        }
3451      }
3452      continue;
3453    }
3454    case VisitorJob::DeclRefExprPartsKind: {
3455      const DeclRefExpr *DR = cast<DeclRefExprParts>(&LI)->get();
3456      // Visit nested-name-specifier, if present.
3457      if (NestedNameSpecifierLoc QualifierLoc = DR->getQualifierLoc())
3458        if (VisitNestedNameSpecifierLoc(QualifierLoc))
3459          return true;
3460      // Visit declaration name.
3461      if (VisitDeclarationNameInfo(DR->getNameInfo()))
3462        return true;
3463      continue;
3464    }
3465    case VisitorJob::OverloadExprPartsKind: {
3466      const OverloadExpr *O = cast<OverloadExprParts>(&LI)->get();
3467      // Visit the nested-name-specifier.
3468      if (NestedNameSpecifierLoc QualifierLoc = O->getQualifierLoc())
3469        if (VisitNestedNameSpecifierLoc(QualifierLoc))
3470          return true;
3471      // Visit the declaration name.
3472      if (VisitDeclarationNameInfo(O->getNameInfo()))
3473        return true;
3474      // Visit the overloaded declaration reference.
3475      if (Visit(MakeCursorOverloadedDeclRef(O, TU)))
3476        return true;
3477      continue;
3478    }
3479    case VisitorJob::SizeOfPackExprPartsKind: {
3480      const SizeOfPackExpr *E = cast<SizeOfPackExprParts>(&LI)->get();
3481      NamedDecl *Pack = E->getPack();
3482      if (isa<TemplateTypeParmDecl>(Pack)) {
3483        if (Visit(MakeCursorTypeRef(cast<TemplateTypeParmDecl>(Pack),
3484                                    E->getPackLoc(), TU)))
3485          return true;
3486
3487        continue;
3488      }
3489
3490      if (isa<TemplateTemplateParmDecl>(Pack)) {
3491        if (Visit(MakeCursorTemplateRef(cast<TemplateTemplateParmDecl>(Pack),
3492                                        E->getPackLoc(), TU)))
3493          return true;
3494
3495        continue;
3496      }
3497
3498      // Non-type template parameter packs and function parameter packs are
3499      // treated like DeclRefExpr cursors.
3500      continue;
3501    }
3502
3503    case VisitorJob::LambdaExprPartsKind: {
3504      // Visit non-init captures.
3505      const LambdaExpr *E = cast<LambdaExprParts>(&LI)->get();
3506      for (LambdaExpr::capture_iterator C = E->explicit_capture_begin(),
3507                                        CEnd = E->explicit_capture_end();
3508           C != CEnd; ++C) {
3509        if (!C->capturesVariable())
3510          continue;
3511        // TODO: handle structured bindings here ?
3512        if (!isa<VarDecl>(C->getCapturedVar()))
3513          continue;
3514        if (Visit(MakeCursorVariableRef(cast<VarDecl>(C->getCapturedVar()),
3515                                        C->getLocation(), TU)))
3516          return true;
3517      }
3518      // Visit init captures
3519      for (auto InitExpr : E->capture_inits()) {
3520        if (InitExpr && Visit(InitExpr))
3521          return true;
3522      }
3523
3524      TypeLoc TL = E->getCallOperator()->getTypeSourceInfo()->getTypeLoc();
3525      // Visit parameters and return type, if present.
3526      if (FunctionTypeLoc Proto = TL.getAs<FunctionProtoTypeLoc>()) {
3527        if (E->hasExplicitParameters()) {
3528          // Visit parameters.
3529          for (unsigned I = 0, N = Proto.getNumParams(); I != N; ++I)
3530            if (Visit(MakeCXCursor(Proto.getParam(I), TU)))
3531              return true;
3532        }
3533        if (E->hasExplicitResultType()) {
3534          // Visit result type.
3535          if (Visit(Proto.getReturnLoc()))
3536            return true;
3537        }
3538      }
3539      break;
3540    }
3541
3542    case VisitorJob::ConceptSpecializationExprVisitKind: {
3543      const ConceptSpecializationExpr *E =
3544          cast<ConceptSpecializationExprVisit>(&LI)->get();
3545      if (NestedNameSpecifierLoc QualifierLoc =
3546              E->getNestedNameSpecifierLoc()) {
3547        if (VisitNestedNameSpecifierLoc(QualifierLoc))
3548          return true;
3549      }
3550
3551      if (E->getNamedConcept() &&
3552          Visit(MakeCursorTemplateRef(E->getNamedConcept(),
3553                                      E->getConceptNameLoc(), TU)))
3554        return true;
3555
3556      if (auto Args = E->getTemplateArgsAsWritten()) {
3557        for (const auto &Arg : Args->arguments()) {
3558          if (VisitTemplateArgumentLoc(Arg))
3559            return true;
3560        }
3561      }
3562      break;
3563    }
3564
3565    case VisitorJob::RequiresExprVisitKind: {
3566      const RequiresExpr *E = cast<RequiresExprVisit>(&LI)->get();
3567      for (const concepts::Requirement *R : E->getRequirements())
3568        VisitConceptRequirement(*R);
3569      break;
3570    }
3571
3572    case VisitorJob::PostChildrenVisitKind:
3573      if (PostChildrenVisitor(Parent, ClientData))
3574        return true;
3575      break;
3576    }
3577  }
3578  return false;
3579}
3580
3581bool CursorVisitor::Visit(const Stmt *S) {
3582  VisitorWorkList *WL = nullptr;
3583  if (!WorkListFreeList.empty()) {
3584    WL = WorkListFreeList.back();
3585    WL->clear();
3586    WorkListFreeList.pop_back();
3587  } else {
3588    WL = new VisitorWorkList();
3589    WorkListCache.push_back(WL);
3590  }
3591  EnqueueWorkList(*WL, S);
3592  bool result = RunVisitorWorkList(*WL);
3593  WorkListFreeList.push_back(WL);
3594  return result;
3595}
3596
3597namespace {
3598typedef SmallVector<SourceRange, 4> RefNamePieces;
3599RefNamePieces buildPieces(unsigned NameFlags, bool IsMemberRefExpr,
3600                          const DeclarationNameInfo &NI, SourceRange QLoc,
3601                          const SourceRange *TemplateArgsLoc = nullptr) {
3602  const bool WantQualifier = NameFlags & CXNameRange_WantQualifier;
3603  const bool WantTemplateArgs = NameFlags & CXNameRange_WantTemplateArgs;
3604  const bool WantSinglePiece = NameFlags & CXNameRange_WantSinglePiece;
3605
3606  const DeclarationName::NameKind Kind = NI.getName().getNameKind();
3607
3608  RefNamePieces Pieces;
3609
3610  if (WantQualifier && QLoc.isValid())
3611    Pieces.push_back(QLoc);
3612
3613  if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr)
3614    Pieces.push_back(NI.getLoc());
3615
3616  if (WantTemplateArgs && TemplateArgsLoc && TemplateArgsLoc->isValid())
3617    Pieces.push_back(*TemplateArgsLoc);
3618
3619  if (Kind == DeclarationName::CXXOperatorName) {
3620    Pieces.push_back(NI.getInfo().getCXXOperatorNameBeginLoc());
3621    Pieces.push_back(NI.getInfo().getCXXOperatorNameEndLoc());
3622  }
3623
3624  if (WantSinglePiece) {
3625    SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd());
3626    Pieces.clear();
3627    Pieces.push_back(R);
3628  }
3629
3630  return Pieces;
3631}
3632} // namespace
3633
3634//===----------------------------------------------------------------------===//
3635// Misc. API hooks.
3636//===----------------------------------------------------------------------===//
3637
3638namespace {
3639struct RegisterFatalErrorHandler {
3640  RegisterFatalErrorHandler() {
3641    clang_install_aborting_llvm_fatal_error_handler();
3642  }
3643};
3644} // namespace
3645
3646static llvm::ManagedStatic<RegisterFatalErrorHandler>
3647    RegisterFatalErrorHandlerOnce;
3648
3649CXIndex clang_createIndex(int excludeDeclarationsFromPCH,
3650                          int displayDiagnostics) {
3651  // We use crash recovery to make some of our APIs more reliable, implicitly
3652  // enable it.
3653  if (!getenv("LIBCLANG_DISABLE_CRASH_RECOVERY"))
3654    llvm::CrashRecoveryContext::Enable();
3655
3656  // Look through the managed static to trigger construction of the managed
3657  // static which registers our fatal error handler. This ensures it is only
3658  // registered once.
3659  (void)*RegisterFatalErrorHandlerOnce;
3660
3661  // Initialize targets for clang module support.
3662  llvm::InitializeAllTargets();
3663  llvm::InitializeAllTargetMCs();
3664  llvm::InitializeAllAsmPrinters();
3665  llvm::InitializeAllAsmParsers();
3666
3667  CIndexer *CIdxr = new CIndexer();
3668
3669  if (excludeDeclarationsFromPCH)
3670    CIdxr->setOnlyLocalDecls();
3671  if (displayDiagnostics)
3672    CIdxr->setDisplayDiagnostics();
3673
3674  if (getenv("LIBCLANG_BGPRIO_INDEX"))
3675    CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() |
3676                               CXGlobalOpt_ThreadBackgroundPriorityForIndexing);
3677  if (getenv("LIBCLANG_BGPRIO_EDIT"))
3678    CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() |
3679                               CXGlobalOpt_ThreadBackgroundPriorityForEditing);
3680
3681  return CIdxr;
3682}
3683
3684void clang_disposeIndex(CXIndex CIdx) {
3685  if (CIdx)
3686    delete static_cast<CIndexer *>(CIdx);
3687}
3688
3689void clang_CXIndex_setGlobalOptions(CXIndex CIdx, unsigned options) {
3690  if (CIdx)
3691    static_cast<CIndexer *>(CIdx)->setCXGlobalOptFlags(options);
3692}
3693
3694unsigned clang_CXIndex_getGlobalOptions(CXIndex CIdx) {
3695  if (CIdx)
3696    return static_cast<CIndexer *>(CIdx)->getCXGlobalOptFlags();
3697  return 0;
3698}
3699
3700void clang_CXIndex_setInvocationEmissionPathOption(CXIndex CIdx,
3701                                                   const char *Path) {
3702  if (CIdx)
3703    static_cast<CIndexer *>(CIdx)->setInvocationEmissionPath(Path ? Path : "");
3704}
3705
3706void clang_toggleCrashRecovery(unsigned isEnabled) {
3707  if (isEnabled)
3708    llvm::CrashRecoveryContext::Enable();
3709  else
3710    llvm::CrashRecoveryContext::Disable();
3711}
3712
3713CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx,
3714                                              const char *ast_filename) {
3715  CXTranslationUnit TU;
3716  enum CXErrorCode Result =
3717      clang_createTranslationUnit2(CIdx, ast_filename, &TU);
3718  (void)Result;
3719  assert((TU && Result == CXError_Success) ||
3720         (!TU && Result != CXError_Success));
3721  return TU;
3722}
3723
3724enum CXErrorCode clang_createTranslationUnit2(CXIndex CIdx,
3725                                              const char *ast_filename,
3726                                              CXTranslationUnit *out_TU) {
3727  if (out_TU)
3728    *out_TU = nullptr;
3729
3730  if (!CIdx || !ast_filename || !out_TU)
3731    return CXError_InvalidArguments;
3732
3733  LOG_FUNC_SECTION { *Log << ast_filename; }
3734
3735  CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
3736  FileSystemOptions FileSystemOpts;
3737
3738  IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
3739      CompilerInstance::createDiagnostics(new DiagnosticOptions());
3740  std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile(
3741      ast_filename, CXXIdx->getPCHContainerOperations()->getRawReader(),
3742      ASTUnit::LoadEverything, Diags, FileSystemOpts, /*UseDebugInfo=*/false,
3743      CXXIdx->getOnlyLocalDecls(), CaptureDiagsKind::All,
3744      /*AllowASTWithCompilerErrors=*/true,
3745      /*UserFilesAreVolatile=*/true);
3746  *out_TU = MakeCXTranslationUnit(CXXIdx, std::move(AU));
3747  return *out_TU ? CXError_Success : CXError_Failure;
3748}
3749
3750unsigned clang_defaultEditingTranslationUnitOptions() {
3751  return CXTranslationUnit_PrecompiledPreamble |
3752         CXTranslationUnit_CacheCompletionResults;
3753}
3754
3755CXTranslationUnit clang_createTranslationUnitFromSourceFile(
3756    CXIndex CIdx, const char *source_filename, int num_command_line_args,
3757    const char *const *command_line_args, unsigned num_unsaved_files,
3758    struct CXUnsavedFile *unsaved_files) {
3759  unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord;
3760  return clang_parseTranslationUnit(CIdx, source_filename, command_line_args,
3761                                    num_command_line_args, unsaved_files,
3762                                    num_unsaved_files, Options);
3763}
3764
3765static CXErrorCode
3766clang_parseTranslationUnit_Impl(CXIndex CIdx, const char *source_filename,
3767                                const char *const *command_line_args,
3768                                int num_command_line_args,
3769                                ArrayRef<CXUnsavedFile> unsaved_files,
3770                                unsigned options, CXTranslationUnit *out_TU) {
3771  // Set up the initial return values.
3772  if (out_TU)
3773    *out_TU = nullptr;
3774
3775  // Check arguments.
3776  if (!CIdx || !out_TU)
3777    return CXError_InvalidArguments;
3778
3779  CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
3780
3781  if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
3782    setThreadBackgroundPriority();
3783
3784  bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble;
3785  bool CreatePreambleOnFirstParse =
3786      options & CXTranslationUnit_CreatePreambleOnFirstParse;
3787  // FIXME: Add a flag for modules.
3788  TranslationUnitKind TUKind = (options & (CXTranslationUnit_Incomplete |
3789                                           CXTranslationUnit_SingleFileParse))
3790                                   ? TU_Prefix
3791                                   : TU_Complete;
3792  bool CacheCodeCompletionResults =
3793      options & CXTranslationUnit_CacheCompletionResults;
3794  bool IncludeBriefCommentsInCodeCompletion =
3795      options & CXTranslationUnit_IncludeBriefCommentsInCodeCompletion;
3796  bool SingleFileParse = options & CXTranslationUnit_SingleFileParse;
3797  bool ForSerialization = options & CXTranslationUnit_ForSerialization;
3798  bool RetainExcludedCB =
3799      options & CXTranslationUnit_RetainExcludedConditionalBlocks;
3800  SkipFunctionBodiesScope SkipFunctionBodies = SkipFunctionBodiesScope::None;
3801  if (options & CXTranslationUnit_SkipFunctionBodies) {
3802    SkipFunctionBodies =
3803        (options & CXTranslationUnit_LimitSkipFunctionBodiesToPreamble)
3804            ? SkipFunctionBodiesScope::Preamble
3805            : SkipFunctionBodiesScope::PreambleAndMainFile;
3806  }
3807
3808  // Configure the diagnostics.
3809  std::unique_ptr<DiagnosticOptions> DiagOpts = CreateAndPopulateDiagOpts(
3810      llvm::ArrayRef(command_line_args, num_command_line_args));
3811  IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
3812      CompilerInstance::createDiagnostics(DiagOpts.release()));
3813
3814  if (options & CXTranslationUnit_KeepGoing)
3815    Diags->setFatalsAsError(true);
3816
3817  CaptureDiagsKind CaptureDiagnostics = CaptureDiagsKind::All;
3818  if (options & CXTranslationUnit_IgnoreNonErrorsFromIncludedFiles)
3819    CaptureDiagnostics = CaptureDiagsKind::AllWithoutNonErrorsFromIncludes;
3820
3821  // Recover resources if we crash before exiting this function.
3822  llvm::CrashRecoveryContextCleanupRegistrar<
3823      DiagnosticsEngine,
3824      llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
3825      DiagCleanup(Diags.get());
3826
3827  std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles(
3828      new std::vector<ASTUnit::RemappedFile>());
3829
3830  // Recover resources if we crash before exiting this function.
3831  llvm::CrashRecoveryContextCleanupRegistrar<std::vector<ASTUnit::RemappedFile>>
3832      RemappedCleanup(RemappedFiles.get());
3833
3834  for (auto &UF : unsaved_files) {
3835    std::unique_ptr<llvm::MemoryBuffer> MB =
3836        llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
3837    RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release()));
3838  }
3839
3840  std::unique_ptr<std::vector<const char *>> Args(
3841      new std::vector<const char *>());
3842
3843  // Recover resources if we crash before exiting this method.
3844  llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char *>>
3845      ArgsCleanup(Args.get());
3846
3847  // Since the Clang C library is primarily used by batch tools dealing with
3848  // (often very broken) source code, where spell-checking can have a
3849  // significant negative impact on performance (particularly when
3850  // precompiled headers are involved), we disable it by default.
3851  // Only do this if we haven't found a spell-checking-related argument.
3852  bool FoundSpellCheckingArgument = false;
3853  for (int I = 0; I != num_command_line_args; ++I) {
3854    if (strcmp(command_line_args[I], "-fno-spell-checking") == 0 ||
3855        strcmp(command_line_args[I], "-fspell-checking") == 0) {
3856      FoundSpellCheckingArgument = true;
3857      break;
3858    }
3859  }
3860  Args->insert(Args->end(), command_line_args,
3861               command_line_args + num_command_line_args);
3862
3863  if (!FoundSpellCheckingArgument)
3864    Args->insert(Args->begin() + 1, "-fno-spell-checking");
3865
3866  // The 'source_filename' argument is optional.  If the caller does not
3867  // specify it then it is assumed that the source file is specified
3868  // in the actual argument list.
3869  // Put the source file after command_line_args otherwise if '-x' flag is
3870  // present it will be unused.
3871  if (source_filename)
3872    Args->push_back(source_filename);
3873
3874  // Do we need the detailed preprocessing record?
3875  if (options & CXTranslationUnit_DetailedPreprocessingRecord) {
3876    Args->push_back("-Xclang");
3877    Args->push_back("-detailed-preprocessing-record");
3878  }
3879
3880  // Suppress any editor placeholder diagnostics.
3881  Args->push_back("-fallow-editor-placeholders");
3882
3883  unsigned NumErrors = Diags->getClient()->getNumErrors();
3884  std::unique_ptr<ASTUnit> ErrUnit;
3885  // Unless the user specified that they want the preamble on the first parse
3886  // set it up to be created on the first reparse. This makes the first parse
3887  // faster, trading for a slower (first) reparse.
3888  unsigned PrecompilePreambleAfterNParses =
3889      !PrecompilePreamble ? 0 : 2 - CreatePreambleOnFirstParse;
3890
3891  LibclangInvocationReporter InvocationReporter(
3892      *CXXIdx, LibclangInvocationReporter::OperationKind::ParseOperation,
3893      options, llvm::ArrayRef(*Args), /*InvocationArgs=*/std::nullopt,
3894      unsaved_files);
3895  std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCommandLine(
3896      Args->data(), Args->data() + Args->size(),
3897      CXXIdx->getPCHContainerOperations(), Diags,
3898      CXXIdx->getClangResourcesPath(), CXXIdx->getOnlyLocalDecls(),
3899      CaptureDiagnostics, *RemappedFiles.get(),
3900      /*RemappedFilesKeepOriginalName=*/true, PrecompilePreambleAfterNParses,
3901      TUKind, CacheCodeCompletionResults, IncludeBriefCommentsInCodeCompletion,
3902      /*AllowPCHWithCompilerErrors=*/true, SkipFunctionBodies, SingleFileParse,
3903      /*UserFilesAreVolatile=*/true, ForSerialization, RetainExcludedCB,
3904      CXXIdx->getPCHContainerOperations()->getRawReader().getFormat(),
3905      &ErrUnit));
3906
3907  // Early failures in LoadFromCommandLine may return with ErrUnit unset.
3908  if (!Unit && !ErrUnit)
3909    return CXError_ASTReadError;
3910
3911  if (NumErrors != Diags->getClient()->getNumErrors()) {
3912    // Make sure to check that 'Unit' is non-NULL.
3913    if (CXXIdx->getDisplayDiagnostics())
3914      printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get());
3915  }
3916
3917  if (isASTReadError(Unit ? Unit.get() : ErrUnit.get()))
3918    return CXError_ASTReadError;
3919
3920  *out_TU = MakeCXTranslationUnit(CXXIdx, std::move(Unit));
3921  if (CXTranslationUnitImpl *TU = *out_TU) {
3922    TU->ParsingOptions = options;
3923    TU->Arguments.reserve(Args->size());
3924    for (const char *Arg : *Args)
3925      TU->Arguments.push_back(Arg);
3926    return CXError_Success;
3927  }
3928  return CXError_Failure;
3929}
3930
3931CXTranslationUnit
3932clang_parseTranslationUnit(CXIndex CIdx, const char *source_filename,
3933                           const char *const *command_line_args,
3934                           int num_command_line_args,
3935                           struct CXUnsavedFile *unsaved_files,
3936                           unsigned num_unsaved_files, unsigned options) {
3937  CXTranslationUnit TU;
3938  enum CXErrorCode Result = clang_parseTranslationUnit2(
3939      CIdx, source_filename, command_line_args, num_command_line_args,
3940      unsaved_files, num_unsaved_files, options, &TU);
3941  (void)Result;
3942  assert((TU && Result == CXError_Success) ||
3943         (!TU && Result != CXError_Success));
3944  return TU;
3945}
3946
3947enum CXErrorCode clang_parseTranslationUnit2(
3948    CXIndex CIdx, const char *source_filename,
3949    const char *const *command_line_args, int num_command_line_args,
3950    struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files,
3951    unsigned options, CXTranslationUnit *out_TU) {
3952  noteBottomOfStack();
3953  SmallVector<const char *, 4> Args;
3954  Args.push_back("clang");
3955  Args.append(command_line_args, command_line_args + num_command_line_args);
3956  return clang_parseTranslationUnit2FullArgv(
3957      CIdx, source_filename, Args.data(), Args.size(), unsaved_files,
3958      num_unsaved_files, options, out_TU);
3959}
3960
3961enum CXErrorCode clang_parseTranslationUnit2FullArgv(
3962    CXIndex CIdx, const char *source_filename,
3963    const char *const *command_line_args, int num_command_line_args,
3964    struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files,
3965    unsigned options, CXTranslationUnit *out_TU) {
3966  LOG_FUNC_SECTION {
3967    *Log << source_filename << ": ";
3968    for (int i = 0; i != num_command_line_args; ++i)
3969      *Log << command_line_args[i] << " ";
3970  }
3971
3972  if (num_unsaved_files && !unsaved_files)
3973    return CXError_InvalidArguments;
3974
3975  CXErrorCode result = CXError_Failure;
3976  auto ParseTranslationUnitImpl = [=, &result] {
3977    noteBottomOfStack();
3978    result = clang_parseTranslationUnit_Impl(
3979        CIdx, source_filename, command_line_args, num_command_line_args,
3980        llvm::ArrayRef(unsaved_files, num_unsaved_files), options, out_TU);
3981  };
3982
3983  llvm::CrashRecoveryContext CRC;
3984
3985  if (!RunSafely(CRC, ParseTranslationUnitImpl)) {
3986    fprintf(stderr, "libclang: crash detected during parsing: {\n");
3987    fprintf(stderr, "  'source_filename' : '%s'\n", source_filename);
3988    fprintf(stderr, "  'command_line_args' : [");
3989    for (int i = 0; i != num_command_line_args; ++i) {
3990      if (i)
3991        fprintf(stderr, ", ");
3992      fprintf(stderr, "'%s'", command_line_args[i]);
3993    }
3994    fprintf(stderr, "],\n");
3995    fprintf(stderr, "  'unsaved_files' : [");
3996    for (unsigned i = 0; i != num_unsaved_files; ++i) {
3997      if (i)
3998        fprintf(stderr, ", ");
3999      fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename,
4000              unsaved_files[i].Length);
4001    }
4002    fprintf(stderr, "],\n");
4003    fprintf(stderr, "  'options' : %d,\n", options);
4004    fprintf(stderr, "}\n");
4005
4006    return CXError_Crashed;
4007  } else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
4008    if (CXTranslationUnit *TU = out_TU)
4009      PrintLibclangResourceUsage(*TU);
4010  }
4011
4012  return result;
4013}
4014
4015CXString clang_Type_getObjCEncoding(CXType CT) {
4016  CXTranslationUnit tu = static_cast<CXTranslationUnit>(CT.data[1]);
4017  ASTContext &Ctx = getASTUnit(tu)->getASTContext();
4018  std::string encoding;
4019  Ctx.getObjCEncodingForType(QualType::getFromOpaquePtr(CT.data[0]), encoding);
4020
4021  return cxstring::createDup(encoding);
4022}
4023
4024static const IdentifierInfo *getMacroIdentifier(CXCursor C) {
4025  if (C.kind == CXCursor_MacroDefinition) {
4026    if (const MacroDefinitionRecord *MDR = getCursorMacroDefinition(C))
4027      return MDR->getName();
4028  } else if (C.kind == CXCursor_MacroExpansion) {
4029    MacroExpansionCursor ME = getCursorMacroExpansion(C);
4030    return ME.getName();
4031  }
4032  return nullptr;
4033}
4034
4035unsigned clang_Cursor_isMacroFunctionLike(CXCursor C) {
4036  const IdentifierInfo *II = getMacroIdentifier(C);
4037  if (!II) {
4038    return false;
4039  }
4040  ASTUnit *ASTU = getCursorASTUnit(C);
4041  Preprocessor &PP = ASTU->getPreprocessor();
4042  if (const MacroInfo *MI = PP.getMacroInfo(II))
4043    return MI->isFunctionLike();
4044  return false;
4045}
4046
4047unsigned clang_Cursor_isMacroBuiltin(CXCursor C) {
4048  const IdentifierInfo *II = getMacroIdentifier(C);
4049  if (!II) {
4050    return false;
4051  }
4052  ASTUnit *ASTU = getCursorASTUnit(C);
4053  Preprocessor &PP = ASTU->getPreprocessor();
4054  if (const MacroInfo *MI = PP.getMacroInfo(II))
4055    return MI->isBuiltinMacro();
4056  return false;
4057}
4058
4059unsigned clang_Cursor_isFunctionInlined(CXCursor C) {
4060  const Decl *D = getCursorDecl(C);
4061  const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
4062  if (!FD) {
4063    return false;
4064  }
4065  return FD->isInlined();
4066}
4067
4068static StringLiteral *getCFSTR_value(CallExpr *callExpr) {
4069  if (callExpr->getNumArgs() != 1) {
4070    return nullptr;
4071  }
4072
4073  StringLiteral *S = nullptr;
4074  auto *arg = callExpr->getArg(0);
4075  if (arg->getStmtClass() == Stmt::ImplicitCastExprClass) {
4076    ImplicitCastExpr *I = static_cast<ImplicitCastExpr *>(arg);
4077    auto *subExpr = I->getSubExprAsWritten();
4078
4079    if (subExpr->getStmtClass() != Stmt::StringLiteralClass) {
4080      return nullptr;
4081    }
4082
4083    S = static_cast<StringLiteral *>(I->getSubExprAsWritten());
4084  } else if (arg->getStmtClass() == Stmt::StringLiteralClass) {
4085    S = static_cast<StringLiteral *>(callExpr->getArg(0));
4086  } else {
4087    return nullptr;
4088  }
4089  return S;
4090}
4091
4092struct ExprEvalResult {
4093  CXEvalResultKind EvalType;
4094  union {
4095    unsigned long long unsignedVal;
4096    long long intVal;
4097    double floatVal;
4098    char *stringVal;
4099  } EvalData;
4100  bool IsUnsignedInt;
4101  ~ExprEvalResult() {
4102    if (EvalType != CXEval_UnExposed && EvalType != CXEval_Float &&
4103        EvalType != CXEval_Int) {
4104      delete[] EvalData.stringVal;
4105    }
4106  }
4107};
4108
4109void clang_EvalResult_dispose(CXEvalResult E) {
4110  delete static_cast<ExprEvalResult *>(E);
4111}
4112
4113CXEvalResultKind clang_EvalResult_getKind(CXEvalResult E) {
4114  if (!E) {
4115    return CXEval_UnExposed;
4116  }
4117  return ((ExprEvalResult *)E)->EvalType;
4118}
4119
4120int clang_EvalResult_getAsInt(CXEvalResult E) {
4121  return clang_EvalResult_getAsLongLong(E);
4122}
4123
4124long long clang_EvalResult_getAsLongLong(CXEvalResult E) {
4125  if (!E) {
4126    return 0;
4127  }
4128  ExprEvalResult *Result = (ExprEvalResult *)E;
4129  if (Result->IsUnsignedInt)
4130    return Result->EvalData.unsignedVal;
4131  return Result->EvalData.intVal;
4132}
4133
4134unsigned clang_EvalResult_isUnsignedInt(CXEvalResult E) {
4135  return ((ExprEvalResult *)E)->IsUnsignedInt;
4136}
4137
4138unsigned long long clang_EvalResult_getAsUnsigned(CXEvalResult E) {
4139  if (!E) {
4140    return 0;
4141  }
4142
4143  ExprEvalResult *Result = (ExprEvalResult *)E;
4144  if (Result->IsUnsignedInt)
4145    return Result->EvalData.unsignedVal;
4146  return Result->EvalData.intVal;
4147}
4148
4149double clang_EvalResult_getAsDouble(CXEvalResult E) {
4150  if (!E) {
4151    return 0;
4152  }
4153  return ((ExprEvalResult *)E)->EvalData.floatVal;
4154}
4155
4156const char *clang_EvalResult_getAsStr(CXEvalResult E) {
4157  if (!E) {
4158    return nullptr;
4159  }
4160  return ((ExprEvalResult *)E)->EvalData.stringVal;
4161}
4162
4163static const ExprEvalResult *evaluateExpr(Expr *expr, CXCursor C) {
4164  Expr::EvalResult ER;
4165  ASTContext &ctx = getCursorContext(C);
4166  if (!expr)
4167    return nullptr;
4168
4169  expr = expr->IgnoreParens();
4170  if (expr->isValueDependent())
4171    return nullptr;
4172  if (!expr->EvaluateAsRValue(ER, ctx))
4173    return nullptr;
4174
4175  QualType rettype;
4176  CallExpr *callExpr;
4177  auto result = std::make_unique<ExprEvalResult>();
4178  result->EvalType = CXEval_UnExposed;
4179  result->IsUnsignedInt = false;
4180
4181  if (ER.Val.isInt()) {
4182    result->EvalType = CXEval_Int;
4183
4184    auto &val = ER.Val.getInt();
4185    if (val.isUnsigned()) {
4186      result->IsUnsignedInt = true;
4187      result->EvalData.unsignedVal = val.getZExtValue();
4188    } else {
4189      result->EvalData.intVal = val.getExtValue();
4190    }
4191
4192    return result.release();
4193  }
4194
4195  if (ER.Val.isFloat()) {
4196    llvm::SmallVector<char, 100> Buffer;
4197    ER.Val.getFloat().toString(Buffer);
4198    std::string floatStr(Buffer.data(), Buffer.size());
4199    result->EvalType = CXEval_Float;
4200    bool ignored;
4201    llvm::APFloat apFloat = ER.Val.getFloat();
4202    apFloat.convert(llvm::APFloat::IEEEdouble(),
4203                    llvm::APFloat::rmNearestTiesToEven, &ignored);
4204    result->EvalData.floatVal = apFloat.convertToDouble();
4205    return result.release();
4206  }
4207
4208  if (expr->getStmtClass() == Stmt::ImplicitCastExprClass) {
4209    const auto *I = cast<ImplicitCastExpr>(expr);
4210    auto *subExpr = I->getSubExprAsWritten();
4211    if (subExpr->getStmtClass() == Stmt::StringLiteralClass ||
4212        subExpr->getStmtClass() == Stmt::ObjCStringLiteralClass) {
4213      const StringLiteral *StrE = nullptr;
4214      const ObjCStringLiteral *ObjCExpr;
4215      ObjCExpr = dyn_cast<ObjCStringLiteral>(subExpr);
4216
4217      if (ObjCExpr) {
4218        StrE = ObjCExpr->getString();
4219        result->EvalType = CXEval_ObjCStrLiteral;
4220      } else {
4221        StrE = cast<StringLiteral>(I->getSubExprAsWritten());
4222        result->EvalType = CXEval_StrLiteral;
4223      }
4224
4225      std::string strRef(StrE->getString().str());
4226      result->EvalData.stringVal = new char[strRef.size() + 1];
4227      strncpy((char *)result->EvalData.stringVal, strRef.c_str(),
4228              strRef.size());
4229      result->EvalData.stringVal[strRef.size()] = '\0';
4230      return result.release();
4231    }
4232  } else if (expr->getStmtClass() == Stmt::ObjCStringLiteralClass ||
4233             expr->getStmtClass() == Stmt::StringLiteralClass) {
4234    const StringLiteral *StrE = nullptr;
4235    const ObjCStringLiteral *ObjCExpr;
4236    ObjCExpr = dyn_cast<ObjCStringLiteral>(expr);
4237
4238    if (ObjCExpr) {
4239      StrE = ObjCExpr->getString();
4240      result->EvalType = CXEval_ObjCStrLiteral;
4241    } else {
4242      StrE = cast<StringLiteral>(expr);
4243      result->EvalType = CXEval_StrLiteral;
4244    }
4245
4246    std::string strRef(StrE->getString().str());
4247    result->EvalData.stringVal = new char[strRef.size() + 1];
4248    strncpy((char *)result->EvalData.stringVal, strRef.c_str(), strRef.size());
4249    result->EvalData.stringVal[strRef.size()] = '\0';
4250    return result.release();
4251  }
4252
4253  if (expr->getStmtClass() == Stmt::CStyleCastExprClass) {
4254    CStyleCastExpr *CC = static_cast<CStyleCastExpr *>(expr);
4255
4256    rettype = CC->getType();
4257    if (rettype.getAsString() == "CFStringRef" &&
4258        CC->getSubExpr()->getStmtClass() == Stmt::CallExprClass) {
4259
4260      callExpr = static_cast<CallExpr *>(CC->getSubExpr());
4261      StringLiteral *S = getCFSTR_value(callExpr);
4262      if (S) {
4263        std::string strLiteral(S->getString().str());
4264        result->EvalType = CXEval_CFStr;
4265
4266        result->EvalData.stringVal = new char[strLiteral.size() + 1];
4267        strncpy((char *)result->EvalData.stringVal, strLiteral.c_str(),
4268                strLiteral.size());
4269        result->EvalData.stringVal[strLiteral.size()] = '\0';
4270        return result.release();
4271      }
4272    }
4273
4274  } else if (expr->getStmtClass() == Stmt::CallExprClass) {
4275    callExpr = static_cast<CallExpr *>(expr);
4276    rettype = callExpr->getCallReturnType(ctx);
4277
4278    if (rettype->isVectorType() || callExpr->getNumArgs() > 1)
4279      return nullptr;
4280
4281    if (rettype->isIntegralType(ctx) || rettype->isRealFloatingType()) {
4282      if (callExpr->getNumArgs() == 1 &&
4283          !callExpr->getArg(0)->getType()->isIntegralType(ctx))
4284        return nullptr;
4285    } else if (rettype.getAsString() == "CFStringRef") {
4286
4287      StringLiteral *S = getCFSTR_value(callExpr);
4288      if (S) {
4289        std::string strLiteral(S->getString().str());
4290        result->EvalType = CXEval_CFStr;
4291        result->EvalData.stringVal = new char[strLiteral.size() + 1];
4292        strncpy((char *)result->EvalData.stringVal, strLiteral.c_str(),
4293                strLiteral.size());
4294        result->EvalData.stringVal[strLiteral.size()] = '\0';
4295        return result.release();
4296      }
4297    }
4298  } else if (expr->getStmtClass() == Stmt::DeclRefExprClass) {
4299    DeclRefExpr *D = static_cast<DeclRefExpr *>(expr);
4300    ValueDecl *V = D->getDecl();
4301    if (V->getKind() == Decl::Function) {
4302      std::string strName = V->getNameAsString();
4303      result->EvalType = CXEval_Other;
4304      result->EvalData.stringVal = new char[strName.size() + 1];
4305      strncpy(result->EvalData.stringVal, strName.c_str(), strName.size());
4306      result->EvalData.stringVal[strName.size()] = '\0';
4307      return result.release();
4308    }
4309  }
4310
4311  return nullptr;
4312}
4313
4314static const Expr *evaluateDeclExpr(const Decl *D) {
4315  if (!D)
4316    return nullptr;
4317  if (auto *Var = dyn_cast<VarDecl>(D))
4318    return Var->getInit();
4319  else if (auto *Field = dyn_cast<FieldDecl>(D))
4320    return Field->getInClassInitializer();
4321  return nullptr;
4322}
4323
4324static const Expr *evaluateCompoundStmtExpr(const CompoundStmt *CS) {
4325  assert(CS && "invalid compound statement");
4326  for (auto *bodyIterator : CS->body()) {
4327    if (const auto *E = dyn_cast<Expr>(bodyIterator))
4328      return E;
4329  }
4330  return nullptr;
4331}
4332
4333CXEvalResult clang_Cursor_Evaluate(CXCursor C) {
4334  const Expr *E = nullptr;
4335  if (clang_getCursorKind(C) == CXCursor_CompoundStmt)
4336    E = evaluateCompoundStmtExpr(cast<CompoundStmt>(getCursorStmt(C)));
4337  else if (clang_isDeclaration(C.kind))
4338    E = evaluateDeclExpr(getCursorDecl(C));
4339  else if (clang_isExpression(C.kind))
4340    E = getCursorExpr(C);
4341  if (E)
4342    return const_cast<CXEvalResult>(
4343        reinterpret_cast<const void *>(evaluateExpr(const_cast<Expr *>(E), C)));
4344  return nullptr;
4345}
4346
4347unsigned clang_Cursor_hasAttrs(CXCursor C) {
4348  const Decl *D = getCursorDecl(C);
4349  if (!D) {
4350    return 0;
4351  }
4352
4353  if (D->hasAttrs()) {
4354    return 1;
4355  }
4356
4357  return 0;
4358}
4359unsigned clang_defaultSaveOptions(CXTranslationUnit TU) {
4360  return CXSaveTranslationUnit_None;
4361}
4362
4363static CXSaveError clang_saveTranslationUnit_Impl(CXTranslationUnit TU,
4364                                                  const char *FileName,
4365                                                  unsigned options) {
4366  CIndexer *CXXIdx = TU->CIdx;
4367  if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
4368    setThreadBackgroundPriority();
4369
4370  bool hadError = cxtu::getASTUnit(TU)->Save(FileName);
4371  return hadError ? CXSaveError_Unknown : CXSaveError_None;
4372}
4373
4374int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName,
4375                              unsigned options) {
4376  LOG_FUNC_SECTION { *Log << TU << ' ' << FileName; }
4377
4378  if (isNotUsableTU(TU)) {
4379    LOG_BAD_TU(TU);
4380    return CXSaveError_InvalidTU;
4381  }
4382
4383  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
4384  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
4385  if (!CXXUnit->hasSema())
4386    return CXSaveError_InvalidTU;
4387
4388  CXSaveError result;
4389  auto SaveTranslationUnitImpl = [=, &result]() {
4390    result = clang_saveTranslationUnit_Impl(TU, FileName, options);
4391  };
4392
4393  if (!CXXUnit->getDiagnostics().hasUnrecoverableErrorOccurred()) {
4394    SaveTranslationUnitImpl();
4395
4396    if (getenv("LIBCLANG_RESOURCE_USAGE"))
4397      PrintLibclangResourceUsage(TU);
4398
4399    return result;
4400  }
4401
4402  // We have an AST that has invalid nodes due to compiler errors.
4403  // Use a crash recovery thread for protection.
4404
4405  llvm::CrashRecoveryContext CRC;
4406
4407  if (!RunSafely(CRC, SaveTranslationUnitImpl)) {
4408    fprintf(stderr, "libclang: crash detected during AST saving: {\n");
4409    fprintf(stderr, "  'filename' : '%s'\n", FileName);
4410    fprintf(stderr, "  'options' : %d,\n", options);
4411    fprintf(stderr, "}\n");
4412
4413    return CXSaveError_Unknown;
4414
4415  } else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
4416    PrintLibclangResourceUsage(TU);
4417  }
4418
4419  return result;
4420}
4421
4422void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) {
4423  if (CTUnit) {
4424    // If the translation unit has been marked as unsafe to free, just discard
4425    // it.
4426    ASTUnit *Unit = cxtu::getASTUnit(CTUnit);
4427    if (Unit && Unit->isUnsafeToFree())
4428      return;
4429
4430    delete cxtu::getASTUnit(CTUnit);
4431    delete CTUnit->StringPool;
4432    delete static_cast<CXDiagnosticSetImpl *>(CTUnit->Diagnostics);
4433    disposeOverridenCXCursorsPool(CTUnit->OverridenCursorsPool);
4434    delete CTUnit->CommentToXML;
4435    delete CTUnit;
4436  }
4437}
4438
4439unsigned clang_suspendTranslationUnit(CXTranslationUnit CTUnit) {
4440  if (CTUnit) {
4441    ASTUnit *Unit = cxtu::getASTUnit(CTUnit);
4442
4443    if (Unit && Unit->isUnsafeToFree())
4444      return false;
4445
4446    Unit->ResetForParse();
4447    return true;
4448  }
4449
4450  return false;
4451}
4452
4453unsigned clang_defaultReparseOptions(CXTranslationUnit TU) {
4454  return CXReparse_None;
4455}
4456
4457static CXErrorCode
4458clang_reparseTranslationUnit_Impl(CXTranslationUnit TU,
4459                                  ArrayRef<CXUnsavedFile> unsaved_files,
4460                                  unsigned options) {
4461  // Check arguments.
4462  if (isNotUsableTU(TU)) {
4463    LOG_BAD_TU(TU);
4464    return CXError_InvalidArguments;
4465  }
4466
4467  // Reset the associated diagnostics.
4468  delete static_cast<CXDiagnosticSetImpl *>(TU->Diagnostics);
4469  TU->Diagnostics = nullptr;
4470
4471  CIndexer *CXXIdx = TU->CIdx;
4472  if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
4473    setThreadBackgroundPriority();
4474
4475  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
4476  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
4477
4478  std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles(
4479      new std::vector<ASTUnit::RemappedFile>());
4480
4481  // Recover resources if we crash before exiting this function.
4482  llvm::CrashRecoveryContextCleanupRegistrar<std::vector<ASTUnit::RemappedFile>>
4483      RemappedCleanup(RemappedFiles.get());
4484
4485  for (auto &UF : unsaved_files) {
4486    std::unique_ptr<llvm::MemoryBuffer> MB =
4487        llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
4488    RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release()));
4489  }
4490
4491  if (!CXXUnit->Reparse(CXXIdx->getPCHContainerOperations(),
4492                        *RemappedFiles.get()))
4493    return CXError_Success;
4494  if (isASTReadError(CXXUnit))
4495    return CXError_ASTReadError;
4496  return CXError_Failure;
4497}
4498
4499int clang_reparseTranslationUnit(CXTranslationUnit TU,
4500                                 unsigned num_unsaved_files,
4501                                 struct CXUnsavedFile *unsaved_files,
4502                                 unsigned options) {
4503  LOG_FUNC_SECTION { *Log << TU; }
4504
4505  if (num_unsaved_files && !unsaved_files)
4506    return CXError_InvalidArguments;
4507
4508  CXErrorCode result;
4509  auto ReparseTranslationUnitImpl = [=, &result]() {
4510    result = clang_reparseTranslationUnit_Impl(
4511        TU, llvm::ArrayRef(unsaved_files, num_unsaved_files), options);
4512  };
4513
4514  llvm::CrashRecoveryContext CRC;
4515
4516  if (!RunSafely(CRC, ReparseTranslationUnitImpl)) {
4517    fprintf(stderr, "libclang: crash detected during reparsing\n");
4518    cxtu::getASTUnit(TU)->setUnsafeToFree(true);
4519    return CXError_Crashed;
4520  } else if (getenv("LIBCLANG_RESOURCE_USAGE"))
4521    PrintLibclangResourceUsage(TU);
4522
4523  return result;
4524}
4525
4526CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) {
4527  if (isNotUsableTU(CTUnit)) {
4528    LOG_BAD_TU(CTUnit);
4529    return cxstring::createEmpty();
4530  }
4531
4532  ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit);
4533  return cxstring::createDup(CXXUnit->getOriginalSourceFileName());
4534}
4535
4536CXCursor clang_getTranslationUnitCursor(CXTranslationUnit TU) {
4537  if (isNotUsableTU(TU)) {
4538    LOG_BAD_TU(TU);
4539    return clang_getNullCursor();
4540  }
4541
4542  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
4543  return MakeCXCursor(CXXUnit->getASTContext().getTranslationUnitDecl(), TU);
4544}
4545
4546CXTargetInfo clang_getTranslationUnitTargetInfo(CXTranslationUnit CTUnit) {
4547  if (isNotUsableTU(CTUnit)) {
4548    LOG_BAD_TU(CTUnit);
4549    return nullptr;
4550  }
4551
4552  CXTargetInfoImpl *impl = new CXTargetInfoImpl();
4553  impl->TranslationUnit = CTUnit;
4554  return impl;
4555}
4556
4557CXString clang_TargetInfo_getTriple(CXTargetInfo TargetInfo) {
4558  if (!TargetInfo)
4559    return cxstring::createEmpty();
4560
4561  CXTranslationUnit CTUnit = TargetInfo->TranslationUnit;
4562  assert(!isNotUsableTU(CTUnit) &&
4563         "Unexpected unusable translation unit in TargetInfo");
4564
4565  ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit);
4566  std::string Triple =
4567      CXXUnit->getASTContext().getTargetInfo().getTriple().normalize();
4568  return cxstring::createDup(Triple);
4569}
4570
4571int clang_TargetInfo_getPointerWidth(CXTargetInfo TargetInfo) {
4572  if (!TargetInfo)
4573    return -1;
4574
4575  CXTranslationUnit CTUnit = TargetInfo->TranslationUnit;
4576  assert(!isNotUsableTU(CTUnit) &&
4577         "Unexpected unusable translation unit in TargetInfo");
4578
4579  ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit);
4580  return CXXUnit->getASTContext().getTargetInfo().getMaxPointerWidth();
4581}
4582
4583void clang_TargetInfo_dispose(CXTargetInfo TargetInfo) {
4584  if (!TargetInfo)
4585    return;
4586
4587  delete TargetInfo;
4588}
4589
4590//===----------------------------------------------------------------------===//
4591// CXFile Operations.
4592//===----------------------------------------------------------------------===//
4593
4594CXString clang_getFileName(CXFile SFile) {
4595  if (!SFile)
4596    return cxstring::createNull();
4597
4598  FileEntry *FEnt = static_cast<FileEntry *>(SFile);
4599  return cxstring::createRef(FEnt->getName());
4600}
4601
4602time_t clang_getFileTime(CXFile SFile) {
4603  if (!SFile)
4604    return 0;
4605
4606  FileEntry *FEnt = static_cast<FileEntry *>(SFile);
4607  return FEnt->getModificationTime();
4608}
4609
4610CXFile clang_getFile(CXTranslationUnit TU, const char *file_name) {
4611  if (isNotUsableTU(TU)) {
4612    LOG_BAD_TU(TU);
4613    return nullptr;
4614  }
4615
4616  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
4617
4618  FileManager &FMgr = CXXUnit->getFileManager();
4619  auto File = FMgr.getFile(file_name);
4620  if (!File)
4621    return nullptr;
4622  return const_cast<FileEntry *>(*File);
4623}
4624
4625const char *clang_getFileContents(CXTranslationUnit TU, CXFile file,
4626                                  size_t *size) {
4627  if (isNotUsableTU(TU)) {
4628    LOG_BAD_TU(TU);
4629    return nullptr;
4630  }
4631
4632  const SourceManager &SM = cxtu::getASTUnit(TU)->getSourceManager();
4633  FileID fid = SM.translateFile(static_cast<FileEntry *>(file));
4634  std::optional<llvm::MemoryBufferRef> buf = SM.getBufferOrNone(fid);
4635  if (!buf) {
4636    if (size)
4637      *size = 0;
4638    return nullptr;
4639  }
4640  if (size)
4641    *size = buf->getBufferSize();
4642  return buf->getBufferStart();
4643}
4644
4645unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit TU, CXFile file) {
4646  if (isNotUsableTU(TU)) {
4647    LOG_BAD_TU(TU);
4648    return 0;
4649  }
4650
4651  if (!file)
4652    return 0;
4653
4654  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
4655  FileEntry *FEnt = static_cast<FileEntry *>(file);
4656  return CXXUnit->getPreprocessor()
4657      .getHeaderSearchInfo()
4658      .isFileMultipleIncludeGuarded(FEnt);
4659}
4660
4661int clang_getFileUniqueID(CXFile file, CXFileUniqueID *outID) {
4662  if (!file || !outID)
4663    return 1;
4664
4665  FileEntry *FEnt = static_cast<FileEntry *>(file);
4666  const llvm::sys::fs::UniqueID &ID = FEnt->getUniqueID();
4667  outID->data[0] = ID.getDevice();
4668  outID->data[1] = ID.getFile();
4669  outID->data[2] = FEnt->getModificationTime();
4670  return 0;
4671}
4672
4673int clang_File_isEqual(CXFile file1, CXFile file2) {
4674  if (file1 == file2)
4675    return true;
4676
4677  if (!file1 || !file2)
4678    return false;
4679
4680  FileEntry *FEnt1 = static_cast<FileEntry *>(file1);
4681  FileEntry *FEnt2 = static_cast<FileEntry *>(file2);
4682  return FEnt1->getUniqueID() == FEnt2->getUniqueID();
4683}
4684
4685CXString clang_File_tryGetRealPathName(CXFile SFile) {
4686  if (!SFile)
4687    return cxstring::createNull();
4688
4689  FileEntry *FEnt = static_cast<FileEntry *>(SFile);
4690  return cxstring::createRef(FEnt->tryGetRealPathName());
4691}
4692
4693//===----------------------------------------------------------------------===//
4694// CXCursor Operations.
4695//===----------------------------------------------------------------------===//
4696
4697static const Decl *getDeclFromExpr(const Stmt *E) {
4698  if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
4699    return getDeclFromExpr(CE->getSubExpr());
4700
4701  if (const DeclRefExpr *RefExpr = dyn_cast<DeclRefExpr>(E))
4702    return RefExpr->getDecl();
4703  if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
4704    return ME->getMemberDecl();
4705  if (const ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(E))
4706    return RE->getDecl();
4707  if (const ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(E)) {
4708    if (PRE->isExplicitProperty())
4709      return PRE->getExplicitProperty();
4710    // It could be messaging both getter and setter as in:
4711    // ++myobj.myprop;
4712    // in which case prefer to associate the setter since it is less obvious
4713    // from inspecting the source that the setter is going to get called.
4714    if (PRE->isMessagingSetter())
4715      return PRE->getImplicitPropertySetter();
4716    return PRE->getImplicitPropertyGetter();
4717  }
4718  if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
4719    return getDeclFromExpr(POE->getSyntacticForm());
4720  if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E))
4721    if (Expr *Src = OVE->getSourceExpr())
4722      return getDeclFromExpr(Src);
4723
4724  if (const CallExpr *CE = dyn_cast<CallExpr>(E))
4725    return getDeclFromExpr(CE->getCallee());
4726  if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E))
4727    if (!CE->isElidable())
4728      return CE->getConstructor();
4729  if (const CXXInheritedCtorInitExpr *CE =
4730          dyn_cast<CXXInheritedCtorInitExpr>(E))
4731    return CE->getConstructor();
4732  if (const ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E))
4733    return OME->getMethodDecl();
4734
4735  if (const ObjCProtocolExpr *PE = dyn_cast<ObjCProtocolExpr>(E))
4736    return PE->getProtocol();
4737  if (const SubstNonTypeTemplateParmPackExpr *NTTP =
4738          dyn_cast<SubstNonTypeTemplateParmPackExpr>(E))
4739    return NTTP->getParameterPack();
4740  if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
4741    if (isa<NonTypeTemplateParmDecl>(SizeOfPack->getPack()) ||
4742        isa<ParmVarDecl>(SizeOfPack->getPack()))
4743      return SizeOfPack->getPack();
4744
4745  return nullptr;
4746}
4747
4748static SourceLocation getLocationFromExpr(const Expr *E) {
4749  if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
4750    return getLocationFromExpr(CE->getSubExpr());
4751
4752  if (const ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E))
4753    return /*FIXME:*/ Msg->getLeftLoc();
4754  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
4755    return DRE->getLocation();
4756  if (const MemberExpr *Member = dyn_cast<MemberExpr>(E))
4757    return Member->getMemberLoc();
4758  if (const ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E))
4759    return Ivar->getLocation();
4760  if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
4761    return SizeOfPack->getPackLoc();
4762  if (const ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E))
4763    return PropRef->getLocation();
4764
4765  return E->getBeginLoc();
4766}
4767
4768extern "C" {
4769
4770unsigned clang_visitChildren(CXCursor parent, CXCursorVisitor visitor,
4771                             CXClientData client_data) {
4772  CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data,
4773                          /*VisitPreprocessorLast=*/false);
4774  return CursorVis.VisitChildren(parent);
4775}
4776
4777#ifndef __has_feature
4778#define __has_feature(x) 0
4779#endif
4780#if __has_feature(blocks)
4781typedef enum CXChildVisitResult (^CXCursorVisitorBlock)(CXCursor cursor,
4782                                                        CXCursor parent);
4783
4784static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
4785                                              CXClientData client_data) {
4786  CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
4787  return block(cursor, parent);
4788}
4789#else
4790// If we are compiled with a compiler that doesn't have native blocks support,
4791// define and call the block manually, so the
4792typedef struct _CXChildVisitResult {
4793  void *isa;
4794  int flags;
4795  int reserved;
4796  enum CXChildVisitResult (*invoke)(struct _CXChildVisitResult *, CXCursor,
4797                                    CXCursor);
4798} * CXCursorVisitorBlock;
4799
4800static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
4801                                              CXClientData client_data) {
4802  CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
4803  return block->invoke(block, cursor, parent);
4804}
4805#endif
4806
4807unsigned clang_visitChildrenWithBlock(CXCursor parent,
4808                                      CXCursorVisitorBlock block) {
4809  return clang_visitChildren(parent, visitWithBlock, block);
4810}
4811
4812static CXString getDeclSpelling(const Decl *D) {
4813  if (!D)
4814    return cxstring::createEmpty();
4815
4816  const NamedDecl *ND = dyn_cast<NamedDecl>(D);
4817  if (!ND) {
4818    if (const ObjCPropertyImplDecl *PropImpl =
4819            dyn_cast<ObjCPropertyImplDecl>(D))
4820      if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl())
4821        return cxstring::createDup(Property->getIdentifier()->getName());
4822
4823    if (const ImportDecl *ImportD = dyn_cast<ImportDecl>(D))
4824      if (Module *Mod = ImportD->getImportedModule())
4825        return cxstring::createDup(Mod->getFullModuleName());
4826
4827    return cxstring::createEmpty();
4828  }
4829
4830  if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
4831    return cxstring::createDup(OMD->getSelector().getAsString());
4832
4833  if (const ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND))
4834    // No, this isn't the same as the code below. getIdentifier() is non-virtual
4835    // and returns different names. NamedDecl returns the class name and
4836    // ObjCCategoryImplDecl returns the category name.
4837    return cxstring::createRef(CIMP->getIdentifier()->getNameStart());
4838
4839  if (isa<UsingDirectiveDecl>(D))
4840    return cxstring::createEmpty();
4841
4842  SmallString<1024> S;
4843  llvm::raw_svector_ostream os(S);
4844  ND->printName(os);
4845
4846  return cxstring::createDup(os.str());
4847}
4848
4849CXString clang_getCursorSpelling(CXCursor C) {
4850  if (clang_isTranslationUnit(C.kind))
4851    return clang_getTranslationUnitSpelling(getCursorTU(C));
4852
4853  if (clang_isReference(C.kind)) {
4854    switch (C.kind) {
4855    case CXCursor_ObjCSuperClassRef: {
4856      const ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first;
4857      return cxstring::createRef(Super->getIdentifier()->getNameStart());
4858    }
4859    case CXCursor_ObjCClassRef: {
4860      const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first;
4861      return cxstring::createRef(Class->getIdentifier()->getNameStart());
4862    }
4863    case CXCursor_ObjCProtocolRef: {
4864      const ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first;
4865      assert(OID && "getCursorSpelling(): Missing protocol decl");
4866      return cxstring::createRef(OID->getIdentifier()->getNameStart());
4867    }
4868    case CXCursor_CXXBaseSpecifier: {
4869      const CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C);
4870      return cxstring::createDup(B->getType().getAsString());
4871    }
4872    case CXCursor_TypeRef: {
4873      const TypeDecl *Type = getCursorTypeRef(C).first;
4874      assert(Type && "Missing type decl");
4875
4876      return cxstring::createDup(
4877          getCursorContext(C).getTypeDeclType(Type).getAsString());
4878    }
4879    case CXCursor_TemplateRef: {
4880      const TemplateDecl *Template = getCursorTemplateRef(C).first;
4881      assert(Template && "Missing template decl");
4882
4883      return cxstring::createDup(Template->getNameAsString());
4884    }
4885
4886    case CXCursor_NamespaceRef: {
4887      const NamedDecl *NS = getCursorNamespaceRef(C).first;
4888      assert(NS && "Missing namespace decl");
4889
4890      return cxstring::createDup(NS->getNameAsString());
4891    }
4892
4893    case CXCursor_MemberRef: {
4894      const FieldDecl *Field = getCursorMemberRef(C).first;
4895      assert(Field && "Missing member decl");
4896
4897      return cxstring::createDup(Field->getNameAsString());
4898    }
4899
4900    case CXCursor_LabelRef: {
4901      const LabelStmt *Label = getCursorLabelRef(C).first;
4902      assert(Label && "Missing label");
4903
4904      return cxstring::createRef(Label->getName());
4905    }
4906
4907    case CXCursor_OverloadedDeclRef: {
4908      OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first;
4909      if (const Decl *D = Storage.dyn_cast<const Decl *>()) {
4910        if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
4911          return cxstring::createDup(ND->getNameAsString());
4912        return cxstring::createEmpty();
4913      }
4914      if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
4915        return cxstring::createDup(E->getName().getAsString());
4916      OverloadedTemplateStorage *Ovl =
4917          Storage.get<OverloadedTemplateStorage *>();
4918      if (Ovl->size() == 0)
4919        return cxstring::createEmpty();
4920      return cxstring::createDup((*Ovl->begin())->getNameAsString());
4921    }
4922
4923    case CXCursor_VariableRef: {
4924      const VarDecl *Var = getCursorVariableRef(C).first;
4925      assert(Var && "Missing variable decl");
4926
4927      return cxstring::createDup(Var->getNameAsString());
4928    }
4929
4930    default:
4931      return cxstring::createRef("<not implemented>");
4932    }
4933  }
4934
4935  if (clang_isExpression(C.kind)) {
4936    const Expr *E = getCursorExpr(C);
4937
4938    if (C.kind == CXCursor_ObjCStringLiteral ||
4939        C.kind == CXCursor_StringLiteral) {
4940      const StringLiteral *SLit;
4941      if (const ObjCStringLiteral *OSL = dyn_cast<ObjCStringLiteral>(E)) {
4942        SLit = OSL->getString();
4943      } else {
4944        SLit = cast<StringLiteral>(E);
4945      }
4946      SmallString<256> Buf;
4947      llvm::raw_svector_ostream OS(Buf);
4948      SLit->outputString(OS);
4949      return cxstring::createDup(OS.str());
4950    }
4951
4952    const Decl *D = getDeclFromExpr(getCursorExpr(C));
4953    if (D)
4954      return getDeclSpelling(D);
4955    return cxstring::createEmpty();
4956  }
4957
4958  if (clang_isStatement(C.kind)) {
4959    const Stmt *S = getCursorStmt(C);
4960    if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
4961      return cxstring::createRef(Label->getName());
4962
4963    return cxstring::createEmpty();
4964  }
4965
4966  if (C.kind == CXCursor_MacroExpansion)
4967    return cxstring::createRef(
4968        getCursorMacroExpansion(C).getName()->getNameStart());
4969
4970  if (C.kind == CXCursor_MacroDefinition)
4971    return cxstring::createRef(
4972        getCursorMacroDefinition(C)->getName()->getNameStart());
4973
4974  if (C.kind == CXCursor_InclusionDirective)
4975    return cxstring::createDup(getCursorInclusionDirective(C)->getFileName());
4976
4977  if (clang_isDeclaration(C.kind))
4978    return getDeclSpelling(getCursorDecl(C));
4979
4980  if (C.kind == CXCursor_AnnotateAttr) {
4981    const AnnotateAttr *AA = cast<AnnotateAttr>(cxcursor::getCursorAttr(C));
4982    return cxstring::createDup(AA->getAnnotation());
4983  }
4984
4985  if (C.kind == CXCursor_AsmLabelAttr) {
4986    const AsmLabelAttr *AA = cast<AsmLabelAttr>(cxcursor::getCursorAttr(C));
4987    return cxstring::createDup(AA->getLabel());
4988  }
4989
4990  if (C.kind == CXCursor_PackedAttr) {
4991    return cxstring::createRef("packed");
4992  }
4993
4994  if (C.kind == CXCursor_VisibilityAttr) {
4995    const VisibilityAttr *AA = cast<VisibilityAttr>(cxcursor::getCursorAttr(C));
4996    switch (AA->getVisibility()) {
4997    case VisibilityAttr::VisibilityType::Default:
4998      return cxstring::createRef("default");
4999    case VisibilityAttr::VisibilityType::Hidden:
5000      return cxstring::createRef("hidden");
5001    case VisibilityAttr::VisibilityType::Protected:
5002      return cxstring::createRef("protected");
5003    }
5004    llvm_unreachable("unknown visibility type");
5005  }
5006
5007  return cxstring::createEmpty();
5008}
5009
5010CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor C, unsigned pieceIndex,
5011                                                unsigned options) {
5012  if (clang_Cursor_isNull(C))
5013    return clang_getNullRange();
5014
5015  ASTContext &Ctx = getCursorContext(C);
5016
5017  if (clang_isStatement(C.kind)) {
5018    const Stmt *S = getCursorStmt(C);
5019    if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) {
5020      if (pieceIndex > 0)
5021        return clang_getNullRange();
5022      return cxloc::translateSourceRange(Ctx, Label->getIdentLoc());
5023    }
5024
5025    return clang_getNullRange();
5026  }
5027
5028  if (C.kind == CXCursor_ObjCMessageExpr) {
5029    if (const ObjCMessageExpr *ME =
5030            dyn_cast_or_null<ObjCMessageExpr>(getCursorExpr(C))) {
5031      if (pieceIndex >= ME->getNumSelectorLocs())
5032        return clang_getNullRange();
5033      return cxloc::translateSourceRange(Ctx, ME->getSelectorLoc(pieceIndex));
5034    }
5035  }
5036
5037  if (C.kind == CXCursor_ObjCInstanceMethodDecl ||
5038      C.kind == CXCursor_ObjCClassMethodDecl) {
5039    if (const ObjCMethodDecl *MD =
5040            dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(C))) {
5041      if (pieceIndex >= MD->getNumSelectorLocs())
5042        return clang_getNullRange();
5043      return cxloc::translateSourceRange(Ctx, MD->getSelectorLoc(pieceIndex));
5044    }
5045  }
5046
5047  if (C.kind == CXCursor_ObjCCategoryDecl ||
5048      C.kind == CXCursor_ObjCCategoryImplDecl) {
5049    if (pieceIndex > 0)
5050      return clang_getNullRange();
5051    if (const ObjCCategoryDecl *CD =
5052            dyn_cast_or_null<ObjCCategoryDecl>(getCursorDecl(C)))
5053      return cxloc::translateSourceRange(Ctx, CD->getCategoryNameLoc());
5054    if (const ObjCCategoryImplDecl *CID =
5055            dyn_cast_or_null<ObjCCategoryImplDecl>(getCursorDecl(C)))
5056      return cxloc::translateSourceRange(Ctx, CID->getCategoryNameLoc());
5057  }
5058
5059  if (C.kind == CXCursor_ModuleImportDecl) {
5060    if (pieceIndex > 0)
5061      return clang_getNullRange();
5062    if (const ImportDecl *ImportD =
5063            dyn_cast_or_null<ImportDecl>(getCursorDecl(C))) {
5064      ArrayRef<SourceLocation> Locs = ImportD->getIdentifierLocs();
5065      if (!Locs.empty())
5066        return cxloc::translateSourceRange(
5067            Ctx, SourceRange(Locs.front(), Locs.back()));
5068    }
5069    return clang_getNullRange();
5070  }
5071
5072  if (C.kind == CXCursor_CXXMethod || C.kind == CXCursor_Destructor ||
5073      C.kind == CXCursor_ConversionFunction ||
5074      C.kind == CXCursor_FunctionDecl) {
5075    if (pieceIndex > 0)
5076      return clang_getNullRange();
5077    if (const FunctionDecl *FD =
5078            dyn_cast_or_null<FunctionDecl>(getCursorDecl(C))) {
5079      DeclarationNameInfo FunctionName = FD->getNameInfo();
5080      return cxloc::translateSourceRange(Ctx, FunctionName.getSourceRange());
5081    }
5082    return clang_getNullRange();
5083  }
5084
5085  // FIXME: A CXCursor_InclusionDirective should give the location of the
5086  // filename, but we don't keep track of this.
5087
5088  // FIXME: A CXCursor_AnnotateAttr should give the location of the annotation
5089  // but we don't keep track of this.
5090
5091  // FIXME: A CXCursor_AsmLabelAttr should give the location of the label
5092  // but we don't keep track of this.
5093
5094  // Default handling, give the location of the cursor.
5095
5096  if (pieceIndex > 0)
5097    return clang_getNullRange();
5098
5099  CXSourceLocation CXLoc = clang_getCursorLocation(C);
5100  SourceLocation Loc = cxloc::translateSourceLocation(CXLoc);
5101  return cxloc::translateSourceRange(Ctx, Loc);
5102}
5103
5104CXString clang_Cursor_getMangling(CXCursor C) {
5105  if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind))
5106    return cxstring::createEmpty();
5107
5108  // Mangling only works for functions and variables.
5109  const Decl *D = getCursorDecl(C);
5110  if (!D || !(isa<FunctionDecl>(D) || isa<VarDecl>(D)))
5111    return cxstring::createEmpty();
5112
5113  ASTContext &Ctx = D->getASTContext();
5114  ASTNameGenerator ASTNameGen(Ctx);
5115  return cxstring::createDup(ASTNameGen.getName(D));
5116}
5117
5118CXStringSet *clang_Cursor_getCXXManglings(CXCursor C) {
5119  if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind))
5120    return nullptr;
5121
5122  const Decl *D = getCursorDecl(C);
5123  if (!(isa<CXXRecordDecl>(D) || isa<CXXMethodDecl>(D)))
5124    return nullptr;
5125
5126  ASTContext &Ctx = D->getASTContext();
5127  ASTNameGenerator ASTNameGen(Ctx);
5128  std::vector<std::string> Manglings = ASTNameGen.getAllManglings(D);
5129  return cxstring::createSet(Manglings);
5130}
5131
5132CXStringSet *clang_Cursor_getObjCManglings(CXCursor C) {
5133  if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind))
5134    return nullptr;
5135
5136  const Decl *D = getCursorDecl(C);
5137  if (!(isa<ObjCInterfaceDecl>(D) || isa<ObjCImplementationDecl>(D)))
5138    return nullptr;
5139
5140  ASTContext &Ctx = D->getASTContext();
5141  ASTNameGenerator ASTNameGen(Ctx);
5142  std::vector<std::string> Manglings = ASTNameGen.getAllManglings(D);
5143  return cxstring::createSet(Manglings);
5144}
5145
5146CXPrintingPolicy clang_getCursorPrintingPolicy(CXCursor C) {
5147  if (clang_Cursor_isNull(C))
5148    return nullptr;
5149  return new PrintingPolicy(getCursorContext(C).getPrintingPolicy());
5150}
5151
5152void clang_PrintingPolicy_dispose(CXPrintingPolicy Policy) {
5153  if (Policy)
5154    delete static_cast<PrintingPolicy *>(Policy);
5155}
5156
5157unsigned
5158clang_PrintingPolicy_getProperty(CXPrintingPolicy Policy,
5159                                 enum CXPrintingPolicyProperty Property) {
5160  if (!Policy)
5161    return 0;
5162
5163  PrintingPolicy *P = static_cast<PrintingPolicy *>(Policy);
5164  switch (Property) {
5165  case CXPrintingPolicy_Indentation:
5166    return P->Indentation;
5167  case CXPrintingPolicy_SuppressSpecifiers:
5168    return P->SuppressSpecifiers;
5169  case CXPrintingPolicy_SuppressTagKeyword:
5170    return P->SuppressTagKeyword;
5171  case CXPrintingPolicy_IncludeTagDefinition:
5172    return P->IncludeTagDefinition;
5173  case CXPrintingPolicy_SuppressScope:
5174    return P->SuppressScope;
5175  case CXPrintingPolicy_SuppressUnwrittenScope:
5176    return P->SuppressUnwrittenScope;
5177  case CXPrintingPolicy_SuppressInitializers:
5178    return P->SuppressInitializers;
5179  case CXPrintingPolicy_ConstantArraySizeAsWritten:
5180    return P->ConstantArraySizeAsWritten;
5181  case CXPrintingPolicy_AnonymousTagLocations:
5182    return P->AnonymousTagLocations;
5183  case CXPrintingPolicy_SuppressStrongLifetime:
5184    return P->SuppressStrongLifetime;
5185  case CXPrintingPolicy_SuppressLifetimeQualifiers:
5186    return P->SuppressLifetimeQualifiers;
5187  case CXPrintingPolicy_SuppressTemplateArgsInCXXConstructors:
5188    return P->SuppressTemplateArgsInCXXConstructors;
5189  case CXPrintingPolicy_Bool:
5190    return P->Bool;
5191  case CXPrintingPolicy_Restrict:
5192    return P->Restrict;
5193  case CXPrintingPolicy_Alignof:
5194    return P->Alignof;
5195  case CXPrintingPolicy_UnderscoreAlignof:
5196    return P->UnderscoreAlignof;
5197  case CXPrintingPolicy_UseVoidForZeroParams:
5198    return P->UseVoidForZeroParams;
5199  case CXPrintingPolicy_TerseOutput:
5200    return P->TerseOutput;
5201  case CXPrintingPolicy_PolishForDeclaration:
5202    return P->PolishForDeclaration;
5203  case CXPrintingPolicy_Half:
5204    return P->Half;
5205  case CXPrintingPolicy_MSWChar:
5206    return P->MSWChar;
5207  case CXPrintingPolicy_IncludeNewlines:
5208    return P->IncludeNewlines;
5209  case CXPrintingPolicy_MSVCFormatting:
5210    return P->MSVCFormatting;
5211  case CXPrintingPolicy_ConstantsAsWritten:
5212    return P->ConstantsAsWritten;
5213  case CXPrintingPolicy_SuppressImplicitBase:
5214    return P->SuppressImplicitBase;
5215  case CXPrintingPolicy_FullyQualifiedName:
5216    return P->FullyQualifiedName;
5217  }
5218
5219  assert(false && "Invalid CXPrintingPolicyProperty");
5220  return 0;
5221}
5222
5223void clang_PrintingPolicy_setProperty(CXPrintingPolicy Policy,
5224                                      enum CXPrintingPolicyProperty Property,
5225                                      unsigned Value) {
5226  if (!Policy)
5227    return;
5228
5229  PrintingPolicy *P = static_cast<PrintingPolicy *>(Policy);
5230  switch (Property) {
5231  case CXPrintingPolicy_Indentation:
5232    P->Indentation = Value;
5233    return;
5234  case CXPrintingPolicy_SuppressSpecifiers:
5235    P->SuppressSpecifiers = Value;
5236    return;
5237  case CXPrintingPolicy_SuppressTagKeyword:
5238    P->SuppressTagKeyword = Value;
5239    return;
5240  case CXPrintingPolicy_IncludeTagDefinition:
5241    P->IncludeTagDefinition = Value;
5242    return;
5243  case CXPrintingPolicy_SuppressScope:
5244    P->SuppressScope = Value;
5245    return;
5246  case CXPrintingPolicy_SuppressUnwrittenScope:
5247    P->SuppressUnwrittenScope = Value;
5248    return;
5249  case CXPrintingPolicy_SuppressInitializers:
5250    P->SuppressInitializers = Value;
5251    return;
5252  case CXPrintingPolicy_ConstantArraySizeAsWritten:
5253    P->ConstantArraySizeAsWritten = Value;
5254    return;
5255  case CXPrintingPolicy_AnonymousTagLocations:
5256    P->AnonymousTagLocations = Value;
5257    return;
5258  case CXPrintingPolicy_SuppressStrongLifetime:
5259    P->SuppressStrongLifetime = Value;
5260    return;
5261  case CXPrintingPolicy_SuppressLifetimeQualifiers:
5262    P->SuppressLifetimeQualifiers = Value;
5263    return;
5264  case CXPrintingPolicy_SuppressTemplateArgsInCXXConstructors:
5265    P->SuppressTemplateArgsInCXXConstructors = Value;
5266    return;
5267  case CXPrintingPolicy_Bool:
5268    P->Bool = Value;
5269    return;
5270  case CXPrintingPolicy_Restrict:
5271    P->Restrict = Value;
5272    return;
5273  case CXPrintingPolicy_Alignof:
5274    P->Alignof = Value;
5275    return;
5276  case CXPrintingPolicy_UnderscoreAlignof:
5277    P->UnderscoreAlignof = Value;
5278    return;
5279  case CXPrintingPolicy_UseVoidForZeroParams:
5280    P->UseVoidForZeroParams = Value;
5281    return;
5282  case CXPrintingPolicy_TerseOutput:
5283    P->TerseOutput = Value;
5284    return;
5285  case CXPrintingPolicy_PolishForDeclaration:
5286    P->PolishForDeclaration = Value;
5287    return;
5288  case CXPrintingPolicy_Half:
5289    P->Half = Value;
5290    return;
5291  case CXPrintingPolicy_MSWChar:
5292    P->MSWChar = Value;
5293    return;
5294  case CXPrintingPolicy_IncludeNewlines:
5295    P->IncludeNewlines = Value;
5296    return;
5297  case CXPrintingPolicy_MSVCFormatting:
5298    P->MSVCFormatting = Value;
5299    return;
5300  case CXPrintingPolicy_ConstantsAsWritten:
5301    P->ConstantsAsWritten = Value;
5302    return;
5303  case CXPrintingPolicy_SuppressImplicitBase:
5304    P->SuppressImplicitBase = Value;
5305    return;
5306  case CXPrintingPolicy_FullyQualifiedName:
5307    P->FullyQualifiedName = Value;
5308    return;
5309  }
5310
5311  assert(false && "Invalid CXPrintingPolicyProperty");
5312}
5313
5314CXString clang_getCursorPrettyPrinted(CXCursor C, CXPrintingPolicy cxPolicy) {
5315  if (clang_Cursor_isNull(C))
5316    return cxstring::createEmpty();
5317
5318  if (clang_isDeclaration(C.kind)) {
5319    const Decl *D = getCursorDecl(C);
5320    if (!D)
5321      return cxstring::createEmpty();
5322
5323    SmallString<128> Str;
5324    llvm::raw_svector_ostream OS(Str);
5325    PrintingPolicy *UserPolicy = static_cast<PrintingPolicy *>(cxPolicy);
5326    D->print(OS, UserPolicy ? *UserPolicy
5327                            : getCursorContext(C).getPrintingPolicy());
5328
5329    return cxstring::createDup(OS.str());
5330  }
5331
5332  return cxstring::createEmpty();
5333}
5334
5335CXString clang_getCursorDisplayName(CXCursor C) {
5336  if (!clang_isDeclaration(C.kind))
5337    return clang_getCursorSpelling(C);
5338
5339  const Decl *D = getCursorDecl(C);
5340  if (!D)
5341    return cxstring::createEmpty();
5342
5343  PrintingPolicy Policy = getCursorContext(C).getPrintingPolicy();
5344  if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
5345    D = FunTmpl->getTemplatedDecl();
5346
5347  if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
5348    SmallString<64> Str;
5349    llvm::raw_svector_ostream OS(Str);
5350    OS << *Function;
5351    if (Function->getPrimaryTemplate())
5352      OS << "<>";
5353    OS << "(";
5354    for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) {
5355      if (I)
5356        OS << ", ";
5357      OS << Function->getParamDecl(I)->getType().getAsString(Policy);
5358    }
5359
5360    if (Function->isVariadic()) {
5361      if (Function->getNumParams())
5362        OS << ", ";
5363      OS << "...";
5364    }
5365    OS << ")";
5366    return cxstring::createDup(OS.str());
5367  }
5368
5369  if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) {
5370    SmallString<64> Str;
5371    llvm::raw_svector_ostream OS(Str);
5372    OS << *ClassTemplate;
5373    OS << "<";
5374    TemplateParameterList *Params = ClassTemplate->getTemplateParameters();
5375    for (unsigned I = 0, N = Params->size(); I != N; ++I) {
5376      if (I)
5377        OS << ", ";
5378
5379      NamedDecl *Param = Params->getParam(I);
5380      if (Param->getIdentifier()) {
5381        OS << Param->getIdentifier()->getName();
5382        continue;
5383      }
5384
5385      // There is no parameter name, which makes this tricky. Try to come up
5386      // with something useful that isn't too long.
5387      if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
5388        if (const auto *TC = TTP->getTypeConstraint()) {
5389          TC->getConceptNameInfo().printName(OS, Policy);
5390          if (TC->hasExplicitTemplateArgs())
5391            OS << "<...>";
5392        } else
5393          OS << (TTP->wasDeclaredWithTypename() ? "typename" : "class");
5394      else if (NonTypeTemplateParmDecl *NTTP =
5395                   dyn_cast<NonTypeTemplateParmDecl>(Param))
5396        OS << NTTP->getType().getAsString(Policy);
5397      else
5398        OS << "template<...> class";
5399    }
5400
5401    OS << ">";
5402    return cxstring::createDup(OS.str());
5403  }
5404
5405  if (const ClassTemplateSpecializationDecl *ClassSpec =
5406          dyn_cast<ClassTemplateSpecializationDecl>(D)) {
5407    // If the type was explicitly written, use that.
5408    if (TypeSourceInfo *TSInfo = ClassSpec->getTypeAsWritten())
5409      return cxstring::createDup(TSInfo->getType().getAsString(Policy));
5410
5411    SmallString<128> Str;
5412    llvm::raw_svector_ostream OS(Str);
5413    OS << *ClassSpec;
5414    printTemplateArgumentList(
5415        OS, ClassSpec->getTemplateArgs().asArray(), Policy,
5416        ClassSpec->getSpecializedTemplate()->getTemplateParameters());
5417    return cxstring::createDup(OS.str());
5418  }
5419
5420  return clang_getCursorSpelling(C);
5421}
5422
5423CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
5424  switch (Kind) {
5425  case CXCursor_FunctionDecl:
5426    return cxstring::createRef("FunctionDecl");
5427  case CXCursor_TypedefDecl:
5428    return cxstring::createRef("TypedefDecl");
5429  case CXCursor_EnumDecl:
5430    return cxstring::createRef("EnumDecl");
5431  case CXCursor_EnumConstantDecl:
5432    return cxstring::createRef("EnumConstantDecl");
5433  case CXCursor_StructDecl:
5434    return cxstring::createRef("StructDecl");
5435  case CXCursor_UnionDecl:
5436    return cxstring::createRef("UnionDecl");
5437  case CXCursor_ClassDecl:
5438    return cxstring::createRef("ClassDecl");
5439  case CXCursor_FieldDecl:
5440    return cxstring::createRef("FieldDecl");
5441  case CXCursor_VarDecl:
5442    return cxstring::createRef("VarDecl");
5443  case CXCursor_ParmDecl:
5444    return cxstring::createRef("ParmDecl");
5445  case CXCursor_ObjCInterfaceDecl:
5446    return cxstring::createRef("ObjCInterfaceDecl");
5447  case CXCursor_ObjCCategoryDecl:
5448    return cxstring::createRef("ObjCCategoryDecl");
5449  case CXCursor_ObjCProtocolDecl:
5450    return cxstring::createRef("ObjCProtocolDecl");
5451  case CXCursor_ObjCPropertyDecl:
5452    return cxstring::createRef("ObjCPropertyDecl");
5453  case CXCursor_ObjCIvarDecl:
5454    return cxstring::createRef("ObjCIvarDecl");
5455  case CXCursor_ObjCInstanceMethodDecl:
5456    return cxstring::createRef("ObjCInstanceMethodDecl");
5457  case CXCursor_ObjCClassMethodDecl:
5458    return cxstring::createRef("ObjCClassMethodDecl");
5459  case CXCursor_ObjCImplementationDecl:
5460    return cxstring::createRef("ObjCImplementationDecl");
5461  case CXCursor_ObjCCategoryImplDecl:
5462    return cxstring::createRef("ObjCCategoryImplDecl");
5463  case CXCursor_CXXMethod:
5464    return cxstring::createRef("CXXMethod");
5465  case CXCursor_UnexposedDecl:
5466    return cxstring::createRef("UnexposedDecl");
5467  case CXCursor_ObjCSuperClassRef:
5468    return cxstring::createRef("ObjCSuperClassRef");
5469  case CXCursor_ObjCProtocolRef:
5470    return cxstring::createRef("ObjCProtocolRef");
5471  case CXCursor_ObjCClassRef:
5472    return cxstring::createRef("ObjCClassRef");
5473  case CXCursor_TypeRef:
5474    return cxstring::createRef("TypeRef");
5475  case CXCursor_TemplateRef:
5476    return cxstring::createRef("TemplateRef");
5477  case CXCursor_NamespaceRef:
5478    return cxstring::createRef("NamespaceRef");
5479  case CXCursor_MemberRef:
5480    return cxstring::createRef("MemberRef");
5481  case CXCursor_LabelRef:
5482    return cxstring::createRef("LabelRef");
5483  case CXCursor_OverloadedDeclRef:
5484    return cxstring::createRef("OverloadedDeclRef");
5485  case CXCursor_VariableRef:
5486    return cxstring::createRef("VariableRef");
5487  case CXCursor_IntegerLiteral:
5488    return cxstring::createRef("IntegerLiteral");
5489  case CXCursor_FixedPointLiteral:
5490    return cxstring::createRef("FixedPointLiteral");
5491  case CXCursor_FloatingLiteral:
5492    return cxstring::createRef("FloatingLiteral");
5493  case CXCursor_ImaginaryLiteral:
5494    return cxstring::createRef("ImaginaryLiteral");
5495  case CXCursor_StringLiteral:
5496    return cxstring::createRef("StringLiteral");
5497  case CXCursor_CharacterLiteral:
5498    return cxstring::createRef("CharacterLiteral");
5499  case CXCursor_ParenExpr:
5500    return cxstring::createRef("ParenExpr");
5501  case CXCursor_UnaryOperator:
5502    return cxstring::createRef("UnaryOperator");
5503  case CXCursor_ArraySubscriptExpr:
5504    return cxstring::createRef("ArraySubscriptExpr");
5505  case CXCursor_OMPArraySectionExpr:
5506    return cxstring::createRef("OMPArraySectionExpr");
5507  case CXCursor_OMPArrayShapingExpr:
5508    return cxstring::createRef("OMPArrayShapingExpr");
5509  case CXCursor_OMPIteratorExpr:
5510    return cxstring::createRef("OMPIteratorExpr");
5511  case CXCursor_BinaryOperator:
5512    return cxstring::createRef("BinaryOperator");
5513  case CXCursor_CompoundAssignOperator:
5514    return cxstring::createRef("CompoundAssignOperator");
5515  case CXCursor_ConditionalOperator:
5516    return cxstring::createRef("ConditionalOperator");
5517  case CXCursor_CStyleCastExpr:
5518    return cxstring::createRef("CStyleCastExpr");
5519  case CXCursor_CompoundLiteralExpr:
5520    return cxstring::createRef("CompoundLiteralExpr");
5521  case CXCursor_InitListExpr:
5522    return cxstring::createRef("InitListExpr");
5523  case CXCursor_AddrLabelExpr:
5524    return cxstring::createRef("AddrLabelExpr");
5525  case CXCursor_StmtExpr:
5526    return cxstring::createRef("StmtExpr");
5527  case CXCursor_GenericSelectionExpr:
5528    return cxstring::createRef("GenericSelectionExpr");
5529  case CXCursor_GNUNullExpr:
5530    return cxstring::createRef("GNUNullExpr");
5531  case CXCursor_CXXStaticCastExpr:
5532    return cxstring::createRef("CXXStaticCastExpr");
5533  case CXCursor_CXXDynamicCastExpr:
5534    return cxstring::createRef("CXXDynamicCastExpr");
5535  case CXCursor_CXXReinterpretCastExpr:
5536    return cxstring::createRef("CXXReinterpretCastExpr");
5537  case CXCursor_CXXConstCastExpr:
5538    return cxstring::createRef("CXXConstCastExpr");
5539  case CXCursor_CXXFunctionalCastExpr:
5540    return cxstring::createRef("CXXFunctionalCastExpr");
5541  case CXCursor_CXXAddrspaceCastExpr:
5542    return cxstring::createRef("CXXAddrspaceCastExpr");
5543  case CXCursor_CXXTypeidExpr:
5544    return cxstring::createRef("CXXTypeidExpr");
5545  case CXCursor_CXXBoolLiteralExpr:
5546    return cxstring::createRef("CXXBoolLiteralExpr");
5547  case CXCursor_CXXNullPtrLiteralExpr:
5548    return cxstring::createRef("CXXNullPtrLiteralExpr");
5549  case CXCursor_CXXThisExpr:
5550    return cxstring::createRef("CXXThisExpr");
5551  case CXCursor_CXXThrowExpr:
5552    return cxstring::createRef("CXXThrowExpr");
5553  case CXCursor_CXXNewExpr:
5554    return cxstring::createRef("CXXNewExpr");
5555  case CXCursor_CXXDeleteExpr:
5556    return cxstring::createRef("CXXDeleteExpr");
5557  case CXCursor_UnaryExpr:
5558    return cxstring::createRef("UnaryExpr");
5559  case CXCursor_ObjCStringLiteral:
5560    return cxstring::createRef("ObjCStringLiteral");
5561  case CXCursor_ObjCBoolLiteralExpr:
5562    return cxstring::createRef("ObjCBoolLiteralExpr");
5563  case CXCursor_ObjCAvailabilityCheckExpr:
5564    return cxstring::createRef("ObjCAvailabilityCheckExpr");
5565  case CXCursor_ObjCSelfExpr:
5566    return cxstring::createRef("ObjCSelfExpr");
5567  case CXCursor_ObjCEncodeExpr:
5568    return cxstring::createRef("ObjCEncodeExpr");
5569  case CXCursor_ObjCSelectorExpr:
5570    return cxstring::createRef("ObjCSelectorExpr");
5571  case CXCursor_ObjCProtocolExpr:
5572    return cxstring::createRef("ObjCProtocolExpr");
5573  case CXCursor_ObjCBridgedCastExpr:
5574    return cxstring::createRef("ObjCBridgedCastExpr");
5575  case CXCursor_BlockExpr:
5576    return cxstring::createRef("BlockExpr");
5577  case CXCursor_PackExpansionExpr:
5578    return cxstring::createRef("PackExpansionExpr");
5579  case CXCursor_SizeOfPackExpr:
5580    return cxstring::createRef("SizeOfPackExpr");
5581  case CXCursor_LambdaExpr:
5582    return cxstring::createRef("LambdaExpr");
5583  case CXCursor_UnexposedExpr:
5584    return cxstring::createRef("UnexposedExpr");
5585  case CXCursor_DeclRefExpr:
5586    return cxstring::createRef("DeclRefExpr");
5587  case CXCursor_MemberRefExpr:
5588    return cxstring::createRef("MemberRefExpr");
5589  case CXCursor_CallExpr:
5590    return cxstring::createRef("CallExpr");
5591  case CXCursor_ObjCMessageExpr:
5592    return cxstring::createRef("ObjCMessageExpr");
5593  case CXCursor_BuiltinBitCastExpr:
5594    return cxstring::createRef("BuiltinBitCastExpr");
5595  case CXCursor_ConceptSpecializationExpr:
5596    return cxstring::createRef("ConceptSpecializationExpr");
5597  case CXCursor_RequiresExpr:
5598    return cxstring::createRef("RequiresExpr");
5599  case CXCursor_CXXParenListInitExpr:
5600    return cxstring::createRef("CXXParenListInitExpr");
5601  case CXCursor_UnexposedStmt:
5602    return cxstring::createRef("UnexposedStmt");
5603  case CXCursor_DeclStmt:
5604    return cxstring::createRef("DeclStmt");
5605  case CXCursor_LabelStmt:
5606    return cxstring::createRef("LabelStmt");
5607  case CXCursor_CompoundStmt:
5608    return cxstring::createRef("CompoundStmt");
5609  case CXCursor_CaseStmt:
5610    return cxstring::createRef("CaseStmt");
5611  case CXCursor_DefaultStmt:
5612    return cxstring::createRef("DefaultStmt");
5613  case CXCursor_IfStmt:
5614    return cxstring::createRef("IfStmt");
5615  case CXCursor_SwitchStmt:
5616    return cxstring::createRef("SwitchStmt");
5617  case CXCursor_WhileStmt:
5618    return cxstring::createRef("WhileStmt");
5619  case CXCursor_DoStmt:
5620    return cxstring::createRef("DoStmt");
5621  case CXCursor_ForStmt:
5622    return cxstring::createRef("ForStmt");
5623  case CXCursor_GotoStmt:
5624    return cxstring::createRef("GotoStmt");
5625  case CXCursor_IndirectGotoStmt:
5626    return cxstring::createRef("IndirectGotoStmt");
5627  case CXCursor_ContinueStmt:
5628    return cxstring::createRef("ContinueStmt");
5629  case CXCursor_BreakStmt:
5630    return cxstring::createRef("BreakStmt");
5631  case CXCursor_ReturnStmt:
5632    return cxstring::createRef("ReturnStmt");
5633  case CXCursor_GCCAsmStmt:
5634    return cxstring::createRef("GCCAsmStmt");
5635  case CXCursor_MSAsmStmt:
5636    return cxstring::createRef("MSAsmStmt");
5637  case CXCursor_ObjCAtTryStmt:
5638    return cxstring::createRef("ObjCAtTryStmt");
5639  case CXCursor_ObjCAtCatchStmt:
5640    return cxstring::createRef("ObjCAtCatchStmt");
5641  case CXCursor_ObjCAtFinallyStmt:
5642    return cxstring::createRef("ObjCAtFinallyStmt");
5643  case CXCursor_ObjCAtThrowStmt:
5644    return cxstring::createRef("ObjCAtThrowStmt");
5645  case CXCursor_ObjCAtSynchronizedStmt:
5646    return cxstring::createRef("ObjCAtSynchronizedStmt");
5647  case CXCursor_ObjCAutoreleasePoolStmt:
5648    return cxstring::createRef("ObjCAutoreleasePoolStmt");
5649  case CXCursor_ObjCForCollectionStmt:
5650    return cxstring::createRef("ObjCForCollectionStmt");
5651  case CXCursor_CXXCatchStmt:
5652    return cxstring::createRef("CXXCatchStmt");
5653  case CXCursor_CXXTryStmt:
5654    return cxstring::createRef("CXXTryStmt");
5655  case CXCursor_CXXForRangeStmt:
5656    return cxstring::createRef("CXXForRangeStmt");
5657  case CXCursor_SEHTryStmt:
5658    return cxstring::createRef("SEHTryStmt");
5659  case CXCursor_SEHExceptStmt:
5660    return cxstring::createRef("SEHExceptStmt");
5661  case CXCursor_SEHFinallyStmt:
5662    return cxstring::createRef("SEHFinallyStmt");
5663  case CXCursor_SEHLeaveStmt:
5664    return cxstring::createRef("SEHLeaveStmt");
5665  case CXCursor_NullStmt:
5666    return cxstring::createRef("NullStmt");
5667  case CXCursor_InvalidFile:
5668    return cxstring::createRef("InvalidFile");
5669  case CXCursor_InvalidCode:
5670    return cxstring::createRef("InvalidCode");
5671  case CXCursor_NoDeclFound:
5672    return cxstring::createRef("NoDeclFound");
5673  case CXCursor_NotImplemented:
5674    return cxstring::createRef("NotImplemented");
5675  case CXCursor_TranslationUnit:
5676    return cxstring::createRef("TranslationUnit");
5677  case CXCursor_UnexposedAttr:
5678    return cxstring::createRef("UnexposedAttr");
5679  case CXCursor_IBActionAttr:
5680    return cxstring::createRef("attribute(ibaction)");
5681  case CXCursor_IBOutletAttr:
5682    return cxstring::createRef("attribute(iboutlet)");
5683  case CXCursor_IBOutletCollectionAttr:
5684    return cxstring::createRef("attribute(iboutletcollection)");
5685  case CXCursor_CXXFinalAttr:
5686    return cxstring::createRef("attribute(final)");
5687  case CXCursor_CXXOverrideAttr:
5688    return cxstring::createRef("attribute(override)");
5689  case CXCursor_AnnotateAttr:
5690    return cxstring::createRef("attribute(annotate)");
5691  case CXCursor_AsmLabelAttr:
5692    return cxstring::createRef("asm label");
5693  case CXCursor_PackedAttr:
5694    return cxstring::createRef("attribute(packed)");
5695  case CXCursor_PureAttr:
5696    return cxstring::createRef("attribute(pure)");
5697  case CXCursor_ConstAttr:
5698    return cxstring::createRef("attribute(const)");
5699  case CXCursor_NoDuplicateAttr:
5700    return cxstring::createRef("attribute(noduplicate)");
5701  case CXCursor_CUDAConstantAttr:
5702    return cxstring::createRef("attribute(constant)");
5703  case CXCursor_CUDADeviceAttr:
5704    return cxstring::createRef("attribute(device)");
5705  case CXCursor_CUDAGlobalAttr:
5706    return cxstring::createRef("attribute(global)");
5707  case CXCursor_CUDAHostAttr:
5708    return cxstring::createRef("attribute(host)");
5709  case CXCursor_CUDASharedAttr:
5710    return cxstring::createRef("attribute(shared)");
5711  case CXCursor_VisibilityAttr:
5712    return cxstring::createRef("attribute(visibility)");
5713  case CXCursor_DLLExport:
5714    return cxstring::createRef("attribute(dllexport)");
5715  case CXCursor_DLLImport:
5716    return cxstring::createRef("attribute(dllimport)");
5717  case CXCursor_NSReturnsRetained:
5718    return cxstring::createRef("attribute(ns_returns_retained)");
5719  case CXCursor_NSReturnsNotRetained:
5720    return cxstring::createRef("attribute(ns_returns_not_retained)");
5721  case CXCursor_NSReturnsAutoreleased:
5722    return cxstring::createRef("attribute(ns_returns_autoreleased)");
5723  case CXCursor_NSConsumesSelf:
5724    return cxstring::createRef("attribute(ns_consumes_self)");
5725  case CXCursor_NSConsumed:
5726    return cxstring::createRef("attribute(ns_consumed)");
5727  case CXCursor_ObjCException:
5728    return cxstring::createRef("attribute(objc_exception)");
5729  case CXCursor_ObjCNSObject:
5730    return cxstring::createRef("attribute(NSObject)");
5731  case CXCursor_ObjCIndependentClass:
5732    return cxstring::createRef("attribute(objc_independent_class)");
5733  case CXCursor_ObjCPreciseLifetime:
5734    return cxstring::createRef("attribute(objc_precise_lifetime)");
5735  case CXCursor_ObjCReturnsInnerPointer:
5736    return cxstring::createRef("attribute(objc_returns_inner_pointer)");
5737  case CXCursor_ObjCRequiresSuper:
5738    return cxstring::createRef("attribute(objc_requires_super)");
5739  case CXCursor_ObjCRootClass:
5740    return cxstring::createRef("attribute(objc_root_class)");
5741  case CXCursor_ObjCSubclassingRestricted:
5742    return cxstring::createRef("attribute(objc_subclassing_restricted)");
5743  case CXCursor_ObjCExplicitProtocolImpl:
5744    return cxstring::createRef(
5745        "attribute(objc_protocol_requires_explicit_implementation)");
5746  case CXCursor_ObjCDesignatedInitializer:
5747    return cxstring::createRef("attribute(objc_designated_initializer)");
5748  case CXCursor_ObjCRuntimeVisible:
5749    return cxstring::createRef("attribute(objc_runtime_visible)");
5750  case CXCursor_ObjCBoxable:
5751    return cxstring::createRef("attribute(objc_boxable)");
5752  case CXCursor_FlagEnum:
5753    return cxstring::createRef("attribute(flag_enum)");
5754  case CXCursor_PreprocessingDirective:
5755    return cxstring::createRef("preprocessing directive");
5756  case CXCursor_MacroDefinition:
5757    return cxstring::createRef("macro definition");
5758  case CXCursor_MacroExpansion:
5759    return cxstring::createRef("macro expansion");
5760  case CXCursor_InclusionDirective:
5761    return cxstring::createRef("inclusion directive");
5762  case CXCursor_Namespace:
5763    return cxstring::createRef("Namespace");
5764  case CXCursor_LinkageSpec:
5765    return cxstring::createRef("LinkageSpec");
5766  case CXCursor_CXXBaseSpecifier:
5767    return cxstring::createRef("C++ base class specifier");
5768  case CXCursor_Constructor:
5769    return cxstring::createRef("CXXConstructor");
5770  case CXCursor_Destructor:
5771    return cxstring::createRef("CXXDestructor");
5772  case CXCursor_ConversionFunction:
5773    return cxstring::createRef("CXXConversion");
5774  case CXCursor_TemplateTypeParameter:
5775    return cxstring::createRef("TemplateTypeParameter");
5776  case CXCursor_NonTypeTemplateParameter:
5777    return cxstring::createRef("NonTypeTemplateParameter");
5778  case CXCursor_TemplateTemplateParameter:
5779    return cxstring::createRef("TemplateTemplateParameter");
5780  case CXCursor_FunctionTemplate:
5781    return cxstring::createRef("FunctionTemplate");
5782  case CXCursor_ClassTemplate:
5783    return cxstring::createRef("ClassTemplate");
5784  case CXCursor_ClassTemplatePartialSpecialization:
5785    return cxstring::createRef("ClassTemplatePartialSpecialization");
5786  case CXCursor_NamespaceAlias:
5787    return cxstring::createRef("NamespaceAlias");
5788  case CXCursor_UsingDirective:
5789    return cxstring::createRef("UsingDirective");
5790  case CXCursor_UsingDeclaration:
5791    return cxstring::createRef("UsingDeclaration");
5792  case CXCursor_TypeAliasDecl:
5793    return cxstring::createRef("TypeAliasDecl");
5794  case CXCursor_ObjCSynthesizeDecl:
5795    return cxstring::createRef("ObjCSynthesizeDecl");
5796  case CXCursor_ObjCDynamicDecl:
5797    return cxstring::createRef("ObjCDynamicDecl");
5798  case CXCursor_CXXAccessSpecifier:
5799    return cxstring::createRef("CXXAccessSpecifier");
5800  case CXCursor_ModuleImportDecl:
5801    return cxstring::createRef("ModuleImport");
5802  case CXCursor_OMPCanonicalLoop:
5803    return cxstring::createRef("OMPCanonicalLoop");
5804  case CXCursor_OMPMetaDirective:
5805    return cxstring::createRef("OMPMetaDirective");
5806  case CXCursor_OMPParallelDirective:
5807    return cxstring::createRef("OMPParallelDirective");
5808  case CXCursor_OMPSimdDirective:
5809    return cxstring::createRef("OMPSimdDirective");
5810  case CXCursor_OMPTileDirective:
5811    return cxstring::createRef("OMPTileDirective");
5812  case CXCursor_OMPUnrollDirective:
5813    return cxstring::createRef("OMPUnrollDirective");
5814  case CXCursor_OMPForDirective:
5815    return cxstring::createRef("OMPForDirective");
5816  case CXCursor_OMPForSimdDirective:
5817    return cxstring::createRef("OMPForSimdDirective");
5818  case CXCursor_OMPSectionsDirective:
5819    return cxstring::createRef("OMPSectionsDirective");
5820  case CXCursor_OMPSectionDirective:
5821    return cxstring::createRef("OMPSectionDirective");
5822  case CXCursor_OMPSingleDirective:
5823    return cxstring::createRef("OMPSingleDirective");
5824  case CXCursor_OMPMasterDirective:
5825    return cxstring::createRef("OMPMasterDirective");
5826  case CXCursor_OMPCriticalDirective:
5827    return cxstring::createRef("OMPCriticalDirective");
5828  case CXCursor_OMPParallelForDirective:
5829    return cxstring::createRef("OMPParallelForDirective");
5830  case CXCursor_OMPParallelForSimdDirective:
5831    return cxstring::createRef("OMPParallelForSimdDirective");
5832  case CXCursor_OMPParallelMasterDirective:
5833    return cxstring::createRef("OMPParallelMasterDirective");
5834  case CXCursor_OMPParallelMaskedDirective:
5835    return cxstring::createRef("OMPParallelMaskedDirective");
5836  case CXCursor_OMPParallelSectionsDirective:
5837    return cxstring::createRef("OMPParallelSectionsDirective");
5838  case CXCursor_OMPTaskDirective:
5839    return cxstring::createRef("OMPTaskDirective");
5840  case CXCursor_OMPTaskyieldDirective:
5841    return cxstring::createRef("OMPTaskyieldDirective");
5842  case CXCursor_OMPBarrierDirective:
5843    return cxstring::createRef("OMPBarrierDirective");
5844  case CXCursor_OMPTaskwaitDirective:
5845    return cxstring::createRef("OMPTaskwaitDirective");
5846  case CXCursor_OMPErrorDirective:
5847    return cxstring::createRef("OMPErrorDirective");
5848  case CXCursor_OMPTaskgroupDirective:
5849    return cxstring::createRef("OMPTaskgroupDirective");
5850  case CXCursor_OMPFlushDirective:
5851    return cxstring::createRef("OMPFlushDirective");
5852  case CXCursor_OMPDepobjDirective:
5853    return cxstring::createRef("OMPDepobjDirective");
5854  case CXCursor_OMPScanDirective:
5855    return cxstring::createRef("OMPScanDirective");
5856  case CXCursor_OMPOrderedDirective:
5857    return cxstring::createRef("OMPOrderedDirective");
5858  case CXCursor_OMPAtomicDirective:
5859    return cxstring::createRef("OMPAtomicDirective");
5860  case CXCursor_OMPTargetDirective:
5861    return cxstring::createRef("OMPTargetDirective");
5862  case CXCursor_OMPTargetDataDirective:
5863    return cxstring::createRef("OMPTargetDataDirective");
5864  case CXCursor_OMPTargetEnterDataDirective:
5865    return cxstring::createRef("OMPTargetEnterDataDirective");
5866  case CXCursor_OMPTargetExitDataDirective:
5867    return cxstring::createRef("OMPTargetExitDataDirective");
5868  case CXCursor_OMPTargetParallelDirective:
5869    return cxstring::createRef("OMPTargetParallelDirective");
5870  case CXCursor_OMPTargetParallelForDirective:
5871    return cxstring::createRef("OMPTargetParallelForDirective");
5872  case CXCursor_OMPTargetUpdateDirective:
5873    return cxstring::createRef("OMPTargetUpdateDirective");
5874  case CXCursor_OMPTeamsDirective:
5875    return cxstring::createRef("OMPTeamsDirective");
5876  case CXCursor_OMPCancellationPointDirective:
5877    return cxstring::createRef("OMPCancellationPointDirective");
5878  case CXCursor_OMPCancelDirective:
5879    return cxstring::createRef("OMPCancelDirective");
5880  case CXCursor_OMPTaskLoopDirective:
5881    return cxstring::createRef("OMPTaskLoopDirective");
5882  case CXCursor_OMPTaskLoopSimdDirective:
5883    return cxstring::createRef("OMPTaskLoopSimdDirective");
5884  case CXCursor_OMPMasterTaskLoopDirective:
5885    return cxstring::createRef("OMPMasterTaskLoopDirective");
5886  case CXCursor_OMPMaskedTaskLoopDirective:
5887    return cxstring::createRef("OMPMaskedTaskLoopDirective");
5888  case CXCursor_OMPMasterTaskLoopSimdDirective:
5889    return cxstring::createRef("OMPMasterTaskLoopSimdDirective");
5890  case CXCursor_OMPMaskedTaskLoopSimdDirective:
5891    return cxstring::createRef("OMPMaskedTaskLoopSimdDirective");
5892  case CXCursor_OMPParallelMasterTaskLoopDirective:
5893    return cxstring::createRef("OMPParallelMasterTaskLoopDirective");
5894  case CXCursor_OMPParallelMaskedTaskLoopDirective:
5895    return cxstring::createRef("OMPParallelMaskedTaskLoopDirective");
5896  case CXCursor_OMPParallelMasterTaskLoopSimdDirective:
5897    return cxstring::createRef("OMPParallelMasterTaskLoopSimdDirective");
5898  case CXCursor_OMPParallelMaskedTaskLoopSimdDirective:
5899    return cxstring::createRef("OMPParallelMaskedTaskLoopSimdDirective");
5900  case CXCursor_OMPDistributeDirective:
5901    return cxstring::createRef("OMPDistributeDirective");
5902  case CXCursor_OMPDistributeParallelForDirective:
5903    return cxstring::createRef("OMPDistributeParallelForDirective");
5904  case CXCursor_OMPDistributeParallelForSimdDirective:
5905    return cxstring::createRef("OMPDistributeParallelForSimdDirective");
5906  case CXCursor_OMPDistributeSimdDirective:
5907    return cxstring::createRef("OMPDistributeSimdDirective");
5908  case CXCursor_OMPTargetParallelForSimdDirective:
5909    return cxstring::createRef("OMPTargetParallelForSimdDirective");
5910  case CXCursor_OMPTargetSimdDirective:
5911    return cxstring::createRef("OMPTargetSimdDirective");
5912  case CXCursor_OMPTeamsDistributeDirective:
5913    return cxstring::createRef("OMPTeamsDistributeDirective");
5914  case CXCursor_OMPTeamsDistributeSimdDirective:
5915    return cxstring::createRef("OMPTeamsDistributeSimdDirective");
5916  case CXCursor_OMPTeamsDistributeParallelForSimdDirective:
5917    return cxstring::createRef("OMPTeamsDistributeParallelForSimdDirective");
5918  case CXCursor_OMPTeamsDistributeParallelForDirective:
5919    return cxstring::createRef("OMPTeamsDistributeParallelForDirective");
5920  case CXCursor_OMPTargetTeamsDirective:
5921    return cxstring::createRef("OMPTargetTeamsDirective");
5922  case CXCursor_OMPTargetTeamsDistributeDirective:
5923    return cxstring::createRef("OMPTargetTeamsDistributeDirective");
5924  case CXCursor_OMPTargetTeamsDistributeParallelForDirective:
5925    return cxstring::createRef("OMPTargetTeamsDistributeParallelForDirective");
5926  case CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective:
5927    return cxstring::createRef(
5928        "OMPTargetTeamsDistributeParallelForSimdDirective");
5929  case CXCursor_OMPTargetTeamsDistributeSimdDirective:
5930    return cxstring::createRef("OMPTargetTeamsDistributeSimdDirective");
5931  case CXCursor_OMPInteropDirective:
5932    return cxstring::createRef("OMPInteropDirective");
5933  case CXCursor_OMPDispatchDirective:
5934    return cxstring::createRef("OMPDispatchDirective");
5935  case CXCursor_OMPMaskedDirective:
5936    return cxstring::createRef("OMPMaskedDirective");
5937  case CXCursor_OMPGenericLoopDirective:
5938    return cxstring::createRef("OMPGenericLoopDirective");
5939  case CXCursor_OMPTeamsGenericLoopDirective:
5940    return cxstring::createRef("OMPTeamsGenericLoopDirective");
5941  case CXCursor_OMPTargetTeamsGenericLoopDirective:
5942    return cxstring::createRef("OMPTargetTeamsGenericLoopDirective");
5943  case CXCursor_OMPParallelGenericLoopDirective:
5944    return cxstring::createRef("OMPParallelGenericLoopDirective");
5945  case CXCursor_OMPTargetParallelGenericLoopDirective:
5946    return cxstring::createRef("OMPTargetParallelGenericLoopDirective");
5947  case CXCursor_OverloadCandidate:
5948    return cxstring::createRef("OverloadCandidate");
5949  case CXCursor_TypeAliasTemplateDecl:
5950    return cxstring::createRef("TypeAliasTemplateDecl");
5951  case CXCursor_StaticAssert:
5952    return cxstring::createRef("StaticAssert");
5953  case CXCursor_FriendDecl:
5954    return cxstring::createRef("FriendDecl");
5955  case CXCursor_ConvergentAttr:
5956    return cxstring::createRef("attribute(convergent)");
5957  case CXCursor_WarnUnusedAttr:
5958    return cxstring::createRef("attribute(warn_unused)");
5959  case CXCursor_WarnUnusedResultAttr:
5960    return cxstring::createRef("attribute(warn_unused_result)");
5961  case CXCursor_AlignedAttr:
5962    return cxstring::createRef("attribute(aligned)");
5963  case CXCursor_ConceptDecl:
5964    return cxstring::createRef("ConceptDecl");
5965  }
5966
5967  llvm_unreachable("Unhandled CXCursorKind");
5968}
5969
5970struct GetCursorData {
5971  SourceLocation TokenBeginLoc;
5972  bool PointsAtMacroArgExpansion;
5973  bool VisitedObjCPropertyImplDecl;
5974  SourceLocation VisitedDeclaratorDeclStartLoc;
5975  CXCursor &BestCursor;
5976
5977  GetCursorData(SourceManager &SM, SourceLocation tokenBegin,
5978                CXCursor &outputCursor)
5979      : TokenBeginLoc(tokenBegin), BestCursor(outputCursor) {
5980    PointsAtMacroArgExpansion = SM.isMacroArgExpansion(tokenBegin);
5981    VisitedObjCPropertyImplDecl = false;
5982  }
5983};
5984
5985static enum CXChildVisitResult
5986GetCursorVisitor(CXCursor cursor, CXCursor parent, CXClientData client_data) {
5987  GetCursorData *Data = static_cast<GetCursorData *>(client_data);
5988  CXCursor *BestCursor = &Data->BestCursor;
5989
5990  // If we point inside a macro argument we should provide info of what the
5991  // token is so use the actual cursor, don't replace it with a macro expansion
5992  // cursor.
5993  if (cursor.kind == CXCursor_MacroExpansion && Data->PointsAtMacroArgExpansion)
5994    return CXChildVisit_Recurse;
5995
5996  if (clang_isDeclaration(cursor.kind)) {
5997    // Avoid having the implicit methods override the property decls.
5998    if (const ObjCMethodDecl *MD =
5999            dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) {
6000      if (MD->isImplicit())
6001        return CXChildVisit_Break;
6002
6003    } else if (const ObjCInterfaceDecl *ID =
6004                   dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(cursor))) {
6005      // Check that when we have multiple @class references in the same line,
6006      // that later ones do not override the previous ones.
6007      // If we have:
6008      // @class Foo, Bar;
6009      // source ranges for both start at '@', so 'Bar' will end up overriding
6010      // 'Foo' even though the cursor location was at 'Foo'.
6011      if (BestCursor->kind == CXCursor_ObjCInterfaceDecl ||
6012          BestCursor->kind == CXCursor_ObjCClassRef)
6013        if (const ObjCInterfaceDecl *PrevID =
6014                dyn_cast_or_null<ObjCInterfaceDecl>(
6015                    getCursorDecl(*BestCursor))) {
6016          if (PrevID != ID && !PrevID->isThisDeclarationADefinition() &&
6017              !ID->isThisDeclarationADefinition())
6018            return CXChildVisit_Break;
6019        }
6020
6021    } else if (const DeclaratorDecl *DD =
6022                   dyn_cast_or_null<DeclaratorDecl>(getCursorDecl(cursor))) {
6023      SourceLocation StartLoc = DD->getSourceRange().getBegin();
6024      // Check that when we have multiple declarators in the same line,
6025      // that later ones do not override the previous ones.
6026      // If we have:
6027      // int Foo, Bar;
6028      // source ranges for both start at 'int', so 'Bar' will end up overriding
6029      // 'Foo' even though the cursor location was at 'Foo'.
6030      if (Data->VisitedDeclaratorDeclStartLoc == StartLoc)
6031        return CXChildVisit_Break;
6032      Data->VisitedDeclaratorDeclStartLoc = StartLoc;
6033
6034    } else if (const ObjCPropertyImplDecl *PropImp =
6035                   dyn_cast_or_null<ObjCPropertyImplDecl>(
6036                       getCursorDecl(cursor))) {
6037      (void)PropImp;
6038      // Check that when we have multiple @synthesize in the same line,
6039      // that later ones do not override the previous ones.
6040      // If we have:
6041      // @synthesize Foo, Bar;
6042      // source ranges for both start at '@', so 'Bar' will end up overriding
6043      // 'Foo' even though the cursor location was at 'Foo'.
6044      if (Data->VisitedObjCPropertyImplDecl)
6045        return CXChildVisit_Break;
6046      Data->VisitedObjCPropertyImplDecl = true;
6047    }
6048  }
6049
6050  if (clang_isExpression(cursor.kind) &&
6051      clang_isDeclaration(BestCursor->kind)) {
6052    if (const Decl *D = getCursorDecl(*BestCursor)) {
6053      // Avoid having the cursor of an expression replace the declaration cursor
6054      // when the expression source range overlaps the declaration range.
6055      // This can happen for C++ constructor expressions whose range generally
6056      // include the variable declaration, e.g.:
6057      //  MyCXXClass foo; // Make sure pointing at 'foo' returns a VarDecl
6058      //  cursor.
6059      if (D->getLocation().isValid() && Data->TokenBeginLoc.isValid() &&
6060          D->getLocation() == Data->TokenBeginLoc)
6061        return CXChildVisit_Break;
6062    }
6063  }
6064
6065  // If our current best cursor is the construction of a temporary object,
6066  // don't replace that cursor with a type reference, because we want
6067  // clang_getCursor() to point at the constructor.
6068  if (clang_isExpression(BestCursor->kind) &&
6069      isa<CXXTemporaryObjectExpr>(getCursorExpr(*BestCursor)) &&
6070      cursor.kind == CXCursor_TypeRef) {
6071    // Keep the cursor pointing at CXXTemporaryObjectExpr but also mark it
6072    // as having the actual point on the type reference.
6073    *BestCursor = getTypeRefedCallExprCursor(*BestCursor);
6074    return CXChildVisit_Recurse;
6075  }
6076
6077  // If we already have an Objective-C superclass reference, don't
6078  // update it further.
6079  if (BestCursor->kind == CXCursor_ObjCSuperClassRef)
6080    return CXChildVisit_Break;
6081
6082  *BestCursor = cursor;
6083  return CXChildVisit_Recurse;
6084}
6085
6086CXCursor clang_getCursor(CXTranslationUnit TU, CXSourceLocation Loc) {
6087  if (isNotUsableTU(TU)) {
6088    LOG_BAD_TU(TU);
6089    return clang_getNullCursor();
6090  }
6091
6092  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
6093  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
6094
6095  SourceLocation SLoc = cxloc::translateSourceLocation(Loc);
6096  CXCursor Result = cxcursor::getCursor(TU, SLoc);
6097
6098  LOG_FUNC_SECTION {
6099    CXFile SearchFile;
6100    unsigned SearchLine, SearchColumn;
6101    CXFile ResultFile;
6102    unsigned ResultLine, ResultColumn;
6103    CXString SearchFileName, ResultFileName, KindSpelling, USR;
6104    const char *IsDef = clang_isCursorDefinition(Result) ? " (Definition)" : "";
6105    CXSourceLocation ResultLoc = clang_getCursorLocation(Result);
6106
6107    clang_getFileLocation(Loc, &SearchFile, &SearchLine, &SearchColumn,
6108                          nullptr);
6109    clang_getFileLocation(ResultLoc, &ResultFile, &ResultLine, &ResultColumn,
6110                          nullptr);
6111    SearchFileName = clang_getFileName(SearchFile);
6112    ResultFileName = clang_getFileName(ResultFile);
6113    KindSpelling = clang_getCursorKindSpelling(Result.kind);
6114    USR = clang_getCursorUSR(Result);
6115    *Log << llvm::format("(%s:%d:%d) = %s", clang_getCString(SearchFileName),
6116                         SearchLine, SearchColumn,
6117                         clang_getCString(KindSpelling))
6118         << llvm::format("(%s:%d:%d):%s%s", clang_getCString(ResultFileName),
6119                         ResultLine, ResultColumn, clang_getCString(USR),
6120                         IsDef);
6121    clang_disposeString(SearchFileName);
6122    clang_disposeString(ResultFileName);
6123    clang_disposeString(KindSpelling);
6124    clang_disposeString(USR);
6125
6126    CXCursor Definition = clang_getCursorDefinition(Result);
6127    if (!clang_equalCursors(Definition, clang_getNullCursor())) {
6128      CXSourceLocation DefinitionLoc = clang_getCursorLocation(Definition);
6129      CXString DefinitionKindSpelling =
6130          clang_getCursorKindSpelling(Definition.kind);
6131      CXFile DefinitionFile;
6132      unsigned DefinitionLine, DefinitionColumn;
6133      clang_getFileLocation(DefinitionLoc, &DefinitionFile, &DefinitionLine,
6134                            &DefinitionColumn, nullptr);
6135      CXString DefinitionFileName = clang_getFileName(DefinitionFile);
6136      *Log << llvm::format("  -> %s(%s:%d:%d)",
6137                           clang_getCString(DefinitionKindSpelling),
6138                           clang_getCString(DefinitionFileName), DefinitionLine,
6139                           DefinitionColumn);
6140      clang_disposeString(DefinitionFileName);
6141      clang_disposeString(DefinitionKindSpelling);
6142    }
6143  }
6144
6145  return Result;
6146}
6147
6148CXCursor clang_getNullCursor(void) {
6149  return MakeCXCursorInvalid(CXCursor_InvalidFile);
6150}
6151
6152unsigned clang_equalCursors(CXCursor X, CXCursor Y) {
6153  // Clear out the "FirstInDeclGroup" part in a declaration cursor, since we
6154  // can't set consistently. For example, when visiting a DeclStmt we will set
6155  // it but we don't set it on the result of clang_getCursorDefinition for
6156  // a reference of the same declaration.
6157  // FIXME: Setting "FirstInDeclGroup" in CXCursors is a hack that only works
6158  // when visiting a DeclStmt currently, the AST should be enhanced to be able
6159  // to provide that kind of info.
6160  if (clang_isDeclaration(X.kind))
6161    X.data[1] = nullptr;
6162  if (clang_isDeclaration(Y.kind))
6163    Y.data[1] = nullptr;
6164
6165  return X == Y;
6166}
6167
6168unsigned clang_hashCursor(CXCursor C) {
6169  unsigned Index = 0;
6170  if (clang_isExpression(C.kind) || clang_isStatement(C.kind))
6171    Index = 1;
6172
6173  return llvm::DenseMapInfo<std::pair<unsigned, const void *>>::getHashValue(
6174      std::make_pair(C.kind, C.data[Index]));
6175}
6176
6177unsigned clang_isInvalid(enum CXCursorKind K) {
6178  return K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid;
6179}
6180
6181unsigned clang_isDeclaration(enum CXCursorKind K) {
6182  return (K >= CXCursor_FirstDecl && K <= CXCursor_LastDecl) ||
6183         (K >= CXCursor_FirstExtraDecl && K <= CXCursor_LastExtraDecl);
6184}
6185
6186unsigned clang_isInvalidDeclaration(CXCursor C) {
6187  if (clang_isDeclaration(C.kind)) {
6188    if (const Decl *D = getCursorDecl(C))
6189      return D->isInvalidDecl();
6190  }
6191
6192  return 0;
6193}
6194
6195unsigned clang_isReference(enum CXCursorKind K) {
6196  return K >= CXCursor_FirstRef && K <= CXCursor_LastRef;
6197}
6198
6199unsigned clang_isExpression(enum CXCursorKind K) {
6200  return K >= CXCursor_FirstExpr && K <= CXCursor_LastExpr;
6201}
6202
6203unsigned clang_isStatement(enum CXCursorKind K) {
6204  return K >= CXCursor_FirstStmt && K <= CXCursor_LastStmt;
6205}
6206
6207unsigned clang_isAttribute(enum CXCursorKind K) {
6208  return K >= CXCursor_FirstAttr && K <= CXCursor_LastAttr;
6209}
6210
6211unsigned clang_isTranslationUnit(enum CXCursorKind K) {
6212  return K == CXCursor_TranslationUnit;
6213}
6214
6215unsigned clang_isPreprocessing(enum CXCursorKind K) {
6216  return K >= CXCursor_FirstPreprocessing && K <= CXCursor_LastPreprocessing;
6217}
6218
6219unsigned clang_isUnexposed(enum CXCursorKind K) {
6220  switch (K) {
6221  case CXCursor_UnexposedDecl:
6222  case CXCursor_UnexposedExpr:
6223  case CXCursor_UnexposedStmt:
6224  case CXCursor_UnexposedAttr:
6225    return true;
6226  default:
6227    return false;
6228  }
6229}
6230
6231CXCursorKind clang_getCursorKind(CXCursor C) { return C.kind; }
6232
6233CXSourceLocation clang_getCursorLocation(CXCursor C) {
6234  if (clang_isReference(C.kind)) {
6235    switch (C.kind) {
6236    case CXCursor_ObjCSuperClassRef: {
6237      std::pair<const ObjCInterfaceDecl *, SourceLocation> P =
6238          getCursorObjCSuperClassRef(C);
6239      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
6240    }
6241
6242    case CXCursor_ObjCProtocolRef: {
6243      std::pair<const ObjCProtocolDecl *, SourceLocation> P =
6244          getCursorObjCProtocolRef(C);
6245      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
6246    }
6247
6248    case CXCursor_ObjCClassRef: {
6249      std::pair<const ObjCInterfaceDecl *, SourceLocation> P =
6250          getCursorObjCClassRef(C);
6251      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
6252    }
6253
6254    case CXCursor_TypeRef: {
6255      std::pair<const TypeDecl *, SourceLocation> P = getCursorTypeRef(C);
6256      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
6257    }
6258
6259    case CXCursor_TemplateRef: {
6260      std::pair<const TemplateDecl *, SourceLocation> P =
6261          getCursorTemplateRef(C);
6262      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
6263    }
6264
6265    case CXCursor_NamespaceRef: {
6266      std::pair<const NamedDecl *, SourceLocation> P = getCursorNamespaceRef(C);
6267      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
6268    }
6269
6270    case CXCursor_MemberRef: {
6271      std::pair<const FieldDecl *, SourceLocation> P = getCursorMemberRef(C);
6272      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
6273    }
6274
6275    case CXCursor_VariableRef: {
6276      std::pair<const VarDecl *, SourceLocation> P = getCursorVariableRef(C);
6277      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
6278    }
6279
6280    case CXCursor_CXXBaseSpecifier: {
6281      const CXXBaseSpecifier *BaseSpec = getCursorCXXBaseSpecifier(C);
6282      if (!BaseSpec)
6283        return clang_getNullLocation();
6284
6285      if (TypeSourceInfo *TSInfo = BaseSpec->getTypeSourceInfo())
6286        return cxloc::translateSourceLocation(
6287            getCursorContext(C), TSInfo->getTypeLoc().getBeginLoc());
6288
6289      return cxloc::translateSourceLocation(getCursorContext(C),
6290                                            BaseSpec->getBeginLoc());
6291    }
6292
6293    case CXCursor_LabelRef: {
6294      std::pair<const LabelStmt *, SourceLocation> P = getCursorLabelRef(C);
6295      return cxloc::translateSourceLocation(getCursorContext(C), P.second);
6296    }
6297
6298    case CXCursor_OverloadedDeclRef:
6299      return cxloc::translateSourceLocation(
6300          getCursorContext(C), getCursorOverloadedDeclRef(C).second);
6301
6302    default:
6303      // FIXME: Need a way to enumerate all non-reference cases.
6304      llvm_unreachable("Missed a reference kind");
6305    }
6306  }
6307
6308  if (clang_isExpression(C.kind))
6309    return cxloc::translateSourceLocation(
6310        getCursorContext(C), getLocationFromExpr(getCursorExpr(C)));
6311
6312  if (clang_isStatement(C.kind))
6313    return cxloc::translateSourceLocation(getCursorContext(C),
6314                                          getCursorStmt(C)->getBeginLoc());
6315
6316  if (C.kind == CXCursor_PreprocessingDirective) {
6317    SourceLocation L = cxcursor::getCursorPreprocessingDirective(C).getBegin();
6318    return cxloc::translateSourceLocation(getCursorContext(C), L);
6319  }
6320
6321  if (C.kind == CXCursor_MacroExpansion) {
6322    SourceLocation L =
6323        cxcursor::getCursorMacroExpansion(C).getSourceRange().getBegin();
6324    return cxloc::translateSourceLocation(getCursorContext(C), L);
6325  }
6326
6327  if (C.kind == CXCursor_MacroDefinition) {
6328    SourceLocation L = cxcursor::getCursorMacroDefinition(C)->getLocation();
6329    return cxloc::translateSourceLocation(getCursorContext(C), L);
6330  }
6331
6332  if (C.kind == CXCursor_InclusionDirective) {
6333    SourceLocation L =
6334        cxcursor::getCursorInclusionDirective(C)->getSourceRange().getBegin();
6335    return cxloc::translateSourceLocation(getCursorContext(C), L);
6336  }
6337
6338  if (clang_isAttribute(C.kind)) {
6339    SourceLocation L = cxcursor::getCursorAttr(C)->getLocation();
6340    return cxloc::translateSourceLocation(getCursorContext(C), L);
6341  }
6342
6343  if (!clang_isDeclaration(C.kind))
6344    return clang_getNullLocation();
6345
6346  const Decl *D = getCursorDecl(C);
6347  if (!D)
6348    return clang_getNullLocation();
6349
6350  SourceLocation Loc = D->getLocation();
6351  // FIXME: Multiple variables declared in a single declaration
6352  // currently lack the information needed to correctly determine their
6353  // ranges when accounting for the type-specifier.  We use context
6354  // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
6355  // and if so, whether it is the first decl.
6356  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
6357    if (!cxcursor::isFirstInDeclGroup(C))
6358      Loc = VD->getLocation();
6359  }
6360
6361  // For ObjC methods, give the start location of the method name.
6362  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
6363    Loc = MD->getSelectorStartLoc();
6364
6365  return cxloc::translateSourceLocation(getCursorContext(C), Loc);
6366}
6367
6368} // end extern "C"
6369
6370CXCursor cxcursor::getCursor(CXTranslationUnit TU, SourceLocation SLoc) {
6371  assert(TU);
6372
6373  // Guard against an invalid SourceLocation, or we may assert in one
6374  // of the following calls.
6375  if (SLoc.isInvalid())
6376    return clang_getNullCursor();
6377
6378  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
6379
6380  // Translate the given source location to make it point at the beginning of
6381  // the token under the cursor.
6382  SLoc = Lexer::GetBeginningOfToken(SLoc, CXXUnit->getSourceManager(),
6383                                    CXXUnit->getASTContext().getLangOpts());
6384
6385  CXCursor Result = MakeCXCursorInvalid(CXCursor_NoDeclFound);
6386  if (SLoc.isValid()) {
6387    GetCursorData ResultData(CXXUnit->getSourceManager(), SLoc, Result);
6388    CursorVisitor CursorVis(TU, GetCursorVisitor, &ResultData,
6389                            /*VisitPreprocessorLast=*/true,
6390                            /*VisitIncludedEntities=*/false,
6391                            SourceLocation(SLoc));
6392    CursorVis.visitFileRegion();
6393  }
6394
6395  return Result;
6396}
6397
6398static SourceRange getRawCursorExtent(CXCursor C) {
6399  if (clang_isReference(C.kind)) {
6400    switch (C.kind) {
6401    case CXCursor_ObjCSuperClassRef:
6402      return getCursorObjCSuperClassRef(C).second;
6403
6404    case CXCursor_ObjCProtocolRef:
6405      return getCursorObjCProtocolRef(C).second;
6406
6407    case CXCursor_ObjCClassRef:
6408      return getCursorObjCClassRef(C).second;
6409
6410    case CXCursor_TypeRef:
6411      return getCursorTypeRef(C).second;
6412
6413    case CXCursor_TemplateRef:
6414      return getCursorTemplateRef(C).second;
6415
6416    case CXCursor_NamespaceRef:
6417      return getCursorNamespaceRef(C).second;
6418
6419    case CXCursor_MemberRef:
6420      return getCursorMemberRef(C).second;
6421
6422    case CXCursor_CXXBaseSpecifier:
6423      return getCursorCXXBaseSpecifier(C)->getSourceRange();
6424
6425    case CXCursor_LabelRef:
6426      return getCursorLabelRef(C).second;
6427
6428    case CXCursor_OverloadedDeclRef:
6429      return getCursorOverloadedDeclRef(C).second;
6430
6431    case CXCursor_VariableRef:
6432      return getCursorVariableRef(C).second;
6433
6434    default:
6435      // FIXME: Need a way to enumerate all non-reference cases.
6436      llvm_unreachable("Missed a reference kind");
6437    }
6438  }
6439
6440  if (clang_isExpression(C.kind))
6441    return getCursorExpr(C)->getSourceRange();
6442
6443  if (clang_isStatement(C.kind))
6444    return getCursorStmt(C)->getSourceRange();
6445
6446  if (clang_isAttribute(C.kind))
6447    return getCursorAttr(C)->getRange();
6448
6449  if (C.kind == CXCursor_PreprocessingDirective)
6450    return cxcursor::getCursorPreprocessingDirective(C);
6451
6452  if (C.kind == CXCursor_MacroExpansion) {
6453    ASTUnit *TU = getCursorASTUnit(C);
6454    SourceRange Range = cxcursor::getCursorMacroExpansion(C).getSourceRange();
6455    return TU->mapRangeFromPreamble(Range);
6456  }
6457
6458  if (C.kind == CXCursor_MacroDefinition) {
6459    ASTUnit *TU = getCursorASTUnit(C);
6460    SourceRange Range = cxcursor::getCursorMacroDefinition(C)->getSourceRange();
6461    return TU->mapRangeFromPreamble(Range);
6462  }
6463
6464  if (C.kind == CXCursor_InclusionDirective) {
6465    ASTUnit *TU = getCursorASTUnit(C);
6466    SourceRange Range =
6467        cxcursor::getCursorInclusionDirective(C)->getSourceRange();
6468    return TU->mapRangeFromPreamble(Range);
6469  }
6470
6471  if (C.kind == CXCursor_TranslationUnit) {
6472    ASTUnit *TU = getCursorASTUnit(C);
6473    FileID MainID = TU->getSourceManager().getMainFileID();
6474    SourceLocation Start = TU->getSourceManager().getLocForStartOfFile(MainID);
6475    SourceLocation End = TU->getSourceManager().getLocForEndOfFile(MainID);
6476    return SourceRange(Start, End);
6477  }
6478
6479  if (clang_isDeclaration(C.kind)) {
6480    const Decl *D = cxcursor::getCursorDecl(C);
6481    if (!D)
6482      return SourceRange();
6483
6484    SourceRange R = D->getSourceRange();
6485    // FIXME: Multiple variables declared in a single declaration
6486    // currently lack the information needed to correctly determine their
6487    // ranges when accounting for the type-specifier.  We use context
6488    // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
6489    // and if so, whether it is the first decl.
6490    if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
6491      if (!cxcursor::isFirstInDeclGroup(C))
6492        R.setBegin(VD->getLocation());
6493    }
6494    return R;
6495  }
6496  return SourceRange();
6497}
6498
6499/// Retrieves the "raw" cursor extent, which is then extended to include
6500/// the decl-specifier-seq for declarations.
6501static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) {
6502  if (clang_isDeclaration(C.kind)) {
6503    const Decl *D = cxcursor::getCursorDecl(C);
6504    if (!D)
6505      return SourceRange();
6506
6507    SourceRange R = D->getSourceRange();
6508
6509    // Adjust the start of the location for declarations preceded by
6510    // declaration specifiers.
6511    SourceLocation StartLoc;
6512    if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
6513      if (TypeSourceInfo *TI = DD->getTypeSourceInfo())
6514        StartLoc = TI->getTypeLoc().getBeginLoc();
6515    } else if (const TypedefDecl *Typedef = dyn_cast<TypedefDecl>(D)) {
6516      if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo())
6517        StartLoc = TI->getTypeLoc().getBeginLoc();
6518    }
6519
6520    if (StartLoc.isValid() && R.getBegin().isValid() &&
6521        SrcMgr.isBeforeInTranslationUnit(StartLoc, R.getBegin()))
6522      R.setBegin(StartLoc);
6523
6524    // FIXME: Multiple variables declared in a single declaration
6525    // currently lack the information needed to correctly determine their
6526    // ranges when accounting for the type-specifier.  We use context
6527    // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
6528    // and if so, whether it is the first decl.
6529    if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
6530      if (!cxcursor::isFirstInDeclGroup(C))
6531        R.setBegin(VD->getLocation());
6532    }
6533
6534    return R;
6535  }
6536
6537  return getRawCursorExtent(C);
6538}
6539
6540CXSourceRange clang_getCursorExtent(CXCursor C) {
6541  SourceRange R = getRawCursorExtent(C);
6542  if (R.isInvalid())
6543    return clang_getNullRange();
6544
6545  return cxloc::translateSourceRange(getCursorContext(C), R);
6546}
6547
6548CXCursor clang_getCursorReferenced(CXCursor C) {
6549  if (clang_isInvalid(C.kind))
6550    return clang_getNullCursor();
6551
6552  CXTranslationUnit tu = getCursorTU(C);
6553  if (clang_isDeclaration(C.kind)) {
6554    const Decl *D = getCursorDecl(C);
6555    if (!D)
6556      return clang_getNullCursor();
6557    if (const UsingDecl *Using = dyn_cast<UsingDecl>(D))
6558      return MakeCursorOverloadedDeclRef(Using, D->getLocation(), tu);
6559    if (const ObjCPropertyImplDecl *PropImpl =
6560            dyn_cast<ObjCPropertyImplDecl>(D))
6561      if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl())
6562        return MakeCXCursor(Property, tu);
6563
6564    return C;
6565  }
6566
6567  if (clang_isExpression(C.kind)) {
6568    const Expr *E = getCursorExpr(C);
6569    const Decl *D = getDeclFromExpr(E);
6570    if (D) {
6571      CXCursor declCursor = MakeCXCursor(D, tu);
6572      declCursor = getSelectorIdentifierCursor(getSelectorIdentifierIndex(C),
6573                                               declCursor);
6574      return declCursor;
6575    }
6576
6577    if (const OverloadExpr *Ovl = dyn_cast_or_null<OverloadExpr>(E))
6578      return MakeCursorOverloadedDeclRef(Ovl, tu);
6579
6580    return clang_getNullCursor();
6581  }
6582
6583  if (clang_isStatement(C.kind)) {
6584    const Stmt *S = getCursorStmt(C);
6585    if (const GotoStmt *Goto = dyn_cast_or_null<GotoStmt>(S))
6586      if (LabelDecl *label = Goto->getLabel())
6587        if (LabelStmt *labelS = label->getStmt())
6588          return MakeCXCursor(labelS, getCursorDecl(C), tu);
6589
6590    return clang_getNullCursor();
6591  }
6592
6593  if (C.kind == CXCursor_MacroExpansion) {
6594    if (const MacroDefinitionRecord *Def =
6595            getCursorMacroExpansion(C).getDefinition())
6596      return MakeMacroDefinitionCursor(Def, tu);
6597  }
6598
6599  if (!clang_isReference(C.kind))
6600    return clang_getNullCursor();
6601
6602  switch (C.kind) {
6603  case CXCursor_ObjCSuperClassRef:
6604    return MakeCXCursor(getCursorObjCSuperClassRef(C).first, tu);
6605
6606  case CXCursor_ObjCProtocolRef: {
6607    const ObjCProtocolDecl *Prot = getCursorObjCProtocolRef(C).first;
6608    if (const ObjCProtocolDecl *Def = Prot->getDefinition())
6609      return MakeCXCursor(Def, tu);
6610
6611    return MakeCXCursor(Prot, tu);
6612  }
6613
6614  case CXCursor_ObjCClassRef: {
6615    const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first;
6616    if (const ObjCInterfaceDecl *Def = Class->getDefinition())
6617      return MakeCXCursor(Def, tu);
6618
6619    return MakeCXCursor(Class, tu);
6620  }
6621
6622  case CXCursor_TypeRef:
6623    return MakeCXCursor(getCursorTypeRef(C).first, tu);
6624
6625  case CXCursor_TemplateRef:
6626    return MakeCXCursor(getCursorTemplateRef(C).first, tu);
6627
6628  case CXCursor_NamespaceRef:
6629    return MakeCXCursor(getCursorNamespaceRef(C).first, tu);
6630
6631  case CXCursor_MemberRef:
6632    return MakeCXCursor(getCursorMemberRef(C).first, tu);
6633
6634  case CXCursor_CXXBaseSpecifier: {
6635    const CXXBaseSpecifier *B = cxcursor::getCursorCXXBaseSpecifier(C);
6636    return clang_getTypeDeclaration(cxtype::MakeCXType(B->getType(), tu));
6637  }
6638
6639  case CXCursor_LabelRef:
6640    // FIXME: We end up faking the "parent" declaration here because we
6641    // don't want to make CXCursor larger.
6642    return MakeCXCursor(
6643        getCursorLabelRef(C).first,
6644        cxtu::getASTUnit(tu)->getASTContext().getTranslationUnitDecl(), tu);
6645
6646  case CXCursor_OverloadedDeclRef:
6647    return C;
6648
6649  case CXCursor_VariableRef:
6650    return MakeCXCursor(getCursorVariableRef(C).first, tu);
6651
6652  default:
6653    // We would prefer to enumerate all non-reference cursor kinds here.
6654    llvm_unreachable("Unhandled reference cursor kind");
6655  }
6656}
6657
6658CXCursor clang_getCursorDefinition(CXCursor C) {
6659  if (clang_isInvalid(C.kind))
6660    return clang_getNullCursor();
6661
6662  CXTranslationUnit TU = getCursorTU(C);
6663
6664  bool WasReference = false;
6665  if (clang_isReference(C.kind) || clang_isExpression(C.kind)) {
6666    C = clang_getCursorReferenced(C);
6667    WasReference = true;
6668  }
6669
6670  if (C.kind == CXCursor_MacroExpansion)
6671    return clang_getCursorReferenced(C);
6672
6673  if (!clang_isDeclaration(C.kind))
6674    return clang_getNullCursor();
6675
6676  const Decl *D = getCursorDecl(C);
6677  if (!D)
6678    return clang_getNullCursor();
6679
6680  switch (D->getKind()) {
6681  // Declaration kinds that don't really separate the notions of
6682  // declaration and definition.
6683  case Decl::Namespace:
6684  case Decl::Typedef:
6685  case Decl::TypeAlias:
6686  case Decl::TypeAliasTemplate:
6687  case Decl::TemplateTypeParm:
6688  case Decl::EnumConstant:
6689  case Decl::Field:
6690  case Decl::Binding:
6691  case Decl::MSProperty:
6692  case Decl::MSGuid:
6693  case Decl::HLSLBuffer:
6694  case Decl::UnnamedGlobalConstant:
6695  case Decl::TemplateParamObject:
6696  case Decl::IndirectField:
6697  case Decl::ObjCIvar:
6698  case Decl::ObjCAtDefsField:
6699  case Decl::ImplicitParam:
6700  case Decl::ParmVar:
6701  case Decl::NonTypeTemplateParm:
6702  case Decl::TemplateTemplateParm:
6703  case Decl::ObjCCategoryImpl:
6704  case Decl::ObjCImplementation:
6705  case Decl::AccessSpec:
6706  case Decl::LinkageSpec:
6707  case Decl::Export:
6708  case Decl::ObjCPropertyImpl:
6709  case Decl::FileScopeAsm:
6710  case Decl::TopLevelStmt:
6711  case Decl::StaticAssert:
6712  case Decl::Block:
6713  case Decl::Captured:
6714  case Decl::OMPCapturedExpr:
6715  case Decl::Label: // FIXME: Is this right??
6716  case Decl::ClassScopeFunctionSpecialization:
6717  case Decl::CXXDeductionGuide:
6718  case Decl::Import:
6719  case Decl::OMPThreadPrivate:
6720  case Decl::OMPAllocate:
6721  case Decl::OMPDeclareReduction:
6722  case Decl::OMPDeclareMapper:
6723  case Decl::OMPRequires:
6724  case Decl::ObjCTypeParam:
6725  case Decl::BuiltinTemplate:
6726  case Decl::PragmaComment:
6727  case Decl::PragmaDetectMismatch:
6728  case Decl::UsingPack:
6729  case Decl::Concept:
6730  case Decl::ImplicitConceptSpecialization:
6731  case Decl::LifetimeExtendedTemporary:
6732  case Decl::RequiresExprBody:
6733  case Decl::UnresolvedUsingIfExists:
6734    return C;
6735
6736  // Declaration kinds that don't make any sense here, but are
6737  // nonetheless harmless.
6738  case Decl::Empty:
6739  case Decl::TranslationUnit:
6740  case Decl::ExternCContext:
6741    break;
6742
6743  // Declaration kinds for which the definition is not resolvable.
6744  case Decl::UnresolvedUsingTypename:
6745  case Decl::UnresolvedUsingValue:
6746    break;
6747
6748  case Decl::UsingDirective:
6749    return MakeCXCursor(cast<UsingDirectiveDecl>(D)->getNominatedNamespace(),
6750                        TU);
6751
6752  case Decl::NamespaceAlias:
6753    return MakeCXCursor(cast<NamespaceAliasDecl>(D)->getNamespace(), TU);
6754
6755  case Decl::Enum:
6756  case Decl::Record:
6757  case Decl::CXXRecord:
6758  case Decl::ClassTemplateSpecialization:
6759  case Decl::ClassTemplatePartialSpecialization:
6760    if (TagDecl *Def = cast<TagDecl>(D)->getDefinition())
6761      return MakeCXCursor(Def, TU);
6762    return clang_getNullCursor();
6763
6764  case Decl::Function:
6765  case Decl::CXXMethod:
6766  case Decl::CXXConstructor:
6767  case Decl::CXXDestructor:
6768  case Decl::CXXConversion: {
6769    const FunctionDecl *Def = nullptr;
6770    if (cast<FunctionDecl>(D)->getBody(Def))
6771      return MakeCXCursor(Def, TU);
6772    return clang_getNullCursor();
6773  }
6774
6775  case Decl::Var:
6776  case Decl::VarTemplateSpecialization:
6777  case Decl::VarTemplatePartialSpecialization:
6778  case Decl::Decomposition: {
6779    // Ask the variable if it has a definition.
6780    if (const VarDecl *Def = cast<VarDecl>(D)->getDefinition())
6781      return MakeCXCursor(Def, TU);
6782    return clang_getNullCursor();
6783  }
6784
6785  case Decl::FunctionTemplate: {
6786    const FunctionDecl *Def = nullptr;
6787    if (cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->getBody(Def))
6788      return MakeCXCursor(Def->getDescribedFunctionTemplate(), TU);
6789    return clang_getNullCursor();
6790  }
6791
6792  case Decl::ClassTemplate: {
6793    if (RecordDecl *Def =
6794            cast<ClassTemplateDecl>(D)->getTemplatedDecl()->getDefinition())
6795      return MakeCXCursor(cast<CXXRecordDecl>(Def)->getDescribedClassTemplate(),
6796                          TU);
6797    return clang_getNullCursor();
6798  }
6799
6800  case Decl::VarTemplate: {
6801    if (VarDecl *Def =
6802            cast<VarTemplateDecl>(D)->getTemplatedDecl()->getDefinition())
6803      return MakeCXCursor(cast<VarDecl>(Def)->getDescribedVarTemplate(), TU);
6804    return clang_getNullCursor();
6805  }
6806
6807  case Decl::Using:
6808  case Decl::UsingEnum:
6809    return MakeCursorOverloadedDeclRef(cast<BaseUsingDecl>(D), D->getLocation(),
6810                                       TU);
6811
6812  case Decl::UsingShadow:
6813  case Decl::ConstructorUsingShadow:
6814    return clang_getCursorDefinition(
6815        MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(), TU));
6816
6817  case Decl::ObjCMethod: {
6818    const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(D);
6819    if (Method->isThisDeclarationADefinition())
6820      return C;
6821
6822    // Dig out the method definition in the associated
6823    // @implementation, if we have it.
6824    // FIXME: The ASTs should make finding the definition easier.
6825    if (const ObjCInterfaceDecl *Class =
6826            dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext()))
6827      if (ObjCImplementationDecl *ClassImpl = Class->getImplementation())
6828        if (ObjCMethodDecl *Def = ClassImpl->getMethod(
6829                Method->getSelector(), Method->isInstanceMethod()))
6830          if (Def->isThisDeclarationADefinition())
6831            return MakeCXCursor(Def, TU);
6832
6833    return clang_getNullCursor();
6834  }
6835
6836  case Decl::ObjCCategory:
6837    if (ObjCCategoryImplDecl *Impl =
6838            cast<ObjCCategoryDecl>(D)->getImplementation())
6839      return MakeCXCursor(Impl, TU);
6840    return clang_getNullCursor();
6841
6842  case Decl::ObjCProtocol:
6843    if (const ObjCProtocolDecl *Def =
6844            cast<ObjCProtocolDecl>(D)->getDefinition())
6845      return MakeCXCursor(Def, TU);
6846    return clang_getNullCursor();
6847
6848  case Decl::ObjCInterface: {
6849    // There are two notions of a "definition" for an Objective-C
6850    // class: the interface and its implementation. When we resolved a
6851    // reference to an Objective-C class, produce the @interface as
6852    // the definition; when we were provided with the interface,
6853    // produce the @implementation as the definition.
6854    const ObjCInterfaceDecl *IFace = cast<ObjCInterfaceDecl>(D);
6855    if (WasReference) {
6856      if (const ObjCInterfaceDecl *Def = IFace->getDefinition())
6857        return MakeCXCursor(Def, TU);
6858    } else if (ObjCImplementationDecl *Impl = IFace->getImplementation())
6859      return MakeCXCursor(Impl, TU);
6860    return clang_getNullCursor();
6861  }
6862
6863  case Decl::ObjCProperty:
6864    // FIXME: We don't really know where to find the
6865    // ObjCPropertyImplDecls that implement this property.
6866    return clang_getNullCursor();
6867
6868  case Decl::ObjCCompatibleAlias:
6869    if (const ObjCInterfaceDecl *Class =
6870            cast<ObjCCompatibleAliasDecl>(D)->getClassInterface())
6871      if (const ObjCInterfaceDecl *Def = Class->getDefinition())
6872        return MakeCXCursor(Def, TU);
6873
6874    return clang_getNullCursor();
6875
6876  case Decl::Friend:
6877    if (NamedDecl *Friend = cast<FriendDecl>(D)->getFriendDecl())
6878      return clang_getCursorDefinition(MakeCXCursor(Friend, TU));
6879    return clang_getNullCursor();
6880
6881  case Decl::FriendTemplate:
6882    if (NamedDecl *Friend = cast<FriendTemplateDecl>(D)->getFriendDecl())
6883      return clang_getCursorDefinition(MakeCXCursor(Friend, TU));
6884    return clang_getNullCursor();
6885  }
6886
6887  return clang_getNullCursor();
6888}
6889
6890unsigned clang_isCursorDefinition(CXCursor C) {
6891  if (!clang_isDeclaration(C.kind))
6892    return 0;
6893
6894  return clang_getCursorDefinition(C) == C;
6895}
6896
6897CXCursor clang_getCanonicalCursor(CXCursor C) {
6898  if (!clang_isDeclaration(C.kind))
6899    return C;
6900
6901  if (const Decl *D = getCursorDecl(C)) {
6902    if (const ObjCCategoryImplDecl *CatImplD =
6903            dyn_cast<ObjCCategoryImplDecl>(D))
6904      if (ObjCCategoryDecl *CatD = CatImplD->getCategoryDecl())
6905        return MakeCXCursor(CatD, getCursorTU(C));
6906
6907    if (const ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
6908      if (const ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
6909        return MakeCXCursor(IFD, getCursorTU(C));
6910
6911    return MakeCXCursor(D->getCanonicalDecl(), getCursorTU(C));
6912  }
6913
6914  return C;
6915}
6916
6917int clang_Cursor_getObjCSelectorIndex(CXCursor cursor) {
6918  return cxcursor::getSelectorIdentifierIndexAndLoc(cursor).first;
6919}
6920
6921unsigned clang_getNumOverloadedDecls(CXCursor C) {
6922  if (C.kind != CXCursor_OverloadedDeclRef)
6923    return 0;
6924
6925  OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first;
6926  if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
6927    return E->getNumDecls();
6928
6929  if (OverloadedTemplateStorage *S =
6930          Storage.dyn_cast<OverloadedTemplateStorage *>())
6931    return S->size();
6932
6933  const Decl *D = Storage.get<const Decl *>();
6934  if (const UsingDecl *Using = dyn_cast<UsingDecl>(D))
6935    return Using->shadow_size();
6936
6937  return 0;
6938}
6939
6940CXCursor clang_getOverloadedDecl(CXCursor cursor, unsigned index) {
6941  if (cursor.kind != CXCursor_OverloadedDeclRef)
6942    return clang_getNullCursor();
6943
6944  if (index >= clang_getNumOverloadedDecls(cursor))
6945    return clang_getNullCursor();
6946
6947  CXTranslationUnit TU = getCursorTU(cursor);
6948  OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(cursor).first;
6949  if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
6950    return MakeCXCursor(E->decls_begin()[index], TU);
6951
6952  if (OverloadedTemplateStorage *S =
6953          Storage.dyn_cast<OverloadedTemplateStorage *>())
6954    return MakeCXCursor(S->begin()[index], TU);
6955
6956  const Decl *D = Storage.get<const Decl *>();
6957  if (const UsingDecl *Using = dyn_cast<UsingDecl>(D)) {
6958    // FIXME: This is, unfortunately, linear time.
6959    UsingDecl::shadow_iterator Pos = Using->shadow_begin();
6960    std::advance(Pos, index);
6961    return MakeCXCursor(cast<UsingShadowDecl>(*Pos)->getTargetDecl(), TU);
6962  }
6963
6964  return clang_getNullCursor();
6965}
6966
6967void clang_getDefinitionSpellingAndExtent(
6968    CXCursor C, const char **startBuf, const char **endBuf, unsigned *startLine,
6969    unsigned *startColumn, unsigned *endLine, unsigned *endColumn) {
6970  assert(getCursorDecl(C) && "CXCursor has null decl");
6971  const auto *FD = cast<FunctionDecl>(getCursorDecl(C));
6972  const auto *Body = cast<CompoundStmt>(FD->getBody());
6973
6974  SourceManager &SM = FD->getASTContext().getSourceManager();
6975  *startBuf = SM.getCharacterData(Body->getLBracLoc());
6976  *endBuf = SM.getCharacterData(Body->getRBracLoc());
6977  *startLine = SM.getSpellingLineNumber(Body->getLBracLoc());
6978  *startColumn = SM.getSpellingColumnNumber(Body->getLBracLoc());
6979  *endLine = SM.getSpellingLineNumber(Body->getRBracLoc());
6980  *endColumn = SM.getSpellingColumnNumber(Body->getRBracLoc());
6981}
6982
6983CXSourceRange clang_getCursorReferenceNameRange(CXCursor C, unsigned NameFlags,
6984                                                unsigned PieceIndex) {
6985  RefNamePieces Pieces;
6986
6987  switch (C.kind) {
6988  case CXCursor_MemberRefExpr:
6989    if (const MemberExpr *E = dyn_cast<MemberExpr>(getCursorExpr(C)))
6990      Pieces = buildPieces(NameFlags, true, E->getMemberNameInfo(),
6991                           E->getQualifierLoc().getSourceRange());
6992    break;
6993
6994  case CXCursor_DeclRefExpr:
6995    if (const DeclRefExpr *E = dyn_cast<DeclRefExpr>(getCursorExpr(C))) {
6996      SourceRange TemplateArgLoc(E->getLAngleLoc(), E->getRAngleLoc());
6997      Pieces =
6998          buildPieces(NameFlags, false, E->getNameInfo(),
6999                      E->getQualifierLoc().getSourceRange(), &TemplateArgLoc);
7000    }
7001    break;
7002
7003  case CXCursor_CallExpr:
7004    if (const CXXOperatorCallExpr *OCE =
7005            dyn_cast<CXXOperatorCallExpr>(getCursorExpr(C))) {
7006      const Expr *Callee = OCE->getCallee();
7007      if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee))
7008        Callee = ICE->getSubExpr();
7009
7010      if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee))
7011        Pieces = buildPieces(NameFlags, false, DRE->getNameInfo(),
7012                             DRE->getQualifierLoc().getSourceRange());
7013    }
7014    break;
7015
7016  default:
7017    break;
7018  }
7019
7020  if (Pieces.empty()) {
7021    if (PieceIndex == 0)
7022      return clang_getCursorExtent(C);
7023  } else if (PieceIndex < Pieces.size()) {
7024    SourceRange R = Pieces[PieceIndex];
7025    if (R.isValid())
7026      return cxloc::translateSourceRange(getCursorContext(C), R);
7027  }
7028
7029  return clang_getNullRange();
7030}
7031
7032void clang_enableStackTraces(void) {
7033  // FIXME: Provide an argv0 here so we can find llvm-symbolizer.
7034  llvm::sys::PrintStackTraceOnErrorSignal(StringRef());
7035}
7036
7037void clang_executeOnThread(void (*fn)(void *), void *user_data,
7038                           unsigned stack_size) {
7039  llvm::thread Thread(stack_size == 0 ? clang::DesiredStackSize
7040                                      : std::optional<unsigned>(stack_size),
7041                      fn, user_data);
7042  Thread.join();
7043}
7044
7045//===----------------------------------------------------------------------===//
7046// Token-based Operations.
7047//===----------------------------------------------------------------------===//
7048
7049/* CXToken layout:
7050 *   int_data[0]: a CXTokenKind
7051 *   int_data[1]: starting token location
7052 *   int_data[2]: token length
7053 *   int_data[3]: reserved
7054 *   ptr_data: for identifiers and keywords, an IdentifierInfo*.
7055 *   otherwise unused.
7056 */
7057CXTokenKind clang_getTokenKind(CXToken CXTok) {
7058  return static_cast<CXTokenKind>(CXTok.int_data[0]);
7059}
7060
7061CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) {
7062  switch (clang_getTokenKind(CXTok)) {
7063  case CXToken_Identifier:
7064  case CXToken_Keyword:
7065    // We know we have an IdentifierInfo*, so use that.
7066    return cxstring::createRef(
7067        static_cast<IdentifierInfo *>(CXTok.ptr_data)->getNameStart());
7068
7069  case CXToken_Literal: {
7070    // We have stashed the starting pointer in the ptr_data field. Use it.
7071    const char *Text = static_cast<const char *>(CXTok.ptr_data);
7072    return cxstring::createDup(StringRef(Text, CXTok.int_data[2]));
7073  }
7074
7075  case CXToken_Punctuation:
7076  case CXToken_Comment:
7077    break;
7078  }
7079
7080  if (isNotUsableTU(TU)) {
7081    LOG_BAD_TU(TU);
7082    return cxstring::createEmpty();
7083  }
7084
7085  // We have to find the starting buffer pointer the hard way, by
7086  // deconstructing the source location.
7087  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
7088  if (!CXXUnit)
7089    return cxstring::createEmpty();
7090
7091  SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]);
7092  std::pair<FileID, unsigned> LocInfo =
7093      CXXUnit->getSourceManager().getDecomposedSpellingLoc(Loc);
7094  bool Invalid = false;
7095  StringRef Buffer =
7096      CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid);
7097  if (Invalid)
7098    return cxstring::createEmpty();
7099
7100  return cxstring::createDup(Buffer.substr(LocInfo.second, CXTok.int_data[2]));
7101}
7102
7103CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) {
7104  if (isNotUsableTU(TU)) {
7105    LOG_BAD_TU(TU);
7106    return clang_getNullLocation();
7107  }
7108
7109  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
7110  if (!CXXUnit)
7111    return clang_getNullLocation();
7112
7113  return cxloc::translateSourceLocation(
7114      CXXUnit->getASTContext(),
7115      SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
7116}
7117
7118CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) {
7119  if (isNotUsableTU(TU)) {
7120    LOG_BAD_TU(TU);
7121    return clang_getNullRange();
7122  }
7123
7124  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
7125  if (!CXXUnit)
7126    return clang_getNullRange();
7127
7128  return cxloc::translateSourceRange(
7129      CXXUnit->getASTContext(),
7130      SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
7131}
7132
7133static void getTokens(ASTUnit *CXXUnit, SourceRange Range,
7134                      SmallVectorImpl<CXToken> &CXTokens) {
7135  SourceManager &SourceMgr = CXXUnit->getSourceManager();
7136  std::pair<FileID, unsigned> BeginLocInfo =
7137      SourceMgr.getDecomposedSpellingLoc(Range.getBegin());
7138  std::pair<FileID, unsigned> EndLocInfo =
7139      SourceMgr.getDecomposedSpellingLoc(Range.getEnd());
7140
7141  // Cannot tokenize across files.
7142  if (BeginLocInfo.first != EndLocInfo.first)
7143    return;
7144
7145  // Create a lexer
7146  bool Invalid = false;
7147  StringRef Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid);
7148  if (Invalid)
7149    return;
7150
7151  Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
7152            CXXUnit->getASTContext().getLangOpts(), Buffer.begin(),
7153            Buffer.data() + BeginLocInfo.second, Buffer.end());
7154  Lex.SetCommentRetentionState(true);
7155
7156  // Lex tokens until we hit the end of the range.
7157  const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second;
7158  Token Tok;
7159  bool previousWasAt = false;
7160  do {
7161    // Lex the next token
7162    Lex.LexFromRawLexer(Tok);
7163    if (Tok.is(tok::eof))
7164      break;
7165
7166    // Initialize the CXToken.
7167    CXToken CXTok;
7168
7169    //   - Common fields
7170    CXTok.int_data[1] = Tok.getLocation().getRawEncoding();
7171    CXTok.int_data[2] = Tok.getLength();
7172    CXTok.int_data[3] = 0;
7173
7174    //   - Kind-specific fields
7175    if (Tok.isLiteral()) {
7176      CXTok.int_data[0] = CXToken_Literal;
7177      CXTok.ptr_data = const_cast<char *>(Tok.getLiteralData());
7178    } else if (Tok.is(tok::raw_identifier)) {
7179      // Lookup the identifier to determine whether we have a keyword.
7180      IdentifierInfo *II = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok);
7181
7182      if ((II->getObjCKeywordID() != tok::objc_not_keyword) && previousWasAt) {
7183        CXTok.int_data[0] = CXToken_Keyword;
7184      } else {
7185        CXTok.int_data[0] =
7186            Tok.is(tok::identifier) ? CXToken_Identifier : CXToken_Keyword;
7187      }
7188      CXTok.ptr_data = II;
7189    } else if (Tok.is(tok::comment)) {
7190      CXTok.int_data[0] = CXToken_Comment;
7191      CXTok.ptr_data = nullptr;
7192    } else {
7193      CXTok.int_data[0] = CXToken_Punctuation;
7194      CXTok.ptr_data = nullptr;
7195    }
7196    CXTokens.push_back(CXTok);
7197    previousWasAt = Tok.is(tok::at);
7198  } while (Lex.getBufferLocation() < EffectiveBufferEnd);
7199}
7200
7201CXToken *clang_getToken(CXTranslationUnit TU, CXSourceLocation Location) {
7202  LOG_FUNC_SECTION { *Log << TU << ' ' << Location; }
7203
7204  if (isNotUsableTU(TU)) {
7205    LOG_BAD_TU(TU);
7206    return nullptr;
7207  }
7208
7209  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
7210  if (!CXXUnit)
7211    return nullptr;
7212
7213  SourceLocation Begin = cxloc::translateSourceLocation(Location);
7214  if (Begin.isInvalid())
7215    return nullptr;
7216  SourceManager &SM = CXXUnit->getSourceManager();
7217  std::pair<FileID, unsigned> DecomposedEnd = SM.getDecomposedLoc(Begin);
7218  DecomposedEnd.second +=
7219      Lexer::MeasureTokenLength(Begin, SM, CXXUnit->getLangOpts());
7220
7221  SourceLocation End =
7222      SM.getComposedLoc(DecomposedEnd.first, DecomposedEnd.second);
7223
7224  SmallVector<CXToken, 32> CXTokens;
7225  getTokens(CXXUnit, SourceRange(Begin, End), CXTokens);
7226
7227  if (CXTokens.empty())
7228    return nullptr;
7229
7230  CXTokens.resize(1);
7231  CXToken *Token = static_cast<CXToken *>(llvm::safe_malloc(sizeof(CXToken)));
7232
7233  memmove(Token, CXTokens.data(), sizeof(CXToken));
7234  return Token;
7235}
7236
7237void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range, CXToken **Tokens,
7238                    unsigned *NumTokens) {
7239  LOG_FUNC_SECTION { *Log << TU << ' ' << Range; }
7240
7241  if (Tokens)
7242    *Tokens = nullptr;
7243  if (NumTokens)
7244    *NumTokens = 0;
7245
7246  if (isNotUsableTU(TU)) {
7247    LOG_BAD_TU(TU);
7248    return;
7249  }
7250
7251  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
7252  if (!CXXUnit || !Tokens || !NumTokens)
7253    return;
7254
7255  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
7256
7257  SourceRange R = cxloc::translateCXSourceRange(Range);
7258  if (R.isInvalid())
7259    return;
7260
7261  SmallVector<CXToken, 32> CXTokens;
7262  getTokens(CXXUnit, R, CXTokens);
7263
7264  if (CXTokens.empty())
7265    return;
7266
7267  *Tokens = static_cast<CXToken *>(
7268      llvm::safe_malloc(sizeof(CXToken) * CXTokens.size()));
7269  memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size());
7270  *NumTokens = CXTokens.size();
7271}
7272
7273void clang_disposeTokens(CXTranslationUnit TU, CXToken *Tokens,
7274                         unsigned NumTokens) {
7275  free(Tokens);
7276}
7277
7278//===----------------------------------------------------------------------===//
7279// Token annotation APIs.
7280//===----------------------------------------------------------------------===//
7281
7282static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor,
7283                                                     CXCursor parent,
7284                                                     CXClientData client_data);
7285static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor,
7286                                              CXClientData client_data);
7287
7288namespace {
7289class AnnotateTokensWorker {
7290  CXToken *Tokens;
7291  CXCursor *Cursors;
7292  unsigned NumTokens;
7293  unsigned TokIdx;
7294  unsigned PreprocessingTokIdx;
7295  CursorVisitor AnnotateVis;
7296  SourceManager &SrcMgr;
7297  bool HasContextSensitiveKeywords;
7298
7299  struct PostChildrenAction {
7300    CXCursor cursor;
7301    enum Action { Invalid, Ignore, Postpone } action;
7302  };
7303  using PostChildrenActions = SmallVector<PostChildrenAction, 0>;
7304
7305  struct PostChildrenInfo {
7306    CXCursor Cursor;
7307    SourceRange CursorRange;
7308    unsigned BeforeReachingCursorIdx;
7309    unsigned BeforeChildrenTokenIdx;
7310    PostChildrenActions ChildActions;
7311  };
7312  SmallVector<PostChildrenInfo, 8> PostChildrenInfos;
7313
7314  CXToken &getTok(unsigned Idx) {
7315    assert(Idx < NumTokens);
7316    return Tokens[Idx];
7317  }
7318  const CXToken &getTok(unsigned Idx) const {
7319    assert(Idx < NumTokens);
7320    return Tokens[Idx];
7321  }
7322  bool MoreTokens() const { return TokIdx < NumTokens; }
7323  unsigned NextToken() const { return TokIdx; }
7324  void AdvanceToken() { ++TokIdx; }
7325  SourceLocation GetTokenLoc(unsigned tokI) {
7326    return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[1]);
7327  }
7328  bool isFunctionMacroToken(unsigned tokI) const {
7329    return getTok(tokI).int_data[3] != 0;
7330  }
7331  SourceLocation getFunctionMacroTokenLoc(unsigned tokI) const {
7332    return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[3]);
7333  }
7334
7335  void annotateAndAdvanceTokens(CXCursor, RangeComparisonResult, SourceRange);
7336  bool annotateAndAdvanceFunctionMacroTokens(CXCursor, RangeComparisonResult,
7337                                             SourceRange);
7338
7339public:
7340  AnnotateTokensWorker(CXToken *tokens, CXCursor *cursors, unsigned numTokens,
7341                       CXTranslationUnit TU, SourceRange RegionOfInterest)
7342      : Tokens(tokens), Cursors(cursors), NumTokens(numTokens), TokIdx(0),
7343        PreprocessingTokIdx(0),
7344        AnnotateVis(TU, AnnotateTokensVisitor, this,
7345                    /*VisitPreprocessorLast=*/true,
7346                    /*VisitIncludedEntities=*/false, RegionOfInterest,
7347                    /*VisitDeclsOnly=*/false,
7348                    AnnotateTokensPostChildrenVisitor),
7349        SrcMgr(cxtu::getASTUnit(TU)->getSourceManager()),
7350        HasContextSensitiveKeywords(false) {}
7351
7352  void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); }
7353  enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent);
7354  bool IsIgnoredChildCursor(CXCursor cursor) const;
7355  PostChildrenActions DetermineChildActions(CXCursor Cursor) const;
7356
7357  bool postVisitChildren(CXCursor cursor);
7358  void HandlePostPonedChildCursors(const PostChildrenInfo &Info);
7359  void HandlePostPonedChildCursor(CXCursor Cursor, unsigned StartTokenIndex);
7360
7361  void AnnotateTokens();
7362
7363  /// Determine whether the annotator saw any cursors that have
7364  /// context-sensitive keywords.
7365  bool hasContextSensitiveKeywords() const {
7366    return HasContextSensitiveKeywords;
7367  }
7368
7369  ~AnnotateTokensWorker() { assert(PostChildrenInfos.empty()); }
7370};
7371} // namespace
7372
7373void AnnotateTokensWorker::AnnotateTokens() {
7374  // Walk the AST within the region of interest, annotating tokens
7375  // along the way.
7376  AnnotateVis.visitFileRegion();
7377}
7378
7379bool AnnotateTokensWorker::IsIgnoredChildCursor(CXCursor cursor) const {
7380  if (PostChildrenInfos.empty())
7381    return false;
7382
7383  for (const auto &ChildAction : PostChildrenInfos.back().ChildActions) {
7384    if (ChildAction.cursor == cursor &&
7385        ChildAction.action == PostChildrenAction::Ignore) {
7386      return true;
7387    }
7388  }
7389
7390  return false;
7391}
7392
7393const CXXOperatorCallExpr *GetSubscriptOrCallOperator(CXCursor Cursor) {
7394  if (!clang_isExpression(Cursor.kind))
7395    return nullptr;
7396
7397  const Expr *E = getCursorExpr(Cursor);
7398  if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
7399    const OverloadedOperatorKind Kind = OCE->getOperator();
7400    if (Kind == OO_Call || Kind == OO_Subscript)
7401      return OCE;
7402  }
7403
7404  return nullptr;
7405}
7406
7407AnnotateTokensWorker::PostChildrenActions
7408AnnotateTokensWorker::DetermineChildActions(CXCursor Cursor) const {
7409  PostChildrenActions actions;
7410
7411  // The DeclRefExpr of CXXOperatorCallExpr referring to the custom operator is
7412  // visited before the arguments to the operator call. For the Call and
7413  // Subscript operator the range of this DeclRefExpr includes the whole call
7414  // expression, so that all tokens in that range would be mapped to the
7415  // operator function, including the tokens of the arguments. To avoid that,
7416  // ensure to visit this DeclRefExpr as last node.
7417  if (const auto *OCE = GetSubscriptOrCallOperator(Cursor)) {
7418    const Expr *Callee = OCE->getCallee();
7419    if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee)) {
7420      const Expr *SubExpr = ICE->getSubExpr();
7421      if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(SubExpr)) {
7422        const Decl *parentDecl = getCursorDecl(Cursor);
7423        CXTranslationUnit TU = clang_Cursor_getTranslationUnit(Cursor);
7424
7425        // Visit the DeclRefExpr as last.
7426        CXCursor cxChild = MakeCXCursor(DRE, parentDecl, TU);
7427        actions.push_back({cxChild, PostChildrenAction::Postpone});
7428
7429        // The parent of the DeclRefExpr, an ImplicitCastExpr, has an equally
7430        // wide range as the DeclRefExpr. We can skip visiting this entirely.
7431        cxChild = MakeCXCursor(ICE, parentDecl, TU);
7432        actions.push_back({cxChild, PostChildrenAction::Ignore});
7433      }
7434    }
7435  }
7436
7437  return actions;
7438}
7439
7440static inline void updateCursorAnnotation(CXCursor &Cursor,
7441                                          const CXCursor &updateC) {
7442  if (clang_isInvalid(updateC.kind) || !clang_isInvalid(Cursor.kind))
7443    return;
7444  Cursor = updateC;
7445}
7446
7447/// It annotates and advances tokens with a cursor until the comparison
7448//// between the cursor location and the source range is the same as
7449/// \arg compResult.
7450///
7451/// Pass RangeBefore to annotate tokens with a cursor until a range is reached.
7452/// Pass RangeOverlap to annotate tokens inside a range.
7453void AnnotateTokensWorker::annotateAndAdvanceTokens(
7454    CXCursor updateC, RangeComparisonResult compResult, SourceRange range) {
7455  while (MoreTokens()) {
7456    const unsigned I = NextToken();
7457    if (isFunctionMacroToken(I))
7458      if (!annotateAndAdvanceFunctionMacroTokens(updateC, compResult, range))
7459        return;
7460
7461    SourceLocation TokLoc = GetTokenLoc(I);
7462    if (LocationCompare(SrcMgr, TokLoc, range) == compResult) {
7463      updateCursorAnnotation(Cursors[I], updateC);
7464      AdvanceToken();
7465      continue;
7466    }
7467    break;
7468  }
7469}
7470
7471/// Special annotation handling for macro argument tokens.
7472/// \returns true if it advanced beyond all macro tokens, false otherwise.
7473bool AnnotateTokensWorker::annotateAndAdvanceFunctionMacroTokens(
7474    CXCursor updateC, RangeComparisonResult compResult, SourceRange range) {
7475  assert(MoreTokens());
7476  assert(isFunctionMacroToken(NextToken()) &&
7477         "Should be called only for macro arg tokens");
7478
7479  // This works differently than annotateAndAdvanceTokens; because expanded
7480  // macro arguments can have arbitrary translation-unit source order, we do not
7481  // advance the token index one by one until a token fails the range test.
7482  // We only advance once past all of the macro arg tokens if all of them
7483  // pass the range test. If one of them fails we keep the token index pointing
7484  // at the start of the macro arg tokens so that the failing token will be
7485  // annotated by a subsequent annotation try.
7486
7487  bool atLeastOneCompFail = false;
7488
7489  unsigned I = NextToken();
7490  for (; I < NumTokens && isFunctionMacroToken(I); ++I) {
7491    SourceLocation TokLoc = getFunctionMacroTokenLoc(I);
7492    if (TokLoc.isFileID())
7493      continue; // not macro arg token, it's parens or comma.
7494    if (LocationCompare(SrcMgr, TokLoc, range) == compResult) {
7495      if (clang_isInvalid(clang_getCursorKind(Cursors[I])))
7496        Cursors[I] = updateC;
7497    } else
7498      atLeastOneCompFail = true;
7499  }
7500
7501  if (atLeastOneCompFail)
7502    return false;
7503
7504  TokIdx = I; // All of the tokens were handled, advance beyond all of them.
7505  return true;
7506}
7507
7508enum CXChildVisitResult AnnotateTokensWorker::Visit(CXCursor cursor,
7509                                                    CXCursor parent) {
7510  SourceRange cursorRange = getRawCursorExtent(cursor);
7511  if (cursorRange.isInvalid())
7512    return CXChildVisit_Recurse;
7513
7514  if (IsIgnoredChildCursor(cursor))
7515    return CXChildVisit_Continue;
7516
7517  if (!HasContextSensitiveKeywords) {
7518    // Objective-C properties can have context-sensitive keywords.
7519    if (cursor.kind == CXCursor_ObjCPropertyDecl) {
7520      if (const ObjCPropertyDecl *Property =
7521              dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(cursor)))
7522        HasContextSensitiveKeywords =
7523            Property->getPropertyAttributesAsWritten() != 0;
7524    }
7525    // Objective-C methods can have context-sensitive keywords.
7526    else if (cursor.kind == CXCursor_ObjCInstanceMethodDecl ||
7527             cursor.kind == CXCursor_ObjCClassMethodDecl) {
7528      if (const ObjCMethodDecl *Method =
7529              dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) {
7530        if (Method->getObjCDeclQualifier())
7531          HasContextSensitiveKeywords = true;
7532        else {
7533          for (const auto *P : Method->parameters()) {
7534            if (P->getObjCDeclQualifier()) {
7535              HasContextSensitiveKeywords = true;
7536              break;
7537            }
7538          }
7539        }
7540      }
7541    }
7542    // C++ methods can have context-sensitive keywords.
7543    else if (cursor.kind == CXCursor_CXXMethod) {
7544      if (const CXXMethodDecl *Method =
7545              dyn_cast_or_null<CXXMethodDecl>(getCursorDecl(cursor))) {
7546        if (Method->hasAttr<FinalAttr>() || Method->hasAttr<OverrideAttr>())
7547          HasContextSensitiveKeywords = true;
7548      }
7549    }
7550    // C++ classes can have context-sensitive keywords.
7551    else if (cursor.kind == CXCursor_StructDecl ||
7552             cursor.kind == CXCursor_ClassDecl ||
7553             cursor.kind == CXCursor_ClassTemplate ||
7554             cursor.kind == CXCursor_ClassTemplatePartialSpecialization) {
7555      if (const Decl *D = getCursorDecl(cursor))
7556        if (D->hasAttr<FinalAttr>())
7557          HasContextSensitiveKeywords = true;
7558    }
7559  }
7560
7561  // Don't override a property annotation with its getter/setter method.
7562  if (cursor.kind == CXCursor_ObjCInstanceMethodDecl &&
7563      parent.kind == CXCursor_ObjCPropertyDecl)
7564    return CXChildVisit_Continue;
7565
7566  if (clang_isPreprocessing(cursor.kind)) {
7567    // Items in the preprocessing record are kept separate from items in
7568    // declarations, so we keep a separate token index.
7569    unsigned SavedTokIdx = TokIdx;
7570    TokIdx = PreprocessingTokIdx;
7571
7572    // Skip tokens up until we catch up to the beginning of the preprocessing
7573    // entry.
7574    while (MoreTokens()) {
7575      const unsigned I = NextToken();
7576      SourceLocation TokLoc = GetTokenLoc(I);
7577      switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) {
7578      case RangeBefore:
7579        AdvanceToken();
7580        continue;
7581      case RangeAfter:
7582      case RangeOverlap:
7583        break;
7584      }
7585      break;
7586    }
7587
7588    // Look at all of the tokens within this range.
7589    while (MoreTokens()) {
7590      const unsigned I = NextToken();
7591      SourceLocation TokLoc = GetTokenLoc(I);
7592      switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) {
7593      case RangeBefore:
7594        llvm_unreachable("Infeasible");
7595      case RangeAfter:
7596        break;
7597      case RangeOverlap:
7598        // For macro expansions, just note where the beginning of the macro
7599        // expansion occurs.
7600        if (cursor.kind == CXCursor_MacroExpansion) {
7601          if (TokLoc == cursorRange.getBegin())
7602            Cursors[I] = cursor;
7603          AdvanceToken();
7604          break;
7605        }
7606        // We may have already annotated macro names inside macro definitions.
7607        if (Cursors[I].kind != CXCursor_MacroExpansion)
7608          Cursors[I] = cursor;
7609        AdvanceToken();
7610        continue;
7611      }
7612      break;
7613    }
7614
7615    // Save the preprocessing token index; restore the non-preprocessing
7616    // token index.
7617    PreprocessingTokIdx = TokIdx;
7618    TokIdx = SavedTokIdx;
7619    return CXChildVisit_Recurse;
7620  }
7621
7622  if (cursorRange.isInvalid())
7623    return CXChildVisit_Continue;
7624
7625  unsigned BeforeReachingCursorIdx = NextToken();
7626  const enum CXCursorKind cursorK = clang_getCursorKind(cursor);
7627  const enum CXCursorKind K = clang_getCursorKind(parent);
7628  const CXCursor updateC =
7629      (clang_isInvalid(K) || K == CXCursor_TranslationUnit ||
7630       // Attributes are annotated out-of-order, skip tokens until we reach it.
7631       clang_isAttribute(cursor.kind))
7632          ? clang_getNullCursor()
7633          : parent;
7634
7635  annotateAndAdvanceTokens(updateC, RangeBefore, cursorRange);
7636
7637  // Avoid having the cursor of an expression "overwrite" the annotation of the
7638  // variable declaration that it belongs to.
7639  // This can happen for C++ constructor expressions whose range generally
7640  // include the variable declaration, e.g.:
7641  //  MyCXXClass foo; // Make sure we don't annotate 'foo' as a CallExpr cursor.
7642  if (clang_isExpression(cursorK) && MoreTokens()) {
7643    const Expr *E = getCursorExpr(cursor);
7644    if (const Decl *D = getCursorDecl(cursor)) {
7645      const unsigned I = NextToken();
7646      if (E->getBeginLoc().isValid() && D->getLocation().isValid() &&
7647          E->getBeginLoc() == D->getLocation() &&
7648          E->getBeginLoc() == GetTokenLoc(I)) {
7649        updateCursorAnnotation(Cursors[I], updateC);
7650        AdvanceToken();
7651      }
7652    }
7653  }
7654
7655  // Before recursing into the children keep some state that we are going
7656  // to use in the AnnotateTokensWorker::postVisitChildren callback to do some
7657  // extra work after the child nodes are visited.
7658  // Note that we don't call VisitChildren here to avoid traversing statements
7659  // code-recursively which can blow the stack.
7660
7661  PostChildrenInfo Info;
7662  Info.Cursor = cursor;
7663  Info.CursorRange = cursorRange;
7664  Info.BeforeReachingCursorIdx = BeforeReachingCursorIdx;
7665  Info.BeforeChildrenTokenIdx = NextToken();
7666  Info.ChildActions = DetermineChildActions(cursor);
7667  PostChildrenInfos.push_back(Info);
7668
7669  return CXChildVisit_Recurse;
7670}
7671
7672bool AnnotateTokensWorker::postVisitChildren(CXCursor cursor) {
7673  if (PostChildrenInfos.empty())
7674    return false;
7675  const PostChildrenInfo &Info = PostChildrenInfos.back();
7676  if (!clang_equalCursors(Info.Cursor, cursor))
7677    return false;
7678
7679  HandlePostPonedChildCursors(Info);
7680
7681  const unsigned BeforeChildren = Info.BeforeChildrenTokenIdx;
7682  const unsigned AfterChildren = NextToken();
7683  SourceRange cursorRange = Info.CursorRange;
7684
7685  // Scan the tokens that are at the end of the cursor, but are not captured
7686  // but the child cursors.
7687  annotateAndAdvanceTokens(cursor, RangeOverlap, cursorRange);
7688
7689  // Scan the tokens that are at the beginning of the cursor, but are not
7690  // capture by the child cursors.
7691  for (unsigned I = BeforeChildren; I != AfterChildren; ++I) {
7692    if (!clang_isInvalid(clang_getCursorKind(Cursors[I])))
7693      break;
7694
7695    Cursors[I] = cursor;
7696  }
7697
7698  // Attributes are annotated out-of-order, rewind TokIdx to when we first
7699  // encountered the attribute cursor.
7700  if (clang_isAttribute(cursor.kind))
7701    TokIdx = Info.BeforeReachingCursorIdx;
7702
7703  PostChildrenInfos.pop_back();
7704  return false;
7705}
7706
7707void AnnotateTokensWorker::HandlePostPonedChildCursors(
7708    const PostChildrenInfo &Info) {
7709  for (const auto &ChildAction : Info.ChildActions) {
7710    if (ChildAction.action == PostChildrenAction::Postpone) {
7711      HandlePostPonedChildCursor(ChildAction.cursor,
7712                                 Info.BeforeChildrenTokenIdx);
7713    }
7714  }
7715}
7716
7717void AnnotateTokensWorker::HandlePostPonedChildCursor(
7718    CXCursor Cursor, unsigned StartTokenIndex) {
7719  unsigned I = StartTokenIndex;
7720
7721  // The bracket tokens of a Call or Subscript operator are mapped to
7722  // CallExpr/CXXOperatorCallExpr because we skipped visiting the corresponding
7723  // DeclRefExpr. Remap these tokens to the DeclRefExpr cursors.
7724  for (unsigned RefNameRangeNr = 0; I < NumTokens; RefNameRangeNr++) {
7725    const CXSourceRange CXRefNameRange = clang_getCursorReferenceNameRange(
7726        Cursor, CXNameRange_WantQualifier, RefNameRangeNr);
7727    if (clang_Range_isNull(CXRefNameRange))
7728      break; // All ranges handled.
7729
7730    SourceRange RefNameRange = cxloc::translateCXSourceRange(CXRefNameRange);
7731    while (I < NumTokens) {
7732      const SourceLocation TokenLocation = GetTokenLoc(I);
7733      if (!TokenLocation.isValid())
7734        break;
7735
7736      // Adapt the end range, because LocationCompare() reports
7737      // RangeOverlap even for the not-inclusive end location.
7738      const SourceLocation fixedEnd =
7739          RefNameRange.getEnd().getLocWithOffset(-1);
7740      RefNameRange = SourceRange(RefNameRange.getBegin(), fixedEnd);
7741
7742      const RangeComparisonResult ComparisonResult =
7743          LocationCompare(SrcMgr, TokenLocation, RefNameRange);
7744
7745      if (ComparisonResult == RangeOverlap) {
7746        Cursors[I++] = Cursor;
7747      } else if (ComparisonResult == RangeBefore) {
7748        ++I; // Not relevant token, check next one.
7749      } else if (ComparisonResult == RangeAfter) {
7750        break; // All tokens updated for current range, check next.
7751      }
7752    }
7753  }
7754}
7755
7756static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor,
7757                                                     CXCursor parent,
7758                                                     CXClientData client_data) {
7759  return static_cast<AnnotateTokensWorker *>(client_data)
7760      ->Visit(cursor, parent);
7761}
7762
7763static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor,
7764                                              CXClientData client_data) {
7765  return static_cast<AnnotateTokensWorker *>(client_data)
7766      ->postVisitChildren(cursor);
7767}
7768
7769namespace {
7770
7771/// Uses the macro expansions in the preprocessing record to find
7772/// and mark tokens that are macro arguments. This info is used by the
7773/// AnnotateTokensWorker.
7774class MarkMacroArgTokensVisitor {
7775  SourceManager &SM;
7776  CXToken *Tokens;
7777  unsigned NumTokens;
7778  unsigned CurIdx;
7779
7780public:
7781  MarkMacroArgTokensVisitor(SourceManager &SM, CXToken *tokens,
7782                            unsigned numTokens)
7783      : SM(SM), Tokens(tokens), NumTokens(numTokens), CurIdx(0) {}
7784
7785  CXChildVisitResult visit(CXCursor cursor, CXCursor parent) {
7786    if (cursor.kind != CXCursor_MacroExpansion)
7787      return CXChildVisit_Continue;
7788
7789    SourceRange macroRange = getCursorMacroExpansion(cursor).getSourceRange();
7790    if (macroRange.getBegin() == macroRange.getEnd())
7791      return CXChildVisit_Continue; // it's not a function macro.
7792
7793    for (; CurIdx < NumTokens; ++CurIdx) {
7794      if (!SM.isBeforeInTranslationUnit(getTokenLoc(CurIdx),
7795                                        macroRange.getBegin()))
7796        break;
7797    }
7798
7799    if (CurIdx == NumTokens)
7800      return CXChildVisit_Break;
7801
7802    for (; CurIdx < NumTokens; ++CurIdx) {
7803      SourceLocation tokLoc = getTokenLoc(CurIdx);
7804      if (!SM.isBeforeInTranslationUnit(tokLoc, macroRange.getEnd()))
7805        break;
7806
7807      setFunctionMacroTokenLoc(CurIdx, SM.getMacroArgExpandedLocation(tokLoc));
7808    }
7809
7810    if (CurIdx == NumTokens)
7811      return CXChildVisit_Break;
7812
7813    return CXChildVisit_Continue;
7814  }
7815
7816private:
7817  CXToken &getTok(unsigned Idx) {
7818    assert(Idx < NumTokens);
7819    return Tokens[Idx];
7820  }
7821  const CXToken &getTok(unsigned Idx) const {
7822    assert(Idx < NumTokens);
7823    return Tokens[Idx];
7824  }
7825
7826  SourceLocation getTokenLoc(unsigned tokI) {
7827    return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[1]);
7828  }
7829
7830  void setFunctionMacroTokenLoc(unsigned tokI, SourceLocation loc) {
7831    // The third field is reserved and currently not used. Use it here
7832    // to mark macro arg expanded tokens with their expanded locations.
7833    getTok(tokI).int_data[3] = loc.getRawEncoding();
7834  }
7835};
7836
7837} // end anonymous namespace
7838
7839static CXChildVisitResult
7840MarkMacroArgTokensVisitorDelegate(CXCursor cursor, CXCursor parent,
7841                                  CXClientData client_data) {
7842  return static_cast<MarkMacroArgTokensVisitor *>(client_data)
7843      ->visit(cursor, parent);
7844}
7845
7846/// Used by \c annotatePreprocessorTokens.
7847/// \returns true if lexing was finished, false otherwise.
7848static bool lexNext(Lexer &Lex, Token &Tok, unsigned &NextIdx,
7849                    unsigned NumTokens) {
7850  if (NextIdx >= NumTokens)
7851    return true;
7852
7853  ++NextIdx;
7854  Lex.LexFromRawLexer(Tok);
7855  return Tok.is(tok::eof);
7856}
7857
7858static void annotatePreprocessorTokens(CXTranslationUnit TU,
7859                                       SourceRange RegionOfInterest,
7860                                       CXCursor *Cursors, CXToken *Tokens,
7861                                       unsigned NumTokens) {
7862  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
7863
7864  Preprocessor &PP = CXXUnit->getPreprocessor();
7865  SourceManager &SourceMgr = CXXUnit->getSourceManager();
7866  std::pair<FileID, unsigned> BeginLocInfo =
7867      SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getBegin());
7868  std::pair<FileID, unsigned> EndLocInfo =
7869      SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getEnd());
7870
7871  if (BeginLocInfo.first != EndLocInfo.first)
7872    return;
7873
7874  StringRef Buffer;
7875  bool Invalid = false;
7876  Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid);
7877  if (Buffer.empty() || Invalid)
7878    return;
7879
7880  Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
7881            CXXUnit->getASTContext().getLangOpts(), Buffer.begin(),
7882            Buffer.data() + BeginLocInfo.second, Buffer.end());
7883  Lex.SetCommentRetentionState(true);
7884
7885  unsigned NextIdx = 0;
7886  // Lex tokens in raw mode until we hit the end of the range, to avoid
7887  // entering #includes or expanding macros.
7888  while (true) {
7889    Token Tok;
7890    if (lexNext(Lex, Tok, NextIdx, NumTokens))
7891      break;
7892    unsigned TokIdx = NextIdx - 1;
7893    assert(Tok.getLocation() ==
7894           SourceLocation::getFromRawEncoding(Tokens[TokIdx].int_data[1]));
7895
7896  reprocess:
7897    if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) {
7898      // We have found a preprocessing directive. Annotate the tokens
7899      // appropriately.
7900      //
7901      // FIXME: Some simple tests here could identify macro definitions and
7902      // #undefs, to provide specific cursor kinds for those.
7903
7904      SourceLocation BeginLoc = Tok.getLocation();
7905      if (lexNext(Lex, Tok, NextIdx, NumTokens))
7906        break;
7907
7908      MacroInfo *MI = nullptr;
7909      if (Tok.is(tok::raw_identifier) && Tok.getRawIdentifier() == "define") {
7910        if (lexNext(Lex, Tok, NextIdx, NumTokens))
7911          break;
7912
7913        if (Tok.is(tok::raw_identifier)) {
7914          IdentifierInfo &II =
7915              PP.getIdentifierTable().get(Tok.getRawIdentifier());
7916          SourceLocation MappedTokLoc =
7917              CXXUnit->mapLocationToPreamble(Tok.getLocation());
7918          MI = getMacroInfo(II, MappedTokLoc, TU);
7919        }
7920      }
7921
7922      bool finished = false;
7923      do {
7924        if (lexNext(Lex, Tok, NextIdx, NumTokens)) {
7925          finished = true;
7926          break;
7927        }
7928        // If we are in a macro definition, check if the token was ever a
7929        // macro name and annotate it if that's the case.
7930        if (MI) {
7931          SourceLocation SaveLoc = Tok.getLocation();
7932          Tok.setLocation(CXXUnit->mapLocationToPreamble(SaveLoc));
7933          MacroDefinitionRecord *MacroDef =
7934              checkForMacroInMacroDefinition(MI, Tok, TU);
7935          Tok.setLocation(SaveLoc);
7936          if (MacroDef)
7937            Cursors[NextIdx - 1] =
7938                MakeMacroExpansionCursor(MacroDef, Tok.getLocation(), TU);
7939        }
7940      } while (!Tok.isAtStartOfLine());
7941
7942      unsigned LastIdx = finished ? NextIdx - 1 : NextIdx - 2;
7943      assert(TokIdx <= LastIdx);
7944      SourceLocation EndLoc =
7945          SourceLocation::getFromRawEncoding(Tokens[LastIdx].int_data[1]);
7946      CXCursor Cursor =
7947          MakePreprocessingDirectiveCursor(SourceRange(BeginLoc, EndLoc), TU);
7948
7949      for (; TokIdx <= LastIdx; ++TokIdx)
7950        updateCursorAnnotation(Cursors[TokIdx], Cursor);
7951
7952      if (finished)
7953        break;
7954      goto reprocess;
7955    }
7956  }
7957}
7958
7959// This gets run a separate thread to avoid stack blowout.
7960static void clang_annotateTokensImpl(CXTranslationUnit TU, ASTUnit *CXXUnit,
7961                                     CXToken *Tokens, unsigned NumTokens,
7962                                     CXCursor *Cursors) {
7963  CIndexer *CXXIdx = TU->CIdx;
7964  if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
7965    setThreadBackgroundPriority();
7966
7967  // Determine the region of interest, which contains all of the tokens.
7968  SourceRange RegionOfInterest;
7969  RegionOfInterest.setBegin(
7970      cxloc::translateSourceLocation(clang_getTokenLocation(TU, Tokens[0])));
7971  RegionOfInterest.setEnd(cxloc::translateSourceLocation(
7972      clang_getTokenLocation(TU, Tokens[NumTokens - 1])));
7973
7974  // Relex the tokens within the source range to look for preprocessing
7975  // directives.
7976  annotatePreprocessorTokens(TU, RegionOfInterest, Cursors, Tokens, NumTokens);
7977
7978  // If begin location points inside a macro argument, set it to the expansion
7979  // location so we can have the full context when annotating semantically.
7980  {
7981    SourceManager &SM = CXXUnit->getSourceManager();
7982    SourceLocation Loc =
7983        SM.getMacroArgExpandedLocation(RegionOfInterest.getBegin());
7984    if (Loc.isMacroID())
7985      RegionOfInterest.setBegin(SM.getExpansionLoc(Loc));
7986  }
7987
7988  if (CXXUnit->getPreprocessor().getPreprocessingRecord()) {
7989    // Search and mark tokens that are macro argument expansions.
7990    MarkMacroArgTokensVisitor Visitor(CXXUnit->getSourceManager(), Tokens,
7991                                      NumTokens);
7992    CursorVisitor MacroArgMarker(
7993        TU, MarkMacroArgTokensVisitorDelegate, &Visitor,
7994        /*VisitPreprocessorLast=*/true,
7995        /*VisitIncludedEntities=*/false, RegionOfInterest);
7996    MacroArgMarker.visitPreprocessedEntitiesInRegion();
7997  }
7998
7999  // Annotate all of the source locations in the region of interest that map to
8000  // a specific cursor.
8001  AnnotateTokensWorker W(Tokens, Cursors, NumTokens, TU, RegionOfInterest);
8002
8003  // FIXME: We use a ridiculous stack size here because the data-recursion
8004  // algorithm uses a large stack frame than the non-data recursive version,
8005  // and AnnotationTokensWorker currently transforms the data-recursion
8006  // algorithm back into a traditional recursion by explicitly calling
8007  // VisitChildren().  We will need to remove this explicit recursive call.
8008  W.AnnotateTokens();
8009
8010  // If we ran into any entities that involve context-sensitive keywords,
8011  // take another pass through the tokens to mark them as such.
8012  if (W.hasContextSensitiveKeywords()) {
8013    for (unsigned I = 0; I != NumTokens; ++I) {
8014      if (clang_getTokenKind(Tokens[I]) != CXToken_Identifier)
8015        continue;
8016
8017      if (Cursors[I].kind == CXCursor_ObjCPropertyDecl) {
8018        IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data);
8019        if (const ObjCPropertyDecl *Property =
8020                dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(Cursors[I]))) {
8021          if (Property->getPropertyAttributesAsWritten() != 0 &&
8022              llvm::StringSwitch<bool>(II->getName())
8023                  .Case("readonly", true)
8024                  .Case("assign", true)
8025                  .Case("unsafe_unretained", true)
8026                  .Case("readwrite", true)
8027                  .Case("retain", true)
8028                  .Case("copy", true)
8029                  .Case("nonatomic", true)
8030                  .Case("atomic", true)
8031                  .Case("getter", true)
8032                  .Case("setter", true)
8033                  .Case("strong", true)
8034                  .Case("weak", true)
8035                  .Case("class", true)
8036                  .Default(false))
8037            Tokens[I].int_data[0] = CXToken_Keyword;
8038        }
8039        continue;
8040      }
8041
8042      if (Cursors[I].kind == CXCursor_ObjCInstanceMethodDecl ||
8043          Cursors[I].kind == CXCursor_ObjCClassMethodDecl) {
8044        IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data);
8045        if (llvm::StringSwitch<bool>(II->getName())
8046                .Case("in", true)
8047                .Case("out", true)
8048                .Case("inout", true)
8049                .Case("oneway", true)
8050                .Case("bycopy", true)
8051                .Case("byref", true)
8052                .Default(false))
8053          Tokens[I].int_data[0] = CXToken_Keyword;
8054        continue;
8055      }
8056
8057      if (Cursors[I].kind == CXCursor_CXXFinalAttr ||
8058          Cursors[I].kind == CXCursor_CXXOverrideAttr) {
8059        Tokens[I].int_data[0] = CXToken_Keyword;
8060        continue;
8061      }
8062    }
8063  }
8064}
8065
8066void clang_annotateTokens(CXTranslationUnit TU, CXToken *Tokens,
8067                          unsigned NumTokens, CXCursor *Cursors) {
8068  if (isNotUsableTU(TU)) {
8069    LOG_BAD_TU(TU);
8070    return;
8071  }
8072  if (NumTokens == 0 || !Tokens || !Cursors) {
8073    LOG_FUNC_SECTION { *Log << "<null input>"; }
8074    return;
8075  }
8076
8077  LOG_FUNC_SECTION {
8078    *Log << TU << ' ';
8079    CXSourceLocation bloc = clang_getTokenLocation(TU, Tokens[0]);
8080    CXSourceLocation eloc = clang_getTokenLocation(TU, Tokens[NumTokens - 1]);
8081    *Log << clang_getRange(bloc, eloc);
8082  }
8083
8084  // Any token we don't specifically annotate will have a NULL cursor.
8085  CXCursor C = clang_getNullCursor();
8086  for (unsigned I = 0; I != NumTokens; ++I)
8087    Cursors[I] = C;
8088
8089  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
8090  if (!CXXUnit)
8091    return;
8092
8093  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
8094
8095  auto AnnotateTokensImpl = [=]() {
8096    clang_annotateTokensImpl(TU, CXXUnit, Tokens, NumTokens, Cursors);
8097  };
8098  llvm::CrashRecoveryContext CRC;
8099  if (!RunSafely(CRC, AnnotateTokensImpl, GetSafetyThreadStackSize() * 2)) {
8100    fprintf(stderr, "libclang: crash detected while annotating tokens\n");
8101  }
8102}
8103
8104//===----------------------------------------------------------------------===//
8105// Operations for querying linkage of a cursor.
8106//===----------------------------------------------------------------------===//
8107
8108CXLinkageKind clang_getCursorLinkage(CXCursor cursor) {
8109  if (!clang_isDeclaration(cursor.kind))
8110    return CXLinkage_Invalid;
8111
8112  const Decl *D = cxcursor::getCursorDecl(cursor);
8113  if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D))
8114    switch (ND->getLinkageInternal()) {
8115    case NoLinkage:
8116    case VisibleNoLinkage:
8117      return CXLinkage_NoLinkage;
8118    case ModuleInternalLinkage:
8119    case InternalLinkage:
8120      return CXLinkage_Internal;
8121    case UniqueExternalLinkage:
8122      return CXLinkage_UniqueExternal;
8123    case ModuleLinkage:
8124    case ExternalLinkage:
8125      return CXLinkage_External;
8126    };
8127
8128  return CXLinkage_Invalid;
8129}
8130
8131//===----------------------------------------------------------------------===//
8132// Operations for querying visibility of a cursor.
8133//===----------------------------------------------------------------------===//
8134
8135CXVisibilityKind clang_getCursorVisibility(CXCursor cursor) {
8136  if (!clang_isDeclaration(cursor.kind))
8137    return CXVisibility_Invalid;
8138
8139  const Decl *D = cxcursor::getCursorDecl(cursor);
8140  if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D))
8141    switch (ND->getVisibility()) {
8142    case HiddenVisibility:
8143      return CXVisibility_Hidden;
8144    case ProtectedVisibility:
8145      return CXVisibility_Protected;
8146    case DefaultVisibility:
8147      return CXVisibility_Default;
8148    };
8149
8150  return CXVisibility_Invalid;
8151}
8152
8153//===----------------------------------------------------------------------===//
8154// Operations for querying language of a cursor.
8155//===----------------------------------------------------------------------===//
8156
8157static CXLanguageKind getDeclLanguage(const Decl *D) {
8158  if (!D)
8159    return CXLanguage_C;
8160
8161  switch (D->getKind()) {
8162  default:
8163    break;
8164  case Decl::ImplicitParam:
8165  case Decl::ObjCAtDefsField:
8166  case Decl::ObjCCategory:
8167  case Decl::ObjCCategoryImpl:
8168  case Decl::ObjCCompatibleAlias:
8169  case Decl::ObjCImplementation:
8170  case Decl::ObjCInterface:
8171  case Decl::ObjCIvar:
8172  case Decl::ObjCMethod:
8173  case Decl::ObjCProperty:
8174  case Decl::ObjCPropertyImpl:
8175  case Decl::ObjCProtocol:
8176  case Decl::ObjCTypeParam:
8177    return CXLanguage_ObjC;
8178  case Decl::CXXConstructor:
8179  case Decl::CXXConversion:
8180  case Decl::CXXDestructor:
8181  case Decl::CXXMethod:
8182  case Decl::CXXRecord:
8183  case Decl::ClassTemplate:
8184  case Decl::ClassTemplatePartialSpecialization:
8185  case Decl::ClassTemplateSpecialization:
8186  case Decl::Friend:
8187  case Decl::FriendTemplate:
8188  case Decl::FunctionTemplate:
8189  case Decl::LinkageSpec:
8190  case Decl::Namespace:
8191  case Decl::NamespaceAlias:
8192  case Decl::NonTypeTemplateParm:
8193  case Decl::StaticAssert:
8194  case Decl::TemplateTemplateParm:
8195  case Decl::TemplateTypeParm:
8196  case Decl::UnresolvedUsingTypename:
8197  case Decl::UnresolvedUsingValue:
8198  case Decl::Using:
8199  case Decl::UsingDirective:
8200  case Decl::UsingShadow:
8201    return CXLanguage_CPlusPlus;
8202  }
8203
8204  return CXLanguage_C;
8205}
8206
8207static CXAvailabilityKind getCursorAvailabilityForDecl(const Decl *D) {
8208  if (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isDeleted())
8209    return CXAvailability_NotAvailable;
8210
8211  switch (D->getAvailability()) {
8212  case AR_Available:
8213  case AR_NotYetIntroduced:
8214    if (const EnumConstantDecl *EnumConst = dyn_cast<EnumConstantDecl>(D))
8215      return getCursorAvailabilityForDecl(
8216          cast<Decl>(EnumConst->getDeclContext()));
8217    return CXAvailability_Available;
8218
8219  case AR_Deprecated:
8220    return CXAvailability_Deprecated;
8221
8222  case AR_Unavailable:
8223    return CXAvailability_NotAvailable;
8224  }
8225
8226  llvm_unreachable("Unknown availability kind!");
8227}
8228
8229enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor) {
8230  if (clang_isDeclaration(cursor.kind))
8231    if (const Decl *D = cxcursor::getCursorDecl(cursor))
8232      return getCursorAvailabilityForDecl(D);
8233
8234  return CXAvailability_Available;
8235}
8236
8237static CXVersion convertVersion(VersionTuple In) {
8238  CXVersion Out = {-1, -1, -1};
8239  if (In.empty())
8240    return Out;
8241
8242  Out.Major = In.getMajor();
8243
8244  std::optional<unsigned> Minor = In.getMinor();
8245  if (Minor)
8246    Out.Minor = *Minor;
8247  else
8248    return Out;
8249
8250  std::optional<unsigned> Subminor = In.getSubminor();
8251  if (Subminor)
8252    Out.Subminor = *Subminor;
8253
8254  return Out;
8255}
8256
8257static void getCursorPlatformAvailabilityForDecl(
8258    const Decl *D, int *always_deprecated, CXString *deprecated_message,
8259    int *always_unavailable, CXString *unavailable_message,
8260    SmallVectorImpl<AvailabilityAttr *> &AvailabilityAttrs) {
8261  bool HadAvailAttr = false;
8262  for (auto A : D->attrs()) {
8263    if (DeprecatedAttr *Deprecated = dyn_cast<DeprecatedAttr>(A)) {
8264      HadAvailAttr = true;
8265      if (always_deprecated)
8266        *always_deprecated = 1;
8267      if (deprecated_message) {
8268        clang_disposeString(*deprecated_message);
8269        *deprecated_message = cxstring::createDup(Deprecated->getMessage());
8270      }
8271      continue;
8272    }
8273
8274    if (UnavailableAttr *Unavailable = dyn_cast<UnavailableAttr>(A)) {
8275      HadAvailAttr = true;
8276      if (always_unavailable)
8277        *always_unavailable = 1;
8278      if (unavailable_message) {
8279        clang_disposeString(*unavailable_message);
8280        *unavailable_message = cxstring::createDup(Unavailable->getMessage());
8281      }
8282      continue;
8283    }
8284
8285    if (AvailabilityAttr *Avail = dyn_cast<AvailabilityAttr>(A)) {
8286      AvailabilityAttrs.push_back(Avail);
8287      HadAvailAttr = true;
8288    }
8289  }
8290
8291  if (!HadAvailAttr)
8292    if (const EnumConstantDecl *EnumConst = dyn_cast<EnumConstantDecl>(D))
8293      return getCursorPlatformAvailabilityForDecl(
8294          cast<Decl>(EnumConst->getDeclContext()), always_deprecated,
8295          deprecated_message, always_unavailable, unavailable_message,
8296          AvailabilityAttrs);
8297
8298  // If no availability attributes are found, inherit the attribute from the
8299  // containing decl or the class or category interface decl.
8300  if (AvailabilityAttrs.empty()) {
8301    const ObjCContainerDecl *CD = nullptr;
8302    const DeclContext *DC = D->getDeclContext();
8303
8304    if (auto *IMD = dyn_cast<ObjCImplementationDecl>(D))
8305      CD = IMD->getClassInterface();
8306    else if (auto *CatD = dyn_cast<ObjCCategoryDecl>(D))
8307      CD = CatD->getClassInterface();
8308    else if (auto *IMD = dyn_cast<ObjCCategoryImplDecl>(D))
8309      CD = IMD->getCategoryDecl();
8310    else if (auto *ID = dyn_cast<ObjCInterfaceDecl>(DC))
8311      CD = ID;
8312    else if (auto *CatD = dyn_cast<ObjCCategoryDecl>(DC))
8313      CD = CatD;
8314    else if (auto *IMD = dyn_cast<ObjCImplementationDecl>(DC))
8315      CD = IMD->getClassInterface();
8316    else if (auto *IMD = dyn_cast<ObjCCategoryImplDecl>(DC))
8317      CD = IMD->getCategoryDecl();
8318    else if (auto *PD = dyn_cast<ObjCProtocolDecl>(DC))
8319      CD = PD;
8320
8321    if (CD)
8322      getCursorPlatformAvailabilityForDecl(
8323          CD, always_deprecated, deprecated_message, always_unavailable,
8324          unavailable_message, AvailabilityAttrs);
8325    return;
8326  }
8327
8328  llvm::sort(
8329      AvailabilityAttrs, [](AvailabilityAttr *LHS, AvailabilityAttr *RHS) {
8330        return LHS->getPlatform()->getName() < RHS->getPlatform()->getName();
8331      });
8332  ASTContext &Ctx = D->getASTContext();
8333  auto It = std::unique(
8334      AvailabilityAttrs.begin(), AvailabilityAttrs.end(),
8335      [&Ctx](AvailabilityAttr *LHS, AvailabilityAttr *RHS) {
8336        if (LHS->getPlatform() != RHS->getPlatform())
8337          return false;
8338
8339        if (LHS->getIntroduced() == RHS->getIntroduced() &&
8340            LHS->getDeprecated() == RHS->getDeprecated() &&
8341            LHS->getObsoleted() == RHS->getObsoleted() &&
8342            LHS->getMessage() == RHS->getMessage() &&
8343            LHS->getReplacement() == RHS->getReplacement())
8344          return true;
8345
8346        if ((!LHS->getIntroduced().empty() && !RHS->getIntroduced().empty()) ||
8347            (!LHS->getDeprecated().empty() && !RHS->getDeprecated().empty()) ||
8348            (!LHS->getObsoleted().empty() && !RHS->getObsoleted().empty()))
8349          return false;
8350
8351        if (LHS->getIntroduced().empty() && !RHS->getIntroduced().empty())
8352          LHS->setIntroduced(Ctx, RHS->getIntroduced());
8353
8354        if (LHS->getDeprecated().empty() && !RHS->getDeprecated().empty()) {
8355          LHS->setDeprecated(Ctx, RHS->getDeprecated());
8356          if (LHS->getMessage().empty())
8357            LHS->setMessage(Ctx, RHS->getMessage());
8358          if (LHS->getReplacement().empty())
8359            LHS->setReplacement(Ctx, RHS->getReplacement());
8360        }
8361
8362        if (LHS->getObsoleted().empty() && !RHS->getObsoleted().empty()) {
8363          LHS->setObsoleted(Ctx, RHS->getObsoleted());
8364          if (LHS->getMessage().empty())
8365            LHS->setMessage(Ctx, RHS->getMessage());
8366          if (LHS->getReplacement().empty())
8367            LHS->setReplacement(Ctx, RHS->getReplacement());
8368        }
8369
8370        return true;
8371      });
8372  AvailabilityAttrs.erase(It, AvailabilityAttrs.end());
8373}
8374
8375int clang_getCursorPlatformAvailability(CXCursor cursor, int *always_deprecated,
8376                                        CXString *deprecated_message,
8377                                        int *always_unavailable,
8378                                        CXString *unavailable_message,
8379                                        CXPlatformAvailability *availability,
8380                                        int availability_size) {
8381  if (always_deprecated)
8382    *always_deprecated = 0;
8383  if (deprecated_message)
8384    *deprecated_message = cxstring::createEmpty();
8385  if (always_unavailable)
8386    *always_unavailable = 0;
8387  if (unavailable_message)
8388    *unavailable_message = cxstring::createEmpty();
8389
8390  if (!clang_isDeclaration(cursor.kind))
8391    return 0;
8392
8393  const Decl *D = cxcursor::getCursorDecl(cursor);
8394  if (!D)
8395    return 0;
8396
8397  SmallVector<AvailabilityAttr *, 8> AvailabilityAttrs;
8398  getCursorPlatformAvailabilityForDecl(D, always_deprecated, deprecated_message,
8399                                       always_unavailable, unavailable_message,
8400                                       AvailabilityAttrs);
8401  for (const auto &Avail : llvm::enumerate(
8402           llvm::ArrayRef(AvailabilityAttrs).take_front(availability_size))) {
8403    availability[Avail.index()].Platform =
8404        cxstring::createDup(Avail.value()->getPlatform()->getName());
8405    availability[Avail.index()].Introduced =
8406        convertVersion(Avail.value()->getIntroduced());
8407    availability[Avail.index()].Deprecated =
8408        convertVersion(Avail.value()->getDeprecated());
8409    availability[Avail.index()].Obsoleted =
8410        convertVersion(Avail.value()->getObsoleted());
8411    availability[Avail.index()].Unavailable = Avail.value()->getUnavailable();
8412    availability[Avail.index()].Message =
8413        cxstring::createDup(Avail.value()->getMessage());
8414  }
8415
8416  return AvailabilityAttrs.size();
8417}
8418
8419void clang_disposeCXPlatformAvailability(CXPlatformAvailability *availability) {
8420  clang_disposeString(availability->Platform);
8421  clang_disposeString(availability->Message);
8422}
8423
8424CXLanguageKind clang_getCursorLanguage(CXCursor cursor) {
8425  if (clang_isDeclaration(cursor.kind))
8426    return getDeclLanguage(cxcursor::getCursorDecl(cursor));
8427
8428  return CXLanguage_Invalid;
8429}
8430
8431CXTLSKind clang_getCursorTLSKind(CXCursor cursor) {
8432  const Decl *D = cxcursor::getCursorDecl(cursor);
8433  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
8434    switch (VD->getTLSKind()) {
8435    case VarDecl::TLS_None:
8436      return CXTLS_None;
8437    case VarDecl::TLS_Dynamic:
8438      return CXTLS_Dynamic;
8439    case VarDecl::TLS_Static:
8440      return CXTLS_Static;
8441    }
8442  }
8443
8444  return CXTLS_None;
8445}
8446
8447/// If the given cursor is the "templated" declaration
8448/// describing a class or function template, return the class or
8449/// function template.
8450static const Decl *maybeGetTemplateCursor(const Decl *D) {
8451  if (!D)
8452    return nullptr;
8453
8454  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
8455    if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate())
8456      return FunTmpl;
8457
8458  if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
8459    if (ClassTemplateDecl *ClassTmpl = RD->getDescribedClassTemplate())
8460      return ClassTmpl;
8461
8462  return D;
8463}
8464
8465enum CX_StorageClass clang_Cursor_getStorageClass(CXCursor C) {
8466  StorageClass sc = SC_None;
8467  const Decl *D = getCursorDecl(C);
8468  if (D) {
8469    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
8470      sc = FD->getStorageClass();
8471    } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
8472      sc = VD->getStorageClass();
8473    } else {
8474      return CX_SC_Invalid;
8475    }
8476  } else {
8477    return CX_SC_Invalid;
8478  }
8479  switch (sc) {
8480  case SC_None:
8481    return CX_SC_None;
8482  case SC_Extern:
8483    return CX_SC_Extern;
8484  case SC_Static:
8485    return CX_SC_Static;
8486  case SC_PrivateExtern:
8487    return CX_SC_PrivateExtern;
8488  case SC_Auto:
8489    return CX_SC_Auto;
8490  case SC_Register:
8491    return CX_SC_Register;
8492  }
8493  llvm_unreachable("Unhandled storage class!");
8494}
8495
8496CXCursor clang_getCursorSemanticParent(CXCursor cursor) {
8497  if (clang_isDeclaration(cursor.kind)) {
8498    if (const Decl *D = getCursorDecl(cursor)) {
8499      const DeclContext *DC = D->getDeclContext();
8500      if (!DC)
8501        return clang_getNullCursor();
8502
8503      return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)),
8504                          getCursorTU(cursor));
8505    }
8506  }
8507
8508  if (clang_isStatement(cursor.kind) || clang_isExpression(cursor.kind)) {
8509    if (const Decl *D = getCursorDecl(cursor))
8510      return MakeCXCursor(D, getCursorTU(cursor));
8511  }
8512
8513  return clang_getNullCursor();
8514}
8515
8516CXCursor clang_getCursorLexicalParent(CXCursor cursor) {
8517  if (clang_isDeclaration(cursor.kind)) {
8518    if (const Decl *D = getCursorDecl(cursor)) {
8519      const DeclContext *DC = D->getLexicalDeclContext();
8520      if (!DC)
8521        return clang_getNullCursor();
8522
8523      return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)),
8524                          getCursorTU(cursor));
8525    }
8526  }
8527
8528  // FIXME: Note that we can't easily compute the lexical context of a
8529  // statement or expression, so we return nothing.
8530  return clang_getNullCursor();
8531}
8532
8533CXFile clang_getIncludedFile(CXCursor cursor) {
8534  if (cursor.kind != CXCursor_InclusionDirective)
8535    return nullptr;
8536
8537  const InclusionDirective *ID = getCursorInclusionDirective(cursor);
8538  OptionalFileEntryRef File = ID->getFile();
8539  return const_cast<FileEntry *>(File ? &File->getFileEntry() : nullptr);
8540}
8541
8542unsigned clang_Cursor_getObjCPropertyAttributes(CXCursor C, unsigned reserved) {
8543  if (C.kind != CXCursor_ObjCPropertyDecl)
8544    return CXObjCPropertyAttr_noattr;
8545
8546  unsigned Result = CXObjCPropertyAttr_noattr;
8547  const auto *PD = cast<ObjCPropertyDecl>(getCursorDecl(C));
8548  ObjCPropertyAttribute::Kind Attr = PD->getPropertyAttributesAsWritten();
8549
8550#define SET_CXOBJCPROP_ATTR(A)                                                 \
8551  if (Attr & ObjCPropertyAttribute::kind_##A)                                  \
8552  Result |= CXObjCPropertyAttr_##A
8553  SET_CXOBJCPROP_ATTR(readonly);
8554  SET_CXOBJCPROP_ATTR(getter);
8555  SET_CXOBJCPROP_ATTR(assign);
8556  SET_CXOBJCPROP_ATTR(readwrite);
8557  SET_CXOBJCPROP_ATTR(retain);
8558  SET_CXOBJCPROP_ATTR(copy);
8559  SET_CXOBJCPROP_ATTR(nonatomic);
8560  SET_CXOBJCPROP_ATTR(setter);
8561  SET_CXOBJCPROP_ATTR(atomic);
8562  SET_CXOBJCPROP_ATTR(weak);
8563  SET_CXOBJCPROP_ATTR(strong);
8564  SET_CXOBJCPROP_ATTR(unsafe_unretained);
8565  SET_CXOBJCPROP_ATTR(class);
8566#undef SET_CXOBJCPROP_ATTR
8567
8568  return Result;
8569}
8570
8571CXString clang_Cursor_getObjCPropertyGetterName(CXCursor C) {
8572  if (C.kind != CXCursor_ObjCPropertyDecl)
8573    return cxstring::createNull();
8574
8575  const auto *PD = cast<ObjCPropertyDecl>(getCursorDecl(C));
8576  Selector sel = PD->getGetterName();
8577  if (sel.isNull())
8578    return cxstring::createNull();
8579
8580  return cxstring::createDup(sel.getAsString());
8581}
8582
8583CXString clang_Cursor_getObjCPropertySetterName(CXCursor C) {
8584  if (C.kind != CXCursor_ObjCPropertyDecl)
8585    return cxstring::createNull();
8586
8587  const auto *PD = cast<ObjCPropertyDecl>(getCursorDecl(C));
8588  Selector sel = PD->getSetterName();
8589  if (sel.isNull())
8590    return cxstring::createNull();
8591
8592  return cxstring::createDup(sel.getAsString());
8593}
8594
8595unsigned clang_Cursor_getObjCDeclQualifiers(CXCursor C) {
8596  if (!clang_isDeclaration(C.kind))
8597    return CXObjCDeclQualifier_None;
8598
8599  Decl::ObjCDeclQualifier QT = Decl::OBJC_TQ_None;
8600  const Decl *D = getCursorDecl(C);
8601  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
8602    QT = MD->getObjCDeclQualifier();
8603  else if (const ParmVarDecl *PD = dyn_cast<ParmVarDecl>(D))
8604    QT = PD->getObjCDeclQualifier();
8605  if (QT == Decl::OBJC_TQ_None)
8606    return CXObjCDeclQualifier_None;
8607
8608  unsigned Result = CXObjCDeclQualifier_None;
8609  if (QT & Decl::OBJC_TQ_In)
8610    Result |= CXObjCDeclQualifier_In;
8611  if (QT & Decl::OBJC_TQ_Inout)
8612    Result |= CXObjCDeclQualifier_Inout;
8613  if (QT & Decl::OBJC_TQ_Out)
8614    Result |= CXObjCDeclQualifier_Out;
8615  if (QT & Decl::OBJC_TQ_Bycopy)
8616    Result |= CXObjCDeclQualifier_Bycopy;
8617  if (QT & Decl::OBJC_TQ_Byref)
8618    Result |= CXObjCDeclQualifier_Byref;
8619  if (QT & Decl::OBJC_TQ_Oneway)
8620    Result |= CXObjCDeclQualifier_Oneway;
8621
8622  return Result;
8623}
8624
8625unsigned clang_Cursor_isObjCOptional(CXCursor C) {
8626  if (!clang_isDeclaration(C.kind))
8627    return 0;
8628
8629  const Decl *D = getCursorDecl(C);
8630  if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
8631    return PD->getPropertyImplementation() == ObjCPropertyDecl::Optional;
8632  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
8633    return MD->getImplementationControl() == ObjCMethodDecl::Optional;
8634
8635  return 0;
8636}
8637
8638unsigned clang_Cursor_isVariadic(CXCursor C) {
8639  if (!clang_isDeclaration(C.kind))
8640    return 0;
8641
8642  const Decl *D = getCursorDecl(C);
8643  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
8644    return FD->isVariadic();
8645  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
8646    return MD->isVariadic();
8647
8648  return 0;
8649}
8650
8651unsigned clang_Cursor_isExternalSymbol(CXCursor C, CXString *language,
8652                                       CXString *definedIn,
8653                                       unsigned *isGenerated) {
8654  if (!clang_isDeclaration(C.kind))
8655    return 0;
8656
8657  const Decl *D = getCursorDecl(C);
8658
8659  if (auto *attr = D->getExternalSourceSymbolAttr()) {
8660    if (language)
8661      *language = cxstring::createDup(attr->getLanguage());
8662    if (definedIn)
8663      *definedIn = cxstring::createDup(attr->getDefinedIn());
8664    if (isGenerated)
8665      *isGenerated = attr->getGeneratedDeclaration();
8666    return 1;
8667  }
8668  return 0;
8669}
8670
8671CXSourceRange clang_Cursor_getCommentRange(CXCursor C) {
8672  if (!clang_isDeclaration(C.kind))
8673    return clang_getNullRange();
8674
8675  const Decl *D = getCursorDecl(C);
8676  ASTContext &Context = getCursorContext(C);
8677  const RawComment *RC = Context.getRawCommentForAnyRedecl(D);
8678  if (!RC)
8679    return clang_getNullRange();
8680
8681  return cxloc::translateSourceRange(Context, RC->getSourceRange());
8682}
8683
8684CXString clang_Cursor_getRawCommentText(CXCursor C) {
8685  if (!clang_isDeclaration(C.kind))
8686    return cxstring::createNull();
8687
8688  const Decl *D = getCursorDecl(C);
8689  ASTContext &Context = getCursorContext(C);
8690  const RawComment *RC = Context.getRawCommentForAnyRedecl(D);
8691  StringRef RawText =
8692      RC ? RC->getRawText(Context.getSourceManager()) : StringRef();
8693
8694  // Don't duplicate the string because RawText points directly into source
8695  // code.
8696  return cxstring::createRef(RawText);
8697}
8698
8699CXString clang_Cursor_getBriefCommentText(CXCursor C) {
8700  if (!clang_isDeclaration(C.kind))
8701    return cxstring::createNull();
8702
8703  const Decl *D = getCursorDecl(C);
8704  const ASTContext &Context = getCursorContext(C);
8705  const RawComment *RC = Context.getRawCommentForAnyRedecl(D);
8706
8707  if (RC) {
8708    StringRef BriefText = RC->getBriefText(Context);
8709
8710    // Don't duplicate the string because RawComment ensures that this memory
8711    // will not go away.
8712    return cxstring::createRef(BriefText);
8713  }
8714
8715  return cxstring::createNull();
8716}
8717
8718CXModule clang_Cursor_getModule(CXCursor C) {
8719  if (C.kind == CXCursor_ModuleImportDecl) {
8720    if (const ImportDecl *ImportD =
8721            dyn_cast_or_null<ImportDecl>(getCursorDecl(C)))
8722      return ImportD->getImportedModule();
8723  }
8724
8725  return nullptr;
8726}
8727
8728CXModule clang_getModuleForFile(CXTranslationUnit TU, CXFile File) {
8729  if (isNotUsableTU(TU)) {
8730    LOG_BAD_TU(TU);
8731    return nullptr;
8732  }
8733  if (!File)
8734    return nullptr;
8735  FileEntry *FE = static_cast<FileEntry *>(File);
8736
8737  ASTUnit &Unit = *cxtu::getASTUnit(TU);
8738  HeaderSearch &HS = Unit.getPreprocessor().getHeaderSearchInfo();
8739  ModuleMap::KnownHeader Header = HS.findModuleForHeader(FE);
8740
8741  return Header.getModule();
8742}
8743
8744CXFile clang_Module_getASTFile(CXModule CXMod) {
8745  if (!CXMod)
8746    return nullptr;
8747  Module *Mod = static_cast<Module *>(CXMod);
8748  if (auto File = Mod->getASTFile())
8749    return const_cast<FileEntry *>(&File->getFileEntry());
8750  return nullptr;
8751}
8752
8753CXModule clang_Module_getParent(CXModule CXMod) {
8754  if (!CXMod)
8755    return nullptr;
8756  Module *Mod = static_cast<Module *>(CXMod);
8757  return Mod->Parent;
8758}
8759
8760CXString clang_Module_getName(CXModule CXMod) {
8761  if (!CXMod)
8762    return cxstring::createEmpty();
8763  Module *Mod = static_cast<Module *>(CXMod);
8764  return cxstring::createDup(Mod->Name);
8765}
8766
8767CXString clang_Module_getFullName(CXModule CXMod) {
8768  if (!CXMod)
8769    return cxstring::createEmpty();
8770  Module *Mod = static_cast<Module *>(CXMod);
8771  return cxstring::createDup(Mod->getFullModuleName());
8772}
8773
8774int clang_Module_isSystem(CXModule CXMod) {
8775  if (!CXMod)
8776    return 0;
8777  Module *Mod = static_cast<Module *>(CXMod);
8778  return Mod->IsSystem;
8779}
8780
8781unsigned clang_Module_getNumTopLevelHeaders(CXTranslationUnit TU,
8782                                            CXModule CXMod) {
8783  if (isNotUsableTU(TU)) {
8784    LOG_BAD_TU(TU);
8785    return 0;
8786  }
8787  if (!CXMod)
8788    return 0;
8789  Module *Mod = static_cast<Module *>(CXMod);
8790  FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager();
8791  ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr);
8792  return TopHeaders.size();
8793}
8794
8795CXFile clang_Module_getTopLevelHeader(CXTranslationUnit TU, CXModule CXMod,
8796                                      unsigned Index) {
8797  if (isNotUsableTU(TU)) {
8798    LOG_BAD_TU(TU);
8799    return nullptr;
8800  }
8801  if (!CXMod)
8802    return nullptr;
8803  Module *Mod = static_cast<Module *>(CXMod);
8804  FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager();
8805
8806  ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr);
8807  if (Index < TopHeaders.size())
8808    return const_cast<FileEntry *>(TopHeaders[Index]);
8809
8810  return nullptr;
8811}
8812
8813//===----------------------------------------------------------------------===//
8814// C++ AST instrospection.
8815//===----------------------------------------------------------------------===//
8816
8817unsigned clang_CXXConstructor_isDefaultConstructor(CXCursor C) {
8818  if (!clang_isDeclaration(C.kind))
8819    return 0;
8820
8821  const Decl *D = cxcursor::getCursorDecl(C);
8822  const CXXConstructorDecl *Constructor =
8823      D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
8824  return (Constructor && Constructor->isDefaultConstructor()) ? 1 : 0;
8825}
8826
8827unsigned clang_CXXConstructor_isCopyConstructor(CXCursor C) {
8828  if (!clang_isDeclaration(C.kind))
8829    return 0;
8830
8831  const Decl *D = cxcursor::getCursorDecl(C);
8832  const CXXConstructorDecl *Constructor =
8833      D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
8834  return (Constructor && Constructor->isCopyConstructor()) ? 1 : 0;
8835}
8836
8837unsigned clang_CXXConstructor_isMoveConstructor(CXCursor C) {
8838  if (!clang_isDeclaration(C.kind))
8839    return 0;
8840
8841  const Decl *D = cxcursor::getCursorDecl(C);
8842  const CXXConstructorDecl *Constructor =
8843      D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
8844  return (Constructor && Constructor->isMoveConstructor()) ? 1 : 0;
8845}
8846
8847unsigned clang_CXXConstructor_isConvertingConstructor(CXCursor C) {
8848  if (!clang_isDeclaration(C.kind))
8849    return 0;
8850
8851  const Decl *D = cxcursor::getCursorDecl(C);
8852  const CXXConstructorDecl *Constructor =
8853      D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
8854  // Passing 'false' excludes constructors marked 'explicit'.
8855  return (Constructor && Constructor->isConvertingConstructor(false)) ? 1 : 0;
8856}
8857
8858unsigned clang_CXXField_isMutable(CXCursor C) {
8859  if (!clang_isDeclaration(C.kind))
8860    return 0;
8861
8862  if (const auto D = cxcursor::getCursorDecl(C))
8863    if (const auto FD = dyn_cast_or_null<FieldDecl>(D))
8864      return FD->isMutable() ? 1 : 0;
8865  return 0;
8866}
8867
8868unsigned clang_CXXMethod_isPureVirtual(CXCursor C) {
8869  if (!clang_isDeclaration(C.kind))
8870    return 0;
8871
8872  const Decl *D = cxcursor::getCursorDecl(C);
8873  const CXXMethodDecl *Method =
8874      D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
8875  return (Method && Method->isVirtual() && Method->isPure()) ? 1 : 0;
8876}
8877
8878unsigned clang_CXXMethod_isConst(CXCursor C) {
8879  if (!clang_isDeclaration(C.kind))
8880    return 0;
8881
8882  const Decl *D = cxcursor::getCursorDecl(C);
8883  const CXXMethodDecl *Method =
8884      D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
8885  return (Method && Method->getMethodQualifiers().hasConst()) ? 1 : 0;
8886}
8887
8888unsigned clang_CXXMethod_isDefaulted(CXCursor C) {
8889  if (!clang_isDeclaration(C.kind))
8890    return 0;
8891
8892  const Decl *D = cxcursor::getCursorDecl(C);
8893  const CXXMethodDecl *Method =
8894      D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
8895  return (Method && Method->isDefaulted()) ? 1 : 0;
8896}
8897
8898unsigned clang_CXXMethod_isDeleted(CXCursor C) {
8899  if (!clang_isDeclaration(C.kind))
8900    return 0;
8901
8902  const Decl *D = cxcursor::getCursorDecl(C);
8903  const CXXMethodDecl *Method =
8904      D ? dyn_cast_if_present<CXXMethodDecl>(D->getAsFunction()) : nullptr;
8905  return (Method && Method->isDeleted()) ? 1 : 0;
8906}
8907
8908unsigned clang_CXXMethod_isStatic(CXCursor C) {
8909  if (!clang_isDeclaration(C.kind))
8910    return 0;
8911
8912  const Decl *D = cxcursor::getCursorDecl(C);
8913  const CXXMethodDecl *Method =
8914      D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
8915  return (Method && Method->isStatic()) ? 1 : 0;
8916}
8917
8918unsigned clang_CXXMethod_isVirtual(CXCursor C) {
8919  if (!clang_isDeclaration(C.kind))
8920    return 0;
8921
8922  const Decl *D = cxcursor::getCursorDecl(C);
8923  const CXXMethodDecl *Method =
8924      D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
8925  return (Method && Method->isVirtual()) ? 1 : 0;
8926}
8927
8928unsigned clang_CXXMethod_isCopyAssignmentOperator(CXCursor C) {
8929  if (!clang_isDeclaration(C.kind))
8930    return 0;
8931
8932  const Decl *D = cxcursor::getCursorDecl(C);
8933  const CXXMethodDecl *Method =
8934      D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
8935
8936  return (Method && Method->isCopyAssignmentOperator()) ? 1 : 0;
8937}
8938
8939unsigned clang_CXXMethod_isMoveAssignmentOperator(CXCursor C) {
8940  if (!clang_isDeclaration(C.kind))
8941    return 0;
8942
8943  const Decl *D = cxcursor::getCursorDecl(C);
8944  const CXXMethodDecl *Method =
8945      D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
8946
8947  return (Method && Method->isMoveAssignmentOperator()) ? 1 : 0;
8948}
8949
8950unsigned clang_CXXRecord_isAbstract(CXCursor C) {
8951  if (!clang_isDeclaration(C.kind))
8952    return 0;
8953
8954  const auto *D = cxcursor::getCursorDecl(C);
8955  const auto *RD = dyn_cast_or_null<CXXRecordDecl>(D);
8956  if (RD)
8957    RD = RD->getDefinition();
8958  return (RD && RD->isAbstract()) ? 1 : 0;
8959}
8960
8961unsigned clang_EnumDecl_isScoped(CXCursor C) {
8962  if (!clang_isDeclaration(C.kind))
8963    return 0;
8964
8965  const Decl *D = cxcursor::getCursorDecl(C);
8966  auto *Enum = dyn_cast_or_null<EnumDecl>(D);
8967  return (Enum && Enum->isScoped()) ? 1 : 0;
8968}
8969
8970//===----------------------------------------------------------------------===//
8971// Attribute introspection.
8972//===----------------------------------------------------------------------===//
8973
8974CXType clang_getIBOutletCollectionType(CXCursor C) {
8975  if (C.kind != CXCursor_IBOutletCollectionAttr)
8976    return cxtype::MakeCXType(QualType(), cxcursor::getCursorTU(C));
8977
8978  const IBOutletCollectionAttr *A =
8979      cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(C));
8980
8981  return cxtype::MakeCXType(A->getInterface(), cxcursor::getCursorTU(C));
8982}
8983
8984//===----------------------------------------------------------------------===//
8985// Inspecting memory usage.
8986//===----------------------------------------------------------------------===//
8987
8988typedef std::vector<CXTUResourceUsageEntry> MemUsageEntries;
8989
8990static inline void createCXTUResourceUsageEntry(MemUsageEntries &entries,
8991                                                enum CXTUResourceUsageKind k,
8992                                                unsigned long amount) {
8993  CXTUResourceUsageEntry entry = {k, amount};
8994  entries.push_back(entry);
8995}
8996
8997const char *clang_getTUResourceUsageName(CXTUResourceUsageKind kind) {
8998  const char *str = "";
8999  switch (kind) {
9000  case CXTUResourceUsage_AST:
9001    str = "ASTContext: expressions, declarations, and types";
9002    break;
9003  case CXTUResourceUsage_Identifiers:
9004    str = "ASTContext: identifiers";
9005    break;
9006  case CXTUResourceUsage_Selectors:
9007    str = "ASTContext: selectors";
9008    break;
9009  case CXTUResourceUsage_GlobalCompletionResults:
9010    str = "Code completion: cached global results";
9011    break;
9012  case CXTUResourceUsage_SourceManagerContentCache:
9013    str = "SourceManager: content cache allocator";
9014    break;
9015  case CXTUResourceUsage_AST_SideTables:
9016    str = "ASTContext: side tables";
9017    break;
9018  case CXTUResourceUsage_SourceManager_Membuffer_Malloc:
9019    str = "SourceManager: malloc'ed memory buffers";
9020    break;
9021  case CXTUResourceUsage_SourceManager_Membuffer_MMap:
9022    str = "SourceManager: mmap'ed memory buffers";
9023    break;
9024  case CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc:
9025    str = "ExternalASTSource: malloc'ed memory buffers";
9026    break;
9027  case CXTUResourceUsage_ExternalASTSource_Membuffer_MMap:
9028    str = "ExternalASTSource: mmap'ed memory buffers";
9029    break;
9030  case CXTUResourceUsage_Preprocessor:
9031    str = "Preprocessor: malloc'ed memory";
9032    break;
9033  case CXTUResourceUsage_PreprocessingRecord:
9034    str = "Preprocessor: PreprocessingRecord";
9035    break;
9036  case CXTUResourceUsage_SourceManager_DataStructures:
9037    str = "SourceManager: data structures and tables";
9038    break;
9039  case CXTUResourceUsage_Preprocessor_HeaderSearch:
9040    str = "Preprocessor: header search tables";
9041    break;
9042  }
9043  return str;
9044}
9045
9046CXTUResourceUsage clang_getCXTUResourceUsage(CXTranslationUnit TU) {
9047  if (isNotUsableTU(TU)) {
9048    LOG_BAD_TU(TU);
9049    CXTUResourceUsage usage = {(void *)nullptr, 0, nullptr};
9050    return usage;
9051  }
9052
9053  ASTUnit *astUnit = cxtu::getASTUnit(TU);
9054  std::unique_ptr<MemUsageEntries> entries(new MemUsageEntries());
9055  ASTContext &astContext = astUnit->getASTContext();
9056
9057  // How much memory is used by AST nodes and types?
9058  createCXTUResourceUsageEntry(
9059      *entries, CXTUResourceUsage_AST,
9060      (unsigned long)astContext.getASTAllocatedMemory());
9061
9062  // How much memory is used by identifiers?
9063  createCXTUResourceUsageEntry(
9064      *entries, CXTUResourceUsage_Identifiers,
9065      (unsigned long)astContext.Idents.getAllocator().getTotalMemory());
9066
9067  // How much memory is used for selectors?
9068  createCXTUResourceUsageEntry(
9069      *entries, CXTUResourceUsage_Selectors,
9070      (unsigned long)astContext.Selectors.getTotalMemory());
9071
9072  // How much memory is used by ASTContext's side tables?
9073  createCXTUResourceUsageEntry(
9074      *entries, CXTUResourceUsage_AST_SideTables,
9075      (unsigned long)astContext.getSideTableAllocatedMemory());
9076
9077  // How much memory is used for caching global code completion results?
9078  unsigned long completionBytes = 0;
9079  if (GlobalCodeCompletionAllocator *completionAllocator =
9080          astUnit->getCachedCompletionAllocator().get()) {
9081    completionBytes = completionAllocator->getTotalMemory();
9082  }
9083  createCXTUResourceUsageEntry(
9084      *entries, CXTUResourceUsage_GlobalCompletionResults, completionBytes);
9085
9086  // How much memory is being used by SourceManager's content cache?
9087  createCXTUResourceUsageEntry(
9088      *entries, CXTUResourceUsage_SourceManagerContentCache,
9089      (unsigned long)astContext.getSourceManager().getContentCacheSize());
9090
9091  // How much memory is being used by the MemoryBuffer's in SourceManager?
9092  const SourceManager::MemoryBufferSizes &srcBufs =
9093      astUnit->getSourceManager().getMemoryBufferSizes();
9094
9095  createCXTUResourceUsageEntry(*entries,
9096                               CXTUResourceUsage_SourceManager_Membuffer_Malloc,
9097                               (unsigned long)srcBufs.malloc_bytes);
9098  createCXTUResourceUsageEntry(*entries,
9099                               CXTUResourceUsage_SourceManager_Membuffer_MMap,
9100                               (unsigned long)srcBufs.mmap_bytes);
9101  createCXTUResourceUsageEntry(
9102      *entries, CXTUResourceUsage_SourceManager_DataStructures,
9103      (unsigned long)astContext.getSourceManager().getDataStructureSizes());
9104
9105  // How much memory is being used by the ExternalASTSource?
9106  if (ExternalASTSource *esrc = astContext.getExternalSource()) {
9107    const ExternalASTSource::MemoryBufferSizes &sizes =
9108        esrc->getMemoryBufferSizes();
9109
9110    createCXTUResourceUsageEntry(
9111        *entries, CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc,
9112        (unsigned long)sizes.malloc_bytes);
9113    createCXTUResourceUsageEntry(
9114        *entries, CXTUResourceUsage_ExternalASTSource_Membuffer_MMap,
9115        (unsigned long)sizes.mmap_bytes);
9116  }
9117
9118  // How much memory is being used by the Preprocessor?
9119  Preprocessor &pp = astUnit->getPreprocessor();
9120  createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Preprocessor,
9121                               pp.getTotalMemory());
9122
9123  if (PreprocessingRecord *pRec = pp.getPreprocessingRecord()) {
9124    createCXTUResourceUsageEntry(*entries,
9125                                 CXTUResourceUsage_PreprocessingRecord,
9126                                 pRec->getTotalMemory());
9127  }
9128
9129  createCXTUResourceUsageEntry(*entries,
9130                               CXTUResourceUsage_Preprocessor_HeaderSearch,
9131                               pp.getHeaderSearchInfo().getTotalMemory());
9132
9133  CXTUResourceUsage usage = {(void *)entries.get(), (unsigned)entries->size(),
9134                             !entries->empty() ? &(*entries)[0] : nullptr};
9135  (void)entries.release();
9136  return usage;
9137}
9138
9139void clang_disposeCXTUResourceUsage(CXTUResourceUsage usage) {
9140  if (usage.data)
9141    delete (MemUsageEntries *)usage.data;
9142}
9143
9144CXSourceRangeList *clang_getSkippedRanges(CXTranslationUnit TU, CXFile file) {
9145  CXSourceRangeList *skipped = new CXSourceRangeList;
9146  skipped->count = 0;
9147  skipped->ranges = nullptr;
9148
9149  if (isNotUsableTU(TU)) {
9150    LOG_BAD_TU(TU);
9151    return skipped;
9152  }
9153
9154  if (!file)
9155    return skipped;
9156
9157  ASTUnit *astUnit = cxtu::getASTUnit(TU);
9158  PreprocessingRecord *ppRec =
9159      astUnit->getPreprocessor().getPreprocessingRecord();
9160  if (!ppRec)
9161    return skipped;
9162
9163  ASTContext &Ctx = astUnit->getASTContext();
9164  SourceManager &sm = Ctx.getSourceManager();
9165  FileEntry *fileEntry = static_cast<FileEntry *>(file);
9166  FileID wantedFileID = sm.translateFile(fileEntry);
9167  bool isMainFile = wantedFileID == sm.getMainFileID();
9168
9169  const std::vector<SourceRange> &SkippedRanges = ppRec->getSkippedRanges();
9170  std::vector<SourceRange> wantedRanges;
9171  for (std::vector<SourceRange>::const_iterator i = SkippedRanges.begin(),
9172                                                ei = SkippedRanges.end();
9173       i != ei; ++i) {
9174    if (sm.getFileID(i->getBegin()) == wantedFileID ||
9175        sm.getFileID(i->getEnd()) == wantedFileID)
9176      wantedRanges.push_back(*i);
9177    else if (isMainFile && (astUnit->isInPreambleFileID(i->getBegin()) ||
9178                            astUnit->isInPreambleFileID(i->getEnd())))
9179      wantedRanges.push_back(*i);
9180  }
9181
9182  skipped->count = wantedRanges.size();
9183  skipped->ranges = new CXSourceRange[skipped->count];
9184  for (unsigned i = 0, ei = skipped->count; i != ei; ++i)
9185    skipped->ranges[i] = cxloc::translateSourceRange(Ctx, wantedRanges[i]);
9186
9187  return skipped;
9188}
9189
9190CXSourceRangeList *clang_getAllSkippedRanges(CXTranslationUnit TU) {
9191  CXSourceRangeList *skipped = new CXSourceRangeList;
9192  skipped->count = 0;
9193  skipped->ranges = nullptr;
9194
9195  if (isNotUsableTU(TU)) {
9196    LOG_BAD_TU(TU);
9197    return skipped;
9198  }
9199
9200  ASTUnit *astUnit = cxtu::getASTUnit(TU);
9201  PreprocessingRecord *ppRec =
9202      astUnit->getPreprocessor().getPreprocessingRecord();
9203  if (!ppRec)
9204    return skipped;
9205
9206  ASTContext &Ctx = astUnit->getASTContext();
9207
9208  const std::vector<SourceRange> &SkippedRanges = ppRec->getSkippedRanges();
9209
9210  skipped->count = SkippedRanges.size();
9211  skipped->ranges = new CXSourceRange[skipped->count];
9212  for (unsigned i = 0, ei = skipped->count; i != ei; ++i)
9213    skipped->ranges[i] = cxloc::translateSourceRange(Ctx, SkippedRanges[i]);
9214
9215  return skipped;
9216}
9217
9218void clang_disposeSourceRangeList(CXSourceRangeList *ranges) {
9219  if (ranges) {
9220    delete[] ranges->ranges;
9221    delete ranges;
9222  }
9223}
9224
9225void clang::PrintLibclangResourceUsage(CXTranslationUnit TU) {
9226  CXTUResourceUsage Usage = clang_getCXTUResourceUsage(TU);
9227  for (unsigned I = 0; I != Usage.numEntries; ++I)
9228    fprintf(stderr, "  %s: %lu\n",
9229            clang_getTUResourceUsageName(Usage.entries[I].kind),
9230            Usage.entries[I].amount);
9231
9232  clang_disposeCXTUResourceUsage(Usage);
9233}
9234
9235CXCursor clang_Cursor_getVarDeclInitializer(CXCursor cursor) {
9236  const Decl *const D = getCursorDecl(cursor);
9237  if (!D)
9238    return clang_getNullCursor();
9239  const auto *const VD = dyn_cast<VarDecl>(D);
9240  if (!VD)
9241    return clang_getNullCursor();
9242  const Expr *const Init = VD->getInit();
9243  if (!Init)
9244    return clang_getNullCursor();
9245
9246  return cxcursor::MakeCXCursor(Init, VD, cxcursor::getCursorTU(cursor));
9247}
9248
9249int clang_Cursor_hasVarDeclGlobalStorage(CXCursor cursor) {
9250  const Decl *const D = getCursorDecl(cursor);
9251  if (!D)
9252    return -1;
9253  const auto *const VD = dyn_cast<VarDecl>(D);
9254  if (!VD)
9255    return -1;
9256
9257  return VD->hasGlobalStorage();
9258}
9259
9260int clang_Cursor_hasVarDeclExternalStorage(CXCursor cursor) {
9261  const Decl *const D = getCursorDecl(cursor);
9262  if (!D)
9263    return -1;
9264  const auto *const VD = dyn_cast<VarDecl>(D);
9265  if (!VD)
9266    return -1;
9267
9268  return VD->hasExternalStorage();
9269}
9270
9271//===----------------------------------------------------------------------===//
9272// Misc. utility functions.
9273//===----------------------------------------------------------------------===//
9274
9275/// Default to using our desired 8 MB stack size on "safety" threads.
9276static unsigned SafetyStackThreadSize = DesiredStackSize;
9277
9278namespace clang {
9279
9280bool RunSafely(llvm::CrashRecoveryContext &CRC, llvm::function_ref<void()> Fn,
9281               unsigned Size) {
9282  if (!Size)
9283    Size = GetSafetyThreadStackSize();
9284  if (Size && !getenv("LIBCLANG_NOTHREADS"))
9285    return CRC.RunSafelyOnThread(Fn, Size);
9286  return CRC.RunSafely(Fn);
9287}
9288
9289unsigned GetSafetyThreadStackSize() { return SafetyStackThreadSize; }
9290
9291void SetSafetyThreadStackSize(unsigned Value) { SafetyStackThreadSize = Value; }
9292
9293} // namespace clang
9294
9295void clang::setThreadBackgroundPriority() {
9296  if (getenv("LIBCLANG_BGPRIO_DISABLE"))
9297    return;
9298
9299#if LLVM_ENABLE_THREADS
9300  // The function name setThreadBackgroundPriority is for historical reasons;
9301  // Low is more appropriate.
9302  llvm::set_thread_priority(llvm::ThreadPriority::Low);
9303#endif
9304}
9305
9306void cxindex::printDiagsToStderr(ASTUnit *Unit) {
9307  if (!Unit)
9308    return;
9309
9310  for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(),
9311                                     DEnd = Unit->stored_diag_end();
9312       D != DEnd; ++D) {
9313    CXStoredDiagnostic Diag(*D, Unit->getLangOpts());
9314    CXString Msg =
9315        clang_formatDiagnostic(&Diag, clang_defaultDiagnosticDisplayOptions());
9316    fprintf(stderr, "%s\n", clang_getCString(Msg));
9317    clang_disposeString(Msg);
9318  }
9319#ifdef _WIN32
9320  // On Windows, force a flush, since there may be multiple copies of
9321  // stderr and stdout in the file system, all with different buffers
9322  // but writing to the same device.
9323  fflush(stderr);
9324#endif
9325}
9326
9327MacroInfo *cxindex::getMacroInfo(const IdentifierInfo &II,
9328                                 SourceLocation MacroDefLoc,
9329                                 CXTranslationUnit TU) {
9330  if (MacroDefLoc.isInvalid() || !TU)
9331    return nullptr;
9332  if (!II.hadMacroDefinition())
9333    return nullptr;
9334
9335  ASTUnit *Unit = cxtu::getASTUnit(TU);
9336  Preprocessor &PP = Unit->getPreprocessor();
9337  MacroDirective *MD = PP.getLocalMacroDirectiveHistory(&II);
9338  if (MD) {
9339    for (MacroDirective::DefInfo Def = MD->getDefinition(); Def;
9340         Def = Def.getPreviousDefinition()) {
9341      if (MacroDefLoc == Def.getMacroInfo()->getDefinitionLoc())
9342        return Def.getMacroInfo();
9343    }
9344  }
9345
9346  return nullptr;
9347}
9348
9349const MacroInfo *cxindex::getMacroInfo(const MacroDefinitionRecord *MacroDef,
9350                                       CXTranslationUnit TU) {
9351  if (!MacroDef || !TU)
9352    return nullptr;
9353  const IdentifierInfo *II = MacroDef->getName();
9354  if (!II)
9355    return nullptr;
9356
9357  return getMacroInfo(*II, MacroDef->getLocation(), TU);
9358}
9359
9360MacroDefinitionRecord *
9361cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI, const Token &Tok,
9362                                        CXTranslationUnit TU) {
9363  if (!MI || !TU)
9364    return nullptr;
9365  if (Tok.isNot(tok::raw_identifier))
9366    return nullptr;
9367
9368  if (MI->getNumTokens() == 0)
9369    return nullptr;
9370  SourceRange DefRange(MI->getReplacementToken(0).getLocation(),
9371                       MI->getDefinitionEndLoc());
9372  ASTUnit *Unit = cxtu::getASTUnit(TU);
9373
9374  // Check that the token is inside the definition and not its argument list.
9375  SourceManager &SM = Unit->getSourceManager();
9376  if (SM.isBeforeInTranslationUnit(Tok.getLocation(), DefRange.getBegin()))
9377    return nullptr;
9378  if (SM.isBeforeInTranslationUnit(DefRange.getEnd(), Tok.getLocation()))
9379    return nullptr;
9380
9381  Preprocessor &PP = Unit->getPreprocessor();
9382  PreprocessingRecord *PPRec = PP.getPreprocessingRecord();
9383  if (!PPRec)
9384    return nullptr;
9385
9386  IdentifierInfo &II = PP.getIdentifierTable().get(Tok.getRawIdentifier());
9387  if (!II.hadMacroDefinition())
9388    return nullptr;
9389
9390  // Check that the identifier is not one of the macro arguments.
9391  if (llvm::is_contained(MI->params(), &II))
9392    return nullptr;
9393
9394  MacroDirective *InnerMD = PP.getLocalMacroDirectiveHistory(&II);
9395  if (!InnerMD)
9396    return nullptr;
9397
9398  return PPRec->findMacroDefinition(InnerMD->getMacroInfo());
9399}
9400
9401MacroDefinitionRecord *
9402cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI, SourceLocation Loc,
9403                                        CXTranslationUnit TU) {
9404  if (Loc.isInvalid() || !MI || !TU)
9405    return nullptr;
9406
9407  if (MI->getNumTokens() == 0)
9408    return nullptr;
9409  ASTUnit *Unit = cxtu::getASTUnit(TU);
9410  Preprocessor &PP = Unit->getPreprocessor();
9411  if (!PP.getPreprocessingRecord())
9412    return nullptr;
9413  Loc = Unit->getSourceManager().getSpellingLoc(Loc);
9414  Token Tok;
9415  if (PP.getRawToken(Loc, Tok))
9416    return nullptr;
9417
9418  return checkForMacroInMacroDefinition(MI, Tok, TU);
9419}
9420
9421CXString clang_getClangVersion() {
9422  return cxstring::createDup(getClangFullVersion());
9423}
9424
9425Logger &cxindex::Logger::operator<<(CXTranslationUnit TU) {
9426  if (TU) {
9427    if (ASTUnit *Unit = cxtu::getASTUnit(TU)) {
9428      LogOS << '<' << Unit->getMainFileName() << '>';
9429      if (Unit->isMainFileAST())
9430        LogOS << " (" << Unit->getASTFileName() << ')';
9431      return *this;
9432    }
9433  } else {
9434    LogOS << "<NULL TU>";
9435  }
9436  return *this;
9437}
9438
9439Logger &cxindex::Logger::operator<<(const FileEntry *FE) {
9440  *this << FE->getName();
9441  return *this;
9442}
9443
9444Logger &cxindex::Logger::operator<<(CXCursor cursor) {
9445  CXString cursorName = clang_getCursorDisplayName(cursor);
9446  *this << cursorName << "@" << clang_getCursorLocation(cursor);
9447  clang_disposeString(cursorName);
9448  return *this;
9449}
9450
9451Logger &cxindex::Logger::operator<<(CXSourceLocation Loc) {
9452  CXFile File;
9453  unsigned Line, Column;
9454  clang_getFileLocation(Loc, &File, &Line, &Column, nullptr);
9455  CXString FileName = clang_getFileName(File);
9456  *this << llvm::format("(%s:%d:%d)", clang_getCString(FileName), Line, Column);
9457  clang_disposeString(FileName);
9458  return *this;
9459}
9460
9461Logger &cxindex::Logger::operator<<(CXSourceRange range) {
9462  CXSourceLocation BLoc = clang_getRangeStart(range);
9463  CXSourceLocation ELoc = clang_getRangeEnd(range);
9464
9465  CXFile BFile;
9466  unsigned BLine, BColumn;
9467  clang_getFileLocation(BLoc, &BFile, &BLine, &BColumn, nullptr);
9468
9469  CXFile EFile;
9470  unsigned ELine, EColumn;
9471  clang_getFileLocation(ELoc, &EFile, &ELine, &EColumn, nullptr);
9472
9473  CXString BFileName = clang_getFileName(BFile);
9474  if (BFile == EFile) {
9475    *this << llvm::format("[%s %d:%d-%d:%d]", clang_getCString(BFileName),
9476                          BLine, BColumn, ELine, EColumn);
9477  } else {
9478    CXString EFileName = clang_getFileName(EFile);
9479    *this << llvm::format("[%s:%d:%d - ", clang_getCString(BFileName), BLine,
9480                          BColumn)
9481          << llvm::format("%s:%d:%d]", clang_getCString(EFileName), ELine,
9482                          EColumn);
9483    clang_disposeString(EFileName);
9484  }
9485  clang_disposeString(BFileName);
9486  return *this;
9487}
9488
9489Logger &cxindex::Logger::operator<<(CXString Str) {
9490  *this << clang_getCString(Str);
9491  return *this;
9492}
9493
9494Logger &cxindex::Logger::operator<<(const llvm::format_object_base &Fmt) {
9495  LogOS << Fmt;
9496  return *this;
9497}
9498
9499static llvm::ManagedStatic<std::mutex> LoggingMutex;
9500
9501cxindex::Logger::~Logger() {
9502  std::lock_guard<std::mutex> L(*LoggingMutex);
9503
9504  static llvm::TimeRecord sBeginTR = llvm::TimeRecord::getCurrentTime();
9505
9506  raw_ostream &OS = llvm::errs();
9507  OS << "[libclang:" << Name << ':';
9508
9509#ifdef USE_DARWIN_THREADS
9510  // TODO: Portability.
9511  mach_port_t tid = pthread_mach_thread_np(pthread_self());
9512  OS << tid << ':';
9513#endif
9514
9515  llvm::TimeRecord TR = llvm::TimeRecord::getCurrentTime();
9516  OS << llvm::format("%7.4f] ", TR.getWallTime() - sBeginTR.getWallTime());
9517  OS << Msg << '\n';
9518
9519  if (Trace) {
9520    llvm::sys::PrintStackTrace(OS);
9521    OS << "--------------------------------------------------\n";
9522  }
9523}
9524