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