[TrailingObjects] Convert ASTTemplateKWAndArgsInfo and ASTTemplateArgumentListInfo.
[lldb.git] / clang / tools / libclang / CIndex.cpp
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/Mangle.h"
26 #include "clang/AST/StmtVisitor.h"
27 #include "clang/Basic/Diagnostic.h"
28 #include "clang/Basic/DiagnosticCategories.h"
29 #include "clang/Basic/DiagnosticIDs.h"
30 #include "clang/Basic/TargetInfo.h"
31 #include "clang/Basic/Version.h"
32 #include "clang/Frontend/ASTUnit.h"
33 #include "clang/Frontend/CompilerInstance.h"
34 #include "clang/Frontend/FrontendDiagnostic.h"
35 #include "clang/Index/CommentToXML.h"
36 #include "clang/Lex/HeaderSearch.h"
37 #include "clang/Lex/Lexer.h"
38 #include "clang/Lex/PreprocessingRecord.h"
39 #include "clang/Lex/Preprocessor.h"
40 #include "clang/Serialization/SerializationDiagnostic.h"
41 #include "llvm/ADT/Optional.h"
42 #include "llvm/ADT/STLExtras.h"
43 #include "llvm/ADT/StringSwitch.h"
44 #include "llvm/Config/llvm-config.h"
45 #include "llvm/IR/DataLayout.h"
46 #include "llvm/IR/Mangler.h"
47 #include "llvm/Support/Compiler.h"
48 #include "llvm/Support/CrashRecoveryContext.h"
49 #include "llvm/Support/Format.h"
50 #include "llvm/Support/ManagedStatic.h"
51 #include "llvm/Support/MemoryBuffer.h"
52 #include "llvm/Support/Mutex.h"
53 #include "llvm/Support/Program.h"
54 #include "llvm/Support/SaveAndRestore.h"
55 #include "llvm/Support/Signals.h"
56 #include "llvm/Support/TargetSelect.h"
57 #include "llvm/Support/Threading.h"
58 #include "llvm/Support/Timer.h"
59 #include "llvm/Support/raw_ostream.h"
60
61 #if LLVM_ENABLE_THREADS != 0 && defined(__APPLE__)
62 #define USE_DARWIN_THREADS
63 #endif
64
65 #ifdef USE_DARWIN_THREADS
66 #include <pthread.h>
67 #endif
68
69 using namespace clang;
70 using namespace clang::cxcursor;
71 using namespace clang::cxtu;
72 using namespace clang::cxindex;
73
74 CXTranslationUnit cxtu::MakeCXTranslationUnit(CIndexer *CIdx, ASTUnit *AU) {
75   if (!AU)
76     return nullptr;
77   assert(CIdx);
78   CXTranslationUnit D = new CXTranslationUnitImpl();
79   D->CIdx = CIdx;
80   D->TheASTUnit = AU;
81   D->StringPool = new cxstring::CXStringPool();
82   D->Diagnostics = nullptr;
83   D->OverridenCursorsPool = createOverridenCXCursorsPool();
84   D->CommentToXML = nullptr;
85   return D;
86 }
87
88 bool cxtu::isASTReadError(ASTUnit *AU) {
89   for (ASTUnit::stored_diag_iterator D = AU->stored_diag_begin(),
90                                      DEnd = AU->stored_diag_end();
91        D != DEnd; ++D) {
92     if (D->getLevel() >= DiagnosticsEngine::Error &&
93         DiagnosticIDs::getCategoryNumberForDiag(D->getID()) ==
94             diag::DiagCat_AST_Deserialization_Issue)
95       return true;
96   }
97   return false;
98 }
99
100 cxtu::CXTUOwner::~CXTUOwner() {
101   if (TU)
102     clang_disposeTranslationUnit(TU);
103 }
104
105 /// \brief Compare two source ranges to determine their relative position in
106 /// the translation unit.
107 static RangeComparisonResult RangeCompare(SourceManager &SM,
108                                           SourceRange R1,
109                                           SourceRange R2) {
110   assert(R1.isValid() && "First range is invalid?");
111   assert(R2.isValid() && "Second range is invalid?");
112   if (R1.getEnd() != R2.getBegin() &&
113       SM.isBeforeInTranslationUnit(R1.getEnd(), R2.getBegin()))
114     return RangeBefore;
115   if (R2.getEnd() != R1.getBegin() &&
116       SM.isBeforeInTranslationUnit(R2.getEnd(), R1.getBegin()))
117     return RangeAfter;
118   return RangeOverlap;
119 }
120
121 /// \brief Determine if a source location falls within, before, or after a
122 ///   a given source range.
123 static RangeComparisonResult LocationCompare(SourceManager &SM,
124                                              SourceLocation L, SourceRange R) {
125   assert(R.isValid() && "First range is invalid?");
126   assert(L.isValid() && "Second range is invalid?");
127   if (L == R.getBegin() || L == R.getEnd())
128     return RangeOverlap;
129   if (SM.isBeforeInTranslationUnit(L, R.getBegin()))
130     return RangeBefore;
131   if (SM.isBeforeInTranslationUnit(R.getEnd(), L))
132     return RangeAfter;
133   return RangeOverlap;
134 }
135
136 /// \brief Translate a Clang source range into a CIndex source range.
137 ///
138 /// Clang internally represents ranges where the end location points to the
139 /// start of the token at the end. However, for external clients it is more
140 /// useful to have a CXSourceRange be a proper half-open interval. This routine
141 /// does the appropriate translation.
142 CXSourceRange cxloc::translateSourceRange(const SourceManager &SM,
143                                           const LangOptions &LangOpts,
144                                           const CharSourceRange &R) {
145   // We want the last character in this location, so we will adjust the
146   // location accordingly.
147   SourceLocation EndLoc = R.getEnd();
148   if (EndLoc.isValid() && EndLoc.isMacroID() && !SM.isMacroArgExpansion(EndLoc))
149     EndLoc = SM.getExpansionRange(EndLoc).second;
150   if (R.isTokenRange() && EndLoc.isValid()) {
151     unsigned Length = Lexer::MeasureTokenLength(SM.getSpellingLoc(EndLoc),
152                                                 SM, LangOpts);
153     EndLoc = EndLoc.getLocWithOffset(Length);
154   }
155
156   CXSourceRange Result = {
157     { &SM, &LangOpts },
158     R.getBegin().getRawEncoding(),
159     EndLoc.getRawEncoding()
160   };
161   return Result;
162 }
163
164 //===----------------------------------------------------------------------===//
165 // Cursor visitor.
166 //===----------------------------------------------------------------------===//
167
168 static SourceRange getRawCursorExtent(CXCursor C);
169 static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr);
170
171
172 RangeComparisonResult CursorVisitor::CompareRegionOfInterest(SourceRange R) {
173   return RangeCompare(AU->getSourceManager(), R, RegionOfInterest);
174 }
175
176 /// \brief Visit the given cursor and, if requested by the visitor,
177 /// its children.
178 ///
179 /// \param Cursor the cursor to visit.
180 ///
181 /// \param CheckedRegionOfInterest if true, then the caller already checked
182 /// that this cursor is within the region of interest.
183 ///
184 /// \returns true if the visitation should be aborted, false if it
185 /// should continue.
186 bool CursorVisitor::Visit(CXCursor Cursor, bool CheckedRegionOfInterest) {
187   if (clang_isInvalid(Cursor.kind))
188     return false;
189
190   if (clang_isDeclaration(Cursor.kind)) {
191     const Decl *D = getCursorDecl(Cursor);
192     if (!D) {
193       assert(0 && "Invalid declaration cursor");
194       return true; // abort.
195     }
196     
197     // Ignore implicit declarations, unless it's an objc method because
198     // currently we should report implicit methods for properties when indexing.
199     if (D->isImplicit() && !isa<ObjCMethodDecl>(D))
200       return false;
201   }
202
203   // If we have a range of interest, and this cursor doesn't intersect with it,
204   // we're done.
205   if (RegionOfInterest.isValid() && !CheckedRegionOfInterest) {
206     SourceRange Range = getRawCursorExtent(Cursor);
207     if (Range.isInvalid() || CompareRegionOfInterest(Range))
208       return false;
209   }
210
211   switch (Visitor(Cursor, Parent, ClientData)) {
212   case CXChildVisit_Break:
213     return true;
214
215   case CXChildVisit_Continue:
216     return false;
217
218   case CXChildVisit_Recurse: {
219     bool ret = VisitChildren(Cursor);
220     if (PostChildrenVisitor)
221       if (PostChildrenVisitor(Cursor, ClientData))
222         return true;
223     return ret;
224   }
225   }
226
227   llvm_unreachable("Invalid CXChildVisitResult!");
228 }
229
230 static bool visitPreprocessedEntitiesInRange(SourceRange R,
231                                              PreprocessingRecord &PPRec,
232                                              CursorVisitor &Visitor) {
233   SourceManager &SM = Visitor.getASTUnit()->getSourceManager();
234   FileID FID;
235   
236   if (!Visitor.shouldVisitIncludedEntities()) {
237     // If the begin/end of the range lie in the same FileID, do the optimization
238     // where we skip preprocessed entities that do not come from the same FileID.
239     FID = SM.getFileID(SM.getFileLoc(R.getBegin()));
240     if (FID != SM.getFileID(SM.getFileLoc(R.getEnd())))
241       FID = FileID();
242   }
243
244   const auto &Entities = PPRec.getPreprocessedEntitiesInRange(R);
245   return Visitor.visitPreprocessedEntities(Entities.begin(), Entities.end(),
246                                            PPRec, FID);
247 }
248
249 bool CursorVisitor::visitFileRegion() {
250   if (RegionOfInterest.isInvalid())
251     return false;
252
253   ASTUnit *Unit = cxtu::getASTUnit(TU);
254   SourceManager &SM = Unit->getSourceManager();
255   
256   std::pair<FileID, unsigned>
257     Begin = SM.getDecomposedLoc(SM.getFileLoc(RegionOfInterest.getBegin())), 
258     End = SM.getDecomposedLoc(SM.getFileLoc(RegionOfInterest.getEnd())); 
259
260   if (End.first != Begin.first) {
261     // If the end does not reside in the same file, try to recover by
262     // picking the end of the file of begin location.
263     End.first = Begin.first;
264     End.second = SM.getFileIDSize(Begin.first);
265   }
266
267   assert(Begin.first == End.first);
268   if (Begin.second > End.second)
269     return false;
270   
271   FileID File = Begin.first;
272   unsigned Offset = Begin.second;
273   unsigned Length = End.second - Begin.second;
274
275   if (!VisitDeclsOnly && !VisitPreprocessorLast)
276     if (visitPreprocessedEntitiesInRegion())
277       return true; // visitation break.
278
279   if (visitDeclsFromFileRegion(File, Offset, Length))
280     return true; // visitation break.
281
282   if (!VisitDeclsOnly && VisitPreprocessorLast)
283     return visitPreprocessedEntitiesInRegion();
284
285   return false;
286 }
287
288 static bool isInLexicalContext(Decl *D, DeclContext *DC) {
289   if (!DC)
290     return false;
291
292   for (DeclContext *DeclDC = D->getLexicalDeclContext();
293          DeclDC; DeclDC = DeclDC->getLexicalParent()) {
294     if (DeclDC == DC)
295       return true;
296   }
297   return false;
298 }
299
300 bool CursorVisitor::visitDeclsFromFileRegion(FileID File,
301                                              unsigned Offset, unsigned Length) {
302   ASTUnit *Unit = cxtu::getASTUnit(TU);
303   SourceManager &SM = Unit->getSourceManager();
304   SourceRange Range = RegionOfInterest;
305
306   SmallVector<Decl *, 16> Decls;
307   Unit->findFileRegionDecls(File, Offset, Length, Decls);
308
309   // If we didn't find any file level decls for the file, try looking at the
310   // file that it was included from.
311   while (Decls.empty() || Decls.front()->isTopLevelDeclInObjCContainer()) {
312     bool Invalid = false;
313     const SrcMgr::SLocEntry &SLEntry = SM.getSLocEntry(File, &Invalid);
314     if (Invalid)
315       return false;
316
317     SourceLocation Outer;
318     if (SLEntry.isFile())
319       Outer = SLEntry.getFile().getIncludeLoc();
320     else
321       Outer = SLEntry.getExpansion().getExpansionLocStart();
322     if (Outer.isInvalid())
323       return false;
324
325     std::tie(File, Offset) = SM.getDecomposedExpansionLoc(Outer);
326     Length = 0;
327     Unit->findFileRegionDecls(File, Offset, Length, Decls);
328   }
329
330   assert(!Decls.empty());
331
332   bool VisitedAtLeastOnce = false;
333   DeclContext *CurDC = nullptr;
334   SmallVectorImpl<Decl *>::iterator DIt = Decls.begin();
335   for (SmallVectorImpl<Decl *>::iterator DE = Decls.end(); DIt != DE; ++DIt) {
336     Decl *D = *DIt;
337     if (D->getSourceRange().isInvalid())
338       continue;
339
340     if (isInLexicalContext(D, CurDC))
341       continue;
342
343     CurDC = dyn_cast<DeclContext>(D);
344
345     if (TagDecl *TD = dyn_cast<TagDecl>(D))
346       if (!TD->isFreeStanding())
347         continue;
348
349     RangeComparisonResult CompRes = RangeCompare(SM, D->getSourceRange(),Range);
350     if (CompRes == RangeBefore)
351       continue;
352     if (CompRes == RangeAfter)
353       break;
354
355     assert(CompRes == RangeOverlap);
356     VisitedAtLeastOnce = true;
357
358     if (isa<ObjCContainerDecl>(D)) {
359       FileDI_current = &DIt;
360       FileDE_current = DE;
361     } else {
362       FileDI_current = nullptr;
363     }
364
365     if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true))
366       return true; // visitation break.
367   }
368
369   if (VisitedAtLeastOnce)
370     return false;
371
372   // No Decls overlapped with the range. Move up the lexical context until there
373   // is a context that contains the range or we reach the translation unit
374   // level.
375   DeclContext *DC = DIt == Decls.begin() ? (*DIt)->getLexicalDeclContext()
376                                          : (*(DIt-1))->getLexicalDeclContext();
377
378   while (DC && !DC->isTranslationUnit()) {
379     Decl *D = cast<Decl>(DC);
380     SourceRange CurDeclRange = D->getSourceRange();
381     if (CurDeclRange.isInvalid())
382       break;
383
384     if (RangeCompare(SM, CurDeclRange, Range) == RangeOverlap) {
385       if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true))
386         return true; // visitation break.
387     }
388
389     DC = D->getLexicalDeclContext();
390   }
391
392   return false;
393 }
394
395 bool CursorVisitor::visitPreprocessedEntitiesInRegion() {
396   if (!AU->getPreprocessor().getPreprocessingRecord())
397     return false;
398
399   PreprocessingRecord &PPRec
400     = *AU->getPreprocessor().getPreprocessingRecord();
401   SourceManager &SM = AU->getSourceManager();
402   
403   if (RegionOfInterest.isValid()) {
404     SourceRange MappedRange = AU->mapRangeToPreamble(RegionOfInterest);
405     SourceLocation B = MappedRange.getBegin();
406     SourceLocation E = MappedRange.getEnd();
407
408     if (AU->isInPreambleFileID(B)) {
409       if (SM.isLoadedSourceLocation(E))
410         return visitPreprocessedEntitiesInRange(SourceRange(B, E),
411                                                  PPRec, *this);
412
413       // Beginning of range lies in the preamble but it also extends beyond
414       // it into the main file. Split the range into 2 parts, one covering
415       // the preamble and another covering the main file. This allows subsequent
416       // calls to visitPreprocessedEntitiesInRange to accept a source range that
417       // lies in the same FileID, allowing it to skip preprocessed entities that
418       // do not come from the same FileID.
419       bool breaked =
420         visitPreprocessedEntitiesInRange(
421                                    SourceRange(B, AU->getEndOfPreambleFileID()),
422                                           PPRec, *this);
423       if (breaked) return true;
424       return visitPreprocessedEntitiesInRange(
425                                     SourceRange(AU->getStartOfMainFileID(), E),
426                                         PPRec, *this);
427     }
428
429     return visitPreprocessedEntitiesInRange(SourceRange(B, E), PPRec, *this);
430   }
431
432   bool OnlyLocalDecls
433     = !AU->isMainFileAST() && AU->getOnlyLocalDecls(); 
434   
435   if (OnlyLocalDecls)
436     return visitPreprocessedEntities(PPRec.local_begin(), PPRec.local_end(),
437                                      PPRec);
438
439   return visitPreprocessedEntities(PPRec.begin(), PPRec.end(), PPRec);
440 }
441
442 template<typename InputIterator>
443 bool CursorVisitor::visitPreprocessedEntities(InputIterator First,
444                                               InputIterator Last,
445                                               PreprocessingRecord &PPRec,
446                                               FileID FID) {
447   for (; First != Last; ++First) {
448     if (!FID.isInvalid() && !PPRec.isEntityInFileID(First, FID))
449       continue;
450
451     PreprocessedEntity *PPE = *First;
452     if (!PPE)
453       continue;
454
455     if (MacroExpansion *ME = dyn_cast<MacroExpansion>(PPE)) {
456       if (Visit(MakeMacroExpansionCursor(ME, TU)))
457         return true;
458
459       continue;
460     }
461
462     if (MacroDefinitionRecord *MD = dyn_cast<MacroDefinitionRecord>(PPE)) {
463       if (Visit(MakeMacroDefinitionCursor(MD, TU)))
464         return true;
465
466       continue;
467     }
468     
469     if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) {
470       if (Visit(MakeInclusionDirectiveCursor(ID, TU)))
471         return true;
472       
473       continue;
474     }
475   }
476
477   return false;
478 }
479
480 /// \brief Visit the children of the given cursor.
481 /// 
482 /// \returns true if the visitation should be aborted, false if it
483 /// should continue.
484 bool CursorVisitor::VisitChildren(CXCursor Cursor) {
485   if (clang_isReference(Cursor.kind) && 
486       Cursor.kind != CXCursor_CXXBaseSpecifier) {
487     // By definition, references have no children.
488     return false;
489   }
490
491   // Set the Parent field to Cursor, then back to its old value once we're
492   // done.
493   SetParentRAII SetParent(Parent, StmtParent, Cursor);
494
495   if (clang_isDeclaration(Cursor.kind)) {
496     Decl *D = const_cast<Decl *>(getCursorDecl(Cursor));
497     if (!D)
498       return false;
499
500     return VisitAttributes(D) || Visit(D);
501   }
502
503   if (clang_isStatement(Cursor.kind)) {
504     if (const Stmt *S = getCursorStmt(Cursor))
505       return Visit(S);
506
507     return false;
508   }
509
510   if (clang_isExpression(Cursor.kind)) {
511     if (const Expr *E = getCursorExpr(Cursor))
512       return Visit(E);
513
514     return false;
515   }
516
517   if (clang_isTranslationUnit(Cursor.kind)) {
518     CXTranslationUnit TU = getCursorTU(Cursor);
519     ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
520     
521     int VisitOrder[2] = { VisitPreprocessorLast, !VisitPreprocessorLast };
522     for (unsigned I = 0; I != 2; ++I) {
523       if (VisitOrder[I]) {
524         if (!CXXUnit->isMainFileAST() && CXXUnit->getOnlyLocalDecls() &&
525             RegionOfInterest.isInvalid()) {
526           for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(),
527                                         TLEnd = CXXUnit->top_level_end();
528                TL != TLEnd; ++TL) {
529             if (Visit(MakeCXCursor(*TL, TU, RegionOfInterest), true))
530               return true;
531           }
532         } else if (VisitDeclContext(
533                                 CXXUnit->getASTContext().getTranslationUnitDecl()))
534           return true;
535         continue;
536       }
537
538       // Walk the preprocessing record.
539       if (CXXUnit->getPreprocessor().getPreprocessingRecord())
540         visitPreprocessedEntitiesInRegion();
541     }
542     
543     return false;
544   }
545
546   if (Cursor.kind == CXCursor_CXXBaseSpecifier) {
547     if (const CXXBaseSpecifier *Base = getCursorCXXBaseSpecifier(Cursor)) {
548       if (TypeSourceInfo *BaseTSInfo = Base->getTypeSourceInfo()) {
549         return Visit(BaseTSInfo->getTypeLoc());
550       }
551     }
552   }
553
554   if (Cursor.kind == CXCursor_IBOutletCollectionAttr) {
555     const IBOutletCollectionAttr *A =
556       cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(Cursor));
557     if (const ObjCObjectType *ObjT = A->getInterface()->getAs<ObjCObjectType>())
558       return Visit(cxcursor::MakeCursorObjCClassRef(
559           ObjT->getInterface(),
560           A->getInterfaceLoc()->getTypeLoc().getLocStart(), TU));
561   }
562
563   // If pointing inside a macro definition, check if the token is an identifier
564   // that was ever defined as a macro. In such a case, create a "pseudo" macro
565   // expansion cursor for that token.
566   SourceLocation BeginLoc = RegionOfInterest.getBegin();
567   if (Cursor.kind == CXCursor_MacroDefinition &&
568       BeginLoc == RegionOfInterest.getEnd()) {
569     SourceLocation Loc = AU->mapLocationToPreamble(BeginLoc);
570     const MacroInfo *MI =
571         getMacroInfo(cxcursor::getCursorMacroDefinition(Cursor), TU);
572     if (MacroDefinitionRecord *MacroDef =
573             checkForMacroInMacroDefinition(MI, Loc, TU))
574       return Visit(cxcursor::MakeMacroExpansionCursor(MacroDef, BeginLoc, TU));
575   }
576
577   // Nothing to visit at the moment.
578   return false;
579 }
580
581 bool CursorVisitor::VisitBlockDecl(BlockDecl *B) {
582   if (TypeSourceInfo *TSInfo = B->getSignatureAsWritten())
583     if (Visit(TSInfo->getTypeLoc()))
584         return true;
585
586   if (Stmt *Body = B->getBody())
587     return Visit(MakeCXCursor(Body, StmtParent, TU, RegionOfInterest));
588
589   return false;
590 }
591
592 Optional<bool> CursorVisitor::shouldVisitCursor(CXCursor Cursor) {
593   if (RegionOfInterest.isValid()) {
594     SourceRange Range = getFullCursorExtent(Cursor, AU->getSourceManager());
595     if (Range.isInvalid())
596       return None;
597     
598     switch (CompareRegionOfInterest(Range)) {
599     case RangeBefore:
600       // This declaration comes before the region of interest; skip it.
601       return None;
602
603     case RangeAfter:
604       // This declaration comes after the region of interest; we're done.
605       return false;
606
607     case RangeOverlap:
608       // This declaration overlaps the region of interest; visit it.
609       break;
610     }
611   }
612   return true;
613 }
614
615 bool CursorVisitor::VisitDeclContext(DeclContext *DC) {
616   DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end();
617
618   // FIXME: Eventually remove.  This part of a hack to support proper
619   // iteration over all Decls contained lexically within an ObjC container.
620   SaveAndRestore<DeclContext::decl_iterator*> DI_saved(DI_current, &I);
621   SaveAndRestore<DeclContext::decl_iterator> DE_saved(DE_current, E);
622
623   for ( ; I != E; ++I) {
624     Decl *D = *I;
625     if (D->getLexicalDeclContext() != DC)
626       continue;
627     CXCursor Cursor = MakeCXCursor(D, TU, RegionOfInterest);
628
629     // Ignore synthesized ivars here, otherwise if we have something like:
630     //   @synthesize prop = _prop;
631     // and '_prop' is not declared, we will encounter a '_prop' ivar before
632     // encountering the 'prop' synthesize declaration and we will think that
633     // we passed the region-of-interest.
634     if (ObjCIvarDecl *ivarD = dyn_cast<ObjCIvarDecl>(D)) {
635       if (ivarD->getSynthesize())
636         continue;
637     }
638
639     // FIXME: ObjCClassRef/ObjCProtocolRef for forward class/protocol
640     // declarations is a mismatch with the compiler semantics.
641     if (Cursor.kind == CXCursor_ObjCInterfaceDecl) {
642       ObjCInterfaceDecl *ID = cast<ObjCInterfaceDecl>(D);
643       if (!ID->isThisDeclarationADefinition())
644         Cursor = MakeCursorObjCClassRef(ID, ID->getLocation(), TU);
645
646     } else if (Cursor.kind == CXCursor_ObjCProtocolDecl) {
647       ObjCProtocolDecl *PD = cast<ObjCProtocolDecl>(D);
648       if (!PD->isThisDeclarationADefinition())
649         Cursor = MakeCursorObjCProtocolRef(PD, PD->getLocation(), TU);
650     }
651
652     const Optional<bool> &V = shouldVisitCursor(Cursor);
653     if (!V.hasValue())
654       continue;
655     if (!V.getValue())
656       return false;
657     if (Visit(Cursor, true))
658       return true;
659   }
660   return false;
661 }
662
663 bool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
664   llvm_unreachable("Translation units are visited directly by Visit()");
665 }
666
667 bool CursorVisitor::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
668     if (VisitTemplateParameters(D->getTemplateParameters()))
669         return true;
670
671     return Visit(MakeCXCursor(D->getTemplatedDecl(), TU, RegionOfInterest));
672 }
673
674 bool CursorVisitor::VisitTypeAliasDecl(TypeAliasDecl *D) {
675   if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo())
676     return Visit(TSInfo->getTypeLoc());
677
678   return false;
679 }
680
681 bool CursorVisitor::VisitTypedefDecl(TypedefDecl *D) {
682   if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo())
683     return Visit(TSInfo->getTypeLoc());
684
685   return false;
686 }
687
688 bool CursorVisitor::VisitTagDecl(TagDecl *D) {
689   return VisitDeclContext(D);
690 }
691
692 bool CursorVisitor::VisitClassTemplateSpecializationDecl(
693                                           ClassTemplateSpecializationDecl *D) {
694   bool ShouldVisitBody = false;
695   switch (D->getSpecializationKind()) {
696   case TSK_Undeclared:
697   case TSK_ImplicitInstantiation:
698     // Nothing to visit
699     return false;
700       
701   case TSK_ExplicitInstantiationDeclaration:
702   case TSK_ExplicitInstantiationDefinition:
703     break;
704       
705   case TSK_ExplicitSpecialization:
706     ShouldVisitBody = true;
707     break;
708   }
709   
710   // Visit the template arguments used in the specialization.
711   if (TypeSourceInfo *SpecType = D->getTypeAsWritten()) {
712     TypeLoc TL = SpecType->getTypeLoc();
713     if (TemplateSpecializationTypeLoc TSTLoc =
714             TL.getAs<TemplateSpecializationTypeLoc>()) {
715       for (unsigned I = 0, N = TSTLoc.getNumArgs(); I != N; ++I)
716         if (VisitTemplateArgumentLoc(TSTLoc.getArgLoc(I)))
717           return true;
718     }
719   }
720   
721   if (ShouldVisitBody && VisitCXXRecordDecl(D))
722     return true;
723   
724   return false;
725 }
726
727 bool CursorVisitor::VisitClassTemplatePartialSpecializationDecl(
728                                    ClassTemplatePartialSpecializationDecl *D) {
729   // FIXME: Visit the "outer" template parameter lists on the TagDecl
730   // before visiting these template parameters.
731   if (VisitTemplateParameters(D->getTemplateParameters()))
732     return true;
733
734   // Visit the partial specialization arguments.
735   const ASTTemplateArgumentListInfo *Info = D->getTemplateArgsAsWritten();
736   const TemplateArgumentLoc *TemplateArgs = Info->getTemplateArgs();
737   for (unsigned I = 0, N = Info->NumTemplateArgs; I != N; ++I)
738     if (VisitTemplateArgumentLoc(TemplateArgs[I]))
739       return true;
740   
741   return VisitCXXRecordDecl(D);
742 }
743
744 bool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
745   // Visit the default argument.
746   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
747     if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo())
748       if (Visit(DefArg->getTypeLoc()))
749         return true;
750   
751   return false;
752 }
753
754 bool CursorVisitor::VisitEnumConstantDecl(EnumConstantDecl *D) {
755   if (Expr *Init = D->getInitExpr())
756     return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));
757   return false;
758 }
759
760 bool CursorVisitor::VisitDeclaratorDecl(DeclaratorDecl *DD) {
761   unsigned NumParamList = DD->getNumTemplateParameterLists();
762   for (unsigned i = 0; i < NumParamList; i++) {
763     TemplateParameterList* Params = DD->getTemplateParameterList(i);
764     if (VisitTemplateParameters(Params))
765       return true;
766   }
767
768   if (TypeSourceInfo *TSInfo = DD->getTypeSourceInfo())
769     if (Visit(TSInfo->getTypeLoc()))
770       return true;
771
772   // Visit the nested-name-specifier, if present.
773   if (NestedNameSpecifierLoc QualifierLoc = DD->getQualifierLoc())
774     if (VisitNestedNameSpecifierLoc(QualifierLoc))
775       return true;
776
777   return false;
778 }
779
780 /// \brief Compare two base or member initializers based on their source order.
781 static int CompareCXXCtorInitializers(CXXCtorInitializer *const *X,
782                                       CXXCtorInitializer *const *Y) {
783   return (*X)->getSourceOrder() - (*Y)->getSourceOrder();
784 }
785
786 bool CursorVisitor::VisitFunctionDecl(FunctionDecl *ND) {
787   unsigned NumParamList = ND->getNumTemplateParameterLists();
788   for (unsigned i = 0; i < NumParamList; i++) {
789     TemplateParameterList* Params = ND->getTemplateParameterList(i);
790     if (VisitTemplateParameters(Params))
791       return true;
792   }
793
794   if (TypeSourceInfo *TSInfo = ND->getTypeSourceInfo()) {
795     // Visit the function declaration's syntactic components in the order
796     // written. This requires a bit of work.
797     TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
798     FunctionTypeLoc FTL = TL.getAs<FunctionTypeLoc>();
799     
800     // If we have a function declared directly (without the use of a typedef),
801     // visit just the return type. Otherwise, just visit the function's type
802     // now.
803     if ((FTL && !isa<CXXConversionDecl>(ND) && Visit(FTL.getReturnLoc())) ||
804         (!FTL && Visit(TL)))
805       return true;
806     
807     // Visit the nested-name-specifier, if present.
808     if (NestedNameSpecifierLoc QualifierLoc = ND->getQualifierLoc())
809       if (VisitNestedNameSpecifierLoc(QualifierLoc))
810         return true;
811     
812     // Visit the declaration name.
813     if (!isa<CXXDestructorDecl>(ND))
814       if (VisitDeclarationNameInfo(ND->getNameInfo()))
815         return true;
816     
817     // FIXME: Visit explicitly-specified template arguments!
818     
819     // Visit the function parameters, if we have a function type.
820     if (FTL && VisitFunctionTypeLoc(FTL, true))
821       return true;
822     
823     // FIXME: Attributes?
824   }
825   
826   if (ND->doesThisDeclarationHaveABody() && !ND->isLateTemplateParsed()) {
827     if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ND)) {
828       // Find the initializers that were written in the source.
829       SmallVector<CXXCtorInitializer *, 4> WrittenInits;
830       for (auto *I : Constructor->inits()) {
831         if (!I->isWritten())
832           continue;
833       
834         WrittenInits.push_back(I);
835       }
836       
837       // Sort the initializers in source order
838       llvm::array_pod_sort(WrittenInits.begin(), WrittenInits.end(),
839                            &CompareCXXCtorInitializers);
840       
841       // Visit the initializers in source order
842       for (unsigned I = 0, N = WrittenInits.size(); I != N; ++I) {
843         CXXCtorInitializer *Init = WrittenInits[I];
844         if (Init->isAnyMemberInitializer()) {
845           if (Visit(MakeCursorMemberRef(Init->getAnyMember(),
846                                         Init->getMemberLocation(), TU)))
847             return true;
848         } else if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo()) {
849           if (Visit(TInfo->getTypeLoc()))
850             return true;
851         }
852         
853         // Visit the initializer value.
854         if (Expr *Initializer = Init->getInit())
855           if (Visit(MakeCXCursor(Initializer, ND, TU, RegionOfInterest)))
856             return true;
857       } 
858     }
859     
860     if (Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest)))
861       return true;
862   }
863
864   return false;
865 }
866
867 bool CursorVisitor::VisitFieldDecl(FieldDecl *D) {
868   if (VisitDeclaratorDecl(D))
869     return true;
870
871   if (Expr *BitWidth = D->getBitWidth())
872     return Visit(MakeCXCursor(BitWidth, StmtParent, TU, RegionOfInterest));
873
874   return false;
875 }
876
877 bool CursorVisitor::VisitVarDecl(VarDecl *D) {
878   if (VisitDeclaratorDecl(D))
879     return true;
880
881   if (Expr *Init = D->getInit())
882     return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));
883
884   return false;
885 }
886
887 bool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
888   if (VisitDeclaratorDecl(D))
889     return true;
890   
891   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
892     if (Expr *DefArg = D->getDefaultArgument())
893       return Visit(MakeCXCursor(DefArg, StmtParent, TU, RegionOfInterest));
894   
895   return false;  
896 }
897
898 bool CursorVisitor::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
899   // FIXME: Visit the "outer" template parameter lists on the FunctionDecl
900   // before visiting these template parameters.
901   if (VisitTemplateParameters(D->getTemplateParameters()))
902     return true;
903   
904   return VisitFunctionDecl(D->getTemplatedDecl());
905 }
906
907 bool CursorVisitor::VisitClassTemplateDecl(ClassTemplateDecl *D) {
908   // FIXME: Visit the "outer" template parameter lists on the TagDecl
909   // before visiting these template parameters.
910   if (VisitTemplateParameters(D->getTemplateParameters()))
911     return true;
912   
913   return VisitCXXRecordDecl(D->getTemplatedDecl());
914 }
915
916 bool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
917   if (VisitTemplateParameters(D->getTemplateParameters()))
918     return true;
919   
920   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited() &&
921       VisitTemplateArgumentLoc(D->getDefaultArgument()))
922     return true;
923   
924   return false;
925 }
926
927 bool CursorVisitor::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
928   // Visit the bound, if it's explicit.
929   if (D->hasExplicitBound()) {
930     if (auto TInfo = D->getTypeSourceInfo()) {
931       if (Visit(TInfo->getTypeLoc()))
932         return true;
933     }
934   }
935
936   return false;
937 }
938
939 bool CursorVisitor::VisitObjCMethodDecl(ObjCMethodDecl *ND) {
940   if (TypeSourceInfo *TSInfo = ND->getReturnTypeSourceInfo())
941     if (Visit(TSInfo->getTypeLoc()))
942       return true;
943
944   for (const auto *P : ND->params()) {
945     if (Visit(MakeCXCursor(P, TU, RegionOfInterest)))
946       return true;
947   }
948
949   if (ND->isThisDeclarationADefinition() &&
950       Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest)))
951     return true;
952
953   return false;
954 }
955
956 template <typename DeclIt>
957 static void addRangedDeclsInContainer(DeclIt *DI_current, DeclIt DE_current,
958                                       SourceManager &SM, SourceLocation EndLoc,
959                                       SmallVectorImpl<Decl *> &Decls) {
960   DeclIt next = *DI_current;
961   while (++next != DE_current) {
962     Decl *D_next = *next;
963     if (!D_next)
964       break;
965     SourceLocation L = D_next->getLocStart();
966     if (!L.isValid())
967       break;
968     if (SM.isBeforeInTranslationUnit(L, EndLoc)) {
969       *DI_current = next;
970       Decls.push_back(D_next);
971       continue;
972     }
973     break;
974   }
975 }
976
977 bool CursorVisitor::VisitObjCContainerDecl(ObjCContainerDecl *D) {
978   // FIXME: Eventually convert back to just 'VisitDeclContext()'.  Essentially
979   // an @implementation can lexically contain Decls that are not properly
980   // nested in the AST.  When we identify such cases, we need to retrofit
981   // this nesting here.
982   if (!DI_current && !FileDI_current)
983     return VisitDeclContext(D);
984
985   // Scan the Decls that immediately come after the container
986   // in the current DeclContext.  If any fall within the
987   // container's lexical region, stash them into a vector
988   // for later processing.
989   SmallVector<Decl *, 24> DeclsInContainer;
990   SourceLocation EndLoc = D->getSourceRange().getEnd();
991   SourceManager &SM = AU->getSourceManager();
992   if (EndLoc.isValid()) {
993     if (DI_current) {
994       addRangedDeclsInContainer(DI_current, DE_current, SM, EndLoc,
995                                 DeclsInContainer);
996     } else {
997       addRangedDeclsInContainer(FileDI_current, FileDE_current, SM, EndLoc,
998                                 DeclsInContainer);
999     }
1000   }
1001
1002   // The common case.
1003   if (DeclsInContainer.empty())
1004     return VisitDeclContext(D);
1005
1006   // Get all the Decls in the DeclContext, and sort them with the
1007   // additional ones we've collected.  Then visit them.
1008   for (auto *SubDecl : D->decls()) {
1009     if (!SubDecl || SubDecl->getLexicalDeclContext() != D ||
1010         SubDecl->getLocStart().isInvalid())
1011       continue;
1012     DeclsInContainer.push_back(SubDecl);
1013   }
1014
1015   // Now sort the Decls so that they appear in lexical order.
1016   std::sort(DeclsInContainer.begin(), DeclsInContainer.end(),
1017             [&SM](Decl *A, Decl *B) {
1018     SourceLocation L_A = A->getLocStart();
1019     SourceLocation L_B = B->getLocStart();
1020     assert(L_A.isValid() && L_B.isValid());
1021     return SM.isBeforeInTranslationUnit(L_A, L_B);
1022   });
1023
1024   // Now visit the decls.
1025   for (SmallVectorImpl<Decl*>::iterator I = DeclsInContainer.begin(),
1026          E = DeclsInContainer.end(); I != E; ++I) {
1027     CXCursor Cursor = MakeCXCursor(*I, TU, RegionOfInterest);
1028     const Optional<bool> &V = shouldVisitCursor(Cursor);
1029     if (!V.hasValue())
1030       continue;
1031     if (!V.getValue())
1032       return false;
1033     if (Visit(Cursor, true))
1034       return true;
1035   }
1036   return false;
1037 }
1038
1039 bool CursorVisitor::VisitObjCCategoryDecl(ObjCCategoryDecl *ND) {
1040   if (Visit(MakeCursorObjCClassRef(ND->getClassInterface(), ND->getLocation(),
1041                                    TU)))
1042     return true;
1043
1044   if (VisitObjCTypeParamList(ND->getTypeParamList()))
1045     return true;
1046
1047   ObjCCategoryDecl::protocol_loc_iterator PL = ND->protocol_loc_begin();
1048   for (ObjCCategoryDecl::protocol_iterator I = ND->protocol_begin(),
1049          E = ND->protocol_end(); I != E; ++I, ++PL)
1050     if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
1051       return true;
1052
1053   return VisitObjCContainerDecl(ND);
1054 }
1055
1056 bool CursorVisitor::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) {
1057   if (!PID->isThisDeclarationADefinition())
1058     return Visit(MakeCursorObjCProtocolRef(PID, PID->getLocation(), TU));
1059   
1060   ObjCProtocolDecl::protocol_loc_iterator PL = PID->protocol_loc_begin();
1061   for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(),
1062        E = PID->protocol_end(); I != E; ++I, ++PL)
1063     if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
1064       return true;
1065
1066   return VisitObjCContainerDecl(PID);
1067 }
1068
1069 bool CursorVisitor::VisitObjCPropertyDecl(ObjCPropertyDecl *PD) {
1070   if (PD->getTypeSourceInfo() && Visit(PD->getTypeSourceInfo()->getTypeLoc()))
1071     return true;
1072
1073   // FIXME: This implements a workaround with @property declarations also being
1074   // installed in the DeclContext for the @interface.  Eventually this code
1075   // should be removed.
1076   ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(PD->getDeclContext());
1077   if (!CDecl || !CDecl->IsClassExtension())
1078     return false;
1079
1080   ObjCInterfaceDecl *ID = CDecl->getClassInterface();
1081   if (!ID)
1082     return false;
1083
1084   IdentifierInfo *PropertyId = PD->getIdentifier();
1085   ObjCPropertyDecl *prevDecl =
1086     ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(ID), PropertyId);
1087
1088   if (!prevDecl)
1089     return false;
1090
1091   // Visit synthesized methods since they will be skipped when visiting
1092   // the @interface.
1093   if (ObjCMethodDecl *MD = prevDecl->getGetterMethodDecl())
1094     if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl)
1095       if (Visit(MakeCXCursor(MD, TU, RegionOfInterest)))
1096         return true;
1097
1098   if (ObjCMethodDecl *MD = prevDecl->getSetterMethodDecl())
1099     if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl)
1100       if (Visit(MakeCXCursor(MD, TU, RegionOfInterest)))
1101         return true;
1102
1103   return false;
1104 }
1105
1106 bool CursorVisitor::VisitObjCTypeParamList(ObjCTypeParamList *typeParamList) {
1107   if (!typeParamList)
1108     return false;
1109
1110   for (auto *typeParam : *typeParamList) {
1111     // Visit the type parameter.
1112     if (Visit(MakeCXCursor(typeParam, TU, RegionOfInterest)))
1113       return true;
1114   }
1115
1116   return false;
1117 }
1118
1119 bool CursorVisitor::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
1120   if (!D->isThisDeclarationADefinition()) {
1121     // Forward declaration is treated like a reference.
1122     return Visit(MakeCursorObjCClassRef(D, D->getLocation(), TU));
1123   }
1124
1125   // Objective-C type parameters.
1126   if (VisitObjCTypeParamList(D->getTypeParamListAsWritten()))
1127     return true;
1128
1129   // Issue callbacks for super class.
1130   if (D->getSuperClass() &&
1131       Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(),
1132                                         D->getSuperClassLoc(),
1133                                         TU)))
1134     return true;
1135
1136   if (TypeSourceInfo *SuperClassTInfo = D->getSuperClassTInfo())
1137     if (Visit(SuperClassTInfo->getTypeLoc()))
1138       return true;
1139
1140   ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin();
1141   for (ObjCInterfaceDecl::protocol_iterator I = D->protocol_begin(),
1142          E = D->protocol_end(); I != E; ++I, ++PL)
1143     if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
1144       return true;
1145
1146   return VisitObjCContainerDecl(D);
1147 }
1148
1149 bool CursorVisitor::VisitObjCImplDecl(ObjCImplDecl *D) {
1150   return VisitObjCContainerDecl(D);
1151 }
1152
1153 bool CursorVisitor::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
1154   // 'ID' could be null when dealing with invalid code.
1155   if (ObjCInterfaceDecl *ID = D->getClassInterface())
1156     if (Visit(MakeCursorObjCClassRef(ID, D->getLocation(), TU)))
1157       return true;
1158
1159   return VisitObjCImplDecl(D);
1160 }
1161
1162 bool CursorVisitor::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
1163 #if 0
1164   // Issue callbacks for super class.
1165   // FIXME: No source location information!
1166   if (D->getSuperClass() &&
1167       Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(),
1168                                         D->getSuperClassLoc(),
1169                                         TU)))
1170     return true;
1171 #endif
1172
1173   return VisitObjCImplDecl(D);
1174 }
1175
1176 bool CursorVisitor::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PD) {
1177   if (ObjCIvarDecl *Ivar = PD->getPropertyIvarDecl())
1178     if (PD->isIvarNameSpecified())
1179       return Visit(MakeCursorMemberRef(Ivar, PD->getPropertyIvarDeclLoc(), TU));
1180   
1181   return false;
1182 }
1183
1184 bool CursorVisitor::VisitNamespaceDecl(NamespaceDecl *D) {
1185   return VisitDeclContext(D);
1186 }
1187
1188 bool CursorVisitor::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1189   // Visit nested-name-specifier.
1190   if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1191     if (VisitNestedNameSpecifierLoc(QualifierLoc))
1192       return true;
1193   
1194   return Visit(MakeCursorNamespaceRef(D->getAliasedNamespace(), 
1195                                       D->getTargetNameLoc(), TU));
1196 }
1197
1198 bool CursorVisitor::VisitUsingDecl(UsingDecl *D) {
1199   // Visit nested-name-specifier.
1200   if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) {
1201     if (VisitNestedNameSpecifierLoc(QualifierLoc))
1202       return true;
1203   }
1204   
1205   if (Visit(MakeCursorOverloadedDeclRef(D, D->getLocation(), TU)))
1206     return true;
1207     
1208   return VisitDeclarationNameInfo(D->getNameInfo());
1209 }
1210
1211 bool CursorVisitor::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1212   // Visit nested-name-specifier.
1213   if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1214     if (VisitNestedNameSpecifierLoc(QualifierLoc))
1215       return true;
1216
1217   return Visit(MakeCursorNamespaceRef(D->getNominatedNamespaceAsWritten(),
1218                                       D->getIdentLocation(), TU));
1219 }
1220
1221 bool CursorVisitor::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1222   // Visit nested-name-specifier.
1223   if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) {
1224     if (VisitNestedNameSpecifierLoc(QualifierLoc))
1225       return true;
1226   }
1227
1228   return VisitDeclarationNameInfo(D->getNameInfo());
1229 }
1230
1231 bool CursorVisitor::VisitUnresolvedUsingTypenameDecl(
1232                                                UnresolvedUsingTypenameDecl *D) {
1233   // Visit nested-name-specifier.
1234   if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1235     if (VisitNestedNameSpecifierLoc(QualifierLoc))
1236       return true;
1237   
1238   return false;
1239 }
1240
1241 bool CursorVisitor::VisitDeclarationNameInfo(DeclarationNameInfo Name) {
1242   switch (Name.getName().getNameKind()) {
1243   case clang::DeclarationName::Identifier:
1244   case clang::DeclarationName::CXXLiteralOperatorName:
1245   case clang::DeclarationName::CXXOperatorName:
1246   case clang::DeclarationName::CXXUsingDirective:
1247     return false;
1248       
1249   case clang::DeclarationName::CXXConstructorName:
1250   case clang::DeclarationName::CXXDestructorName:
1251   case clang::DeclarationName::CXXConversionFunctionName:
1252     if (TypeSourceInfo *TSInfo = Name.getNamedTypeInfo())
1253       return Visit(TSInfo->getTypeLoc());
1254     return false;
1255
1256   case clang::DeclarationName::ObjCZeroArgSelector:
1257   case clang::DeclarationName::ObjCOneArgSelector:
1258   case clang::DeclarationName::ObjCMultiArgSelector:
1259     // FIXME: Per-identifier location info?
1260     return false;
1261   }
1262
1263   llvm_unreachable("Invalid DeclarationName::Kind!");
1264 }
1265
1266 bool CursorVisitor::VisitNestedNameSpecifier(NestedNameSpecifier *NNS, 
1267                                              SourceRange Range) {
1268   // FIXME: This whole routine is a hack to work around the lack of proper
1269   // source information in nested-name-specifiers (PR5791). Since we do have
1270   // a beginning source location, we can visit the first component of the
1271   // nested-name-specifier, if it's a single-token component.
1272   if (!NNS)
1273     return false;
1274   
1275   // Get the first component in the nested-name-specifier.
1276   while (NestedNameSpecifier *Prefix = NNS->getPrefix())
1277     NNS = Prefix;
1278   
1279   switch (NNS->getKind()) {
1280   case NestedNameSpecifier::Namespace:
1281     return Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), Range.getBegin(),
1282                                         TU));
1283
1284   case NestedNameSpecifier::NamespaceAlias:
1285     return Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(), 
1286                                         Range.getBegin(), TU));
1287
1288   case NestedNameSpecifier::TypeSpec: {
1289     // If the type has a form where we know that the beginning of the source
1290     // range matches up with a reference cursor. Visit the appropriate reference
1291     // cursor.
1292     const Type *T = NNS->getAsType();
1293     if (const TypedefType *Typedef = dyn_cast<TypedefType>(T))
1294       return Visit(MakeCursorTypeRef(Typedef->getDecl(), Range.getBegin(), TU));
1295     if (const TagType *Tag = dyn_cast<TagType>(T))
1296       return Visit(MakeCursorTypeRef(Tag->getDecl(), Range.getBegin(), TU));
1297     if (const TemplateSpecializationType *TST
1298                                       = dyn_cast<TemplateSpecializationType>(T))
1299       return VisitTemplateName(TST->getTemplateName(), Range.getBegin());
1300     break;
1301   }
1302       
1303   case NestedNameSpecifier::TypeSpecWithTemplate:
1304   case NestedNameSpecifier::Global:
1305   case NestedNameSpecifier::Identifier:
1306   case NestedNameSpecifier::Super:
1307     break;      
1308   }
1309   
1310   return false;
1311 }
1312
1313 bool 
1314 CursorVisitor::VisitNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) {
1315   SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;
1316   for (; Qualifier; Qualifier = Qualifier.getPrefix())
1317     Qualifiers.push_back(Qualifier);
1318   
1319   while (!Qualifiers.empty()) {
1320     NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
1321     NestedNameSpecifier *NNS = Q.getNestedNameSpecifier();
1322     switch (NNS->getKind()) {
1323     case NestedNameSpecifier::Namespace:
1324       if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), 
1325                                        Q.getLocalBeginLoc(),
1326                                        TU)))
1327         return true;
1328         
1329       break;
1330       
1331     case NestedNameSpecifier::NamespaceAlias:
1332       if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(), 
1333                                        Q.getLocalBeginLoc(),
1334                                        TU)))
1335         return true;
1336         
1337       break;
1338         
1339     case NestedNameSpecifier::TypeSpec:
1340     case NestedNameSpecifier::TypeSpecWithTemplate:
1341       if (Visit(Q.getTypeLoc()))
1342         return true;
1343         
1344       break;
1345         
1346     case NestedNameSpecifier::Global:
1347     case NestedNameSpecifier::Identifier:
1348     case NestedNameSpecifier::Super:
1349       break;              
1350     }
1351   }
1352   
1353   return false;
1354 }
1355
1356 bool CursorVisitor::VisitTemplateParameters(
1357                                           const TemplateParameterList *Params) {
1358   if (!Params)
1359     return false;
1360   
1361   for (TemplateParameterList::const_iterator P = Params->begin(),
1362                                           PEnd = Params->end();
1363        P != PEnd; ++P) {
1364     if (Visit(MakeCXCursor(*P, TU, RegionOfInterest)))
1365       return true;
1366   }
1367   
1368   return false;
1369 }
1370
1371 bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) {
1372   switch (Name.getKind()) {
1373   case TemplateName::Template:
1374     return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU));
1375
1376   case TemplateName::OverloadedTemplate:
1377     // Visit the overloaded template set.
1378     if (Visit(MakeCursorOverloadedDeclRef(Name, Loc, TU)))
1379       return true;
1380
1381     return false;
1382
1383   case TemplateName::DependentTemplate:
1384     // FIXME: Visit nested-name-specifier.
1385     return false;
1386       
1387   case TemplateName::QualifiedTemplate:
1388     // FIXME: Visit nested-name-specifier.
1389     return Visit(MakeCursorTemplateRef(
1390                                   Name.getAsQualifiedTemplateName()->getDecl(), 
1391                                        Loc, TU));
1392
1393   case TemplateName::SubstTemplateTemplateParm:
1394     return Visit(MakeCursorTemplateRef(
1395                          Name.getAsSubstTemplateTemplateParm()->getParameter(),
1396                                        Loc, TU));
1397       
1398   case TemplateName::SubstTemplateTemplateParmPack:
1399     return Visit(MakeCursorTemplateRef(
1400                   Name.getAsSubstTemplateTemplateParmPack()->getParameterPack(),
1401                                        Loc, TU));
1402   }
1403
1404   llvm_unreachable("Invalid TemplateName::Kind!");
1405 }
1406
1407 bool CursorVisitor::VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL) {
1408   switch (TAL.getArgument().getKind()) {
1409   case TemplateArgument::Null:
1410   case TemplateArgument::Integral:
1411   case TemplateArgument::Pack:
1412     return false;
1413       
1414   case TemplateArgument::Type:
1415     if (TypeSourceInfo *TSInfo = TAL.getTypeSourceInfo())
1416       return Visit(TSInfo->getTypeLoc());
1417     return false;
1418       
1419   case TemplateArgument::Declaration:
1420     if (Expr *E = TAL.getSourceDeclExpression())
1421       return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
1422     return false;
1423
1424   case TemplateArgument::NullPtr:
1425     if (Expr *E = TAL.getSourceNullPtrExpression())
1426       return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
1427     return false;
1428
1429   case TemplateArgument::Expression:
1430     if (Expr *E = TAL.getSourceExpression())
1431       return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
1432     return false;
1433   
1434   case TemplateArgument::Template:
1435   case TemplateArgument::TemplateExpansion:
1436     if (VisitNestedNameSpecifierLoc(TAL.getTemplateQualifierLoc()))
1437       return true;
1438       
1439     return VisitTemplateName(TAL.getArgument().getAsTemplateOrTemplatePattern(), 
1440                              TAL.getTemplateNameLoc());
1441   }
1442
1443   llvm_unreachable("Invalid TemplateArgument::Kind!");
1444 }
1445
1446 bool CursorVisitor::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1447   return VisitDeclContext(D);
1448 }
1449
1450 bool CursorVisitor::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
1451   return Visit(TL.getUnqualifiedLoc());
1452 }
1453
1454 bool CursorVisitor::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
1455   ASTContext &Context = AU->getASTContext();
1456
1457   // Some builtin types (such as Objective-C's "id", "sel", and
1458   // "Class") have associated declarations. Create cursors for those.
1459   QualType VisitType;
1460   switch (TL.getTypePtr()->getKind()) {
1461
1462   case BuiltinType::Void:
1463   case BuiltinType::NullPtr:
1464   case BuiltinType::Dependent:
1465   case BuiltinType::OCLImage1d:
1466   case BuiltinType::OCLImage1dArray:
1467   case BuiltinType::OCLImage1dBuffer:
1468   case BuiltinType::OCLImage2d:
1469   case BuiltinType::OCLImage2dArray:
1470   case BuiltinType::OCLImage2dDepth:
1471   case BuiltinType::OCLImage2dArrayDepth:
1472   case BuiltinType::OCLImage2dMSAA:
1473   case BuiltinType::OCLImage2dArrayMSAA:
1474   case BuiltinType::OCLImage2dMSAADepth:
1475   case BuiltinType::OCLImage2dArrayMSAADepth:
1476   case BuiltinType::OCLImage3d:
1477   case BuiltinType::OCLSampler:
1478   case BuiltinType::OCLEvent:
1479   case BuiltinType::OCLClkEvent:
1480   case BuiltinType::OCLQueue:
1481   case BuiltinType::OCLNDRange:
1482   case BuiltinType::OCLReserveID:
1483 #define BUILTIN_TYPE(Id, SingletonId)
1484 #define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
1485 #define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
1486 #define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
1487 #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
1488 #include "clang/AST/BuiltinTypes.def"
1489     break;
1490
1491   case BuiltinType::ObjCId:
1492     VisitType = Context.getObjCIdType();
1493     break;
1494
1495   case BuiltinType::ObjCClass:
1496     VisitType = Context.getObjCClassType();
1497     break;
1498
1499   case BuiltinType::ObjCSel:
1500     VisitType = Context.getObjCSelType();
1501     break;
1502   }
1503
1504   if (!VisitType.isNull()) {
1505     if (const TypedefType *Typedef = VisitType->getAs<TypedefType>())
1506       return Visit(MakeCursorTypeRef(Typedef->getDecl(), TL.getBuiltinLoc(),
1507                                      TU));
1508   }
1509
1510   return false;
1511 }
1512
1513 bool CursorVisitor::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
1514   return Visit(MakeCursorTypeRef(TL.getTypedefNameDecl(), TL.getNameLoc(), TU));
1515 }
1516
1517 bool CursorVisitor::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
1518   return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1519 }
1520
1521 bool CursorVisitor::VisitTagTypeLoc(TagTypeLoc TL) {
1522   if (TL.isDefinition())
1523     return Visit(MakeCXCursor(TL.getDecl(), TU, RegionOfInterest));
1524
1525   return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1526 }
1527
1528 bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
1529   return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1530 }
1531
1532 bool CursorVisitor::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
1533   return Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU));
1534 }
1535
1536 bool CursorVisitor::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
1537   if (TL.hasBaseTypeAsWritten() && Visit(TL.getBaseLoc()))
1538     return true;
1539
1540   for (unsigned I = 0, N = TL.getNumTypeArgs(); I != N; ++I) {
1541     if (Visit(TL.getTypeArgTInfo(I)->getTypeLoc()))
1542       return true;
1543   }
1544
1545   for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {
1546     if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I),
1547                                         TU)))
1548       return true;
1549   }
1550
1551   return false;
1552 }
1553
1554 bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
1555   return Visit(TL.getPointeeLoc());
1556 }
1557
1558 bool CursorVisitor::VisitParenTypeLoc(ParenTypeLoc TL) {
1559   return Visit(TL.getInnerLoc());
1560 }
1561
1562 bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) {
1563   return Visit(TL.getPointeeLoc());
1564 }
1565
1566 bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
1567   return Visit(TL.getPointeeLoc());
1568 }
1569
1570 bool CursorVisitor::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
1571   return Visit(TL.getPointeeLoc());
1572 }
1573
1574 bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
1575   return Visit(TL.getPointeeLoc());
1576 }
1577
1578 bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
1579   return Visit(TL.getPointeeLoc());
1580 }
1581
1582 bool CursorVisitor::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
1583   return Visit(TL.getModifiedLoc());
1584 }
1585
1586 bool CursorVisitor::VisitFunctionTypeLoc(FunctionTypeLoc TL, 
1587                                          bool SkipResultType) {
1588   if (!SkipResultType && Visit(TL.getReturnLoc()))
1589     return true;
1590
1591   for (unsigned I = 0, N = TL.getNumParams(); I != N; ++I)
1592     if (Decl *D = TL.getParam(I))
1593       if (Visit(MakeCXCursor(D, TU, RegionOfInterest)))
1594         return true;
1595
1596   return false;
1597 }
1598
1599 bool CursorVisitor::VisitArrayTypeLoc(ArrayTypeLoc TL) {
1600   if (Visit(TL.getElementLoc()))
1601     return true;
1602
1603   if (Expr *Size = TL.getSizeExpr())
1604     return Visit(MakeCXCursor(Size, StmtParent, TU, RegionOfInterest));
1605
1606   return false;
1607 }
1608
1609 bool CursorVisitor::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
1610   return Visit(TL.getOriginalLoc());
1611 }
1612
1613 bool CursorVisitor::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
1614   return Visit(TL.getOriginalLoc());
1615 }
1616
1617 bool CursorVisitor::VisitTemplateSpecializationTypeLoc(
1618                                              TemplateSpecializationTypeLoc TL) {
1619   // Visit the template name.
1620   if (VisitTemplateName(TL.getTypePtr()->getTemplateName(), 
1621                         TL.getTemplateNameLoc()))
1622     return true;
1623   
1624   // Visit the template arguments.
1625   for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1626     if (VisitTemplateArgumentLoc(TL.getArgLoc(I)))
1627       return true;
1628   
1629   return false;
1630 }
1631
1632 bool CursorVisitor::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
1633   return Visit(MakeCXCursor(TL.getUnderlyingExpr(), StmtParent, TU));
1634 }
1635
1636 bool CursorVisitor::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
1637   if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo())
1638     return Visit(TSInfo->getTypeLoc());
1639
1640   return false;
1641 }
1642
1643 bool CursorVisitor::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
1644   if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo())
1645     return Visit(TSInfo->getTypeLoc());
1646
1647   return false;
1648 }
1649
1650 bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
1651   return VisitNestedNameSpecifierLoc(TL.getQualifierLoc());
1652 }
1653
1654 bool CursorVisitor::VisitDependentTemplateSpecializationTypeLoc(
1655                                     DependentTemplateSpecializationTypeLoc TL) {
1656   // Visit the nested-name-specifier, if there is one.
1657   if (TL.getQualifierLoc() &&
1658       VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
1659     return true;
1660   
1661   // Visit the template arguments.
1662   for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1663     if (VisitTemplateArgumentLoc(TL.getArgLoc(I)))
1664       return true;
1665
1666   return false;
1667 }
1668
1669 bool CursorVisitor::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
1670   if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
1671     return true;
1672   
1673   return Visit(TL.getNamedTypeLoc());
1674 }
1675
1676 bool CursorVisitor::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
1677   return Visit(TL.getPatternLoc());
1678 }
1679
1680 bool CursorVisitor::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
1681   if (Expr *E = TL.getUnderlyingExpr())
1682     return Visit(MakeCXCursor(E, StmtParent, TU));
1683
1684   return false;
1685 }
1686
1687 bool CursorVisitor::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
1688   return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1689 }
1690
1691 bool CursorVisitor::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
1692   return Visit(TL.getValueLoc());
1693 }
1694
1695 #define DEFAULT_TYPELOC_IMPL(CLASS, PARENT) \
1696 bool CursorVisitor::Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { \
1697   return Visit##PARENT##Loc(TL); \
1698 }
1699
1700 DEFAULT_TYPELOC_IMPL(Complex, Type)
1701 DEFAULT_TYPELOC_IMPL(ConstantArray, ArrayType)
1702 DEFAULT_TYPELOC_IMPL(IncompleteArray, ArrayType)
1703 DEFAULT_TYPELOC_IMPL(VariableArray, ArrayType)
1704 DEFAULT_TYPELOC_IMPL(DependentSizedArray, ArrayType)
1705 DEFAULT_TYPELOC_IMPL(DependentSizedExtVector, Type)
1706 DEFAULT_TYPELOC_IMPL(Vector, Type)
1707 DEFAULT_TYPELOC_IMPL(ExtVector, VectorType)
1708 DEFAULT_TYPELOC_IMPL(FunctionProto, FunctionType)
1709 DEFAULT_TYPELOC_IMPL(FunctionNoProto, FunctionType)
1710 DEFAULT_TYPELOC_IMPL(Record, TagType)
1711 DEFAULT_TYPELOC_IMPL(Enum, TagType)
1712 DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParm, Type)
1713 DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParmPack, Type)
1714 DEFAULT_TYPELOC_IMPL(Auto, Type)
1715
1716 bool CursorVisitor::VisitCXXRecordDecl(CXXRecordDecl *D) {
1717   // Visit the nested-name-specifier, if present.
1718   if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1719     if (VisitNestedNameSpecifierLoc(QualifierLoc))
1720       return true;
1721
1722   if (D->isCompleteDefinition()) {
1723     for (const auto &I : D->bases()) {
1724       if (Visit(cxcursor::MakeCursorCXXBaseSpecifier(&I, TU)))
1725         return true;
1726     }
1727   }
1728
1729   return VisitTagDecl(D);
1730 }
1731
1732 bool CursorVisitor::VisitAttributes(Decl *D) {
1733   for (const auto *I : D->attrs())
1734     if (Visit(MakeCXCursor(I, D, TU)))
1735         return true;
1736
1737   return false;
1738 }
1739
1740 //===----------------------------------------------------------------------===//
1741 // Data-recursive visitor methods.
1742 //===----------------------------------------------------------------------===//
1743
1744 namespace {
1745 #define DEF_JOB(NAME, DATA, KIND)\
1746 class NAME : public VisitorJob {\
1747 public:\
1748   NAME(const DATA *d, CXCursor parent) : \
1749       VisitorJob(parent, VisitorJob::KIND, d) {} \
1750   static bool classof(const VisitorJob *VJ) { return VJ->getKind() == KIND; }\
1751   const DATA *get() const { return static_cast<const DATA*>(data[0]); }\
1752 };
1753
1754 DEF_JOB(StmtVisit, Stmt, StmtVisitKind)
1755 DEF_JOB(MemberExprParts, MemberExpr, MemberExprPartsKind)
1756 DEF_JOB(DeclRefExprParts, DeclRefExpr, DeclRefExprPartsKind)
1757 DEF_JOB(OverloadExprParts, OverloadExpr, OverloadExprPartsKind)
1758 DEF_JOB(SizeOfPackExprParts, SizeOfPackExpr, SizeOfPackExprPartsKind)
1759 DEF_JOB(LambdaExprParts, LambdaExpr, LambdaExprPartsKind)
1760 DEF_JOB(PostChildrenVisit, void, PostChildrenVisitKind)
1761 #undef DEF_JOB
1762
1763 class ExplicitTemplateArgsVisit : public VisitorJob {
1764 public:
1765   ExplicitTemplateArgsVisit(const TemplateArgumentLoc *Begin,
1766                             const TemplateArgumentLoc *End, CXCursor parent)
1767       : VisitorJob(parent, VisitorJob::ExplicitTemplateArgsVisitKind, Begin,
1768                    End) {}
1769   static bool classof(const VisitorJob *VJ) {
1770     return VJ->getKind() == ExplicitTemplateArgsVisitKind;
1771   }
1772   const TemplateArgumentLoc *begin() const {
1773     return static_cast<const TemplateArgumentLoc *>(data[0]);
1774   }
1775   const TemplateArgumentLoc *end() {
1776     return static_cast<const TemplateArgumentLoc *>(data[1]);
1777   }
1778 };
1779 class DeclVisit : public VisitorJob {
1780 public:
1781   DeclVisit(const Decl *D, CXCursor parent, bool isFirst) :
1782     VisitorJob(parent, VisitorJob::DeclVisitKind,
1783                D, isFirst ? (void*) 1 : (void*) nullptr) {}
1784   static bool classof(const VisitorJob *VJ) {
1785     return VJ->getKind() == DeclVisitKind;
1786   }
1787   const Decl *get() const { return static_cast<const Decl *>(data[0]); }
1788   bool isFirst() const { return data[1] != nullptr; }
1789 };
1790 class TypeLocVisit : public VisitorJob {
1791 public:
1792   TypeLocVisit(TypeLoc tl, CXCursor parent) :
1793     VisitorJob(parent, VisitorJob::TypeLocVisitKind,
1794                tl.getType().getAsOpaquePtr(), tl.getOpaqueData()) {}
1795
1796   static bool classof(const VisitorJob *VJ) {
1797     return VJ->getKind() == TypeLocVisitKind;
1798   }
1799
1800   TypeLoc get() const { 
1801     QualType T = QualType::getFromOpaquePtr(data[0]);
1802     return TypeLoc(T, const_cast<void *>(data[1]));
1803   }
1804 };
1805
1806 class LabelRefVisit : public VisitorJob {
1807 public:
1808   LabelRefVisit(LabelDecl *LD, SourceLocation labelLoc, CXCursor parent)
1809     : VisitorJob(parent, VisitorJob::LabelRefVisitKind, LD,
1810                  labelLoc.getPtrEncoding()) {}
1811   
1812   static bool classof(const VisitorJob *VJ) {
1813     return VJ->getKind() == VisitorJob::LabelRefVisitKind;
1814   }
1815   const LabelDecl *get() const {
1816     return static_cast<const LabelDecl *>(data[0]);
1817   }
1818   SourceLocation getLoc() const { 
1819     return SourceLocation::getFromPtrEncoding(data[1]); }
1820 };
1821   
1822 class NestedNameSpecifierLocVisit : public VisitorJob {
1823 public:
1824   NestedNameSpecifierLocVisit(NestedNameSpecifierLoc Qualifier, CXCursor parent)
1825     : VisitorJob(parent, VisitorJob::NestedNameSpecifierLocVisitKind,
1826                  Qualifier.getNestedNameSpecifier(),
1827                  Qualifier.getOpaqueData()) { }
1828   
1829   static bool classof(const VisitorJob *VJ) {
1830     return VJ->getKind() == VisitorJob::NestedNameSpecifierLocVisitKind;
1831   }
1832   
1833   NestedNameSpecifierLoc get() const {
1834     return NestedNameSpecifierLoc(
1835             const_cast<NestedNameSpecifier *>(
1836               static_cast<const NestedNameSpecifier *>(data[0])),
1837             const_cast<void *>(data[1]));
1838   }
1839 };
1840   
1841 class DeclarationNameInfoVisit : public VisitorJob {
1842 public:
1843   DeclarationNameInfoVisit(const Stmt *S, CXCursor parent)
1844     : VisitorJob(parent, VisitorJob::DeclarationNameInfoVisitKind, S) {}
1845   static bool classof(const VisitorJob *VJ) {
1846     return VJ->getKind() == VisitorJob::DeclarationNameInfoVisitKind;
1847   }
1848   DeclarationNameInfo get() const {
1849     const Stmt *S = static_cast<const Stmt *>(data[0]);
1850     switch (S->getStmtClass()) {
1851     default:
1852       llvm_unreachable("Unhandled Stmt");
1853     case clang::Stmt::MSDependentExistsStmtClass:
1854       return cast<MSDependentExistsStmt>(S)->getNameInfo();
1855     case Stmt::CXXDependentScopeMemberExprClass:
1856       return cast<CXXDependentScopeMemberExpr>(S)->getMemberNameInfo();
1857     case Stmt::DependentScopeDeclRefExprClass:
1858       return cast<DependentScopeDeclRefExpr>(S)->getNameInfo();
1859     case Stmt::OMPCriticalDirectiveClass:
1860       return cast<OMPCriticalDirective>(S)->getDirectiveName();
1861     }
1862   }
1863 };
1864 class MemberRefVisit : public VisitorJob {
1865 public:
1866   MemberRefVisit(const FieldDecl *D, SourceLocation L, CXCursor parent)
1867     : VisitorJob(parent, VisitorJob::MemberRefVisitKind, D,
1868                  L.getPtrEncoding()) {}
1869   static bool classof(const VisitorJob *VJ) {
1870     return VJ->getKind() == VisitorJob::MemberRefVisitKind;
1871   }
1872   const FieldDecl *get() const {
1873     return static_cast<const FieldDecl *>(data[0]);
1874   }
1875   SourceLocation getLoc() const {
1876     return SourceLocation::getFromRawEncoding((unsigned)(uintptr_t) data[1]);
1877   }
1878 };
1879 class EnqueueVisitor : public ConstStmtVisitor<EnqueueVisitor, void> {
1880   friend class OMPClauseEnqueue;
1881   VisitorWorkList &WL;
1882   CXCursor Parent;
1883 public:
1884   EnqueueVisitor(VisitorWorkList &wl, CXCursor parent)
1885     : WL(wl), Parent(parent) {}
1886
1887   void VisitAddrLabelExpr(const AddrLabelExpr *E);
1888   void VisitBlockExpr(const BlockExpr *B);
1889   void VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
1890   void VisitCompoundStmt(const CompoundStmt *S);
1891   void VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) { /* Do nothing. */ }
1892   void VisitMSDependentExistsStmt(const MSDependentExistsStmt *S);
1893   void VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E);
1894   void VisitCXXNewExpr(const CXXNewExpr *E);
1895   void VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E);
1896   void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *E);
1897   void VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E);
1898   void VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *E);
1899   void VisitCXXTypeidExpr(const CXXTypeidExpr *E);
1900   void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *E);
1901   void VisitCXXUuidofExpr(const CXXUuidofExpr *E);
1902   void VisitCXXCatchStmt(const CXXCatchStmt *S);
1903   void VisitCXXForRangeStmt(const CXXForRangeStmt *S);
1904   void VisitDeclRefExpr(const DeclRefExpr *D);
1905   void VisitDeclStmt(const DeclStmt *S);
1906   void VisitDependentScopeDeclRefExpr(const DependentScopeDeclRefExpr *E);
1907   void VisitDesignatedInitExpr(const DesignatedInitExpr *E);
1908   void VisitExplicitCastExpr(const ExplicitCastExpr *E);
1909   void VisitForStmt(const ForStmt *FS);
1910   void VisitGotoStmt(const GotoStmt *GS);
1911   void VisitIfStmt(const IfStmt *If);
1912   void VisitInitListExpr(const InitListExpr *IE);
1913   void VisitMemberExpr(const MemberExpr *M);
1914   void VisitOffsetOfExpr(const OffsetOfExpr *E);
1915   void VisitObjCEncodeExpr(const ObjCEncodeExpr *E);
1916   void VisitObjCMessageExpr(const ObjCMessageExpr *M);
1917   void VisitOverloadExpr(const OverloadExpr *E);
1918   void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
1919   void VisitStmt(const Stmt *S);
1920   void VisitSwitchStmt(const SwitchStmt *S);
1921   void VisitWhileStmt(const WhileStmt *W);
1922   void VisitTypeTraitExpr(const TypeTraitExpr *E);
1923   void VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E);
1924   void VisitExpressionTraitExpr(const ExpressionTraitExpr *E);
1925   void VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U);
1926   void VisitVAArgExpr(const VAArgExpr *E);
1927   void VisitSizeOfPackExpr(const SizeOfPackExpr *E);
1928   void VisitPseudoObjectExpr(const PseudoObjectExpr *E);
1929   void VisitOpaqueValueExpr(const OpaqueValueExpr *E);
1930   void VisitLambdaExpr(const LambdaExpr *E);
1931   void VisitOMPExecutableDirective(const OMPExecutableDirective *D);
1932   void VisitOMPLoopDirective(const OMPLoopDirective *D);
1933   void VisitOMPParallelDirective(const OMPParallelDirective *D);
1934   void VisitOMPSimdDirective(const OMPSimdDirective *D);
1935   void VisitOMPForDirective(const OMPForDirective *D);
1936   void VisitOMPForSimdDirective(const OMPForSimdDirective *D);
1937   void VisitOMPSectionsDirective(const OMPSectionsDirective *D);
1938   void VisitOMPSectionDirective(const OMPSectionDirective *D);
1939   void VisitOMPSingleDirective(const OMPSingleDirective *D);
1940   void VisitOMPMasterDirective(const OMPMasterDirective *D);
1941   void VisitOMPCriticalDirective(const OMPCriticalDirective *D);
1942   void VisitOMPParallelForDirective(const OMPParallelForDirective *D);
1943   void VisitOMPParallelForSimdDirective(const OMPParallelForSimdDirective *D);
1944   void VisitOMPParallelSectionsDirective(const OMPParallelSectionsDirective *D);
1945   void VisitOMPTaskDirective(const OMPTaskDirective *D);
1946   void VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *D);
1947   void VisitOMPBarrierDirective(const OMPBarrierDirective *D);
1948   void VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D);
1949   void VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *D);
1950   void
1951   VisitOMPCancellationPointDirective(const OMPCancellationPointDirective *D);
1952   void VisitOMPCancelDirective(const OMPCancelDirective *D);
1953   void VisitOMPFlushDirective(const OMPFlushDirective *D);
1954   void VisitOMPOrderedDirective(const OMPOrderedDirective *D);
1955   void VisitOMPAtomicDirective(const OMPAtomicDirective *D);
1956   void VisitOMPTargetDirective(const OMPTargetDirective *D);
1957   void VisitOMPTargetDataDirective(const OMPTargetDataDirective *D);
1958   void VisitOMPTeamsDirective(const OMPTeamsDirective *D);
1959   void VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D);
1960   void VisitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective *D);
1961   void VisitOMPDistributeDirective(const OMPDistributeDirective *D);
1962
1963 private:
1964   void AddDeclarationNameInfo(const Stmt *S);
1965   void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier);
1966   void AddExplicitTemplateArgs(const TemplateArgumentLoc *A,
1967                                unsigned NumTemplateArgs);
1968   void AddMemberRef(const FieldDecl *D, SourceLocation L);
1969   void AddStmt(const Stmt *S);
1970   void AddDecl(const Decl *D, bool isFirst = true);
1971   void AddTypeLoc(TypeSourceInfo *TI);
1972   void EnqueueChildren(const Stmt *S);
1973   void EnqueueChildren(const OMPClause *S);
1974 };
1975 } // end anonyous namespace
1976
1977 void EnqueueVisitor::AddDeclarationNameInfo(const Stmt *S) {
1978   // 'S' should always be non-null, since it comes from the
1979   // statement we are visiting.
1980   WL.push_back(DeclarationNameInfoVisit(S, Parent));
1981 }
1982
1983 void 
1984 EnqueueVisitor::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) {
1985   if (Qualifier)
1986     WL.push_back(NestedNameSpecifierLocVisit(Qualifier, Parent));
1987 }
1988
1989 void EnqueueVisitor::AddStmt(const Stmt *S) {
1990   if (S)
1991     WL.push_back(StmtVisit(S, Parent));
1992 }
1993 void EnqueueVisitor::AddDecl(const Decl *D, bool isFirst) {
1994   if (D)
1995     WL.push_back(DeclVisit(D, Parent, isFirst));
1996 }
1997 void EnqueueVisitor::AddExplicitTemplateArgs(const TemplateArgumentLoc *A,
1998                                              unsigned NumTemplateArgs) {
1999   WL.push_back(ExplicitTemplateArgsVisit(A, A + NumTemplateArgs, Parent));
2000 }
2001 void EnqueueVisitor::AddMemberRef(const FieldDecl *D, SourceLocation L) {
2002   if (D)
2003     WL.push_back(MemberRefVisit(D, L, Parent));
2004 }
2005 void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) {
2006   if (TI)
2007     WL.push_back(TypeLocVisit(TI->getTypeLoc(), Parent));
2008  }
2009 void EnqueueVisitor::EnqueueChildren(const Stmt *S) {
2010   unsigned size = WL.size();
2011   for (const Stmt *SubStmt : S->children()) {
2012     AddStmt(SubStmt);
2013   }
2014   if (size == WL.size())
2015     return;
2016   // Now reverse the entries we just added.  This will match the DFS
2017   // ordering performed by the worklist.
2018   VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
2019   std::reverse(I, E);
2020 }
2021 namespace {
2022 class OMPClauseEnqueue : public ConstOMPClauseVisitor<OMPClauseEnqueue> {
2023   EnqueueVisitor *Visitor;
2024   /// \brief Process clauses with list of variables.
2025   template <typename T>
2026   void VisitOMPClauseList(T *Node);
2027 public:
2028   OMPClauseEnqueue(EnqueueVisitor *Visitor) : Visitor(Visitor) { }
2029 #define OPENMP_CLAUSE(Name, Class)                                             \
2030   void Visit##Class(const Class *C);
2031 #include "clang/Basic/OpenMPKinds.def"
2032 };
2033
2034 void OMPClauseEnqueue::VisitOMPIfClause(const OMPIfClause *C) {
2035   Visitor->AddStmt(C->getCondition());
2036 }
2037
2038 void OMPClauseEnqueue::VisitOMPFinalClause(const OMPFinalClause *C) {
2039   Visitor->AddStmt(C->getCondition());
2040 }
2041
2042 void OMPClauseEnqueue::VisitOMPNumThreadsClause(const OMPNumThreadsClause *C) {
2043   Visitor->AddStmt(C->getNumThreads());
2044 }
2045
2046 void OMPClauseEnqueue::VisitOMPSafelenClause(const OMPSafelenClause *C) {
2047   Visitor->AddStmt(C->getSafelen());
2048 }
2049
2050 void OMPClauseEnqueue::VisitOMPSimdlenClause(const OMPSimdlenClause *C) {
2051   Visitor->AddStmt(C->getSimdlen());
2052 }
2053
2054 void OMPClauseEnqueue::VisitOMPCollapseClause(const OMPCollapseClause *C) {
2055   Visitor->AddStmt(C->getNumForLoops());
2056 }
2057
2058 void OMPClauseEnqueue::VisitOMPDefaultClause(const OMPDefaultClause *C) { }
2059
2060 void OMPClauseEnqueue::VisitOMPProcBindClause(const OMPProcBindClause *C) { }
2061
2062 void OMPClauseEnqueue::VisitOMPScheduleClause(const OMPScheduleClause *C) {
2063   Visitor->AddStmt(C->getChunkSize());
2064   Visitor->AddStmt(C->getHelperChunkSize());
2065 }
2066
2067 void OMPClauseEnqueue::VisitOMPOrderedClause(const OMPOrderedClause *C) {
2068   Visitor->AddStmt(C->getNumForLoops());
2069 }
2070
2071 void OMPClauseEnqueue::VisitOMPNowaitClause(const OMPNowaitClause *) {}
2072
2073 void OMPClauseEnqueue::VisitOMPUntiedClause(const OMPUntiedClause *) {}
2074
2075 void OMPClauseEnqueue::VisitOMPMergeableClause(const OMPMergeableClause *) {}
2076
2077 void OMPClauseEnqueue::VisitOMPReadClause(const OMPReadClause *) {}
2078
2079 void OMPClauseEnqueue::VisitOMPWriteClause(const OMPWriteClause *) {}
2080
2081 void OMPClauseEnqueue::VisitOMPUpdateClause(const OMPUpdateClause *) {}
2082
2083 void OMPClauseEnqueue::VisitOMPCaptureClause(const OMPCaptureClause *) {}
2084
2085 void OMPClauseEnqueue::VisitOMPSeqCstClause(const OMPSeqCstClause *) {}
2086
2087 void OMPClauseEnqueue::VisitOMPThreadsClause(const OMPThreadsClause *) {}
2088
2089 void OMPClauseEnqueue::VisitOMPSIMDClause(const OMPSIMDClause *) {}
2090
2091 void OMPClauseEnqueue::VisitOMPNogroupClause(const OMPNogroupClause *) {}
2092
2093 void OMPClauseEnqueue::VisitOMPDeviceClause(const OMPDeviceClause *C) {
2094   Visitor->AddStmt(C->getDevice());
2095 }
2096
2097 void OMPClauseEnqueue::VisitOMPNumTeamsClause(const OMPNumTeamsClause *C) {
2098   Visitor->AddStmt(C->getNumTeams());
2099 }
2100
2101 void OMPClauseEnqueue::VisitOMPThreadLimitClause(const OMPThreadLimitClause *C) {
2102   Visitor->AddStmt(C->getThreadLimit());
2103 }
2104
2105 void OMPClauseEnqueue::VisitOMPPriorityClause(const OMPPriorityClause *C) {
2106   Visitor->AddStmt(C->getPriority());
2107 }
2108
2109 void OMPClauseEnqueue::VisitOMPGrainsizeClause(const OMPGrainsizeClause *C) {
2110   Visitor->AddStmt(C->getGrainsize());
2111 }
2112
2113 void OMPClauseEnqueue::VisitOMPNumTasksClause(const OMPNumTasksClause *C) {
2114   Visitor->AddStmt(C->getNumTasks());
2115 }
2116
2117 void OMPClauseEnqueue::VisitOMPHintClause(const OMPHintClause *C) {
2118   Visitor->AddStmt(C->getHint());
2119 }
2120
2121 template<typename T>
2122 void OMPClauseEnqueue::VisitOMPClauseList(T *Node) {
2123   for (const auto *I : Node->varlists()) {
2124     Visitor->AddStmt(I);
2125   }
2126 }
2127
2128 void OMPClauseEnqueue::VisitOMPPrivateClause(const OMPPrivateClause *C) {
2129   VisitOMPClauseList(C);
2130   for (const auto *E : C->private_copies()) {
2131     Visitor->AddStmt(E);
2132   }
2133 }
2134 void OMPClauseEnqueue::VisitOMPFirstprivateClause(
2135                                         const OMPFirstprivateClause *C) {
2136   VisitOMPClauseList(C);
2137 }
2138 void OMPClauseEnqueue::VisitOMPLastprivateClause(
2139                                         const OMPLastprivateClause *C) {
2140   VisitOMPClauseList(C);
2141   for (auto *E : C->private_copies()) {
2142     Visitor->AddStmt(E);
2143   }
2144   for (auto *E : C->source_exprs()) {
2145     Visitor->AddStmt(E);
2146   }
2147   for (auto *E : C->destination_exprs()) {
2148     Visitor->AddStmt(E);
2149   }
2150   for (auto *E : C->assignment_ops()) {
2151     Visitor->AddStmt(E);
2152   }
2153 }
2154 void OMPClauseEnqueue::VisitOMPSharedClause(const OMPSharedClause *C) {
2155   VisitOMPClauseList(C);
2156 }
2157 void OMPClauseEnqueue::VisitOMPReductionClause(const OMPReductionClause *C) {
2158   VisitOMPClauseList(C);
2159   for (auto *E : C->privates()) {
2160     Visitor->AddStmt(E);
2161   }
2162   for (auto *E : C->lhs_exprs()) {
2163     Visitor->AddStmt(E);
2164   }
2165   for (auto *E : C->rhs_exprs()) {
2166     Visitor->AddStmt(E);
2167   }
2168   for (auto *E : C->reduction_ops()) {
2169     Visitor->AddStmt(E);
2170   }
2171 }
2172 void OMPClauseEnqueue::VisitOMPLinearClause(const OMPLinearClause *C) {
2173   VisitOMPClauseList(C);
2174   for (const auto *E : C->privates()) {
2175     Visitor->AddStmt(E);
2176   }
2177   for (const auto *E : C->inits()) {
2178     Visitor->AddStmt(E);
2179   }
2180   for (const auto *E : C->updates()) {
2181     Visitor->AddStmt(E);
2182   }
2183   for (const auto *E : C->finals()) {
2184     Visitor->AddStmt(E);
2185   }
2186   Visitor->AddStmt(C->getStep());
2187   Visitor->AddStmt(C->getCalcStep());
2188 }
2189 void OMPClauseEnqueue::VisitOMPAlignedClause(const OMPAlignedClause *C) {
2190   VisitOMPClauseList(C);
2191   Visitor->AddStmt(C->getAlignment());
2192 }
2193 void OMPClauseEnqueue::VisitOMPCopyinClause(const OMPCopyinClause *C) {
2194   VisitOMPClauseList(C);
2195   for (auto *E : C->source_exprs()) {
2196     Visitor->AddStmt(E);
2197   }
2198   for (auto *E : C->destination_exprs()) {
2199     Visitor->AddStmt(E);
2200   }
2201   for (auto *E : C->assignment_ops()) {
2202     Visitor->AddStmt(E);
2203   }
2204 }
2205 void
2206 OMPClauseEnqueue::VisitOMPCopyprivateClause(const OMPCopyprivateClause *C) {
2207   VisitOMPClauseList(C);
2208   for (auto *E : C->source_exprs()) {
2209     Visitor->AddStmt(E);
2210   }
2211   for (auto *E : C->destination_exprs()) {
2212     Visitor->AddStmt(E);
2213   }
2214   for (auto *E : C->assignment_ops()) {
2215     Visitor->AddStmt(E);
2216   }
2217 }
2218 void OMPClauseEnqueue::VisitOMPFlushClause(const OMPFlushClause *C) {
2219   VisitOMPClauseList(C);
2220 }
2221 void OMPClauseEnqueue::VisitOMPDependClause(const OMPDependClause *C) {
2222   VisitOMPClauseList(C);
2223 }
2224 void OMPClauseEnqueue::VisitOMPMapClause(const OMPMapClause *C) {
2225   VisitOMPClauseList(C);
2226 }
2227 }
2228
2229 void EnqueueVisitor::EnqueueChildren(const OMPClause *S) {
2230   unsigned size = WL.size();
2231   OMPClauseEnqueue Visitor(this);
2232   Visitor.Visit(S);
2233   if (size == WL.size())
2234     return;
2235   // Now reverse the entries we just added.  This will match the DFS
2236   // ordering performed by the worklist.
2237   VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
2238   std::reverse(I, E);
2239 }
2240 void EnqueueVisitor::VisitAddrLabelExpr(const AddrLabelExpr *E) {
2241   WL.push_back(LabelRefVisit(E->getLabel(), E->getLabelLoc(), Parent));
2242 }
2243 void EnqueueVisitor::VisitBlockExpr(const BlockExpr *B) {
2244   AddDecl(B->getBlockDecl());
2245 }
2246 void EnqueueVisitor::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
2247   EnqueueChildren(E);
2248   AddTypeLoc(E->getTypeSourceInfo());
2249 }
2250 void EnqueueVisitor::VisitCompoundStmt(const CompoundStmt *S) {
2251   for (auto &I : llvm::reverse(S->body()))
2252     AddStmt(I);
2253 }
2254 void EnqueueVisitor::
2255 VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) {
2256   AddStmt(S->getSubStmt());
2257   AddDeclarationNameInfo(S);
2258   if (NestedNameSpecifierLoc QualifierLoc = S->getQualifierLoc())
2259     AddNestedNameSpecifierLoc(QualifierLoc);
2260 }
2261
2262 void EnqueueVisitor::
2263 VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E) {
2264   if (E->hasExplicitTemplateArgs())
2265     AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs());
2266   AddDeclarationNameInfo(E);
2267   if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
2268     AddNestedNameSpecifierLoc(QualifierLoc);
2269   if (!E->isImplicitAccess())
2270     AddStmt(E->getBase());
2271 }
2272 void EnqueueVisitor::VisitCXXNewExpr(const CXXNewExpr *E) {
2273   // Enqueue the initializer , if any.
2274   AddStmt(E->getInitializer());
2275   // Enqueue the array size, if any.
2276   AddStmt(E->getArraySize());
2277   // Enqueue the allocated type.
2278   AddTypeLoc(E->getAllocatedTypeSourceInfo());
2279   // Enqueue the placement arguments.
2280   for (unsigned I = E->getNumPlacementArgs(); I > 0; --I)
2281     AddStmt(E->getPlacementArg(I-1));
2282 }
2283 void EnqueueVisitor::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *CE) {
2284   for (unsigned I = CE->getNumArgs(); I > 1 /* Yes, this is 1 */; --I)
2285     AddStmt(CE->getArg(I-1));
2286   AddStmt(CE->getCallee());
2287   AddStmt(CE->getArg(0));
2288 }
2289 void EnqueueVisitor::VisitCXXPseudoDestructorExpr(
2290                                         const CXXPseudoDestructorExpr *E) {
2291   // Visit the name of the type being destroyed.
2292   AddTypeLoc(E->getDestroyedTypeInfo());
2293   // Visit the scope type that looks disturbingly like the nested-name-specifier
2294   // but isn't.
2295   AddTypeLoc(E->getScopeTypeInfo());
2296   // Visit the nested-name-specifier.
2297   if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
2298     AddNestedNameSpecifierLoc(QualifierLoc);
2299   // Visit base expression.
2300   AddStmt(E->getBase());
2301 }
2302 void EnqueueVisitor::VisitCXXScalarValueInitExpr(
2303                                         const CXXScalarValueInitExpr *E) {
2304   AddTypeLoc(E->getTypeSourceInfo());
2305 }
2306 void EnqueueVisitor::VisitCXXTemporaryObjectExpr(
2307                                         const CXXTemporaryObjectExpr *E) {
2308   EnqueueChildren(E);
2309   AddTypeLoc(E->getTypeSourceInfo());
2310 }
2311 void EnqueueVisitor::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
2312   EnqueueChildren(E);
2313   if (E->isTypeOperand())
2314     AddTypeLoc(E->getTypeOperandSourceInfo());
2315 }
2316
2317 void EnqueueVisitor::VisitCXXUnresolvedConstructExpr(
2318                                         const CXXUnresolvedConstructExpr *E) {
2319   EnqueueChildren(E);
2320   AddTypeLoc(E->getTypeSourceInfo());
2321 }
2322 void EnqueueVisitor::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
2323   EnqueueChildren(E);
2324   if (E->isTypeOperand())
2325     AddTypeLoc(E->getTypeOperandSourceInfo());
2326 }
2327
2328 void EnqueueVisitor::VisitCXXCatchStmt(const CXXCatchStmt *S) {
2329   EnqueueChildren(S);
2330   AddDecl(S->getExceptionDecl());
2331 }
2332
2333 void EnqueueVisitor::VisitCXXForRangeStmt(const CXXForRangeStmt *S) {
2334   AddStmt(S->getBody());
2335   AddStmt(S->getRangeInit());
2336   AddDecl(S->getLoopVariable());
2337 }
2338
2339 void EnqueueVisitor::VisitDeclRefExpr(const DeclRefExpr *DR) {
2340   if (DR->hasExplicitTemplateArgs())
2341     AddExplicitTemplateArgs(DR->getTemplateArgs(), DR->getNumTemplateArgs());
2342   WL.push_back(DeclRefExprParts(DR, Parent));
2343 }
2344 void EnqueueVisitor::VisitDependentScopeDeclRefExpr(
2345                                         const DependentScopeDeclRefExpr *E) {
2346   if (E->hasExplicitTemplateArgs())
2347     AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs());
2348   AddDeclarationNameInfo(E);
2349   AddNestedNameSpecifierLoc(E->getQualifierLoc());
2350 }
2351 void EnqueueVisitor::VisitDeclStmt(const DeclStmt *S) {
2352   unsigned size = WL.size();
2353   bool isFirst = true;
2354   for (const auto *D : S->decls()) {
2355     AddDecl(D, isFirst);
2356     isFirst = false;
2357   }
2358   if (size == WL.size())
2359     return;
2360   // Now reverse the entries we just added.  This will match the DFS
2361   // ordering performed by the worklist.
2362   VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
2363   std::reverse(I, E);
2364 }
2365 void EnqueueVisitor::VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
2366   AddStmt(E->getInit());
2367   for (DesignatedInitExpr::const_reverse_designators_iterator
2368          D = E->designators_rbegin(), DEnd = E->designators_rend();
2369          D != DEnd; ++D) {
2370     if (D->isFieldDesignator()) {
2371       if (FieldDecl *Field = D->getField())
2372         AddMemberRef(Field, D->getFieldLoc());
2373       continue;
2374     }
2375     if (D->isArrayDesignator()) {
2376       AddStmt(E->getArrayIndex(*D));
2377       continue;
2378     }
2379     assert(D->isArrayRangeDesignator() && "Unknown designator kind");
2380     AddStmt(E->getArrayRangeEnd(*D));
2381     AddStmt(E->getArrayRangeStart(*D));
2382   }
2383 }
2384 void EnqueueVisitor::VisitExplicitCastExpr(const ExplicitCastExpr *E) {
2385   EnqueueChildren(E);
2386   AddTypeLoc(E->getTypeInfoAsWritten());
2387 }
2388 void EnqueueVisitor::VisitForStmt(const ForStmt *FS) {
2389   AddStmt(FS->getBody());
2390   AddStmt(FS->getInc());
2391   AddStmt(FS->getCond());
2392   AddDecl(FS->getConditionVariable());
2393   AddStmt(FS->getInit());
2394 }
2395 void EnqueueVisitor::VisitGotoStmt(const GotoStmt *GS) {
2396   WL.push_back(LabelRefVisit(GS->getLabel(), GS->getLabelLoc(), Parent));
2397 }
2398 void EnqueueVisitor::VisitIfStmt(const IfStmt *If) {
2399   AddStmt(If->getElse());
2400   AddStmt(If->getThen());
2401   AddStmt(If->getCond());
2402   AddDecl(If->getConditionVariable());
2403 }
2404 void EnqueueVisitor::VisitInitListExpr(const InitListExpr *IE) {
2405   // We care about the syntactic form of the initializer list, only.
2406   if (InitListExpr *Syntactic = IE->getSyntacticForm())
2407     IE = Syntactic;
2408   EnqueueChildren(IE);
2409 }
2410 void EnqueueVisitor::VisitMemberExpr(const MemberExpr *M) {
2411   WL.push_back(MemberExprParts(M, Parent));
2412   
2413   // If the base of the member access expression is an implicit 'this', don't
2414   // visit it.
2415   // FIXME: If we ever want to show these implicit accesses, this will be
2416   // unfortunate. However, clang_getCursor() relies on this behavior.
2417   if (M->isImplicitAccess())
2418     return;
2419
2420   // Ignore base anonymous struct/union fields, otherwise they will shadow the
2421   // real field that that we are interested in.
2422   if (auto *SubME = dyn_cast<MemberExpr>(M->getBase())) {
2423     if (auto *FD = dyn_cast_or_null<FieldDecl>(SubME->getMemberDecl())) {
2424       if (FD->isAnonymousStructOrUnion()) {
2425         AddStmt(SubME->getBase());
2426         return;
2427       }
2428     }
2429   }
2430
2431   AddStmt(M->getBase());
2432 }
2433 void EnqueueVisitor::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
2434   AddTypeLoc(E->getEncodedTypeSourceInfo());
2435 }
2436 void EnqueueVisitor::VisitObjCMessageExpr(const ObjCMessageExpr *M) {
2437   EnqueueChildren(M);
2438   AddTypeLoc(M->getClassReceiverTypeInfo());
2439 }
2440 void EnqueueVisitor::VisitOffsetOfExpr(const OffsetOfExpr *E) {
2441   // Visit the components of the offsetof expression.
2442   for (unsigned N = E->getNumComponents(), I = N; I > 0; --I) {
2443     typedef OffsetOfExpr::OffsetOfNode OffsetOfNode;
2444     const OffsetOfNode &Node = E->getComponent(I-1);
2445     switch (Node.getKind()) {
2446     case OffsetOfNode::Array:
2447       AddStmt(E->getIndexExpr(Node.getArrayExprIndex()));
2448       break;
2449     case OffsetOfNode::Field:
2450       AddMemberRef(Node.getField(), Node.getSourceRange().getEnd());
2451       break;
2452     case OffsetOfNode::Identifier:
2453     case OffsetOfNode::Base:
2454       continue;
2455     }
2456   }
2457   // Visit the type into which we're computing the offset.
2458   AddTypeLoc(E->getTypeSourceInfo());
2459 }
2460 void EnqueueVisitor::VisitOverloadExpr(const OverloadExpr *E) {
2461   if (E->hasExplicitTemplateArgs())
2462     AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs());
2463   WL.push_back(OverloadExprParts(E, Parent));
2464 }
2465 void EnqueueVisitor::VisitUnaryExprOrTypeTraitExpr(
2466                                         const UnaryExprOrTypeTraitExpr *E) {
2467   EnqueueChildren(E);
2468   if (E->isArgumentType())
2469     AddTypeLoc(E->getArgumentTypeInfo());
2470 }
2471 void EnqueueVisitor::VisitStmt(const Stmt *S) {
2472   EnqueueChildren(S);
2473 }
2474 void EnqueueVisitor::VisitSwitchStmt(const SwitchStmt *S) {
2475   AddStmt(S->getBody());
2476   AddStmt(S->getCond());
2477   AddDecl(S->getConditionVariable());
2478 }
2479
2480 void EnqueueVisitor::VisitWhileStmt(const WhileStmt *W) {
2481   AddStmt(W->getBody());
2482   AddStmt(W->getCond());
2483   AddDecl(W->getConditionVariable());
2484 }
2485
2486 void EnqueueVisitor::VisitTypeTraitExpr(const TypeTraitExpr *E) {
2487   for (unsigned I = E->getNumArgs(); I > 0; --I)
2488     AddTypeLoc(E->getArg(I-1));
2489 }
2490
2491 void EnqueueVisitor::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
2492   AddTypeLoc(E->getQueriedTypeSourceInfo());
2493 }
2494
2495 void EnqueueVisitor::VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
2496   EnqueueChildren(E);
2497 }
2498
2499 void EnqueueVisitor::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U) {
2500   VisitOverloadExpr(U);
2501   if (!U->isImplicitAccess())
2502     AddStmt(U->getBase());
2503 }
2504 void EnqueueVisitor::VisitVAArgExpr(const VAArgExpr *E) {
2505   AddStmt(E->getSubExpr());
2506   AddTypeLoc(E->getWrittenTypeInfo());
2507 }
2508 void EnqueueVisitor::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
2509   WL.push_back(SizeOfPackExprParts(E, Parent));
2510 }
2511 void EnqueueVisitor::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
2512   // If the opaque value has a source expression, just transparently
2513   // visit that.  This is useful for (e.g.) pseudo-object expressions.
2514   if (Expr *SourceExpr = E->getSourceExpr())
2515     return Visit(SourceExpr);
2516 }
2517 void EnqueueVisitor::VisitLambdaExpr(const LambdaExpr *E) {
2518   AddStmt(E->getBody());
2519   WL.push_back(LambdaExprParts(E, Parent));
2520 }
2521 void EnqueueVisitor::VisitPseudoObjectExpr(const PseudoObjectExpr *E) {
2522   // Treat the expression like its syntactic form.
2523   Visit(E->getSyntacticForm());
2524 }
2525
2526 void EnqueueVisitor::VisitOMPExecutableDirective(
2527   const OMPExecutableDirective *D) {
2528   EnqueueChildren(D);
2529   for (ArrayRef<OMPClause *>::iterator I = D->clauses().begin(),
2530                                        E = D->clauses().end();
2531        I != E; ++I)
2532     EnqueueChildren(*I);
2533 }
2534
2535 void EnqueueVisitor::VisitOMPLoopDirective(const OMPLoopDirective *D) {
2536   VisitOMPExecutableDirective(D);
2537 }
2538
2539 void EnqueueVisitor::VisitOMPParallelDirective(const OMPParallelDirective *D) {
2540   VisitOMPExecutableDirective(D);
2541 }
2542
2543 void EnqueueVisitor::VisitOMPSimdDirective(const OMPSimdDirective *D) {
2544   VisitOMPLoopDirective(D);
2545 }
2546
2547 void EnqueueVisitor::VisitOMPForDirective(const OMPForDirective *D) {
2548   VisitOMPLoopDirective(D);
2549 }
2550
2551 void EnqueueVisitor::VisitOMPForSimdDirective(const OMPForSimdDirective *D) {
2552   VisitOMPLoopDirective(D);
2553 }
2554
2555 void EnqueueVisitor::VisitOMPSectionsDirective(const OMPSectionsDirective *D) {
2556   VisitOMPExecutableDirective(D);
2557 }
2558
2559 void EnqueueVisitor::VisitOMPSectionDirective(const OMPSectionDirective *D) {
2560   VisitOMPExecutableDirective(D);
2561 }
2562
2563 void EnqueueVisitor::VisitOMPSingleDirective(const OMPSingleDirective *D) {
2564   VisitOMPExecutableDirective(D);
2565 }
2566
2567 void EnqueueVisitor::VisitOMPMasterDirective(const OMPMasterDirective *D) {
2568   VisitOMPExecutableDirective(D);
2569 }
2570
2571 void EnqueueVisitor::VisitOMPCriticalDirective(const OMPCriticalDirective *D) {
2572   VisitOMPExecutableDirective(D);
2573   AddDeclarationNameInfo(D);
2574 }
2575
2576 void
2577 EnqueueVisitor::VisitOMPParallelForDirective(const OMPParallelForDirective *D) {
2578   VisitOMPLoopDirective(D);
2579 }
2580
2581 void EnqueueVisitor::VisitOMPParallelForSimdDirective(
2582     const OMPParallelForSimdDirective *D) {
2583   VisitOMPLoopDirective(D);
2584 }
2585
2586 void EnqueueVisitor::VisitOMPParallelSectionsDirective(
2587     const OMPParallelSectionsDirective *D) {
2588   VisitOMPExecutableDirective(D);
2589 }
2590
2591 void EnqueueVisitor::VisitOMPTaskDirective(const OMPTaskDirective *D) {
2592   VisitOMPExecutableDirective(D);
2593 }
2594
2595 void
2596 EnqueueVisitor::VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *D) {
2597   VisitOMPExecutableDirective(D);
2598 }
2599
2600 void EnqueueVisitor::VisitOMPBarrierDirective(const OMPBarrierDirective *D) {
2601   VisitOMPExecutableDirective(D);
2602 }
2603
2604 void EnqueueVisitor::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D) {
2605   VisitOMPExecutableDirective(D);
2606 }
2607
2608 void EnqueueVisitor::VisitOMPTaskgroupDirective(
2609     const OMPTaskgroupDirective *D) {
2610   VisitOMPExecutableDirective(D);
2611 }
2612
2613 void EnqueueVisitor::VisitOMPFlushDirective(const OMPFlushDirective *D) {
2614   VisitOMPExecutableDirective(D);
2615 }
2616
2617 void EnqueueVisitor::VisitOMPOrderedDirective(const OMPOrderedDirective *D) {
2618   VisitOMPExecutableDirective(D);
2619 }
2620
2621 void EnqueueVisitor::VisitOMPAtomicDirective(const OMPAtomicDirective *D) {
2622   VisitOMPExecutableDirective(D);
2623 }
2624
2625 void EnqueueVisitor::VisitOMPTargetDirective(const OMPTargetDirective *D) {
2626   VisitOMPExecutableDirective(D);
2627 }
2628
2629 void EnqueueVisitor::VisitOMPTargetDataDirective(const 
2630                                                  OMPTargetDataDirective *D) {
2631   VisitOMPExecutableDirective(D);
2632 }
2633
2634 void EnqueueVisitor::VisitOMPTeamsDirective(const OMPTeamsDirective *D) {
2635   VisitOMPExecutableDirective(D);
2636 }
2637
2638 void EnqueueVisitor::VisitOMPCancellationPointDirective(
2639     const OMPCancellationPointDirective *D) {
2640   VisitOMPExecutableDirective(D);
2641 }
2642
2643 void EnqueueVisitor::VisitOMPCancelDirective(const OMPCancelDirective *D) {
2644   VisitOMPExecutableDirective(D);
2645 }
2646
2647 void EnqueueVisitor::VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D) {
2648   VisitOMPLoopDirective(D);
2649 }
2650
2651 void EnqueueVisitor::VisitOMPTaskLoopSimdDirective(
2652     const OMPTaskLoopSimdDirective *D) {
2653   VisitOMPLoopDirective(D);
2654 }
2655
2656 void EnqueueVisitor::VisitOMPDistributeDirective(
2657     const OMPDistributeDirective *D) {
2658   VisitOMPLoopDirective(D);
2659 }
2660
2661 void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) {
2662   EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S);
2663 }
2664
2665 bool CursorVisitor::IsInRegionOfInterest(CXCursor C) {
2666   if (RegionOfInterest.isValid()) {
2667     SourceRange Range = getRawCursorExtent(C);
2668     if (Range.isInvalid() || CompareRegionOfInterest(Range))
2669       return false;
2670   }
2671   return true;
2672 }
2673
2674 bool CursorVisitor::RunVisitorWorkList(VisitorWorkList &WL) {
2675   while (!WL.empty()) {
2676     // Dequeue the worklist item.
2677     VisitorJob LI = WL.pop_back_val();
2678
2679     // Set the Parent field, then back to its old value once we're done.
2680     SetParentRAII SetParent(Parent, StmtParent, LI.getParent());
2681   
2682     switch (LI.getKind()) {
2683       case VisitorJob::DeclVisitKind: {
2684         const Decl *D = cast<DeclVisit>(&LI)->get();
2685         if (!D)
2686           continue;
2687
2688         // For now, perform default visitation for Decls.
2689         if (Visit(MakeCXCursor(D, TU, RegionOfInterest,
2690                                cast<DeclVisit>(&LI)->isFirst())))
2691             return true;
2692
2693         continue;
2694       }
2695       case VisitorJob::ExplicitTemplateArgsVisitKind: {
2696         for (const TemplateArgumentLoc &Arg :
2697              *cast<ExplicitTemplateArgsVisit>(&LI)) {
2698           if (VisitTemplateArgumentLoc(Arg))
2699             return true;
2700         }
2701         continue;
2702       }
2703       case VisitorJob::TypeLocVisitKind: {
2704         // Perform default visitation for TypeLocs.
2705         if (Visit(cast<TypeLocVisit>(&LI)->get()))
2706           return true;
2707         continue;
2708       }
2709       case VisitorJob::LabelRefVisitKind: {
2710         const LabelDecl *LS = cast<LabelRefVisit>(&LI)->get();
2711         if (LabelStmt *stmt = LS->getStmt()) {
2712           if (Visit(MakeCursorLabelRef(stmt, cast<LabelRefVisit>(&LI)->getLoc(),
2713                                        TU))) {
2714             return true;
2715           }
2716         }
2717         continue;
2718       }
2719
2720       case VisitorJob::NestedNameSpecifierLocVisitKind: {
2721         NestedNameSpecifierLocVisit *V = cast<NestedNameSpecifierLocVisit>(&LI);
2722         if (VisitNestedNameSpecifierLoc(V->get()))
2723           return true;
2724         continue;
2725       }
2726         
2727       case VisitorJob::DeclarationNameInfoVisitKind: {
2728         if (VisitDeclarationNameInfo(cast<DeclarationNameInfoVisit>(&LI)
2729                                      ->get()))
2730           return true;
2731         continue;
2732       }
2733       case VisitorJob::MemberRefVisitKind: {
2734         MemberRefVisit *V = cast<MemberRefVisit>(&LI);
2735         if (Visit(MakeCursorMemberRef(V->get(), V->getLoc(), TU)))
2736           return true;
2737         continue;
2738       }
2739       case VisitorJob::StmtVisitKind: {
2740         const Stmt *S = cast<StmtVisit>(&LI)->get();
2741         if (!S)
2742           continue;
2743
2744         // Update the current cursor.
2745         CXCursor Cursor = MakeCXCursor(S, StmtParent, TU, RegionOfInterest);
2746         if (!IsInRegionOfInterest(Cursor))
2747           continue;
2748         switch (Visitor(Cursor, Parent, ClientData)) {
2749           case CXChildVisit_Break: return true;
2750           case CXChildVisit_Continue: break;
2751           case CXChildVisit_Recurse:
2752             if (PostChildrenVisitor)
2753               WL.push_back(PostChildrenVisit(nullptr, Cursor));
2754             EnqueueWorkList(WL, S);
2755             break;
2756         }
2757         continue;
2758       }
2759       case VisitorJob::MemberExprPartsKind: {
2760         // Handle the other pieces in the MemberExpr besides the base.
2761         const MemberExpr *M = cast<MemberExprParts>(&LI)->get();
2762         
2763         // Visit the nested-name-specifier
2764         if (NestedNameSpecifierLoc QualifierLoc = M->getQualifierLoc())
2765           if (VisitNestedNameSpecifierLoc(QualifierLoc))
2766             return true;
2767         
2768         // Visit the declaration name.
2769         if (VisitDeclarationNameInfo(M->getMemberNameInfo()))
2770           return true;
2771         
2772         // Visit the explicitly-specified template arguments, if any.
2773         if (M->hasExplicitTemplateArgs()) {
2774           for (const TemplateArgumentLoc *Arg = M->getTemplateArgs(),
2775                *ArgEnd = Arg + M->getNumTemplateArgs();
2776                Arg != ArgEnd; ++Arg) {
2777             if (VisitTemplateArgumentLoc(*Arg))
2778               return true;
2779           }
2780         }
2781         continue;
2782       }
2783       case VisitorJob::DeclRefExprPartsKind: {
2784         const DeclRefExpr *DR = cast<DeclRefExprParts>(&LI)->get();
2785         // Visit nested-name-specifier, if present.
2786         if (NestedNameSpecifierLoc QualifierLoc = DR->getQualifierLoc())
2787           if (VisitNestedNameSpecifierLoc(QualifierLoc))
2788             return true;
2789         // Visit declaration name.
2790         if (VisitDeclarationNameInfo(DR->getNameInfo()))
2791           return true;
2792         continue;
2793       }
2794       case VisitorJob::OverloadExprPartsKind: {
2795         const OverloadExpr *O = cast<OverloadExprParts>(&LI)->get();
2796         // Visit the nested-name-specifier.
2797         if (NestedNameSpecifierLoc QualifierLoc = O->getQualifierLoc())
2798           if (VisitNestedNameSpecifierLoc(QualifierLoc))
2799             return true;
2800         // Visit the declaration name.
2801         if (VisitDeclarationNameInfo(O->getNameInfo()))
2802           return true;
2803         // Visit the overloaded declaration reference.
2804         if (Visit(MakeCursorOverloadedDeclRef(O, TU)))
2805           return true;
2806         continue;
2807       }
2808       case VisitorJob::SizeOfPackExprPartsKind: {
2809         const SizeOfPackExpr *E = cast<SizeOfPackExprParts>(&LI)->get();
2810         NamedDecl *Pack = E->getPack();
2811         if (isa<TemplateTypeParmDecl>(Pack)) {
2812           if (Visit(MakeCursorTypeRef(cast<TemplateTypeParmDecl>(Pack),
2813                                       E->getPackLoc(), TU)))
2814             return true;
2815           
2816           continue;
2817         }
2818           
2819         if (isa<TemplateTemplateParmDecl>(Pack)) {
2820           if (Visit(MakeCursorTemplateRef(cast<TemplateTemplateParmDecl>(Pack),
2821                                           E->getPackLoc(), TU)))
2822             return true;
2823           
2824           continue;
2825         }
2826         
2827         // Non-type template parameter packs and function parameter packs are
2828         // treated like DeclRefExpr cursors.
2829         continue;
2830       }
2831         
2832       case VisitorJob::LambdaExprPartsKind: {
2833         // Visit captures.
2834         const LambdaExpr *E = cast<LambdaExprParts>(&LI)->get();
2835         for (LambdaExpr::capture_iterator C = E->explicit_capture_begin(),
2836                                        CEnd = E->explicit_capture_end();
2837              C != CEnd; ++C) {
2838           // FIXME: Lambda init-captures.
2839           if (!C->capturesVariable())
2840             continue;
2841
2842           if (Visit(MakeCursorVariableRef(C->getCapturedVar(),
2843                                           C->getLocation(),
2844                                           TU)))
2845             return true;
2846         }
2847         
2848         // Visit parameters and return type, if present.
2849         if (E->hasExplicitParameters() || E->hasExplicitResultType()) {
2850           TypeLoc TL = E->getCallOperator()->getTypeSourceInfo()->getTypeLoc();
2851           if (E->hasExplicitParameters() && E->hasExplicitResultType()) {
2852             // Visit the whole type.
2853             if (Visit(TL))
2854               return true;
2855           } else if (FunctionProtoTypeLoc Proto =
2856                          TL.getAs<FunctionProtoTypeLoc>()) {
2857             if (E->hasExplicitParameters()) {
2858               // Visit parameters.
2859               for (unsigned I = 0, N = Proto.getNumParams(); I != N; ++I)
2860                 if (Visit(MakeCXCursor(Proto.getParam(I), TU)))
2861                   return true;
2862             } else {
2863               // Visit result type.
2864               if (Visit(Proto.getReturnLoc()))
2865                 return true;
2866             }
2867           }
2868         }
2869         break;
2870       }
2871
2872       case VisitorJob::PostChildrenVisitKind:
2873         if (PostChildrenVisitor(Parent, ClientData))
2874           return true;
2875         break;
2876     }
2877   }
2878   return false;
2879 }
2880
2881 bool CursorVisitor::Visit(const Stmt *S) {
2882   VisitorWorkList *WL = nullptr;
2883   if (!WorkListFreeList.empty()) {
2884     WL = WorkListFreeList.back();
2885     WL->clear();
2886     WorkListFreeList.pop_back();
2887   }
2888   else {
2889     WL = new VisitorWorkList();
2890     WorkListCache.push_back(WL);
2891   }
2892   EnqueueWorkList(*WL, S);
2893   bool result = RunVisitorWorkList(*WL);
2894   WorkListFreeList.push_back(WL);
2895   return result;
2896 }
2897
2898 namespace {
2899 typedef SmallVector<SourceRange, 4> RefNamePieces;
2900 RefNamePieces buildPieces(unsigned NameFlags, bool IsMemberRefExpr,
2901                           const DeclarationNameInfo &NI, SourceRange QLoc,
2902                           const SourceRange *TemplateArgsLoc = nullptr) {
2903   const bool WantQualifier = NameFlags & CXNameRange_WantQualifier;
2904   const bool WantTemplateArgs = NameFlags & CXNameRange_WantTemplateArgs;
2905   const bool WantSinglePiece = NameFlags & CXNameRange_WantSinglePiece;
2906   
2907   const DeclarationName::NameKind Kind = NI.getName().getNameKind();
2908   
2909   RefNamePieces Pieces;
2910
2911   if (WantQualifier && QLoc.isValid())
2912     Pieces.push_back(QLoc);
2913   
2914   if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr)
2915     Pieces.push_back(NI.getLoc());
2916
2917   if (WantTemplateArgs && TemplateArgsLoc && TemplateArgsLoc->isValid())
2918     Pieces.push_back(*TemplateArgsLoc);
2919
2920   if (Kind == DeclarationName::CXXOperatorName) {
2921     Pieces.push_back(SourceLocation::getFromRawEncoding(
2922                        NI.getInfo().CXXOperatorName.BeginOpNameLoc));
2923     Pieces.push_back(SourceLocation::getFromRawEncoding(
2924                        NI.getInfo().CXXOperatorName.EndOpNameLoc));
2925   }
2926   
2927   if (WantSinglePiece) {
2928     SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd());
2929     Pieces.clear();
2930     Pieces.push_back(R);
2931   }  
2932
2933   return Pieces;  
2934 }
2935 }
2936
2937 //===----------------------------------------------------------------------===//
2938 // Misc. API hooks.
2939 //===----------------------------------------------------------------------===//               
2940
2941 static void fatal_error_handler(void *user_data, const std::string& reason,
2942                                 bool gen_crash_diag) {
2943   // Write the result out to stderr avoiding errs() because raw_ostreams can
2944   // call report_fatal_error.
2945   fprintf(stderr, "LIBCLANG FATAL ERROR: %s\n", reason.c_str());
2946   ::abort();
2947 }
2948
2949 namespace {
2950 struct RegisterFatalErrorHandler {
2951   RegisterFatalErrorHandler() {
2952     llvm::install_fatal_error_handler(fatal_error_handler, nullptr);
2953   }
2954 };
2955 }
2956
2957 static llvm::ManagedStatic<RegisterFatalErrorHandler> RegisterFatalErrorHandlerOnce;
2958
2959 extern "C" {
2960 CXIndex clang_createIndex(int excludeDeclarationsFromPCH,
2961                           int displayDiagnostics) {
2962   // We use crash recovery to make some of our APIs more reliable, implicitly
2963   // enable it.
2964   if (!getenv("LIBCLANG_DISABLE_CRASH_RECOVERY"))
2965     llvm::CrashRecoveryContext::Enable();
2966
2967   // Look through the managed static to trigger construction of the managed
2968   // static which registers our fatal error handler. This ensures it is only
2969   // registered once.
2970   (void)*RegisterFatalErrorHandlerOnce;
2971
2972   // Initialize targets for clang module support.
2973   llvm::InitializeAllTargets();
2974   llvm::InitializeAllTargetMCs();
2975   llvm::InitializeAllAsmPrinters();
2976   llvm::InitializeAllAsmParsers();
2977
2978   CIndexer *CIdxr = new CIndexer();
2979
2980   if (excludeDeclarationsFromPCH)
2981     CIdxr->setOnlyLocalDecls();
2982   if (displayDiagnostics)
2983     CIdxr->setDisplayDiagnostics();
2984
2985   if (getenv("LIBCLANG_BGPRIO_INDEX"))
2986     CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() |
2987                                CXGlobalOpt_ThreadBackgroundPriorityForIndexing);
2988   if (getenv("LIBCLANG_BGPRIO_EDIT"))
2989     CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() |
2990                                CXGlobalOpt_ThreadBackgroundPriorityForEditing);
2991
2992   return CIdxr;
2993 }
2994
2995 void clang_disposeIndex(CXIndex CIdx) {
2996   if (CIdx)
2997     delete static_cast<CIndexer *>(CIdx);
2998 }
2999
3000 void clang_CXIndex_setGlobalOptions(CXIndex CIdx, unsigned options) {
3001   if (CIdx)
3002     static_cast<CIndexer *>(CIdx)->setCXGlobalOptFlags(options);
3003 }
3004
3005 unsigned clang_CXIndex_getGlobalOptions(CXIndex CIdx) {
3006   if (CIdx)
3007     return static_cast<CIndexer *>(CIdx)->getCXGlobalOptFlags();
3008   return 0;
3009 }
3010
3011 void clang_toggleCrashRecovery(unsigned isEnabled) {
3012   if (isEnabled)
3013     llvm::CrashRecoveryContext::Enable();
3014   else
3015     llvm::CrashRecoveryContext::Disable();
3016 }
3017
3018 CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx,
3019                                               const char *ast_filename) {
3020   CXTranslationUnit TU;
3021   enum CXErrorCode Result =
3022       clang_createTranslationUnit2(CIdx, ast_filename, &TU);
3023   (void)Result;
3024   assert((TU && Result == CXError_Success) ||
3025          (!TU && Result != CXError_Success));
3026   return TU;
3027 }
3028
3029 enum CXErrorCode clang_createTranslationUnit2(CXIndex CIdx,
3030                                               const char *ast_filename,
3031                                               CXTranslationUnit *out_TU) {
3032   if (out_TU)
3033     *out_TU = nullptr;
3034
3035   if (!CIdx || !ast_filename || !out_TU)
3036     return CXError_InvalidArguments;
3037
3038   LOG_FUNC_SECTION {
3039     *Log << ast_filename;
3040   }
3041
3042   CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
3043   FileSystemOptions FileSystemOpts;
3044
3045   IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
3046       CompilerInstance::createDiagnostics(new DiagnosticOptions());
3047   std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile(
3048       ast_filename, CXXIdx->getPCHContainerOperations()->getRawReader(), Diags,
3049       FileSystemOpts, /*UseDebugInfo=*/false,
3050       CXXIdx->getOnlyLocalDecls(), None,
3051       /*CaptureDiagnostics=*/true,
3052       /*AllowPCHWithCompilerErrors=*/true,
3053       /*UserFilesAreVolatile=*/true);
3054   *out_TU = MakeCXTranslationUnit(CXXIdx, AU.release());
3055   return *out_TU ? CXError_Success : CXError_Failure;
3056 }
3057
3058 unsigned clang_defaultEditingTranslationUnitOptions() {
3059   return CXTranslationUnit_PrecompiledPreamble | 
3060          CXTranslationUnit_CacheCompletionResults;
3061 }
3062
3063 CXTranslationUnit
3064 clang_createTranslationUnitFromSourceFile(CXIndex CIdx,
3065                                           const char *source_filename,
3066                                           int num_command_line_args,
3067                                           const char * const *command_line_args,
3068                                           unsigned num_unsaved_files,
3069                                           struct CXUnsavedFile *unsaved_files) {
3070   unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord;
3071   return clang_parseTranslationUnit(CIdx, source_filename,
3072                                     command_line_args, num_command_line_args,
3073                                     unsaved_files, num_unsaved_files,
3074                                     Options);
3075 }
3076
3077 static CXErrorCode
3078 clang_parseTranslationUnit_Impl(CXIndex CIdx, const char *source_filename,
3079                                 const char *const *command_line_args,
3080                                 int num_command_line_args,
3081                                 ArrayRef<CXUnsavedFile> unsaved_files,
3082                                 unsigned options, CXTranslationUnit *out_TU) {
3083   // Set up the initial return values.
3084   if (out_TU)
3085     *out_TU = nullptr;
3086
3087   // Check arguments.
3088   if (!CIdx || !out_TU)
3089     return CXError_InvalidArguments;
3090
3091   CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
3092
3093   if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
3094     setThreadBackgroundPriority();
3095
3096   bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble;
3097   bool CreatePreambleOnFirstParse =
3098       options & CXTranslationUnit_CreatePreambleOnFirstParse;
3099   // FIXME: Add a flag for modules.
3100   TranslationUnitKind TUKind
3101     = (options & CXTranslationUnit_Incomplete)? TU_Prefix : TU_Complete;
3102   bool CacheCodeCompletionResults
3103     = options & CXTranslationUnit_CacheCompletionResults;
3104   bool IncludeBriefCommentsInCodeCompletion
3105     = options & CXTranslationUnit_IncludeBriefCommentsInCodeCompletion;
3106   bool SkipFunctionBodies = options & CXTranslationUnit_SkipFunctionBodies;
3107   bool ForSerialization = options & CXTranslationUnit_ForSerialization;
3108
3109   // Configure the diagnostics.
3110   IntrusiveRefCntPtr<DiagnosticsEngine>
3111     Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions));
3112
3113   // Recover resources if we crash before exiting this function.
3114   llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
3115     llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
3116     DiagCleanup(Diags.get());
3117
3118   std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles(
3119       new std::vector<ASTUnit::RemappedFile>());
3120
3121   // Recover resources if we crash before exiting this function.
3122   llvm::CrashRecoveryContextCleanupRegistrar<
3123     std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
3124
3125   for (auto &UF : unsaved_files) {
3126     std::unique_ptr<llvm::MemoryBuffer> MB =
3127         llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
3128     RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release()));
3129   }
3130
3131   std::unique_ptr<std::vector<const char *>> Args(
3132       new std::vector<const char *>());
3133
3134   // Recover resources if we crash before exiting this method.
3135   llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char*> >
3136     ArgsCleanup(Args.get());
3137
3138   // Since the Clang C library is primarily used by batch tools dealing with
3139   // (often very broken) source code, where spell-checking can have a
3140   // significant negative impact on performance (particularly when 
3141   // precompiled headers are involved), we disable it by default.
3142   // Only do this if we haven't found a spell-checking-related argument.
3143   bool FoundSpellCheckingArgument = false;
3144   for (int I = 0; I != num_command_line_args; ++I) {
3145     if (strcmp(command_line_args[I], "-fno-spell-checking") == 0 ||
3146         strcmp(command_line_args[I], "-fspell-checking") == 0) {
3147       FoundSpellCheckingArgument = true;
3148       break;
3149     }
3150   }
3151   Args->insert(Args->end(), command_line_args,
3152                command_line_args + num_command_line_args);
3153
3154   if (!FoundSpellCheckingArgument)
3155     Args->insert(Args->begin() + 1, "-fno-spell-checking");
3156
3157   // The 'source_filename' argument is optional.  If the caller does not
3158   // specify it then it is assumed that the source file is specified
3159   // in the actual argument list.
3160   // Put the source file after command_line_args otherwise if '-x' flag is
3161   // present it will be unused.
3162   if (source_filename)
3163     Args->push_back(source_filename);
3164
3165   // Do we need the detailed preprocessing record?
3166   if (options & CXTranslationUnit_DetailedPreprocessingRecord) {
3167     Args->push_back("-Xclang");
3168     Args->push_back("-detailed-preprocessing-record");
3169   }
3170   
3171   unsigned NumErrors = Diags->getClient()->getNumErrors();
3172   std::unique_ptr<ASTUnit> ErrUnit;
3173   // Unless the user specified that they want the preamble on the first parse
3174   // set it up to be created on the first reparse. This makes the first parse
3175   // faster, trading for a slower (first) reparse.
3176   unsigned PrecompilePreambleAfterNParses =
3177       !PrecompilePreamble ? 0 : 2 - CreatePreambleOnFirstParse;
3178   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCommandLine(
3179       Args->data(), Args->data() + Args->size(),
3180       CXXIdx->getPCHContainerOperations(), Diags,
3181       CXXIdx->getClangResourcesPath(), CXXIdx->getOnlyLocalDecls(),
3182       /*CaptureDiagnostics=*/true, *RemappedFiles.get(),
3183       /*RemappedFilesKeepOriginalName=*/true, PrecompilePreambleAfterNParses,
3184       TUKind, CacheCodeCompletionResults, IncludeBriefCommentsInCodeCompletion,
3185       /*AllowPCHWithCompilerErrors=*/true, SkipFunctionBodies,
3186       /*UserFilesAreVolatile=*/true, ForSerialization,
3187       CXXIdx->getPCHContainerOperations()->getRawReader().getFormat(),
3188       &ErrUnit));
3189
3190   // Early failures in LoadFromCommandLine may return with ErrUnit unset.
3191   if (!Unit && !ErrUnit)
3192     return CXError_ASTReadError;
3193
3194   if (NumErrors != Diags->getClient()->getNumErrors()) {
3195     // Make sure to check that 'Unit' is non-NULL.
3196     if (CXXIdx->getDisplayDiagnostics())
3197       printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get());
3198   }
3199
3200   if (isASTReadError(Unit ? Unit.get() : ErrUnit.get()))
3201     return CXError_ASTReadError;
3202
3203   *out_TU = MakeCXTranslationUnit(CXXIdx, Unit.release());
3204   return *out_TU ? CXError_Success : CXError_Failure;
3205 }
3206
3207 CXTranslationUnit
3208 clang_parseTranslationUnit(CXIndex CIdx,
3209                            const char *source_filename,
3210                            const char *const *command_line_args,
3211                            int num_command_line_args,
3212                            struct CXUnsavedFile *unsaved_files,
3213                            unsigned num_unsaved_files,
3214                            unsigned options) {
3215   CXTranslationUnit TU;
3216   enum CXErrorCode Result = clang_parseTranslationUnit2(
3217       CIdx, source_filename, command_line_args, num_command_line_args,
3218       unsaved_files, num_unsaved_files, options, &TU);
3219   (void)Result;
3220   assert((TU && Result == CXError_Success) ||
3221          (!TU && Result != CXError_Success));
3222   return TU;
3223 }
3224
3225 enum CXErrorCode clang_parseTranslationUnit2(
3226     CXIndex CIdx, const char *source_filename,
3227     const char *const *command_line_args, int num_command_line_args,
3228     struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files,
3229     unsigned options, CXTranslationUnit *out_TU) {
3230   SmallVector<const char *, 4> Args;
3231   Args.push_back("clang");
3232   Args.append(command_line_args, command_line_args + num_command_line_args);
3233   return clang_parseTranslationUnit2FullArgv(
3234       CIdx, source_filename, Args.data(), Args.size(), unsaved_files,
3235       num_unsaved_files, options, out_TU);
3236 }
3237
3238 enum CXErrorCode clang_parseTranslationUnit2FullArgv(
3239     CXIndex CIdx, const char *source_filename,
3240     const char *const *command_line_args, int num_command_line_args,
3241     struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files,
3242     unsigned options, CXTranslationUnit *out_TU) {
3243   LOG_FUNC_SECTION {
3244     *Log << source_filename << ": ";
3245     for (int i = 0; i != num_command_line_args; ++i)
3246       *Log << command_line_args[i] << " ";
3247   }
3248
3249   if (num_unsaved_files && !unsaved_files)
3250     return CXError_InvalidArguments;
3251
3252   CXErrorCode result = CXError_Failure;
3253   auto ParseTranslationUnitImpl = [=, &result] {
3254     result = clang_parseTranslationUnit_Impl(
3255         CIdx, source_filename, command_line_args, num_command_line_args,
3256         llvm::makeArrayRef(unsaved_files, num_unsaved_files), options, out_TU);
3257   };
3258   llvm::CrashRecoveryContext CRC;
3259
3260   if (!RunSafely(CRC, ParseTranslationUnitImpl)) {
3261     fprintf(stderr, "libclang: crash detected during parsing: {\n");
3262     fprintf(stderr, "  'source_filename' : '%s'\n", source_filename);
3263     fprintf(stderr, "  'command_line_args' : [");
3264     for (int i = 0; i != num_command_line_args; ++i) {
3265       if (i)
3266         fprintf(stderr, ", ");
3267       fprintf(stderr, "'%s'", command_line_args[i]);
3268     }
3269     fprintf(stderr, "],\n");
3270     fprintf(stderr, "  'unsaved_files' : [");
3271     for (unsigned i = 0; i != num_unsaved_files; ++i) {
3272       if (i)
3273         fprintf(stderr, ", ");
3274       fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename,
3275               unsaved_files[i].Length);
3276     }
3277     fprintf(stderr, "],\n");
3278     fprintf(stderr, "  'options' : %d,\n", options);
3279     fprintf(stderr, "}\n");
3280
3281     return CXError_Crashed;
3282   } else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
3283     if (CXTranslationUnit *TU = out_TU)
3284       PrintLibclangResourceUsage(*TU);
3285   }
3286
3287   return result;
3288 }
3289
3290 unsigned clang_defaultSaveOptions(CXTranslationUnit TU) {
3291   return CXSaveTranslationUnit_None;
3292 }  
3293
3294 static CXSaveError clang_saveTranslationUnit_Impl(CXTranslationUnit TU,
3295                                                   const char *FileName,
3296                                                   unsigned options) {
3297   CIndexer *CXXIdx = TU->CIdx;
3298   if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
3299     setThreadBackgroundPriority();
3300
3301   bool hadError = cxtu::getASTUnit(TU)->Save(FileName);
3302   return hadError ? CXSaveError_Unknown : CXSaveError_None;
3303 }
3304
3305 int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName,
3306                               unsigned options) {
3307   LOG_FUNC_SECTION {
3308     *Log << TU << ' ' << FileName;
3309   }
3310
3311   if (isNotUsableTU(TU)) {
3312     LOG_BAD_TU(TU);
3313     return CXSaveError_InvalidTU;
3314   }
3315
3316   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
3317   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
3318   if (!CXXUnit->hasSema())
3319     return CXSaveError_InvalidTU;
3320
3321   CXSaveError result;
3322   auto SaveTranslationUnitImpl = [=, &result]() {
3323     result = clang_saveTranslationUnit_Impl(TU, FileName, options);
3324   };
3325
3326   if (!CXXUnit->getDiagnostics().hasUnrecoverableErrorOccurred() ||
3327       getenv("LIBCLANG_NOTHREADS")) {
3328     SaveTranslationUnitImpl();
3329
3330     if (getenv("LIBCLANG_RESOURCE_USAGE"))
3331       PrintLibclangResourceUsage(TU);
3332
3333     return result;
3334   }
3335
3336   // We have an AST that has invalid nodes due to compiler errors.
3337   // Use a crash recovery thread for protection.
3338
3339   llvm::CrashRecoveryContext CRC;
3340
3341   if (!RunSafely(CRC, SaveTranslationUnitImpl)) {
3342     fprintf(stderr, "libclang: crash detected during AST saving: {\n");
3343     fprintf(stderr, "  'filename' : '%s'\n", FileName);
3344     fprintf(stderr, "  'options' : %d,\n", options);
3345     fprintf(stderr, "}\n");
3346
3347     return CXSaveError_Unknown;
3348
3349   } else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
3350     PrintLibclangResourceUsage(TU);
3351   }
3352
3353   return result;
3354 }
3355
3356 void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) {
3357   if (CTUnit) {
3358     // If the translation unit has been marked as unsafe to free, just discard
3359     // it.
3360     ASTUnit *Unit = cxtu::getASTUnit(CTUnit);
3361     if (Unit && Unit->isUnsafeToFree())
3362       return;
3363
3364     delete cxtu::getASTUnit(CTUnit);
3365     delete CTUnit->StringPool;
3366     delete static_cast<CXDiagnosticSetImpl *>(CTUnit->Diagnostics);
3367     disposeOverridenCXCursorsPool(CTUnit->OverridenCursorsPool);
3368     delete CTUnit->CommentToXML;
3369     delete CTUnit;
3370   }
3371 }
3372
3373 unsigned clang_defaultReparseOptions(CXTranslationUnit TU) {
3374   return CXReparse_None;
3375 }
3376
3377 static CXErrorCode
3378 clang_reparseTranslationUnit_Impl(CXTranslationUnit TU,
3379                                   ArrayRef<CXUnsavedFile> unsaved_files,
3380                                   unsigned options) {
3381   // Check arguments.
3382   if (isNotUsableTU(TU)) {
3383     LOG_BAD_TU(TU);
3384     return CXError_InvalidArguments;
3385   }
3386
3387   // Reset the associated diagnostics.
3388   delete static_cast<CXDiagnosticSetImpl*>(TU->Diagnostics);
3389   TU->Diagnostics = nullptr;
3390
3391   CIndexer *CXXIdx = TU->CIdx;
3392   if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
3393     setThreadBackgroundPriority();
3394
3395   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
3396   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
3397
3398   std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles(
3399       new std::vector<ASTUnit::RemappedFile>());
3400
3401   // Recover resources if we crash before exiting this function.
3402   llvm::CrashRecoveryContextCleanupRegistrar<
3403     std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
3404
3405   for (auto &UF : unsaved_files) {
3406     std::unique_ptr<llvm::MemoryBuffer> MB =
3407         llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
3408     RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release()));
3409   }
3410
3411   if (!CXXUnit->Reparse(CXXIdx->getPCHContainerOperations(),
3412                         *RemappedFiles.get()))
3413     return CXError_Success;
3414   if (isASTReadError(CXXUnit))
3415     return CXError_ASTReadError;
3416   return CXError_Failure;
3417 }
3418
3419 int clang_reparseTranslationUnit(CXTranslationUnit TU,
3420                                  unsigned num_unsaved_files,
3421                                  struct CXUnsavedFile *unsaved_files,
3422                                  unsigned options) {
3423   LOG_FUNC_SECTION {
3424     *Log << TU;
3425   }
3426
3427   if (num_unsaved_files && !unsaved_files)
3428     return CXError_InvalidArguments;
3429
3430   CXErrorCode result;
3431   auto ReparseTranslationUnitImpl = [=, &result]() {
3432     result = clang_reparseTranslationUnit_Impl(
3433         TU, llvm::makeArrayRef(unsaved_files, num_unsaved_files), options);
3434   };
3435
3436   if (getenv("LIBCLANG_NOTHREADS")) {
3437     ReparseTranslationUnitImpl();
3438     return result;
3439   }
3440
3441   llvm::CrashRecoveryContext CRC;
3442
3443   if (!RunSafely(CRC, ReparseTranslationUnitImpl)) {
3444     fprintf(stderr, "libclang: crash detected during reparsing\n");
3445     cxtu::getASTUnit(TU)->setUnsafeToFree(true);
3446     return CXError_Crashed;
3447   } else if (getenv("LIBCLANG_RESOURCE_USAGE"))
3448     PrintLibclangResourceUsage(TU);
3449
3450   return result;
3451 }
3452
3453
3454 CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) {
3455   if (isNotUsableTU(CTUnit)) {
3456     LOG_BAD_TU(CTUnit);
3457     return cxstring::createEmpty();
3458   }
3459
3460   ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit);
3461   return cxstring::createDup(CXXUnit->getOriginalSourceFileName());
3462 }
3463
3464 CXCursor clang_getTranslationUnitCursor(CXTranslationUnit TU) {
3465   if (isNotUsableTU(TU)) {
3466     LOG_BAD_TU(TU);
3467     return clang_getNullCursor();
3468   }
3469
3470   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
3471   return MakeCXCursor(CXXUnit->getASTContext().getTranslationUnitDecl(), TU);
3472 }
3473
3474 } // end: extern "C"
3475
3476 //===----------------------------------------------------------------------===//
3477 // CXFile Operations.
3478 //===----------------------------------------------------------------------===//
3479
3480 extern "C" {
3481 CXString clang_getFileName(CXFile SFile) {
3482   if (!SFile)
3483     return cxstring::createNull();
3484
3485   FileEntry *FEnt = static_cast<FileEntry *>(SFile);
3486   return cxstring::createRef(FEnt->getName());
3487 }
3488
3489 time_t clang_getFileTime(CXFile SFile) {
3490   if (!SFile)
3491     return 0;
3492
3493   FileEntry *FEnt = static_cast<FileEntry *>(SFile);
3494   return FEnt->getModificationTime();
3495 }
3496
3497 CXFile clang_getFile(CXTranslationUnit TU, const char *file_name) {
3498   if (isNotUsableTU(TU)) {
3499     LOG_BAD_TU(TU);
3500     return nullptr;
3501   }
3502
3503   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
3504
3505   FileManager &FMgr = CXXUnit->getFileManager();
3506   return const_cast<FileEntry *>(FMgr.getFile(file_name));
3507 }
3508
3509 unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit TU,
3510                                             CXFile file) {
3511   if (isNotUsableTU(TU)) {
3512     LOG_BAD_TU(TU);
3513     return 0;
3514   }
3515
3516   if (!file)
3517     return 0;
3518
3519   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
3520   FileEntry *FEnt = static_cast<FileEntry *>(file);
3521   return CXXUnit->getPreprocessor().getHeaderSearchInfo()
3522                                           .isFileMultipleIncludeGuarded(FEnt);
3523 }
3524
3525 int clang_getFileUniqueID(CXFile file, CXFileUniqueID *outID) {
3526   if (!file || !outID)
3527     return 1;
3528
3529   FileEntry *FEnt = static_cast<FileEntry *>(file);
3530   const llvm::sys::fs::UniqueID &ID = FEnt->getUniqueID();
3531   outID->data[0] = ID.getDevice();
3532   outID->data[1] = ID.getFile();
3533   outID->data[2] = FEnt->getModificationTime();
3534   return 0;
3535 }
3536
3537 int clang_File_isEqual(CXFile file1, CXFile file2) {
3538   if (file1 == file2)
3539     return true;
3540
3541   if (!file1 || !file2)
3542     return false;
3543
3544   FileEntry *FEnt1 = static_cast<FileEntry *>(file1);
3545   FileEntry *FEnt2 = static_cast<FileEntry *>(file2);
3546   return FEnt1->getUniqueID() == FEnt2->getUniqueID();
3547 }
3548
3549 } // end: extern "C"
3550
3551 //===----------------------------------------------------------------------===//
3552 // CXCursor Operations.
3553 //===----------------------------------------------------------------------===//
3554
3555 static const Decl *getDeclFromExpr(const Stmt *E) {
3556   if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
3557     return getDeclFromExpr(CE->getSubExpr());
3558
3559   if (const DeclRefExpr *RefExpr = dyn_cast<DeclRefExpr>(E))
3560     return RefExpr->getDecl();
3561   if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
3562     return ME->getMemberDecl();
3563   if (const ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(E))
3564     return RE->getDecl();
3565   if (const ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(E)) {
3566     if (PRE->isExplicitProperty())
3567       return PRE->getExplicitProperty();
3568     // It could be messaging both getter and setter as in:
3569     // ++myobj.myprop;
3570     // in which case prefer to associate the setter since it is less obvious
3571     // from inspecting the source that the setter is going to get called.
3572     if (PRE->isMessagingSetter())
3573       return PRE->getImplicitPropertySetter();
3574     return PRE->getImplicitPropertyGetter();
3575   }
3576   if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
3577     return getDeclFromExpr(POE->getSyntacticForm());
3578   if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E))
3579     if (Expr *Src = OVE->getSourceExpr())
3580       return getDeclFromExpr(Src);
3581       
3582   if (const CallExpr *CE = dyn_cast<CallExpr>(E))
3583     return getDeclFromExpr(CE->getCallee());
3584   if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E))
3585     if (!CE->isElidable())
3586     return CE->getConstructor();
3587   if (const ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E))
3588     return OME->getMethodDecl();
3589
3590   if (const ObjCProtocolExpr *PE = dyn_cast<ObjCProtocolExpr>(E))
3591     return PE->getProtocol();
3592   if (const SubstNonTypeTemplateParmPackExpr *NTTP
3593                               = dyn_cast<SubstNonTypeTemplateParmPackExpr>(E))
3594     return NTTP->getParameterPack();
3595   if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
3596     if (isa<NonTypeTemplateParmDecl>(SizeOfPack->getPack()) || 
3597         isa<ParmVarDecl>(SizeOfPack->getPack()))
3598       return SizeOfPack->getPack();
3599
3600   return nullptr;
3601 }
3602
3603 static SourceLocation getLocationFromExpr(const Expr *E) {
3604   if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
3605     return getLocationFromExpr(CE->getSubExpr());
3606
3607   if (const ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E))
3608     return /*FIXME:*/Msg->getLeftLoc();
3609   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
3610     return DRE->getLocation();
3611   if (const MemberExpr *Member = dyn_cast<MemberExpr>(E))
3612     return Member->getMemberLoc();
3613   if (const ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E))
3614     return Ivar->getLocation();
3615   if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
3616     return SizeOfPack->getPackLoc();
3617   if (const ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E))
3618     return PropRef->getLocation();
3619   
3620   return E->getLocStart();
3621 }
3622
3623 static std::string getMangledStructor(std::unique_ptr<MangleContext> &M,
3624                                       std::unique_ptr<llvm::DataLayout> &DL,
3625                                       const NamedDecl *ND,
3626                                       unsigned StructorType) {
3627   std::string FrontendBuf;
3628   llvm::raw_string_ostream FOS(FrontendBuf);
3629
3630   if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND))
3631     M->mangleCXXCtor(CD, static_cast<CXXCtorType>(StructorType), FOS);
3632   else if (const auto *DD = dyn_cast_or_null<CXXDestructorDecl>(ND))
3633     M->mangleCXXDtor(DD, static_cast<CXXDtorType>(StructorType), FOS);
3634
3635   std::string BackendBuf;
3636   llvm::raw_string_ostream BOS(BackendBuf);
3637
3638   llvm::Mangler::getNameWithPrefix(BOS, llvm::Twine(FOS.str()), *DL);
3639
3640   return BOS.str();
3641 }
3642
3643 extern "C" {
3644
3645 unsigned clang_visitChildren(CXCursor parent,
3646                              CXCursorVisitor visitor,
3647                              CXClientData client_data) {
3648   CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data,
3649                           /*VisitPreprocessorLast=*/false);
3650   return CursorVis.VisitChildren(parent);
3651 }
3652
3653 #ifndef __has_feature
3654 #define __has_feature(x) 0
3655 #endif
3656 #if __has_feature(blocks)
3657 typedef enum CXChildVisitResult 
3658      (^CXCursorVisitorBlock)(CXCursor cursor, CXCursor parent);
3659
3660 static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
3661     CXClientData client_data) {
3662   CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
3663   return block(cursor, parent);
3664 }
3665 #else
3666 // If we are compiled with a compiler that doesn't have native blocks support,
3667 // define and call the block manually, so the 
3668 typedef struct _CXChildVisitResult
3669 {
3670         void *isa;
3671         int flags;
3672         int reserved;
3673         enum CXChildVisitResult(*invoke)(struct _CXChildVisitResult*, CXCursor,
3674                                          CXCursor);
3675 } *CXCursorVisitorBlock;
3676
3677 static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
3678     CXClientData client_data) {
3679   CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
3680   return block->invoke(block, cursor, parent);
3681 }
3682 #endif
3683
3684
3685 unsigned clang_visitChildrenWithBlock(CXCursor parent,
3686                                       CXCursorVisitorBlock block) {
3687   return clang_visitChildren(parent, visitWithBlock, block);
3688 }
3689
3690 static CXString getDeclSpelling(const Decl *D) {
3691   if (!D)
3692     return cxstring::createEmpty();
3693
3694   const NamedDecl *ND = dyn_cast<NamedDecl>(D);
3695   if (!ND) {
3696     if (const ObjCPropertyImplDecl *PropImpl =
3697             dyn_cast<ObjCPropertyImplDecl>(D))
3698       if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl())
3699         return cxstring::createDup(Property->getIdentifier()->getName());
3700     
3701     if (const ImportDecl *ImportD = dyn_cast<ImportDecl>(D))
3702       if (Module *Mod = ImportD->getImportedModule())
3703         return cxstring::createDup(Mod->getFullModuleName());
3704
3705     return cxstring::createEmpty();
3706   }
3707   
3708   if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
3709     return cxstring::createDup(OMD->getSelector().getAsString());
3710
3711   if (const ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND))
3712     // No, this isn't the same as the code below. getIdentifier() is non-virtual
3713     // and returns different names. NamedDecl returns the class name and
3714     // ObjCCategoryImplDecl returns the category name.
3715     return cxstring::createRef(CIMP->getIdentifier()->getNameStart());
3716
3717   if (isa<UsingDirectiveDecl>(D))
3718     return cxstring::createEmpty();
3719   
3720   SmallString<1024> S;
3721   llvm::raw_svector_ostream os(S);
3722   ND->printName(os);
3723   
3724   return cxstring::createDup(os.str());
3725 }
3726
3727 CXString clang_getCursorSpelling(CXCursor C) {
3728   if (clang_isTranslationUnit(C.kind))
3729     return clang_getTranslationUnitSpelling(getCursorTU(C));
3730
3731   if (clang_isReference(C.kind)) {
3732     switch (C.kind) {
3733     case CXCursor_ObjCSuperClassRef: {
3734       const ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first;
3735       return cxstring::createRef(Super->getIdentifier()->getNameStart());
3736     }
3737     case CXCursor_ObjCClassRef: {
3738       const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first;
3739       return cxstring::createRef(Class->getIdentifier()->getNameStart());
3740     }
3741     case CXCursor_ObjCProtocolRef: {
3742       const ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first;
3743       assert(OID && "getCursorSpelling(): Missing protocol decl");
3744       return cxstring::createRef(OID->getIdentifier()->getNameStart());
3745     }
3746     case CXCursor_CXXBaseSpecifier: {
3747       const CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C);
3748       return cxstring::createDup(B->getType().getAsString());
3749     }
3750     case CXCursor_TypeRef: {
3751       const TypeDecl *Type = getCursorTypeRef(C).first;
3752       assert(Type && "Missing type decl");
3753
3754       return cxstring::createDup(getCursorContext(C).getTypeDeclType(Type).
3755                             &