/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp

Bug Summary

File:	tools/clang/tools/libclang/CIndex.cpp
Warning:	line 1410, column 7 Null pointer passed as an argument to a 'nonnull' parameter

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CIndex.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D CLANG_TOOL_EXTRA_BUILD -D _CINDEX_LIB_ -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/tools/libclang -I /build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang -I /build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326246/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/tools/libclang -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-02-28-041547-14988-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp

/build/llvm-toolchain-snapshot-7~svn326246/tools/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//===----------------------------------------------------------------------===//

15#include "CIndexDiagnostic.h"
16#include "CIndexer.h"
17#include "CLog.h"
18#include "CXCursor.h"
19#include "CXSourceLocation.h"
20#include "CXString.h"
21#include "CXTranslationUnit.h"
22#include "CXType.h"
23#include "CursorVisitor.h"
24#include "clang/AST/Attr.h"
25#include "clang/AST/StmtVisitor.h"
26#include "clang/Basic/Diagnostic.h"
27#include "clang/Basic/DiagnosticCategories.h"
28#include "clang/Basic/DiagnosticIDs.h"
29#include "clang/Basic/TargetInfo.h"
30#include "clang/Basic/Version.h"
31#include "clang/Frontend/ASTUnit.h"
32#include "clang/Frontend/CompilerInstance.h"
33#include "clang/Frontend/FrontendDiagnostic.h"
34#include "clang/Index/CodegenNameGenerator.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/Support/Compiler.h"
46#include "llvm/Support/CrashRecoveryContext.h"
47#include "llvm/Support/Format.h"
48#include "llvm/Support/ManagedStatic.h"
49#include "llvm/Support/MemoryBuffer.h"
50#include "llvm/Support/Mutex.h"
51#include "llvm/Support/Program.h"
52#include "llvm/Support/SaveAndRestore.h"
53#include "llvm/Support/Signals.h"
54#include "llvm/Support/TargetSelect.h"
55#include "llvm/Support/Threading.h"
56#include "llvm/Support/Timer.h"
57#include "llvm/Support/raw_ostream.h"

59#if LLVM_ENABLE_THREADS1 != 0 && defined(__APPLE__)
60#define USE_DARWIN_THREADS
61#endif

63#ifdef USE_DARWIN_THREADS
64#include <pthread.h>
65#endif

67using namespace clang;
68using namespace clang::cxcursor;
69using namespace clang::cxtu;
70using namespace clang::cxindex;

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

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

101cxtu::CXTUOwner::~CXTUOwner() {
if (TU)
  clang_disposeTranslationUnit(TU);
104}

106/// \brief Compare two source ranges to determine their relative position in
107/// the translation unit.
108static RangeComparisonResult RangeCompare(SourceManager &SM,
                                        SourceRange R1,
                                        SourceRange R2) {
assert(R1.isValid() && "First range is invalid?")(static_cast <bool> (R1.isValid() && "First range is invalid?"
) ? void (0) : __assert_fail ("R1.isValid() && \"First range is invalid?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 111, __extension__ __PRETTY_FUNCTION__));
assert(R2.isValid() && "Second range is invalid?")(static_cast <bool> (R2.isValid() && "Second range is invalid?"
) ? void (0) : __assert_fail ("R2.isValid() && \"Second range is invalid?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 112, __extension__ __PRETTY_FUNCTION__));
if (R1.getEnd() != R2.getBegin() &&
    SM.isBeforeInTranslationUnit(R1.getEnd(), R2.getBegin()))
  return RangeBefore;
if (R2.getEnd() != R1.getBegin() &&
    SM.isBeforeInTranslationUnit(R2.getEnd(), R1.getBegin()))
  return RangeAfter;
return RangeOverlap;
120}

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

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

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

165//===----------------------------------------------------------------------===//
166// Cursor visitor.
167//===----------------------------------------------------------------------===//

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


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

177/// \brief Visit the given cursor and, if requested by the visitor,
178/// its children.
179///
180/// \param Cursor the cursor to visit.
181///
182/// \param CheckedRegionOfInterest if true, then the caller already checked
183/// that this cursor is within the region of interest.
184///
185/// \returns true if the visitation should be aborted, false if it
186/// should continue.
187bool CursorVisitor::Visit(CXCursor Cursor, bool CheckedRegionOfInterest) {
if (clang_isInvalid(Cursor.kind))
  return false;

if (clang_isDeclaration(Cursor.kind)) {
  const Decl *D = getCursorDecl(Cursor);
  if (!D) {
    assert(0 && "Invalid declaration cursor")(static_cast <bool> (0 && "Invalid declaration cursor"
) ? void (0) : __assert_fail ("0 && \"Invalid declaration cursor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 194, __extension__ __PRETTY_FUNCTION__));
    return true; // abort.
  }
  
  // Ignore implicit declarations, unless it's an objc method because
  // currently we should report implicit methods for properties when indexing.
  if (D->isImplicit() && !isa<ObjCMethodDecl>(D))
    return false;
}

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

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

case CXChildVisit_Continue:
  return false;

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

llvm_unreachable("Invalid CXChildVisitResult!")::llvm::llvm_unreachable_internal("Invalid CXChildVisitResult!"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 228);
229}

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

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

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

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

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

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

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

assert(Begin.first == End.first)(static_cast <bool> (Begin.first == End.first) ? void (
0) : __assert_fail ("Begin.first == End.first", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 268, __extension__ __PRETTY_FUNCTION__));
if (Begin.second > End.second)
  return false;

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

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

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

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

return false;
287}

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

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

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

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

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

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

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

assert(!Decls.empty())(static_cast <bool> (!Decls.empty()) ? void (0) : __assert_fail
 ("!Decls.empty()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 331, __extension__ __PRETTY_FUNCTION__));

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

  if (isInLexicalContext(D, CurDC))
    continue;

  CurDC = dyn_cast<DeclContext>(D);

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

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

  assert(CompRes == RangeOverlap)(static_cast <bool> (CompRes == RangeOverlap) ? void (0
) : __assert_fail ("CompRes == RangeOverlap", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 356, __extension__ __PRETTY_FUNCTION__));
  VisitedAtLeastOnce = true;

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

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

if (VisitedAtLeastOnce)
  return false;

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

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

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

  DC = D->getLexicalDeclContext();
}

return false;
394}

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

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

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

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

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

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

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

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

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

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

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

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

    continue;
  }

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

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

return false;
479}

481/// \brief Visit the children of the given cursor.
482/// 
483/// \returns true if the visitation should be aborted, false if it
484/// should continue.
485bool CursorVisitor::VisitChildren(CXCursor Cursor) {
if (clang_isReference(Cursor.kind) && 
    Cursor.kind != CXCursor_CXXBaseSpecifier) {
  // By definition, references have no children.
  return false;
}

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

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

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

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

  return false;
}

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

  return false;
}

if (clang_isTranslationUnit(Cursor.kind)) {
  CXTranslationUnit TU = getCursorTU(Cursor);
  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
  
  int VisitOrder[2] = { VisitPreprocessorLast, !VisitPreprocessorLast };
  for (unsigned I = 0; I != 2; ++I) {
    if (VisitOrder[I]) {
      if (!CXXUnit->isMainFileAST() && CXXUnit->getOnlyLocalDecls() &&
          RegionOfInterest.isInvalid()) {
        for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(),
                                      TLEnd = CXXUnit->top_level_end();
             TL != TLEnd; ++TL) {
          const Optional<bool> V = handleDeclForVisitation(*TL);
          if (!V.hasValue())
            continue;
          return V.getValue();
        }
      } else if (VisitDeclContext(
                              CXXUnit->getASTContext().getTranslationUnitDecl()))
        return true;
      continue;
    }

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

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

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

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

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

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

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

return false;
593}

595Optional<bool> CursorVisitor::shouldVisitCursor(CXCursor Cursor) {
if (RegionOfInterest.isValid()) {
  SourceRange Range = getFullCursorExtent(Cursor, AU->getSourceManager());
  if (Range.isInvalid())
    return None;
  
  switch (CompareRegionOfInterest(Range)) {
  case RangeBefore:
    // This declaration comes before the region of interest; skip it.
    return None;

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

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

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

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

for ( ; I != E; ++I) {
  Decl *D = *I;
  if (D->getLexicalDeclContext() != DC)
    continue;
  const Optional<bool> V = handleDeclForVisitation(D);
  if (!V.hasValue())
    continue;
  return V.getValue();
}
return false;
636}

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

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

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

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

const Optional<bool> V = shouldVisitCursor(Cursor);
if (!V.hasValue())
  return None;
if (!V.getValue())
  return false;
if (Visit(Cursor, true))
  return true;
return None;
672}

674bool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
llvm_unreachable("Translation units are visited directly by Visit()")::llvm::llvm_unreachable_internal("Translation units are visited directly by Visit()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 675);
676}

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

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

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

return false;
690}

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

return false;
697}

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

703bool CursorVisitor::VisitClassTemplateSpecializationDecl(
                                        ClassTemplateSpecializationDecl *D) {
bool ShouldVisitBody = false;
switch (D->getSpecializationKind()) {
case TSK_Undeclared:
case TSK_ImplicitInstantiation:
  // Nothing to visit
  return false;
    
case TSK_ExplicitInstantiationDeclaration:
case TSK_ExplicitInstantiationDefinition:
  break;
    
case TSK_ExplicitSpecialization:
  ShouldVisitBody = true;
  break;
}

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

return ShouldVisitBody && VisitCXXRecordDecl(D);
733}

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

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

return VisitCXXRecordDecl(D);
750}

752bool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
// Visit the default argument.
if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
  if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo())
    if (Visit(DefArg->getTypeLoc()))
      return true;

return false;
760}

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

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

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

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

return false;
786}

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

return false;
796}

798/// \brief Compare two base or member initializers based on their source order.
799static int CompareCXXCtorInitializers(CXXCtorInitializer *const *X,
                                    CXXCtorInitializer *const *Y) {
return (*X)->getSourceOrder() - (*Y)->getSourceOrder();
802}

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

if (TypeSourceInfo *TSInfo = ND->getTypeSourceInfo()) {
  // Visit the function declaration's syntactic components in the order
  // written. This requires a bit of work.
  TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
  FunctionTypeLoc FTL = TL.getAs<FunctionTypeLoc>();
  const bool HasTrailingRT = HasTrailingReturnType(ND);
  
  // If we have a function declared directly (without the use of a typedef),
  // visit just the return type. Otherwise, just visit the function's type
  // now.
  if ((FTL && !isa<CXXConversionDecl>(ND) && !HasTrailingRT &&
       Visit(FTL.getReturnLoc())) ||
      (!FTL && Visit(TL)))
    return true;

  // Visit the nested-name-specifier, if present.
  if (NestedNameSpecifierLoc QualifierLoc = ND->getQualifierLoc())
    if (VisitNestedNameSpecifierLoc(QualifierLoc))
      return true;
  
  // Visit the declaration name.
  if (!isa<CXXDestructorDecl>(ND))
    if (VisitDeclarationNameInfo(ND->getNameInfo()))
      return true;
  
  // FIXME: Visit explicitly-specified template arguments!
  
  // Visit the function parameters, if we have a function type.
  if (FTL && VisitFunctionTypeLoc(FTL, true))
    return true;

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

  // FIXME: Attributes?
}

if (ND->doesThisDeclarationHaveABody() && !ND->isLateTemplateParsed()) {
  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ND)) {
    // Find the initializers that were written in the source.
    SmallVector<CXXCtorInitializer *, 4> WrittenInits;
    for (auto *I : Constructor->inits()) {
      if (!I->isWritten())
        continue;
    
      WrittenInits.push_back(I);
    }
    
    // Sort the initializers in source order
    llvm::array_pod_sort(WrittenInits.begin(), WrittenInits.end(),
                         &CompareCXXCtorInitializers);
    
    // Visit the initializers in source order
    for (unsigned I = 0, N = WrittenInits.size(); I != N; ++I) {
      CXXCtorInitializer *Init = WrittenInits[I];
      if (Init->isAnyMemberInitializer()) {
        if (Visit(MakeCursorMemberRef(Init->getAnyMember(),
                                      Init->getMemberLocation(), TU)))
          return true;
      } else if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo()) {
        if (Visit(TInfo->getTypeLoc()))
          return true;
      }
      
      // Visit the initializer value.
      if (Expr *Initializer = Init->getInit())
        if (Visit(MakeCXCursor(Initializer, ND, TU, RegionOfInterest)))
          return true;
    } 
  }
  
  if (Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest)))
    return true;
}

return false;
889}

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

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

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

return false;
902}

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

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

return false;
912}

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

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

return false;  
923}

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

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

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

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

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

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

return false;
954}

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

return false;
966}

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

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

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

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

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

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

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

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

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

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

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

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

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

return VisitObjCContainerDecl(ND);
1081}

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

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

return VisitObjCContainerDecl(PID);
1094}

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

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

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

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

if (!prevDecl)
  return false;

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

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

return false;
1132}

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

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

return false;
1145}

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

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

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

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

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

return VisitObjCContainerDecl(D);
1175}

1177bool CursorVisitor::VisitObjCImplDecl(ObjCImplDecl *D) {
return VisitObjCContainerDecl(D);
1179}

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

return VisitObjCImplDecl(D);
1188}

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

return VisitObjCImplDecl(D);
1202}

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

return false;
1210}

1212bool CursorVisitor::VisitNamespaceDecl(NamespaceDecl *D) {
return VisitDeclContext(D);
1214}

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

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

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

if (Visit(MakeCursorOverloadedDeclRef(D, D->getLocation(), TU)))
  return true;
  
return VisitDeclarationNameInfo(D->getNameInfo());
1237}

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

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

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

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

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

return false;
1267}

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

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

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

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

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

llvm_unreachable("Invalid DeclarationName::Kind!")::llvm::llvm_unreachable_internal("Invalid DeclarationName::Kind!"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 1312);
1313}

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

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

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

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

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

return false;
1360}

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

while (!Qualifiers.empty()) {
  NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
  NestedNameSpecifier *NNS = Q.getNestedNameSpecifier();
  switch (NNS->getKind()) {
  case NestedNameSpecifier::Namespace:
    if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), 
                                     Q.getLocalBeginLoc(),
                                     TU)))
      return true;
      
    break;
    
  case NestedNameSpecifier::NamespaceAlias:
    if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(), 
                                     Q.getLocalBeginLoc(),
                                     TU)))
      return true;
      
    break;
      
  case NestedNameSpecifier::TypeSpec:
  case NestedNameSpecifier::TypeSpecWithTemplate:
    if (Visit(Q.getTypeLoc()))
      return true;
      
    break;
      
  case NestedNameSpecifier::Global:
  case NestedNameSpecifier::Identifier:
  case NestedNameSpecifier::Super:
    break;              
  }
}

return false;
1403}

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

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

return false;
1418}

1420bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) {
switch (Name.getKind()) {
case TemplateName::Template:
  return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU));

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

  return false;

case TemplateName::DependentTemplate:
  // FIXME: Visit nested-name-specifier.
  return false;
    
case TemplateName::QualifiedTemplate:
  // FIXME: Visit nested-name-specifier.
  return Visit(MakeCursorTemplateRef(
                                Name.getAsQualifiedTemplateName()->getDecl(), 
                                     Loc, TU));

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

llvm_unreachable("Invalid TemplateName::Kind!")::llvm::llvm_unreachable_internal("Invalid TemplateName::Kind!"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 1453);
1454}

1456bool CursorVisitor::VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL) {
switch (TAL.getArgument().getKind()) {
case TemplateArgument::Null:
case TemplateArgument::Integral:
case TemplateArgument::Pack:
  return false;
    
case TemplateArgument::Type:
  if (TypeSourceInfo *TSInfo = TAL.getTypeSourceInfo())
    return Visit(TSInfo->getTypeLoc());
  return false;
    
case TemplateArgument::Declaration:
  if (Expr *E = TAL.getSourceDeclExpression())
    return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
  return false;

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

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

case TemplateArgument::Template:
case TemplateArgument::TemplateExpansion:
  if (VisitNestedNameSpecifierLoc(TAL.getTemplateQualifierLoc()))
    return true;
    
  return VisitTemplateName(TAL.getArgument().getAsTemplateOrTemplatePattern(), 
                           TAL.getTemplateNameLoc());
}

llvm_unreachable("Invalid TemplateArgument::Kind!")::llvm::llvm_unreachable_internal("Invalid TemplateArgument::Kind!"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 1492);
1493}

1495bool CursorVisitor::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
return VisitDeclContext(D);
1497}

1499bool CursorVisitor::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
return Visit(TL.getUnqualifiedLoc());
1501}

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

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

case BuiltinType::Void:
case BuiltinType::NullPtr:
case BuiltinType::Dependent:
1514#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
1516#include "clang/Basic/OpenCLImageTypes.def"
case BuiltinType::OCLSampler:
case BuiltinType::OCLEvent:
case BuiltinType::OCLClkEvent:
case BuiltinType::OCLQueue:
case BuiltinType::OCLReserveID:
1522#define BUILTIN_TYPE(Id, SingletonId)
1523#define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
1524#define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
1525#define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
1526#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
1527#include "clang/AST/BuiltinTypes.def"
  break;

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

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

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

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

return false;
1550}

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

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

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

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

1567bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1569}

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

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

return false;
1585}

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

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

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

return false;
1603}

1605bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
return Visit(TL.getPointeeLoc());
1607}

1609bool CursorVisitor::VisitParenTypeLoc(ParenTypeLoc TL) {
return Visit(TL.getInnerLoc());
1611}

1613bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) {
return Visit(TL.getPointeeLoc());
1615}

1617bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
return Visit(TL.getPointeeLoc());
1619}

1621bool CursorVisitor::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
return Visit(TL.getPointeeLoc());
1623}

1625bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
return Visit(TL.getPointeeLoc());
1627}

1629bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
return Visit(TL.getPointeeLoc());
1631}

1633bool CursorVisitor::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
return Visit(TL.getModifiedLoc());
1635}

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

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

return false;
1648}

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

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

return false;
1658}

1660bool CursorVisitor::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
return Visit(TL.getOriginalLoc());
1662}

1664bool CursorVisitor::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
return Visit(TL.getOriginalLoc());
1666}

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

return false;
1675}

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

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

return false;
1690}

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

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

return false;
1701}

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

return false;
1708}

1710bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
return VisitNestedNameSpecifierLoc(TL.getQualifierLoc());
1712}

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

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

return false;
1727}

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

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

1736bool CursorVisitor::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
return Visit(TL.getPatternLoc());
1738}

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

return false;
1745}

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

1751bool CursorVisitor::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
return Visit(TL.getValueLoc());
1753}

1755bool CursorVisitor::VisitPipeTypeLoc(PipeTypeLoc TL) {
return Visit(TL.getValueLoc());
1757}

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

1764DEFAULT_TYPELOC_IMPL(Complex, Type)bool CursorVisitor::VisitComplexTypeLoc(ComplexTypeLoc TL) { return
 VisitTypeLoc(TL); }
1765DEFAULT_TYPELOC_IMPL(ConstantArray, ArrayType)bool CursorVisitor::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc
 TL) { return VisitArrayTypeLoc(TL); }
1766DEFAULT_TYPELOC_IMPL(IncompleteArray, ArrayType)bool CursorVisitor::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc
 TL) { return VisitArrayTypeLoc(TL); }
1767DEFAULT_TYPELOC_IMPL(VariableArray, ArrayType)bool CursorVisitor::VisitVariableArrayTypeLoc(VariableArrayTypeLoc
 TL) { return VisitArrayTypeLoc(TL); }
1768DEFAULT_TYPELOC_IMPL(DependentSizedArray, ArrayType)bool CursorVisitor::VisitDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc
 TL) { return VisitArrayTypeLoc(TL); }
1769DEFAULT_TYPELOC_IMPL(DependentAddressSpace, Type)bool CursorVisitor::VisitDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc
 TL) { return VisitTypeLoc(TL); }
1770DEFAULT_TYPELOC_IMPL(DependentSizedExtVector, Type)bool CursorVisitor::VisitDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc
 TL) { return VisitTypeLoc(TL); }
1771DEFAULT_TYPELOC_IMPL(Vector, Type)bool CursorVisitor::VisitVectorTypeLoc(VectorTypeLoc TL) { return
 VisitTypeLoc(TL); }
1772DEFAULT_TYPELOC_IMPL(ExtVector, VectorType)bool CursorVisitor::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL
) { return VisitVectorTypeLoc(TL); }
1773DEFAULT_TYPELOC_IMPL(FunctionProto, FunctionType)bool CursorVisitor::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc
 TL) { return VisitFunctionTypeLoc(TL); }
1774DEFAULT_TYPELOC_IMPL(FunctionNoProto, FunctionType)bool CursorVisitor::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc
 TL) { return VisitFunctionTypeLoc(TL); }
1775DEFAULT_TYPELOC_IMPL(Record, TagType)bool CursorVisitor::VisitRecordTypeLoc(RecordTypeLoc TL) { return
 VisitTagTypeLoc(TL); }
1776DEFAULT_TYPELOC_IMPL(Enum, TagType)bool CursorVisitor::VisitEnumTypeLoc(EnumTypeLoc TL) { return
 VisitTagTypeLoc(TL); }
1777DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParm, Type)bool CursorVisitor::VisitSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc
 TL) { return VisitTypeLoc(TL); }
1778DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParmPack, Type)bool CursorVisitor::VisitSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc
 TL) { return VisitTypeLoc(TL); }
1779DEFAULT_TYPELOC_IMPL(Auto, Type)bool CursorVisitor::VisitAutoTypeLoc(AutoTypeLoc TL) { return
 VisitTypeLoc(TL); }

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

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

return VisitTagDecl(D);
1795}

1797bool CursorVisitor::VisitAttributes(Decl *D) {
for (const auto *I : D->attrs())
  if (Visit(MakeCXCursor(I, D, TU)))
      return true;

return false;
1803}

1805//===----------------------------------------------------------------------===//
1806// Data-recursive visitor methods.
1807//===----------------------------------------------------------------------===//

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

1819DEF_JOB(StmtVisit, Stmt, StmtVisitKind)
1820DEF_JOB(MemberExprParts, MemberExpr, MemberExprPartsKind)
1821DEF_JOB(DeclRefExprParts, DeclRefExpr, DeclRefExprPartsKind)
1822DEF_JOB(OverloadExprParts, OverloadExpr, OverloadExprPartsKind)
1823DEF_JOB(SizeOfPackExprParts, SizeOfPackExpr, SizeOfPackExprPartsKind)
1824DEF_JOB(LambdaExprParts, LambdaExpr, LambdaExprPartsKind)
1825DEF_JOB(PostChildrenVisit, void, PostChildrenVisitKind)
1826#undef DEF_JOB

1828class ExplicitTemplateArgsVisit : public VisitorJob {
1829public:
ExplicitTemplateArgsVisit(const TemplateArgumentLoc *Begin,
                          const TemplateArgumentLoc *End, CXCursor parent)
    : VisitorJob(parent, VisitorJob::ExplicitTemplateArgsVisitKind, Begin,
                 End) {}
static bool classof(const VisitorJob *VJ) {
  return VJ->getKind() == ExplicitTemplateArgsVisitKind;
}
const TemplateArgumentLoc *begin() const {
  return static_cast<const TemplateArgumentLoc *>(data[0]);
}
const TemplateArgumentLoc *end() {
  return static_cast<const TemplateArgumentLoc *>(data[1]);
}
1843};
1844class DeclVisit : public VisitorJob {
1845public:
DeclVisit(const Decl *D, CXCursor parent, bool isFirst) :
  VisitorJob(parent, VisitorJob::DeclVisitKind,
             D, isFirst ? (void*) 1 : (void*) nullptr) {}
static bool classof(const VisitorJob *VJ) {
  return VJ->getKind() == DeclVisitKind;
}
const Decl *get() const { return static_cast<const Decl *>(data[0]); }
bool isFirst() const { return data[1] != nullptr; }
1854};
1855class TypeLocVisit : public VisitorJob {
1856public:
TypeLocVisit(TypeLoc tl, CXCursor parent) :
  VisitorJob(parent, VisitorJob::TypeLocVisitKind,
             tl.getType().getAsOpaquePtr(), tl.getOpaqueData()) {}

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

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

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

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

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

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

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

1906class DeclarationNameInfoVisit : public VisitorJob {
1907public:
DeclarationNameInfoVisit(const Stmt *S, CXCursor parent)
  : VisitorJob(parent, VisitorJob::DeclarationNameInfoVisitKind, S) {}
static bool classof(const VisitorJob *VJ) {
  return VJ->getKind() == VisitorJob::DeclarationNameInfoVisitKind;
}
DeclarationNameInfo get() const {
  const Stmt *S = static_cast<const Stmt *>(data[0]);
  switch (S->getStmtClass()) {
  default:
    llvm_unreachable("Unhandled Stmt")::llvm::llvm_unreachable_internal("Unhandled Stmt", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 1917);
  case clang::Stmt::MSDependentExistsStmtClass:
    return cast<MSDependentExistsStmt>(S)->getNameInfo();
  case Stmt::CXXDependentScopeMemberExprClass:
    return cast<CXXDependentScopeMemberExpr>(S)->getMemberNameInfo();
  case Stmt::DependentScopeDeclRefExprClass:
    return cast<DependentScopeDeclRefExpr>(S)->getNameInfo();
  case Stmt::OMPCriticalDirectiveClass:
    return cast<OMPCriticalDirective>(S)->getDirectiveName();
  }
}
1928};
1929class MemberRefVisit : public VisitorJob {
1930public:
MemberRefVisit(const FieldDecl *D, SourceLocation L, CXCursor parent)
  : VisitorJob(parent, VisitorJob::MemberRefVisitKind, D,
               L.getPtrEncoding()) {}
static bool classof(const VisitorJob *VJ) {
  return VJ->getKind() == VisitorJob::MemberRefVisitKind;
}
const FieldDecl *get() const {
  return static_cast<const FieldDecl *>(data[0]);
}
SourceLocation getLoc() const {
  return SourceLocation::getFromRawEncoding((unsigned)(uintptr_t) data[1]);
}
1943};
1944class EnqueueVisitor : public ConstStmtVisitor<EnqueueVisitor, void> {
friend class OMPClauseEnqueue;
VisitorWorkList &WL;
CXCursor Parent;
1948public:
EnqueueVisitor(VisitorWorkList &wl, CXCursor parent)
  : WL(wl), Parent(parent) {}

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

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

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

2077void 
2078EnqueueVisitor::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) {
if (Qualifier)
  WL.push_back(NestedNameSpecifierLocVisit(Qualifier, Parent));
2081}

2083void EnqueueVisitor::AddStmt(const Stmt *S) {
if (S)
  WL.push_back(StmtVisit(S, Parent));
2086}
2087void EnqueueVisitor::AddDecl(const Decl *D, bool isFirst) {
if (D)
  WL.push_back(DeclVisit(D, Parent, isFirst));
2090}
2091void EnqueueVisitor::AddExplicitTemplateArgs(const TemplateArgumentLoc *A,
                                           unsigned NumTemplateArgs) {
WL.push_back(ExplicitTemplateArgsVisit(A, A + NumTemplateArgs, Parent));
2094}
2095void EnqueueVisitor::AddMemberRef(const FieldDecl *D, SourceLocation L) {
if (D)
  WL.push_back(MemberRefVisit(D, L, Parent));
2098}
2099void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) {
if (TI)
  WL.push_back(TypeLocVisit(TI->getTypeLoc(), Parent));
}
2103void EnqueueVisitor::EnqueueChildren(const Stmt *S) {
unsigned size = WL.size();
for (const Stmt *SubStmt : S->children()) {
  AddStmt(SubStmt);
}
if (size == WL.size())
  return;
// Now reverse the entries we just added.  This will match the DFS
// ordering performed by the worklist.
VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
std::reverse(I, E);
2114}
2115namespace {
2116class OMPClauseEnqueue : public ConstOMPClauseVisitor<OMPClauseEnqueue> {
EnqueueVisitor *Visitor;
/// \brief Process clauses with list of variables.
template <typename T>
void VisitOMPClauseList(T *Node);
2121public:
OMPClauseEnqueue(EnqueueVisitor *Visitor) : Visitor(Visitor) { }
2123#define OPENMP_CLAUSE(Name, Class)                                             \
void Visit##Class(const Class *C);
2125#include "clang/Basic/OpenMPKinds.def"
void VisitOMPClauseWithPreInit(const OMPClauseWithPreInit *C);
void VisitOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C);
2128};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2239void OMPClauseEnqueue::VisitOMPPrivateClause(const OMPPrivateClause *C) {
VisitOMPClauseList(C);
for (const auto *E : C->private_copies()) {
  Visitor->AddStmt(E);
}
2244}
2245void OMPClauseEnqueue::VisitOMPFirstprivateClause(
                                      const OMPFirstprivateClause *C) {
VisitOMPClauseList(C);
VisitOMPClauseWithPreInit(C);
for (const auto *E : C->private_copies()) {
  Visitor->AddStmt(E);
}
for (const auto *E : C->inits()) {
  Visitor->AddStmt(E);
}
2255}
2256void OMPClauseEnqueue::VisitOMPLastprivateClause(
                                      const OMPLastprivateClause *C) {
VisitOMPClauseList(C);
VisitOMPClauseWithPostUpdate(C);
for (auto *E : C->private_copies()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->source_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->destination_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->assignment_ops()) {
  Visitor->AddStmt(E);
}
2272}
2273void OMPClauseEnqueue::VisitOMPSharedClause(const OMPSharedClause *C) {
VisitOMPClauseList(C);
2275}
2276void OMPClauseEnqueue::VisitOMPReductionClause(const OMPReductionClause *C) {
VisitOMPClauseList(C);
VisitOMPClauseWithPostUpdate(C);
for (auto *E : C->privates()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->lhs_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->rhs_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->reduction_ops()) {
  Visitor->AddStmt(E);
}
2291}
2292void OMPClauseEnqueue::VisitOMPTaskReductionClause(
  const OMPTaskReductionClause *C) {
VisitOMPClauseList(C);
VisitOMPClauseWithPostUpdate(C);
for (auto *E : C->privates()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->lhs_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->rhs_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->reduction_ops()) {
  Visitor->AddStmt(E);
}
2308}
2309void OMPClauseEnqueue::VisitOMPInReductionClause(
  const OMPInReductionClause *C) {
VisitOMPClauseList(C);
VisitOMPClauseWithPostUpdate(C);
for (auto *E : C->privates()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->lhs_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->rhs_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->reduction_ops()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->taskgroup_descriptors())
  Visitor->AddStmt(E);
2327}
2328void OMPClauseEnqueue::VisitOMPLinearClause(const OMPLinearClause *C) {
VisitOMPClauseList(C);
VisitOMPClauseWithPostUpdate(C);
for (const auto *E : C->privates()) {
  Visitor->AddStmt(E);
}
for (const auto *E : C->inits()) {
  Visitor->AddStmt(E);
}
for (const auto *E : C->updates()) {
  Visitor->AddStmt(E);
}
for (const auto *E : C->finals()) {
  Visitor->AddStmt(E);
}
Visitor->AddStmt(C->getStep());
Visitor->AddStmt(C->getCalcStep());
2345}
2346void OMPClauseEnqueue::VisitOMPAlignedClause(const OMPAlignedClause *C) {
VisitOMPClauseList(C);
Visitor->AddStmt(C->getAlignment());
2349}
2350void OMPClauseEnqueue::VisitOMPCopyinClause(const OMPCopyinClause *C) {
VisitOMPClauseList(C);
for (auto *E : C->source_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->destination_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->assignment_ops()) {
  Visitor->AddStmt(E);
}
2361}
2362void
2363OMPClauseEnqueue::VisitOMPCopyprivateClause(const OMPCopyprivateClause *C) {
VisitOMPClauseList(C);
for (auto *E : C->source_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->destination_exprs()) {
  Visitor->AddStmt(E);
}
for (auto *E : C->assignment_ops()) {
  Visitor->AddStmt(E);
}
2374}
2375void OMPClauseEnqueue::VisitOMPFlushClause(const OMPFlushClause *C) {
VisitOMPClauseList(C);
2377}
2378void OMPClauseEnqueue::VisitOMPDependClause(const OMPDependClause *C) {
VisitOMPClauseList(C);
2380}
2381void OMPClauseEnqueue::VisitOMPMapClause(const OMPMapClause *C) {
VisitOMPClauseList(C);
2383}
2384void OMPClauseEnqueue::VisitOMPDistScheduleClause(
  const OMPDistScheduleClause *C) {
VisitOMPClauseWithPreInit(C);
Visitor->AddStmt(C->getChunkSize());
2388}
2389void OMPClauseEnqueue::VisitOMPDefaultmapClause(
  const OMPDefaultmapClause * /*C*/) {}
2391void OMPClauseEnqueue::VisitOMPToClause(const OMPToClause *C) {
VisitOMPClauseList(C);
2393}
2394void OMPClauseEnqueue::VisitOMPFromClause(const OMPFromClause *C) {
VisitOMPClauseList(C);
2396}
2397void OMPClauseEnqueue::VisitOMPUseDevicePtrClause(const OMPUseDevicePtrClause *C) {
VisitOMPClauseList(C);
2399}
2400void OMPClauseEnqueue::VisitOMPIsDevicePtrClause(const OMPIsDevicePtrClause *C) {
VisitOMPClauseList(C);
2402}
2403}

2405void EnqueueVisitor::EnqueueChildren(const OMPClause *S) {
unsigned size = WL.size();
OMPClauseEnqueue Visitor(this);
Visitor.Visit(S);
if (size == WL.size())
  return;
// Now reverse the entries we just added.  This will match the DFS
// ordering performed by the worklist.
VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
std::reverse(I, E);
2415}
2416void EnqueueVisitor::VisitAddrLabelExpr(const AddrLabelExpr *E) {
WL.push_back(LabelRefVisit(E->getLabel(), E->getLabelLoc(), Parent));
2418}
2419void EnqueueVisitor::VisitBlockExpr(const BlockExpr *B) {
AddDecl(B->getBlockDecl());
2421}
2422void EnqueueVisitor::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
EnqueueChildren(E);
AddTypeLoc(E->getTypeSourceInfo());
2425}
2426void EnqueueVisitor::VisitCompoundStmt(const CompoundStmt *S) {
for (auto &I : llvm::reverse(S->body()))
  AddStmt(I);
2429}
2430void EnqueueVisitor::
2431VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) {
AddStmt(S->getSubStmt());
AddDeclarationNameInfo(S);
if (NestedNameSpecifierLoc QualifierLoc = S->getQualifierLoc())
  AddNestedNameSpecifierLoc(QualifierLoc);
2436}

2438void EnqueueVisitor::
2439VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E) {
if (E->hasExplicitTemplateArgs())
  AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs());
AddDeclarationNameInfo(E);
if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
  AddNestedNameSpecifierLoc(QualifierLoc);
if (!E->isImplicitAccess())
  AddStmt(E->getBase());
2447}
2448void EnqueueVisitor::VisitCXXNewExpr(const CXXNewExpr *E) {
// Enqueue the initializer , if any.
AddStmt(E->getInitializer());
// Enqueue the array size, if any.
AddStmt(E->getArraySize());
// Enqueue the allocated type.
AddTypeLoc(E->getAllocatedTypeSourceInfo());
// Enqueue the placement arguments.
for (unsigned I = E->getNumPlacementArgs(); I > 0; --I)
  AddStmt(E->getPlacementArg(I-1));
2458}
2459void EnqueueVisitor::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *CE) {
for (unsigned I = CE->getNumArgs(); I > 1 /* Yes, this is 1 */; --I)
  AddStmt(CE->getArg(I-1));
AddStmt(CE->getCallee());
AddStmt(CE->getArg(0));
2464}
2465void EnqueueVisitor::VisitCXXPseudoDestructorExpr(
                                      const CXXPseudoDestructorExpr *E) {
// Visit the name of the type being destroyed.
AddTypeLoc(E->getDestroyedTypeInfo());
// Visit the scope type that looks disturbingly like the nested-name-specifier
// but isn't.
AddTypeLoc(E->getScopeTypeInfo());
// Visit the nested-name-specifier.
if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
  AddNestedNameSpecifierLoc(QualifierLoc);
// Visit base expression.
AddStmt(E->getBase());
2477}
2478void EnqueueVisitor::VisitCXXScalarValueInitExpr(
                                      const CXXScalarValueInitExpr *E) {
AddTypeLoc(E->getTypeSourceInfo());
2481}
2482void EnqueueVisitor::VisitCXXTemporaryObjectExpr(
                                      const CXXTemporaryObjectExpr *E) {
EnqueueChildren(E);
AddTypeLoc(E->getTypeSourceInfo());
2486}
2487void EnqueueVisitor::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
EnqueueChildren(E);
if (E->isTypeOperand())
  AddTypeLoc(E->getTypeOperandSourceInfo());
2491}

2493void EnqueueVisitor::VisitCXXUnresolvedConstructExpr(
                                      const CXXUnresolvedConstructExpr *E) {
EnqueueChildren(E);
AddTypeLoc(E->getTypeSourceInfo());
2497}
2498void EnqueueVisitor::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
EnqueueChildren(E);
if (E->isTypeOperand())
  AddTypeLoc(E->getTypeOperandSourceInfo());
2502}

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

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

2515void EnqueueVisitor::VisitDeclRefExpr(const DeclRefExpr *DR) {
if (DR->hasExplicitTemplateArgs())
  AddExplicitTemplateArgs(DR->getTemplateArgs(), DR->getNumTemplateArgs());
WL.push_back(DeclRefExprParts(DR, Parent));
2519}
2520void EnqueueVisitor::VisitDependentScopeDeclRefExpr(
                                      const DependentScopeDeclRefExpr *E) {
if (E->hasExplicitTemplateArgs())
  AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs());
AddDeclarationNameInfo(E);
AddNestedNameSpecifierLoc(E->getQualifierLoc());
2526}
2527void EnqueueVisitor::VisitDeclStmt(const DeclStmt *S) {
unsigned size = WL.size();
bool isFirst = true;
for (const auto *D : S->decls()) {
  AddDecl(D, isFirst);
  isFirst = false;
}
if (size == WL.size())
  return;
// Now reverse the entries we just added.  This will match the DFS
// ordering performed by the worklist.
VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
std::reverse(I, E);
2540}
2541void EnqueueVisitor::VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
AddStmt(E->getInit());
for (const DesignatedInitExpr::Designator &D :
     llvm::reverse(E->designators())) {
  if (D.isFieldDesignator()) {
    if (FieldDecl *Field = D.getField())
      AddMemberRef(Field, D.getFieldLoc());
    continue;
  }
  if (D.isArrayDesignator()) {
    AddStmt(E->getArrayIndex(D));
    continue;
  }
  assert(D.isArrayRangeDesignator() && "Unknown designator kind")(static_cast <bool> (D.isArrayRangeDesignator() &&
 "Unknown designator kind") ? void (0) : __assert_fail ("D.isArrayRangeDesignator() && \"Unknown designator kind\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 2554, __extension__ __PRETTY_FUNCTION__));
  AddStmt(E->getArrayRangeEnd(D));
  AddStmt(E->getArrayRangeStart(D));
}
2558}
2559void EnqueueVisitor::VisitExplicitCastExpr(const ExplicitCastExpr *E) {
EnqueueChildren(E);
AddTypeLoc(E->getTypeInfoAsWritten());
2562}
2563void EnqueueVisitor::VisitForStmt(const ForStmt *FS) {
AddStmt(FS->getBody());
AddStmt(FS->getInc());
AddStmt(FS->getCond());
AddDecl(FS->getConditionVariable());
AddStmt(FS->getInit());
2569}
2570void EnqueueVisitor::VisitGotoStmt(const GotoStmt *GS) {
WL.push_back(LabelRefVisit(GS->getLabel(), GS->getLabelLoc(), Parent));
2572}
2573void EnqueueVisitor::VisitIfStmt(const IfStmt *If) {
AddStmt(If->getElse());
AddStmt(If->getThen());
AddStmt(If->getCond());
AddDecl(If->getConditionVariable());
2578}
2579void EnqueueVisitor::VisitInitListExpr(const InitListExpr *IE) {
// We care about the syntactic form of the initializer list, only.
if (InitListExpr *Syntactic = IE->getSyntacticForm())
  IE = Syntactic;
EnqueueChildren(IE);
2584}
2585void EnqueueVisitor::VisitMemberExpr(const MemberExpr *M) {
WL.push_back(MemberExprParts(M, Parent));

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

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

AddStmt(M->getBase());
2607}
2608void EnqueueVisitor::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
AddTypeLoc(E->getEncodedTypeSourceInfo());
2610}
2611void EnqueueVisitor::VisitObjCMessageExpr(const ObjCMessageExpr *M) {
EnqueueChildren(M);
AddTypeLoc(M->getClassReceiverTypeInfo());
2614}
2615void EnqueueVisitor::VisitOffsetOfExpr(const OffsetOfExpr *E) {
// Visit the components of the offsetof expression.
for (unsigned N = E->getNumComponents(), I = N; I > 0; --I) {
  const OffsetOfNode &Node = E->getComponent(I-1);
  switch (Node.getKind()) {
  case OffsetOfNode::Array:
    AddStmt(E->getIndexExpr(Node.getArrayExprIndex()));
    break;
  case OffsetOfNode::Field:
    AddMemberRef(Node.getField(), Node.getSourceRange().getEnd());
    break;
  case OffsetOfNode::Identifier:
  case OffsetOfNode::Base:
    continue;
  }
}
// Visit the type into which we're computing the offset.
AddTypeLoc(E->getTypeSourceInfo());
2633}
2634void EnqueueVisitor::VisitOverloadExpr(const OverloadExpr *E) {
if (E->hasExplicitTemplateArgs())
  AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs());
WL.push_back(OverloadExprParts(E, Parent));
2638}
2639void EnqueueVisitor::VisitUnaryExprOrTypeTraitExpr(
                                      const UnaryExprOrTypeTraitExpr *E) {
EnqueueChildren(E);
if (E->isArgumentType())
  AddTypeLoc(E->getArgumentTypeInfo());
2644}
2645void EnqueueVisitor::VisitStmt(const Stmt *S) {
EnqueueChildren(S);
2647}
2648void EnqueueVisitor::VisitSwitchStmt(const SwitchStmt *S) {
AddStmt(S->getBody());
AddStmt(S->getCond());
AddDecl(S->getConditionVariable());
2652}

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

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

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

2669void EnqueueVisitor::VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
EnqueueChildren(E);
2671}

2673void EnqueueVisitor::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U) {
VisitOverloadExpr(U);
if (!U->isImplicitAccess())
  AddStmt(U->getBase());
2677}
2678void EnqueueVisitor::VisitVAArgExpr(const VAArgExpr *E) {
AddStmt(E->getSubExpr());
AddTypeLoc(E->getWrittenTypeInfo());
2681}
2682void EnqueueVisitor::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
WL.push_back(SizeOfPackExprParts(E, Parent));
2684}
2685void EnqueueVisitor::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
// If the opaque value has a source expression, just transparently
// visit that.  This is useful for (e.g.) pseudo-object expressions.
if (Expr *SourceExpr = E->getSourceExpr())
  return Visit(SourceExpr);
2690}
2691void EnqueueVisitor::VisitLambdaExpr(const LambdaExpr *E) {
AddStmt(E->getBody());
WL.push_back(LambdaExprParts(E, Parent));
2694}
2695void EnqueueVisitor::VisitPseudoObjectExpr(const PseudoObjectExpr *E) {
// Treat the expression like its syntactic form.
Visit(E->getSyntacticForm());
2698}

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

2709void EnqueueVisitor::VisitOMPLoopDirective(const OMPLoopDirective *D) {
VisitOMPExecutableDirective(D);
2711}

2713void EnqueueVisitor::VisitOMPParallelDirective(const OMPParallelDirective *D) {
VisitOMPExecutableDirective(D);
2715}

2717void EnqueueVisitor::VisitOMPSimdDirective(const OMPSimdDirective *D) {
VisitOMPLoopDirective(D);
2719}

2721void EnqueueVisitor::VisitOMPForDirective(const OMPForDirective *D) {
VisitOMPLoopDirective(D);
2723}

2725void EnqueueVisitor::VisitOMPForSimdDirective(const OMPForSimdDirective *D) {
VisitOMPLoopDirective(D);
2727}

2729void EnqueueVisitor::VisitOMPSectionsDirective(const OMPSectionsDirective *D) {
VisitOMPExecutableDirective(D);
2731}

2733void EnqueueVisitor::VisitOMPSectionDirective(const OMPSectionDirective *D) {
VisitOMPExecutableDirective(D);
2735}

2737void EnqueueVisitor::VisitOMPSingleDirective(const OMPSingleDirective *D) {
VisitOMPExecutableDirective(D);
2739}

2741void EnqueueVisitor::VisitOMPMasterDirective(const OMPMasterDirective *D) {
VisitOMPExecutableDirective(D);
2743}

2745void EnqueueVisitor::VisitOMPCriticalDirective(const OMPCriticalDirective *D) {
VisitOMPExecutableDirective(D);
AddDeclarationNameInfo(D);
2748}

2750void
2751EnqueueVisitor::VisitOMPParallelForDirective(const OMPParallelForDirective *D) {
VisitOMPLoopDirective(D);
2753}

2755void EnqueueVisitor::VisitOMPParallelForSimdDirective(
  const OMPParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
2758}

2760void EnqueueVisitor::VisitOMPParallelSectionsDirective(
  const OMPParallelSectionsDirective *D) {
VisitOMPExecutableDirective(D);
2763}

2765void EnqueueVisitor::VisitOMPTaskDirective(const OMPTaskDirective *D) {
VisitOMPExecutableDirective(D);
2767}

2769void
2770EnqueueVisitor::VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *D) {
VisitOMPExecutableDirective(D);
2772}

2774void EnqueueVisitor::VisitOMPBarrierDirective(const OMPBarrierDirective *D) {
VisitOMPExecutableDirective(D);
2776}

2778void EnqueueVisitor::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D) {
VisitOMPExecutableDirective(D);
2780}

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

2789void EnqueueVisitor::VisitOMPFlushDirective(const OMPFlushDirective *D) {
VisitOMPExecutableDirective(D);
2791}

2793void EnqueueVisitor::VisitOMPOrderedDirective(const OMPOrderedDirective *D) {
VisitOMPExecutableDirective(D);
2795}

2797void EnqueueVisitor::VisitOMPAtomicDirective(const OMPAtomicDirective *D) {
VisitOMPExecutableDirective(D);
2799}

2801void EnqueueVisitor::VisitOMPTargetDirective(const OMPTargetDirective *D) {
VisitOMPExecutableDirective(D);
2803}

2805void EnqueueVisitor::VisitOMPTargetDataDirective(const 
                                               OMPTargetDataDirective *D) {
VisitOMPExecutableDirective(D);
2808}

2810void EnqueueVisitor::VisitOMPTargetEnterDataDirective(
  const OMPTargetEnterDataDirective *D) {
VisitOMPExecutableDirective(D);
2813}

2815void EnqueueVisitor::VisitOMPTargetExitDataDirective(
  const OMPTargetExitDataDirective *D) {
VisitOMPExecutableDirective(D);
2818}

2820void EnqueueVisitor::VisitOMPTargetParallelDirective(
  const OMPTargetParallelDirective *D) {
VisitOMPExecutableDirective(D);
2823}

2825void EnqueueVisitor::VisitOMPTargetParallelForDirective(
  const OMPTargetParallelForDirective *D) {
VisitOMPLoopDirective(D);
2828}

2830void EnqueueVisitor::VisitOMPTeamsDirective(const OMPTeamsDirective *D) {
VisitOMPExecutableDirective(D);
2832}

2834void EnqueueVisitor::VisitOMPCancellationPointDirective(
  const OMPCancellationPointDirective *D) {
VisitOMPExecutableDirective(D);
2837}

2839void EnqueueVisitor::VisitOMPCancelDirective(const OMPCancelDirective *D) {
VisitOMPExecutableDirective(D);
2841}

2843void EnqueueVisitor::VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D) {
VisitOMPLoopDirective(D);
2845}

2847void EnqueueVisitor::VisitOMPTaskLoopSimdDirective(
  const OMPTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
2850}

2852void EnqueueVisitor::VisitOMPDistributeDirective(
  const OMPDistributeDirective *D) {
VisitOMPLoopDirective(D);
2855}

2857void EnqueueVisitor::VisitOMPDistributeParallelForDirective(
  const OMPDistributeParallelForDirective *D) {
VisitOMPLoopDirective(D);
2860}

2862void EnqueueVisitor::VisitOMPDistributeParallelForSimdDirective(
  const OMPDistributeParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
2865}

2867void EnqueueVisitor::VisitOMPDistributeSimdDirective(
  const OMPDistributeSimdDirective *D) {
VisitOMPLoopDirective(D);
2870}

2872void EnqueueVisitor::VisitOMPTargetParallelForSimdDirective(
  const OMPTargetParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
2875}

2877void EnqueueVisitor::VisitOMPTargetSimdDirective(
  const OMPTargetSimdDirective *D) {
VisitOMPLoopDirective(D);
2880}

2882void EnqueueVisitor::VisitOMPTeamsDistributeDirective(
  const OMPTeamsDistributeDirective *D) {
VisitOMPLoopDirective(D);
2885}

2887void EnqueueVisitor::VisitOMPTeamsDistributeSimdDirective(
  const OMPTeamsDistributeSimdDirective *D) {
VisitOMPLoopDirective(D);
2890}

2892void EnqueueVisitor::VisitOMPTeamsDistributeParallelForSimdDirective(
  const OMPTeamsDistributeParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
2895}

2897void EnqueueVisitor::VisitOMPTeamsDistributeParallelForDirective(
  const OMPTeamsDistributeParallelForDirective *D) {
VisitOMPLoopDirective(D);
2900}

2902void EnqueueVisitor::VisitOMPTargetTeamsDirective(
  const OMPTargetTeamsDirective *D) {
VisitOMPExecutableDirective(D);
2905}

2907void EnqueueVisitor::VisitOMPTargetTeamsDistributeDirective(
  const OMPTargetTeamsDistributeDirective *D) {
VisitOMPLoopDirective(D);
2910}

2912void EnqueueVisitor::VisitOMPTargetTeamsDistributeParallelForDirective(
  const OMPTargetTeamsDistributeParallelForDirective *D) {
VisitOMPLoopDirective(D);
2915}

2917void EnqueueVisitor::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
  const OMPTargetTeamsDistributeParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
2920}

2922void EnqueueVisitor::VisitOMPTargetTeamsDistributeSimdDirective(
  const OMPTargetTeamsDistributeSimdDirective *D) {
VisitOMPLoopDirective(D);
2925}

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

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

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

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

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

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

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

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

      // Update the current cursor.
      CXCursor Cursor = MakeCXCursor(S, StmtParent, TU, RegionOfInterest);
      if (!IsInRegionOfInterest(Cursor))
        continue;
      switch (Visitor(Cursor, Parent, ClientData)) {
        case CXChildVisit_Break: return true;
        case CXChildVisit_Continue: break;
        case CXChildVisit_Recurse:
          if (PostChildrenVisitor)
            WL.push_back(PostChildrenVisit(nullptr, Cursor));
          EnqueueWorkList(WL, S);
          break;
      }
      continue;
    }
    case VisitorJob::MemberExprPartsKind: {
      // Handle the other pieces in the MemberExpr besides the base.
      const MemberExpr *M = cast<MemberExprParts>(&LI)->get();
      
      // Visit the nested-name-specifier
      if (NestedNameSpecifierLoc QualifierLoc = M->getQualifierLoc())
        if (VisitNestedNameSpecifierLoc(QualifierLoc))
          return true;
      
      // Visit the declaration name.
      if (VisitDeclarationNameInfo(M->getMemberNameInfo()))
        return true;
      
      // Visit the explicitly-specified template arguments, if any.
      if (M->hasExplicitTemplateArgs()) {
        for (const TemplateArgumentLoc *Arg = M->getTemplateArgs(),
             *ArgEnd = Arg + M->getNumTemplateArgs();
             Arg != ArgEnd; ++Arg) {
          if (VisitTemplateArgumentLoc(*Arg))
            return true;
        }
      }
      continue;
    }
    case VisitorJob::DeclRefExprPartsKind: {
      const DeclRefExpr *DR = cast<DeclRefExprParts>(&LI)->get();
      // Visit nested-name-specifier, if present.
      if (NestedNameSpecifierLoc QualifierLoc = DR->getQualifierLoc())
        if (VisitNestedNameSpecifierLoc(QualifierLoc))
          return true;
      // Visit declaration name.
      if (VisitDeclarationNameInfo(DR->getNameInfo()))
        return true;
      continue;
    }
    case VisitorJob::OverloadExprPartsKind: {
      const OverloadExpr *O = cast<OverloadExprParts>(&LI)->get();
      // Visit the nested-name-specifier.
      if (NestedNameSpecifierLoc QualifierLoc = O->getQualifierLoc())
        if (VisitNestedNameSpecifierLoc(QualifierLoc))
          return true;
      // Visit the declaration name.
      if (VisitDeclarationNameInfo(O->getNameInfo()))
        return true;
      // Visit the overloaded declaration reference.
      if (Visit(MakeCursorOverloadedDeclRef(O, TU)))
        return true;
      continue;
    }
    case VisitorJob::SizeOfPackExprPartsKind: {
      const SizeOfPackExpr *E = cast<SizeOfPackExprParts>(&LI)->get();
      NamedDecl *Pack = E->getPack();
      if (isa<TemplateTypeParmDecl>(Pack)) {
        if (Visit(MakeCursorTypeRef(cast<TemplateTypeParmDecl>(Pack),
                                    E->getPackLoc(), TU)))
          return true;
        
        continue;
      }
        
      if (isa<TemplateTemplateParmDecl>(Pack)) {
        if (Visit(MakeCursorTemplateRef(cast<TemplateTemplateParmDecl>(Pack),
                                        E->getPackLoc(), TU)))
          return true;
        
        continue;
      }
      
      // Non-type template parameter packs and function parameter packs are
      // treated like DeclRefExpr cursors.
      continue;
    }
      
    case VisitorJob::LambdaExprPartsKind: {
      // Visit captures.
      const LambdaExpr *E = cast<LambdaExprParts>(&LI)->get();
      for (LambdaExpr::capture_iterator C = E->explicit_capture_begin(),
                                     CEnd = E->explicit_capture_end();
           C != CEnd; ++C) {
        // FIXME: Lambda init-captures.
        if (!C->capturesVariable())
          continue;

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

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

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

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

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

RefNamePieces Pieces;

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

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

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

if (Kind == DeclarationName::CXXOperatorName) {
  Pieces.push_back(SourceLocation::getFromRawEncoding(
                     NI.getInfo().CXXOperatorName.BeginOpNameLoc));
  Pieces.push_back(SourceLocation::getFromRawEncoding(
                     NI.getInfo().CXXOperatorName.EndOpNameLoc));
}

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

return Pieces;  
3200}
3201}

3203//===----------------------------------------------------------------------===//
3204// Misc. API hooks.
3205//===----------------------------------------------------------------------===//               

3207static void fatal_error_handler(void *user_data, const std::string& reason,
                              bool gen_crash_diag) {
// Write the result out to stderr avoiding errs() because raw_ostreams can
// call report_fatal_error.
fprintf(stderrstderr, "LIBCLANG FATAL ERROR: %s\n", reason.c_str());
::abort();
3213}

3215namespace {
3216struct RegisterFatalErrorHandler {
RegisterFatalErrorHandler() {
  llvm::install_fatal_error_handler(fatal_error_handler, nullptr);
}
3220};
3221}

3223static llvm::ManagedStatic<RegisterFatalErrorHandler> RegisterFatalErrorHandlerOnce;

3225CXIndex clang_createIndex(int excludeDeclarationsFromPCH,
                        int displayDiagnostics) {
// We use crash recovery to make some of our APIs more reliable, implicitly
// enable it.
if (!getenv("LIBCLANG_DISABLE_CRASH_RECOVERY"))
  llvm::CrashRecoveryContext::Enable();

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

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

CIndexer *CIdxr = new CIndexer();

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

if (getenv("LIBCLANG_BGPRIO_INDEX"))
  CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() |
                             CXGlobalOpt_ThreadBackgroundPriorityForIndexing);
if (getenv("LIBCLANG_BGPRIO_EDIT"))
  CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() |
                             CXGlobalOpt_ThreadBackgroundPriorityForEditing);

return CIdxr;
3258}

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

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

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

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

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

3289CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx,
                                            const char *ast_filename) {
CXTranslationUnit TU;
enum CXErrorCode Result =
    clang_createTranslationUnit2(CIdx, ast_filename, &TU);
(void)Result;
assert((TU && Result == CXError_Success) ||(static_cast <bool> ((TU && Result == CXError_Success
) || (!TU && Result != CXError_Success)) ? void (0) :
 __assert_fail ("(TU && Result == CXError_Success) || (!TU && Result != CXError_Success)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 3296, __extension__ __PRETTY_FUNCTION__))
       (!TU && Result != CXError_Success))(static_cast <bool> ((TU && Result == CXError_Success
) || (!TU && Result != CXError_Success)) ? void (0) :
 __assert_fail ("(TU && Result == CXError_Success) || (!TU && Result != CXError_Success)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 3296, __extension__ __PRETTY_FUNCTION__));
return TU;
3298}

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

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

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

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

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

3330unsigned clang_defaultEditingTranslationUnitOptions() {
return CXTranslationUnit_PrecompiledPreamble | 
       CXTranslationUnit_CacheCompletionResults;
3333}

3335CXTranslationUnit
3336clang_createTranslationUnitFromSourceFile(CXIndex CIdx,
                                        const char *source_filename,
                                        int num_command_line_args,
                                        const char * const *command_line_args,
                                        unsigned num_unsaved_files,
                                        struct CXUnsavedFile *unsaved_files) {
unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord;
return clang_parseTranslationUnit(CIdx, source_filename,
                                  command_line_args, num_command_line_args,
                                  unsaved_files, num_unsaved_files,
                                  Options);
3347}

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

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

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

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

bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble;
bool CreatePreambleOnFirstParse =
    options & CXTranslationUnit_CreatePreambleOnFirstParse;
// FIXME: Add a flag for modules.
TranslationUnitKind TUKind
  = (options & (CXTranslationUnit_Incomplete |
                CXTranslationUnit_SingleFileParse))? TU_Prefix : TU_Complete;
bool CacheCodeCompletionResults
  = options & CXTranslationUnit_CacheCompletionResults;
bool IncludeBriefCommentsInCodeCompletion
  = options & CXTranslationUnit_IncludeBriefCommentsInCodeCompletion;
bool SkipFunctionBodies = options & CXTranslationUnit_SkipFunctionBodies;
bool SingleFileParse = options & CXTranslationUnit_SingleFileParse;
bool ForSerialization = options & CXTranslationUnit_ForSerialization;

// Configure the diagnostics.
IntrusiveRefCntPtr<DiagnosticsEngine>
  Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions));

if (options & CXTranslationUnit_KeepGoing)
  Diags->setSuppressAfterFatalError(false);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3499CXTranslationUnit
3500clang_parseTranslationUnit(CXIndex CIdx,
                         const char *source_filename,
                         const char *const *command_line_args,
                         int num_command_line_args,
                         struct CXUnsavedFile *unsaved_files,
                         unsigned num_unsaved_files,
                         unsigned options) {
CXTranslationUnit TU;
enum CXErrorCode Result = clang_parseTranslationUnit2(
    CIdx, source_filename, command_line_args, num_command_line_args,
    unsaved_files, num_unsaved_files, options, &TU);
(void)Result;
assert((TU && Result == CXError_Success) ||(static_cast <bool> ((TU && Result == CXError_Success
) || (!TU && Result != CXError_Success)) ? void (0) :
 __assert_fail ("(TU && Result == CXError_Success) || (!TU && Result != CXError_Success)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 3513, __extension__ __PRETTY_FUNCTION__))
       (!TU && Result != CXError_Success))(static_cast <bool> ((TU && Result == CXError_Success
) || (!TU && Result != CXError_Success)) ? void (0) :
 __assert_fail ("(TU && Result == CXError_Success) || (!TU && Result != CXError_Success)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 3513, __extension__ __PRETTY_FUNCTION__));
return TU;
3515}

3517enum CXErrorCode clang_parseTranslationUnit2(
  CXIndex CIdx, const char *source_filename,
  const char *const *command_line_args, int num_command_line_args,
  struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files,
  unsigned options, CXTranslationUnit *out_TU) {
SmallVector<const char *, 4> Args;
Args.push_back("clang");
Args.append(command_line_args, command_line_args + num_command_line_args);
return clang_parseTranslationUnit2FullArgv(
    CIdx, source_filename, Args.data(), Args.size(), unsaved_files,
    num_unsaved_files, options, out_TU);
3528}

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

if (num_unsaved_files && !unsaved_files)
  return CXError_InvalidArguments;

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

llvm::CrashRecoveryContext CRC;

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

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

return result;
3581}

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

return cxstring::createDup(encoding);
3591}

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

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

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

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

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

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

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

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

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

3678void clang_EvalResult_dispose(CXEvalResult E) {
delete static_cast<ExprEvalResult *>(E);
3680}

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

3689int clang_EvalResult_getAsInt(CXEvalResult E) {
return clang_EvalResult_getAsLongLong(E);
3691}

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

3703unsigned clang_EvalResult_isUnsignedInt(CXEvalResult E) {
return ((ExprEvalResult *)E)->IsUnsignedInt;
3705}

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

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

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

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

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

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

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

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

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

  return result.release();
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

return nullptr;
3879}

3881CXEvalResult clang_Cursor_Evaluate(CXCursor C) {
const Decl *D = getCursorDecl(C);
if (D) {
  const Expr *expr = nullptr;
  if (auto *Var = dyn_cast<VarDecl>(D)) {
    expr = Var->getInit();
  } else if (auto *Field = dyn_cast<FieldDecl>(D)) {
    expr = Field->getInClassInitializer();
  }
  if (expr)
    return const_cast<CXEvalResult>(reinterpret_cast<const void *>(
        evaluateExpr(const_cast<Expr *>(expr), C)));
  return nullptr;
}

const CompoundStmt *compoundStmt = dyn_cast_or_null<CompoundStmt>(getCursorStmt(C));
if (compoundStmt) {
  Expr *expr = nullptr;
  for (auto *bodyIterator : compoundStmt->body()) {
    if ((expr = dyn_cast<Expr>(bodyIterator))) {
      break;
    }
  }
  if (expr)
    return const_cast<CXEvalResult>(
        reinterpret_cast<const void *>(evaluateExpr(expr, C)));
}
return nullptr;
3909}

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

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

return 0;
3922}
3923unsigned clang_defaultSaveOptions(CXTranslationUnit TU) {
return CXSaveTranslationUnit_None;
3925}  

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

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

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

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

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

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

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

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

  return result;
}

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

llvm::CrashRecoveryContext CRC;

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

  return CXSaveError_Unknown;

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

return result;
3986}

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

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

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

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

  Unit->ResetForParse();
  return true;
}

return false;
4017}

4019unsigned clang_defaultReparseOptions(CXTranslationUnit TU) {
return CXReparse_None;
4021}

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

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

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

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

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

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

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

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

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

if (num_unsaved_files && !unsaved_files)
  return CXError_InvalidArguments;

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

llvm::CrashRecoveryContext CRC;

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

return result;
4092}


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

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

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

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

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

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

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

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

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

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

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

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

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

delete TargetInfo;
4157}

4159//===----------------------------------------------------------------------===//
4160// CXFile Operations.
4161//===----------------------------------------------------------------------===//

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

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

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

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

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

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

FileManager &FMgr = CXXUnit->getFileManager();
return const_cast<FileEntry *>(FMgr.getFile(file_name));
4189}

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

const SourceManager &SM = cxtu::getASTUnit(TU)->getSourceManager();
FileID fid = SM.translateFile(static_cast<FileEntry *>(file));
bool Invalid = true;
llvm::MemoryBuffer *buf = SM.getBuffer(fid, &Invalid);
if (Invalid) {
  if (size)
    *size = 0;
  return nullptr;
}
if (size)
  *size = buf->getBufferSize();
return buf->getBufferStart();
4210}

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

if (!file)
  return 0;

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

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

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

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

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

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

4252//===----------------------------------------------------------------------===//
4253// CXCursor Operations.
4254//===----------------------------------------------------------------------===//

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

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

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

return nullptr;
4305}

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

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

return E->getLocStart();
4325}

4327extern "C" {

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

4337#ifndef __has_feature
4338#define0 __has_feature(x)0 0
4339#endif
4340#if __has_feature(blocks)0
4341typedef enum CXChildVisitResult 
   (^CXCursorVisitorBlock)(CXCursor cursor, CXCursor parent);

4344static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
  CXClientData client_data) {
CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
return block(cursor, parent);
4348}
4349#else
4350// If we are compiled with a compiler that doesn't have native blocks support,
4351// define and call the block manually, so the 
4352typedef struct _CXChildVisitResult
4353{
void *isa;
int flags;
int reserved;
enum CXChildVisitResult(*invoke)(struct _CXChildVisitResult*, CXCursor,
                                       CXCursor);
4359} *CXCursorVisitorBlock;

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


4369unsigned clang_visitChildrenWithBlock(CXCursor parent,
                                    CXCursorVisitorBlock block) {
return clang_visitChildren(parent, visitWithBlock, block);
4372}

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

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

  return cxstring::createEmpty();
}

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

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

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

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

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

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

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

    return cxstring::createDup(getCursorContext(C).getTypeDeclType(Type).
                            getAsString());
  }
  case CXCursor_TemplateRef: {
    const TemplateDecl *Template = getCursorTemplateRef(C).first;
    assert(Template && "Missing template decl")(static_cast <bool> (Template && "Missing template decl"
) ? void (0) : __assert_fail ("Template && \"Missing template decl\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 4443, __extension__ __PRETTY_FUNCTION__));
    
    return cxstring::createDup(Template->getNameAsString());
  }
      
  case CXCursor_NamespaceRef: {
    const NamedDecl *NS = getCursorNamespaceRef(C).first;
    assert(NS && "Missing namespace decl")(static_cast <bool> (NS && "Missing namespace decl"
) ? void (0) : __assert_fail ("NS && \"Missing namespace decl\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 4450, __extension__ __PRETTY_FUNCTION__));
    
    return cxstring::createDup(NS->getNameAsString());
  }

  case CXCursor_MemberRef: {
    const FieldDecl *Field = getCursorMemberRef(C).first;
    assert(Field && "Missing member decl")(static_cast <bool> (Field && "Missing member decl"
) ? void (0) : __assert_fail ("Field && \"Missing member decl\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 4457, __extension__ __PRETTY_FUNCTION__));
    
    return cxstring::createDup(Field->getNameAsString());
  }

  case CXCursor_LabelRef: {
    const LabelStmt *Label = getCursorLabelRef(C).first;
    assert(Label && "Missing label")(static_cast <bool> (Label && "Missing label") ?
 void (0) : __assert_fail ("Label && \"Missing label\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 4464, __extension__ __PRETTY_FUNCTION__));
    
    return cxstring::createRef(Label->getName());
  }

  case CXCursor_OverloadedDeclRef: {
    OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first;
    if (const Decl *D = Storage.dyn_cast<const Decl *>()) {
      if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
        return cxstring::createDup(ND->getNameAsString());
      return cxstring::createEmpty();
    }
    if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
      return cxstring::createDup(E->getName().getAsString());
    OverloadedTemplateStorage *Ovl
      = Storage.get<OverloadedTemplateStorage*>();
    if (Ovl->size() == 0)
      return cxstring::createEmpty();
    return cxstring::createDup((*Ovl->begin())->getNameAsString());
  }
      
  case CXCursor_VariableRef: {
    const VarDecl *Var = getCursorVariableRef(C).first;
    assert(Var && "Missing variable decl")(static_cast <bool> (Var && "Missing variable decl"
) ? void (0) : __assert_fail ("Var && \"Missing variable decl\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 4487, __extension__ __PRETTY_FUNCTION__));
    
    return cxstring::createDup(Var->getNameAsString());
  }
      
  default:
    return cxstring::createRef("<not implemented>");
  }
}

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

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

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

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

  return cxstring::createEmpty();
}

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

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

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

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

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

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

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

return cxstring::createEmpty();
4570}

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

ASTContext &Ctx = getCursorContext(C);

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

  return clang_getNullRange();
}

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

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

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

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

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

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

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

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

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

if (pieceIndex > 0)
  return clang_getNullRange();

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

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

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

ASTContext &Ctx = D->getASTContext();
index::CodegenNameGenerator CGNameGen(Ctx);
return cxstring::createDup(CGNameGen.getName(D));
4679}

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

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

ASTContext &Ctx = D->getASTContext();
index::CodegenNameGenerator CGNameGen(Ctx);
std::vector<std::string> Manglings = CGNameGen.getAllManglings(D);
return cxstring::createSet(Manglings);
4693}

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

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

ASTContext &Ctx = D->getASTContext();
index::CodegenNameGenerator CGNameGen(Ctx);
std::vector<std::string> Manglings = CGNameGen.getAllManglings(D);
return cxstring::createSet(Manglings);
4707}

4709CXPrintingPolicy clang_getCursorPrintingPolicy(CXCursor C) {
if (clang_Cursor_isNull(C))
  return 0;
return new PrintingPolicy(getCursorContext(C).getPrintingPolicy());
4713}

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

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

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

assert(false && "Invalid CXPrintingPolicyProperty")(static_cast <bool> (false && "Invalid CXPrintingPolicyProperty"
) ? void (0) : __assert_fail ("false && \"Invalid CXPrintingPolicyProperty\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 4782, __extension__ __PRETTY_FUNCTION__));
return 0;
4784}

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

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

assert(false && "Invalid CXPrintingPolicyProperty")(static_cast <bool> (false && "Invalid CXPrintingPolicyProperty"
) ? void (0) : __assert_fail ("false && \"Invalid CXPrintingPolicyProperty\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 4874, __extension__ __PRETTY_FUNCTION__));
4875}

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

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

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

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

return cxstring::createEmpty();
4896}

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

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

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

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

if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) {
  SmallString<64> Str;
  llvm::raw_svector_ostream OS(Str);
  OS << *ClassTemplate;
  OS << "<";
  TemplateParameterList *Params = ClassTemplate->getTemplateParameters();
  for (unsigned I = 0, N = Params->size(); I != N; ++I) {
    if (I)
      OS << ", ";
    
    NamedDecl *Param = Params->getParam(I);
    if (Param->getIdentifier()) {
      OS << Param->getIdentifier()->getName();
      continue;
    }
    
    // There is no parameter name, which makes this tricky. Try to come up
    // with something useful that isn't too long.
    if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
      OS << (TTP->wasDeclaredWithTypename()? "typename" : "class");
    else if (NonTypeTemplateParmDecl *NTTP
                                  = dyn_cast<NonTypeTemplateParmDecl>(Param))
      OS << NTTP->getType().getAsString(Policy);
    else
      OS << "template<...> class";
  }
  
  OS << ">";
  return cxstring::createDup(OS.str());
}

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

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

return clang_getCursorSpelling(C);
4978}

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

llvm_unreachable("Unhandled CXCursorKind")::llvm::llvm_unreachable_internal("Unhandled CXCursorKind", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 5411);
5412}

5414struct GetCursorData {
SourceLocation TokenBeginLoc;
bool PointsAtMacroArgExpansion;
bool VisitedObjCPropertyImplDecl;
SourceLocation VisitedDeclaratorDeclStartLoc;
CXCursor &BestCursor;

GetCursorData(SourceManager &SM,
              SourceLocation tokenBegin, CXCursor &outputCursor)
  : TokenBeginLoc(tokenBegin), BestCursor(outputCursor) {
  PointsAtMacroArgExpansion = SM.isMacroArgExpansion(tokenBegin);
  VisitedObjCPropertyImplDecl = false;
}
5427};

5429static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor,
                                              CXCursor parent,
                                              CXClientData client_data) {
GetCursorData *Data = static_cast<GetCursorData *>(client_data);
CXCursor *BestCursor = &Data->BestCursor;

// If we point inside a macro argument we should provide info of what the
// token is so use the actual cursor, don't replace it with a macro expansion
// cursor.
if (cursor.kind == CXCursor_MacroExpansion && Data->PointsAtMacroArgExpansion)
  return CXChildVisit_Recurse;

if (clang_isDeclaration(cursor.kind)) {
  // Avoid having the implicit methods override the property decls.
  if (const ObjCMethodDecl *MD
        = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) {
    if (MD->isImplicit())
      return CXChildVisit_Break;

  } else if (const ObjCInterfaceDecl *ID
               = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(cursor))) {
    // Check that when we have multiple @class references in the same line,
    // that later ones do not override the previous ones.
    // If we have:
    // @class Foo, Bar;
    // source ranges for both start at '@', so 'Bar' will end up overriding
    // 'Foo' even though the cursor location was at 'Foo'.
    if (BestCursor->kind == CXCursor_ObjCInterfaceDecl ||
        BestCursor->kind == CXCursor_ObjCClassRef)
      if (const ObjCInterfaceDecl *PrevID
           = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(*BestCursor))){
       if (PrevID != ID &&
           !PrevID->isThisDeclarationADefinition() &&
           !ID->isThisDeclarationADefinition())
         return CXChildVisit_Break;
      }

  } else if (const DeclaratorDecl *DD
                  = dyn_cast_or_null<DeclaratorDecl>(getCursorDecl(cursor))) {
    SourceLocation StartLoc = DD->getSourceRange().getBegin();
    // Check that when we have multiple declarators in the same line,
    // that later ones do not override the previous ones.
    // If we have:
    // int Foo, Bar;
    // source ranges for both start at 'int', so 'Bar' will end up overriding
    // 'Foo' even though the cursor location was at 'Foo'.
    if (Data->VisitedDeclaratorDeclStartLoc == StartLoc)
      return CXChildVisit_Break;
    Data->VisitedDeclaratorDeclStartLoc = StartLoc;

  } else if (const ObjCPropertyImplDecl *PropImp
            = dyn_cast_or_null<ObjCPropertyImplDecl>(getCursorDecl(cursor))) {
    (void)PropImp;
    // Check that when we have multiple @synthesize in the same line,
    // that later ones do not override the previous ones.
    // If we have:
    // @synthesize Foo, Bar;
    // source ranges for both start at '@', so 'Bar' will end up overriding
    // 'Foo' even though the cursor location was at 'Foo'.
    if (Data->VisitedObjCPropertyImplDecl)
      return CXChildVisit_Break;
    Data->VisitedObjCPropertyImplDecl = true;
  }
}

if (clang_isExpression(cursor.kind) &&
    clang_isDeclaration(BestCursor->kind)) {
  if (const Decl *D = getCursorDecl(*BestCursor)) {
    // Avoid having the cursor of an expression replace the declaration cursor
    // when the expression source range overlaps the declaration range.
    // This can happen for C++ constructor expressions whose range generally
    // include the variable declaration, e.g.:
    //  MyCXXClass foo; // Make sure pointing at 'foo' returns a VarDecl cursor.
    if (D->getLocation().isValid() && Data->TokenBeginLoc.isValid() &&
        D->getLocation() == Data->TokenBeginLoc)
      return CXChildVisit_Break;
  }
}

// If our current best cursor is the construction of a temporary object, 
// don't replace that cursor with a type reference, because we want 
// clang_getCursor() to point at the constructor.
if (clang_isExpression(BestCursor->kind) &&
    isa<CXXTemporaryObjectExpr>(getCursorExpr(*BestCursor)) &&
    cursor.kind == CXCursor_TypeRef) {
  // Keep the cursor pointing at CXXTemporaryObjectExpr but also mark it
  // as having the actual point on the type reference.
  *BestCursor = getTypeRefedCallExprCursor(*BestCursor);
  return CXChildVisit_Recurse;
}

// If we already have an Objective-C superclass reference, don't
// update it further.
if (BestCursor->kind == CXCursor_ObjCSuperClassRef)
  return CXChildVisit_Break;

*BestCursor = cursor;
return CXChildVisit_Recurse;
5527}

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

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

SourceLocation SLoc = cxloc::translateSourceLocation(Loc);
CXCursor Result = cxcursor::getCursor(TU, SLoc);

LOG_FUNC_SECTIONif (clang::cxindex::LogRef Log = clang::cxindex::Logger::make
(__func__)) {
  CXFile SearchFile;
  unsigned SearchLine, SearchColumn;
  CXFile ResultFile;
  unsigned ResultLine, ResultColumn;
  CXString SearchFileName, ResultFileName, KindSpelling, USR;
  const char *IsDef = clang_isCursorDefinition(Result)? " (Definition)" : "";
  CXSourceLocation ResultLoc = clang_getCursorLocation(Result);

  clang_getFileLocation(Loc, &SearchFile, &SearchLine, &SearchColumn,
                        nullptr);
  clang_getFileLocation(ResultLoc, &ResultFile, &ResultLine,
                        &ResultColumn, nullptr);
  SearchFileName = clang_getFileName(SearchFile);
  ResultFileName = clang_getFileName(ResultFile);
  KindSpelling = clang_getCursorKindSpelling(Result.kind);
  USR = clang_getCursorUSR(Result);
  *Log << llvm::format("(%s:%d:%d) = %s",
                 clang_getCString(SearchFileName), SearchLine, SearchColumn,
                 clang_getCString(KindSpelling))
      << llvm::format("(%s:%d:%d):%s%s",
                   clang_getCString(ResultFileName), ResultLine, ResultColumn,
                   clang_getCString(USR), IsDef);
  clang_disposeString(SearchFileName);
  clang_disposeString(ResultFileName);
  clang_disposeString(KindSpelling);
  clang_disposeString(USR);
  
  CXCursor Definition = clang_getCursorDefinition(Result);
  if (!clang_equalCursors(Definition, clang_getNullCursor())) {
    CXSourceLocation DefinitionLoc = clang_getCursorLocation(Definition);
    CXString DefinitionKindSpelling
                              = clang_getCursorKindSpelling(Definition.kind);
    CXFile DefinitionFile;
    unsigned DefinitionLine, DefinitionColumn;
    clang_getFileLocation(DefinitionLoc, &DefinitionFile,
                          &DefinitionLine, &DefinitionColumn, nullptr);
    CXString DefinitionFileName = clang_getFileName(DefinitionFile);
    *Log << llvm::format("  -> %s(%s:%d:%d)",
                   clang_getCString(DefinitionKindSpelling),
                   clang_getCString(DefinitionFileName),
                   DefinitionLine, DefinitionColumn);
    clang_disposeString(DefinitionFileName);
    clang_disposeString(DefinitionKindSpelling);
  }
}

return Result;
5589}

5591CXCursor clang_getNullCursor(void) {
return MakeCXCursorInvalid(CXCursor_InvalidFile);
5593}

5595unsigned clang_equalCursors(CXCursor X, CXCursor Y) {
// Clear out the "FirstInDeclGroup" part in a declaration cursor, since we
// can't set consistently. For example, when visiting a DeclStmt we will set
// it but we don't set it on the result of clang_getCursorDefinition for
// a reference of the same declaration.
// FIXME: Setting "FirstInDeclGroup" in CXCursors is a hack that only works
// when visiting a DeclStmt currently, the AST should be enhanced to be able
// to provide that kind of info.
if (clang_isDeclaration(X.kind))
  X.data[1] = nullptr;
if (clang_isDeclaration(Y.kind))
  Y.data[1] = nullptr;

return X == Y;
5609}

5611unsigned clang_hashCursor(CXCursor C) {
unsigned Index = 0;
if (clang_isExpression(C.kind) || clang_isStatement(C.kind))
  Index = 1;

return llvm::DenseMapInfo<std::pair<unsigned, const void*> >::getHashValue(
                                      std::make_pair(C.kind, C.data[Index]));
5618}

5620unsigned clang_isInvalid(enum CXCursorKind K) {
return K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid;
5622}

5624unsigned clang_isDeclaration(enum CXCursorKind K) {
return (K >= CXCursor_FirstDecl && K <= CXCursor_LastDecl) ||
       (K >= CXCursor_FirstExtraDecl && K <= CXCursor_LastExtraDecl);
5627}

5629unsigned clang_isInvalidDeclaration(CXCursor C) {
if (clang_isDeclaration(C.kind)) {
  if (const Decl *D = getCursorDecl(C))
    return D->isInvalidDecl();
}

return 0;
5636}

5638unsigned clang_isReference(enum CXCursorKind K) {
return K >= CXCursor_FirstRef && K <= CXCursor_LastRef;
5640}

5642unsigned clang_isExpression(enum CXCursorKind K) {
return K >= CXCursor_FirstExpr && K <= CXCursor_LastExpr;
5644}

5646unsigned clang_isStatement(enum CXCursorKind K) {
return K >= CXCursor_FirstStmt && K <= CXCursor_LastStmt;
5648}

5650unsigned clang_isAttribute(enum CXCursorKind K) {
  return K >= CXCursor_FirstAttr && K <= CXCursor_LastAttr;
5652}

5654unsigned clang_isTranslationUnit(enum CXCursorKind K) {
return K == CXCursor_TranslationUnit;
5656}

5658unsigned clang_isPreprocessing(enum CXCursorKind K) {
return K >= CXCursor_FirstPreprocessing && K <= CXCursor_LastPreprocessing;
5660}

5662unsigned clang_isUnexposed(enum CXCursorKind K) {
switch (K) {
  case CXCursor_UnexposedDecl:
  case CXCursor_UnexposedExpr:
  case CXCursor_UnexposedStmt:
  case CXCursor_UnexposedAttr:
    return true;
  default:
    return false;
}
5672}

5674CXCursorKind clang_getCursorKind(CXCursor C) {
return C.kind;
5676}

5678CXSourceLocation clang_getCursorLocation(CXCursor C) {
if (clang_isReference(C.kind)) {
  switch (C.kind) {
  case CXCursor_ObjCSuperClassRef: {
    std::pair<const ObjCInterfaceDecl *, SourceLocation> P
      = getCursorObjCSuperClassRef(C);
    return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
  }

  case CXCursor_ObjCProtocolRef: {
    std::pair<const ObjCProtocolDecl *, SourceLocation> P
      = getCursorObjCProtocolRef(C);
    return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
  }

  case CXCursor_ObjCClassRef: {
    std::pair<const ObjCInterfaceDecl *, SourceLocation> P
      = getCursorObjCClassRef(C);
    return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
  }

  case CXCursor_TypeRef: {
    std::pair<const TypeDecl *, SourceLocation> P = getCursorTypeRef(C);
    return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
  }

  case CXCursor_TemplateRef: {
    std::pair<const TemplateDecl *, SourceLocation> P =
        getCursorTemplateRef(C);
    return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
  }

  case CXCursor_NamespaceRef: {
    std::pair<const NamedDecl *, SourceLocation> P = getCursorNamespaceRef(C);
    return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
  }

  case CXCursor_MemberRef: {
    std::pair<const FieldDecl *, SourceLocation> P = getCursorMemberRef(C);
    return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
  }

  case CXCursor_VariableRef: {
    std::pair<const VarDecl *, SourceLocation> P = getCursorVariableRef(C);
    return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
  }

  case CXCursor_CXXBaseSpecifier: {
    const CXXBaseSpecifier *BaseSpec = getCursorCXXBaseSpecifier(C);
    if (!BaseSpec)
      return clang_getNullLocation();
    
    if (TypeSourceInfo *TSInfo = BaseSpec->getTypeSourceInfo())
      return cxloc::translateSourceLocation(getCursorContext(C),
                                          TSInfo->getTypeLoc().getBeginLoc());
    
    return cxloc::translateSourceLocation(getCursorContext(C),
                                      BaseSpec->getLocStart());
  }

  case CXCursor_LabelRef: {
    std::pair<const LabelStmt *, SourceLocation> P = getCursorLabelRef(C);
    return cxloc::translateSourceLocation(getCursorContext(C), P.second);
  }

  case CXCursor_OverloadedDeclRef:
    return cxloc::translateSourceLocation(getCursorContext(C),
                                        getCursorOverloadedDeclRef(C).second);

  default:
    // FIXME: Need a way to enumerate all non-reference cases.
    llvm_unreachable("Missed a reference kind")::llvm::llvm_unreachable_internal("Missed a reference kind", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 5749);
  }
}

if (clang_isExpression(C.kind))
  return cxloc::translateSourceLocation(getCursorContext(C),
                                 getLocationFromExpr(getCursorExpr(C)));

if (clang_isStatement(C.kind))
  return cxloc::translateSourceLocation(getCursorContext(C),
                                        getCursorStmt(C)->getLocStart());

if (C.kind == CXCursor_PreprocessingDirective) {
  SourceLocation L = cxcursor::getCursorPreprocessingDirective(C).getBegin();
  return cxloc::translateSourceLocation(getCursorContext(C), L);
}

if (C.kind == CXCursor_MacroExpansion) {
  SourceLocation L
    = cxcursor::getCursorMacroExpansion(C).getSourceRange().getBegin();
  return cxloc::translateSourceLocation(getCursorContext(C), L);
}

if (C.kind == CXCursor_MacroDefinition) {
  SourceLocation L = cxcursor::getCursorMacroDefinition(C)->getLocation();
  return cxloc::translateSourceLocation(getCursorContext(C), L);
}

if (C.kind == CXCursor_InclusionDirective) {
  SourceLocation L
    = cxcursor::getCursorInclusionDirective(C)->getSourceRange().getBegin();
  return cxloc::translateSourceLocation(getCursorContext(C), L);
}

if (clang_isAttribute(C.kind)) {
  SourceLocation L
    = cxcursor::getCursorAttr(C)->getLocation();
  return cxloc::translateSourceLocation(getCursorContext(C), L);
}

if (!clang_isDeclaration(C.kind))
  return clang_getNullLocation();

const Decl *D = getCursorDecl(C);
if (!D)
  return clang_getNullLocation();

SourceLocation Loc = D->getLocation();
// FIXME: Multiple variables declared in a single declaration
// currently lack the information needed to correctly determine their
// ranges when accounting for the type-specifier.  We use context
// stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
// and if so, whether it is the first decl.
if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
  if (!cxcursor::isFirstInDeclGroup(C))
    Loc = VD->getLocation();
}

// For ObjC methods, give the start location of the method name.
if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
  Loc = MD->getSelectorStartLoc();

return cxloc::translateSourceLocation(getCursorContext(C), Loc);
5812}

5814} // end extern "C"

5816CXCursor cxcursor::getCursor(CXTranslationUnit TU, SourceLocation SLoc) {
assert(TU)(static_cast <bool> (TU) ? void (0) : __assert_fail ("TU"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 5817, __extension__ __PRETTY_FUNCTION__));

// Guard against an invalid SourceLocation, or we may assert in one
// of the following calls.
if (SLoc.isInvalid())
  return clang_getNullCursor();

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

// Translate the given source location to make it point at the beginning of
// the token under the cursor.
SLoc = Lexer::GetBeginningOfToken(SLoc, CXXUnit->getSourceManager(),
                                  CXXUnit->getASTContext().getLangOpts());

CXCursor Result = MakeCXCursorInvalid(CXCursor_NoDeclFound);
if (SLoc.isValid()) {
  GetCursorData ResultData(CXXUnit->getSourceManager(), SLoc, Result);
  CursorVisitor CursorVis(TU, GetCursorVisitor, &ResultData,
                          /*VisitPreprocessorLast=*/true, 
                          /*VisitIncludedEntities=*/false,
                          SourceLocation(SLoc));
  CursorVis.visitFileRegion();
}

return Result;
5842}

5844static SourceRange getRawCursorExtent(CXCursor C) {
if (clang_isReference(C.kind)) {
  switch (C.kind) {
  case CXCursor_ObjCSuperClassRef:
    return  getCursorObjCSuperClassRef(C).second;

  case CXCursor_ObjCProtocolRef:
    return getCursorObjCProtocolRef(C).second;

  case CXCursor_ObjCClassRef:
    return getCursorObjCClassRef(C).second;

  case CXCursor_TypeRef:
    return getCursorTypeRef(C).second;

  case CXCursor_TemplateRef:
    return getCursorTemplateRef(C).second;

  case CXCursor_NamespaceRef:
    return getCursorNamespaceRef(C).second;

  case CXCursor_MemberRef:
    return getCursorMemberRef(C).second;

  case CXCursor_CXXBaseSpecifier:
    return getCursorCXXBaseSpecifier(C)->getSourceRange();

  case CXCursor_LabelRef:
    return getCursorLabelRef(C).second;

  case CXCursor_OverloadedDeclRef:
    return getCursorOverloadedDeclRef(C).second;

  case CXCursor_VariableRef:
    return getCursorVariableRef(C).second;
      
  default:
    // FIXME: Need a way to enumerate all non-reference cases.
    llvm_unreachable("Missed a reference kind")::llvm::llvm_unreachable_internal("Missed a reference kind", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 5882);
  }
}

if (clang_isExpression(C.kind))
  return getCursorExpr(C)->getSourceRange();

if (clang_isStatement(C.kind))
  return getCursorStmt(C)->getSourceRange();

if (clang_isAttribute(C.kind))
  return getCursorAttr(C)->getRange();

if (C.kind == CXCursor_PreprocessingDirective)
  return cxcursor::getCursorPreprocessingDirective(C);

if (C.kind == CXCursor_MacroExpansion) {
  ASTUnit *TU = getCursorASTUnit(C);
  SourceRange Range = cxcursor::getCursorMacroExpansion(C).getSourceRange();
  return TU->mapRangeFromPreamble(Range);
}

if (C.kind == CXCursor_MacroDefinition) {
  ASTUnit *TU = getCursorASTUnit(C);
  SourceRange Range = cxcursor::getCursorMacroDefinition(C)->getSourceRange();
  return TU->mapRangeFromPreamble(Range);
}

if (C.kind == CXCursor_InclusionDirective) {
  ASTUnit *TU = getCursorASTUnit(C);
  SourceRange Range = cxcursor::getCursorInclusionDirective(C)->getSourceRange();
  return TU->mapRangeFromPreamble(Range);
}

if (C.kind == CXCursor_TranslationUnit) {
  ASTUnit *TU = getCursorASTUnit(C);
  FileID MainID = TU->getSourceManager().getMainFileID();
  SourceLocation Start = TU->getSourceManager().getLocForStartOfFile(MainID);
  SourceLocation End = TU->getSourceManager().getLocForEndOfFile(MainID);
  return SourceRange(Start, End);
}

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

  SourceRange R = D->getSourceRange();
  // FIXME: Multiple variables declared in a single declaration
  // currently lack the information needed to correctly determine their
  // ranges when accounting for the type-specifier.  We use context
  // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
  // and if so, whether it is the first decl.
  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
    if (!cxcursor::isFirstInDeclGroup(C))
      R.setBegin(VD->getLocation());
  }
  return R;
}
return SourceRange();
5942}

5944/// \brief Retrieves the "raw" cursor extent, which is then extended to include
5945/// the decl-specifier-seq for declarations.
5946static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) {
if (clang_isDeclaration(C.kind)) {
  const Decl *D = cxcursor::getCursorDecl(C);
  if (!D)
    return SourceRange();

  SourceRange R = D->getSourceRange();

  // Adjust the start of the location for declarations preceded by
  // declaration specifiers.
  SourceLocation StartLoc;
  if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
    if (TypeSourceInfo *TI = DD->getTypeSourceInfo())
      StartLoc = TI->getTypeLoc().getLocStart();
  } else if (const TypedefDecl *Typedef = dyn_cast<TypedefDecl>(D)) {
    if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo())
      StartLoc = TI->getTypeLoc().getLocStart();
  }

  if (StartLoc.isValid() && R.getBegin().isValid() &&
      SrcMgr.isBeforeInTranslationUnit(StartLoc, R.getBegin()))
    R.setBegin(StartLoc);

  // FIXME: Multiple variables declared in a single declaration
  // currently lack the information needed to correctly determine their
  // ranges when accounting for the type-specifier.  We use context
  // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
  // and if so, whether it is the first decl.
  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
    if (!cxcursor::isFirstInDeclGroup(C))
      R.setBegin(VD->getLocation());
  }

  return R;    
}

return getRawCursorExtent(C);
5983}

5985CXSourceRange clang_getCursorExtent(CXCursor C) {
SourceRange R = getRawCursorExtent(C);
if (R.isInvalid())
  return clang_getNullRange();

return cxloc::translateSourceRange(getCursorContext(C), R);
5991}

5993CXCursor clang_getCursorReferenced(CXCursor C) {
if (clang_isInvalid(C.kind))
  return clang_getNullCursor();

CXTranslationUnit tu = getCursorTU(C);
if (clang_isDeclaration(C.kind)) {
  const Decl *D = getCursorDecl(C);
  if (!D)
    return clang_getNullCursor();
  if (const UsingDecl *Using = dyn_cast<UsingDecl>(D))
    return MakeCursorOverloadedDeclRef(Using, D->getLocation(), tu);
  if (const ObjCPropertyImplDecl *PropImpl =
          dyn_cast<ObjCPropertyImplDecl>(D))
    if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl())
      return MakeCXCursor(Property, tu);
  
  return C;
}

if (clang_isExpression(C.kind)) {
  const Expr *E = getCursorExpr(C);
  const Decl *D = getDeclFromExpr(E);
  if (D) {
    CXCursor declCursor = MakeCXCursor(D, tu);
    declCursor = getSelectorIdentifierCursor(getSelectorIdentifierIndex(C),
                                             declCursor);
    return declCursor;
  }
  
  if (const OverloadExpr *Ovl = dyn_cast_or_null<OverloadExpr>(E))
    return MakeCursorOverloadedDeclRef(Ovl, tu);
      
  return clang_getNullCursor();
}

if (clang_isStatement(C.kind)) {
  const Stmt *S = getCursorStmt(C);
  if (const GotoStmt *Goto = dyn_cast_or_null<GotoStmt>(S))
    if (LabelDecl *label = Goto->getLabel())
      if (LabelStmt *labelS = label->getStmt())
      return MakeCXCursor(labelS, getCursorDecl(C), tu);

  return clang_getNullCursor();
}

if (C.kind == CXCursor_MacroExpansion) {
  if (const MacroDefinitionRecord *Def =
          getCursorMacroExpansion(C).getDefinition())
    return MakeMacroDefinitionCursor(Def, tu);
}

if (!clang_isReference(C.kind))
  return clang_getNullCursor();

switch (C.kind) {
  case CXCursor_ObjCSuperClassRef:
    return MakeCXCursor(getCursorObjCSuperClassRef(C).first, tu);

  case CXCursor_ObjCProtocolRef: {
    const ObjCProtocolDecl *Prot = getCursorObjCProtocolRef(C).first;
    if (const ObjCProtocolDecl *Def = Prot->getDefinition())
      return MakeCXCursor(Def, tu);

    return MakeCXCursor(Prot, tu);
  }

  case CXCursor_ObjCClassRef: {
    const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first;
    if (const ObjCInterfaceDecl *Def = Class->getDefinition())
      return MakeCXCursor(Def, tu);

    return MakeCXCursor(Class, tu);
  }

  case CXCursor_TypeRef:
    return MakeCXCursor(getCursorTypeRef(C).first, tu );

  case CXCursor_TemplateRef:
    return MakeCXCursor(getCursorTemplateRef(C).first, tu );

  case CXCursor_NamespaceRef:
    return MakeCXCursor(getCursorNamespaceRef(C).first, tu );

  case CXCursor_MemberRef:
    return MakeCXCursor(getCursorMemberRef(C).first, tu );

  case CXCursor_CXXBaseSpecifier: {
    const CXXBaseSpecifier *B = cxcursor::getCursorCXXBaseSpecifier(C);
    return clang_getTypeDeclaration(cxtype::MakeCXType(B->getType(),
                                                       tu ));
  }

  case CXCursor_LabelRef:
    // FIXME: We end up faking the "parent" declaration here because we
    // don't want to make CXCursor larger.
    return MakeCXCursor(getCursorLabelRef(C).first,
                        cxtu::getASTUnit(tu)->getASTContext()
                            .getTranslationUnitDecl(),
                        tu);

  case CXCursor_OverloadedDeclRef:
    return C;
    
  case CXCursor_VariableRef:
    return MakeCXCursor(getCursorVariableRef(C).first, tu);

  default:
    // We would prefer to enumerate all non-reference cursor kinds here.
    llvm_unreachable("Unhandled reference cursor kind")::llvm::llvm_unreachable_internal("Unhandled reference cursor kind"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 6101);
}
6103}

6105CXCursor clang_getCursorDefinition(CXCursor C) {
if (clang_isInvalid(C.kind))
  return clang_getNullCursor();

CXTranslationUnit TU = getCursorTU(C);

bool WasReference = false;
if (clang_isReference(C.kind) || clang_isExpression(C.kind)) {
  C = clang_getCursorReferenced(C);
  WasReference = true;
}

if (C.kind == CXCursor_MacroExpansion)
  return clang_getCursorReferenced(C);

if (!clang_isDeclaration(C.kind))
  return clang_getNullCursor();

const Decl *D = getCursorDecl(C);
if (!D)
  return clang_getNullCursor();

switch (D->getKind()) {
// Declaration kinds that don't really separate the notions of
// declaration and definition.
case Decl::Namespace:
case Decl::Typedef:
case Decl::TypeAlias:
case Decl::TypeAliasTemplate:
case Decl::TemplateTypeParm:
case Decl::EnumConstant:
case Decl::Field:
case Decl::Binding:
case Decl::MSProperty:
case Decl::IndirectField:
case Decl::ObjCIvar:
case Decl::ObjCAtDefsField:
case Decl::ImplicitParam:
case Decl::ParmVar:
case Decl::NonTypeTemplateParm:
case Decl::TemplateTemplateParm:
case Decl::ObjCCategoryImpl:
case Decl::ObjCImplementation:
case Decl::AccessSpec:
case Decl::LinkageSpec:
case Decl::Export:
case Decl::ObjCPropertyImpl:
case Decl::FileScopeAsm:
case Decl::StaticAssert:
case Decl::Block:
case Decl::Captured:
case Decl::OMPCapturedExpr:
case Decl::Label:  // FIXME: Is this right??
case Decl::ClassScopeFunctionSpecialization:
case Decl::CXXDeductionGuide:
case Decl::Import:
case Decl::OMPThreadPrivate:
case Decl::OMPDeclareReduction:
case Decl::ObjCTypeParam:
case Decl::BuiltinTemplate:
case Decl::PragmaComment:
case Decl::PragmaDetectMismatch:
case Decl::UsingPack:
  return C;

// Declaration kinds that don't make any sense here, but are
// nonetheless harmless.
case Decl::Empty:
case Decl::TranslationUnit:
case Decl::ExternCContext:
  break;

// Declaration kinds for which the definition is not resolvable.
case Decl::UnresolvedUsingTypename:
case Decl::UnresolvedUsingValue:
  break;

case Decl::UsingDirective:
  return MakeCXCursor(cast<UsingDirectiveDecl>(D)->getNominatedNamespace(),
                      TU);

case Decl::NamespaceAlias:
  return MakeCXCursor(cast<NamespaceAliasDecl>(D)->getNamespace(), TU);

case Decl::Enum:
case Decl::Record:
case Decl::CXXRecord:
case Decl::ClassTemplateSpecialization:
case Decl::ClassTemplatePartialSpecialization:
  if (TagDecl *Def = cast<TagDecl>(D)->getDefinition())
    return MakeCXCursor(Def, TU);
  return clang_getNullCursor();

case Decl::Function:
case Decl::CXXMethod:
case Decl::CXXConstructor:
case Decl::CXXDestructor:
case Decl::CXXConversion: {
  const FunctionDecl *Def = nullptr;
  if (cast<FunctionDecl>(D)->getBody(Def))
    return MakeCXCursor(Def, TU);
  return clang_getNullCursor();
}

case Decl::Var:
case Decl::VarTemplateSpecialization:
case Decl::VarTemplatePartialSpecialization:
case Decl::Decomposition: {
  // Ask the variable if it has a definition.
  if (const VarDecl *Def = cast<VarDecl>(D)->getDefinition())
    return MakeCXCursor(Def, TU);
  return clang_getNullCursor();
}

case Decl::FunctionTemplate: {
  const FunctionDecl *Def = nullptr;
  if (cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->getBody(Def))
    return MakeCXCursor(Def->getDescribedFunctionTemplate(), TU);
  return clang_getNullCursor();
}

case Decl::ClassTemplate: {
  if (RecordDecl *Def = cast<ClassTemplateDecl>(D)->getTemplatedDecl()
                                                          ->getDefinition())
    return MakeCXCursor(cast<CXXRecordDecl>(Def)->getDescribedClassTemplate(),
                        TU);
  return clang_getNullCursor();
}

case Decl::VarTemplate: {
  if (VarDecl *Def =
          cast<VarTemplateDecl>(D)->getTemplatedDecl()->getDefinition())
    return MakeCXCursor(cast<VarDecl>(Def)->getDescribedVarTemplate(), TU);
  return clang_getNullCursor();
}

case Decl::Using:
  return MakeCursorOverloadedDeclRef(cast<UsingDecl>(D), 
                                     D->getLocation(), TU);

case Decl::UsingShadow:
case Decl::ConstructorUsingShadow:
  return clang_getCursorDefinition(
                     MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(),
                                  TU));

case Decl::ObjCMethod: {
  const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(D);
  if (Method->isThisDeclarationADefinition())
    return C;

  // Dig out the method definition in the associated
  // @implementation, if we have it.
  // FIXME: The ASTs should make finding the definition easier.
  if (const ObjCInterfaceDecl *Class
                     = dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext()))
    if (ObjCImplementationDecl *ClassImpl = Class->getImplementation())
      if (ObjCMethodDecl *Def = ClassImpl->getMethod(Method->getSelector(),
                                                Method->isInstanceMethod()))
        if (Def->isThisDeclarationADefinition())
          return MakeCXCursor(Def, TU);

  return clang_getNullCursor();
}

case Decl::ObjCCategory:
  if (ObjCCategoryImplDecl *Impl
                             = cast<ObjCCategoryDecl>(D)->getImplementation())
    return MakeCXCursor(Impl, TU);
  return clang_getNullCursor();

case Decl::ObjCProtocol:
  if (const ObjCProtocolDecl *Def = cast<ObjCProtocolDecl>(D)->getDefinition())
    return MakeCXCursor(Def, TU);
  return clang_getNullCursor();

case Decl::ObjCInterface: {
  // There are two notions of a "definition" for an Objective-C
  // class: the interface and its implementation. When we resolved a
  // reference to an Objective-C class, produce the @interface as
  // the definition; when we were provided with the interface,
  // produce the @implementation as the definition.
  const ObjCInterfaceDecl *IFace = cast<ObjCInterfaceDecl>(D);
  if (WasReference) {
    if (const ObjCInterfaceDecl *Def = IFace->getDefinition())
      return MakeCXCursor(Def, TU);
  } else if (ObjCImplementationDecl *Impl = IFace->getImplementation())
    return MakeCXCursor(Impl, TU);
  return clang_getNullCursor();
}

case Decl::ObjCProperty:
  // FIXME: We don't really know where to find the
  // ObjCPropertyImplDecls that implement this property.
  return clang_getNullCursor();

case Decl::ObjCCompatibleAlias:
  if (const ObjCInterfaceDecl *Class
        = cast<ObjCCompatibleAliasDecl>(D)->getClassInterface())
    if (const ObjCInterfaceDecl *Def = Class->getDefinition())
      return MakeCXCursor(Def, TU);

  return clang_getNullCursor();

case Decl::Friend:
  if (NamedDecl *Friend = cast<FriendDecl>(D)->getFriendDecl())
    return clang_getCursorDefinition(MakeCXCursor(Friend, TU));
  return clang_getNullCursor();

case Decl::FriendTemplate:
  if (NamedDecl *Friend = cast<FriendTemplateDecl>(D)->getFriendDecl())
    return clang_getCursorDefinition(MakeCXCursor(Friend, TU));
  return clang_getNullCursor();
}

return clang_getNullCursor();
6321}

6323unsigned clang_isCursorDefinition(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

return clang_getCursorDefinition(C) == C;
6328}

6330CXCursor clang_getCanonicalCursor(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return C;

if (const Decl *D = getCursorDecl(C)) {
  if (const ObjCCategoryImplDecl *CatImplD = dyn_cast<ObjCCategoryImplDecl>(D))
    if (ObjCCategoryDecl *CatD = CatImplD->getCategoryDecl())
      return MakeCXCursor(CatD, getCursorTU(C));

  if (const ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
    if (const ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
      return MakeCXCursor(IFD, getCursorTU(C));

  return MakeCXCursor(D->getCanonicalDecl(), getCursorTU(C));
}

return C;
6347}

6349int clang_Cursor_getObjCSelectorIndex(CXCursor cursor) {
return cxcursor::getSelectorIdentifierIndexAndLoc(cursor).first;
6351}

6353unsigned clang_getNumOverloadedDecls(CXCursor C) {
if (C.kind != CXCursor_OverloadedDeclRef)
  return 0;

OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first;
if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
  return E->getNumDecls();

if (OverloadedTemplateStorage *S
                            = Storage.dyn_cast<OverloadedTemplateStorage*>())
  return S->size();

const Decl *D = Storage.get<const Decl *>();
if (const UsingDecl *Using = dyn_cast<UsingDecl>(D))
  return Using->shadow_size();

return 0;
6370}

6372CXCursor clang_getOverloadedDecl(CXCursor cursor, unsigned index) {
if (cursor.kind != CXCursor_OverloadedDeclRef)
  return clang_getNullCursor();

if (index >= clang_getNumOverloadedDecls(cursor))
  return clang_getNullCursor();

CXTranslationUnit TU = getCursorTU(cursor);
OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(cursor).first;
if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
  return MakeCXCursor(E->decls_begin()[index], TU);

if (OverloadedTemplateStorage *S
                            = Storage.dyn_cast<OverloadedTemplateStorage*>())
  return MakeCXCursor(S->begin()[index], TU);

const Decl *D = Storage.get<const Decl *>();
if (const UsingDecl *Using = dyn_cast<UsingDecl>(D)) {
  // FIXME: This is, unfortunately, linear time.
  UsingDecl::shadow_iterator Pos = Using->shadow_begin();
  std::advance(Pos, index);
  return MakeCXCursor(cast<UsingShadowDecl>(*Pos)->getTargetDecl(), TU);
}

return clang_getNullCursor();
6397}

6399void clang_getDefinitionSpellingAndExtent(CXCursor C,
                                        const char **startBuf,
                                        const char **endBuf,
                                        unsigned *startLine,
                                        unsigned *startColumn,
                                        unsigned *endLine,
                                        unsigned *endColumn) {
assert(getCursorDecl(C) && "CXCursor has null decl")(static_cast <bool> (getCursorDecl(C) && "CXCursor has null decl"
) ? void (0) : __assert_fail ("getCursorDecl(C) && \"CXCursor has null decl\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 6406, __extension__ __PRETTY_FUNCTION__));
const FunctionDecl *FD = dyn_cast<FunctionDecl>(getCursorDecl(C));
CompoundStmt *Body = dyn_cast<CompoundStmt>(FD->getBody());

SourceManager &SM = FD->getASTContext().getSourceManager();
*startBuf = SM.getCharacterData(Body->getLBracLoc());
*endBuf = SM.getCharacterData(Body->getRBracLoc());
*startLine = SM.getSpellingLineNumber(Body->getLBracLoc());
*startColumn = SM.getSpellingColumnNumber(Body->getLBracLoc());
*endLine = SM.getSpellingLineNumber(Body->getRBracLoc());
*endColumn = SM.getSpellingColumnNumber(Body->getRBracLoc());
6417}


6420CXSourceRange clang_getCursorReferenceNameRange(CXCursor C, unsigned NameFlags,
                                              unsigned PieceIndex) {
RefNamePieces Pieces;

switch (C.kind) {
case CXCursor_MemberRefExpr:
  if (const MemberExpr *E = dyn_cast<MemberExpr>(getCursorExpr(C)))
    Pieces = buildPieces(NameFlags, true, E->getMemberNameInfo(),
                         E->getQualifierLoc().getSourceRange());
  break;

case CXCursor_DeclRefExpr:
  if (const DeclRefExpr *E = dyn_cast<DeclRefExpr>(getCursorExpr(C))) {
    SourceRange TemplateArgLoc(E->getLAngleLoc(), E->getRAngleLoc());
    Pieces =
        buildPieces(NameFlags, false, E->getNameInfo(),
                    E->getQualifierLoc().getSourceRange(), &TemplateArgLoc);
  }
  break;
  
case CXCursor_CallExpr:
  if (const CXXOperatorCallExpr *OCE = 
      dyn_cast<CXXOperatorCallExpr>(getCursorExpr(C))) {
    const Expr *Callee = OCE->getCallee();
    if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee))
      Callee = ICE->getSubExpr();

    if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee))
      Pieces = buildPieces(NameFlags, false, DRE->getNameInfo(),
                           DRE->getQualifierLoc().getSourceRange());
  }
  break;
  
default:
  break;
}

if (Pieces.empty()) {
  if (PieceIndex == 0)
    return clang_getCursorExtent(C);
} else if (PieceIndex < Pieces.size()) {
    SourceRange R = Pieces[PieceIndex];
    if (R.isValid())
      return cxloc::translateSourceRange(getCursorContext(C), R);
}

return clang_getNullRange();
6467}

6469void clang_enableStackTraces(void) {
// FIXME: Provide an argv0 here so we can find llvm-symbolizer.
llvm::sys::PrintStackTraceOnErrorSignal(StringRef());
6472}

6474void clang_executeOnThread(void (*fn)(void*), void *user_data,
                         unsigned stack_size) {
llvm::llvm_execute_on_thread(fn, user_data, stack_size);
6477}

6479//===----------------------------------------------------------------------===//
6480// Token-based Operations.
6481//===----------------------------------------------------------------------===//

6483/* CXToken layout:
*   int_data[0]: a CXTokenKind
*   int_data[1]: starting token location
*   int_data[2]: token length
*   int_data[3]: reserved
*   ptr_data: for identifiers and keywords, an IdentifierInfo*.
*   otherwise unused.
*/
6491CXTokenKind clang_getTokenKind(CXToken CXTok) {
return static_cast<CXTokenKind>(CXTok.int_data[0]);
6493}

6495CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) {
switch (clang_getTokenKind(CXTok)) {
case CXToken_Identifier:
case CXToken_Keyword:
  // We know we have an IdentifierInfo*, so use that.
  return cxstring::createRef(static_cast<IdentifierInfo *>(CXTok.ptr_data)
                          ->getNameStart());

case CXToken_Literal: {
  // We have stashed the starting pointer in the ptr_data field. Use it.
  const char *Text = static_cast<const char *>(CXTok.ptr_data);
  return cxstring::createDup(StringRef(Text, CXTok.int_data[2]));
}

case CXToken_Punctuation:
case CXToken_Comment:
  break;
}

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

// We have to find the starting buffer pointer the hard way, by
// deconstructing the source location.
ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
if (!CXXUnit)
  return cxstring::createEmpty();

SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]);
std::pair<FileID, unsigned> LocInfo
  = CXXUnit->getSourceManager().getDecomposedSpellingLoc(Loc);
bool Invalid = false;
StringRef Buffer
  = CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid);
if (Invalid)
  return cxstring::createEmpty();

return cxstring::createDup(Buffer.substr(LocInfo.second, CXTok.int_data[2]));
6535}

6537CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) {
if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return clang_getNullLocation();
}

ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
if (!CXXUnit)
  return clang_getNullLocation();

return cxloc::translateSourceLocation(CXXUnit->getASTContext(),
                      SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
6549}

6551CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) {
if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return clang_getNullRange();
}

ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
if (!CXXUnit)
  return clang_getNullRange();

return cxloc::translateSourceRange(CXXUnit->getASTContext(),
                      SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
6563}

6565static void getTokens(ASTUnit *CXXUnit, SourceRange Range,
                    SmallVectorImpl<CXToken> &CXTokens) {
SourceManager &SourceMgr = CXXUnit->getSourceManager();
std::pair<FileID, unsigned> BeginLocInfo
  = SourceMgr.getDecomposedSpellingLoc(Range.getBegin());
std::pair<FileID, unsigned> EndLocInfo
  = SourceMgr.getDecomposedSpellingLoc(Range.getEnd());

// Cannot tokenize across files.
if (BeginLocInfo.first != EndLocInfo.first)
  return;

// Create a lexer
bool Invalid = false;
StringRef Buffer
  = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid);
if (Invalid)
  return;

Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
          CXXUnit->getASTContext().getLangOpts(),
          Buffer.begin(), Buffer.data() + BeginLocInfo.second, Buffer.end());
Lex.SetCommentRetentionState(true);

// Lex tokens until we hit the end of the range.
const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second;
Token Tok;
bool previousWasAt = false;
do {
  // Lex the next token
  Lex.LexFromRawLexer(Tok);
  if (Tok.is(tok::eof))
    break;

  // Initialize the CXToken.
  CXToken CXTok;

  //   - Common fields
  CXTok.int_data[1] = Tok.getLocation().getRawEncoding();
  CXTok.int_data[2] = Tok.getLength();
  CXTok.int_data[3] = 0;

  //   - Kind-specific fields
  if (Tok.isLiteral()) {
    CXTok.int_data[0] = CXToken_Literal;
    CXTok.ptr_data = const_cast<char *>(Tok.getLiteralData());
  } else if (Tok.is(tok::raw_identifier)) {
    // Lookup the identifier to determine whether we have a keyword.
    IdentifierInfo *II
      = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok);

    if ((II->getObjCKeywordID() != tok::objc_not_keyword) && previousWasAt) {
      CXTok.int_data[0] = CXToken_Keyword;
    }
    else {
      CXTok.int_data[0] = Tok.is(tok::identifier)
        ? CXToken_Identifier
        : CXToken_Keyword;
    }
    CXTok.ptr_data = II;
  } else if (Tok.is(tok::comment)) {
    CXTok.int_data[0] = CXToken_Comment;
    CXTok.ptr_data = nullptr;
  } else {
    CXTok.int_data[0] = CXToken_Punctuation;
    CXTok.ptr_data = nullptr;
  }
  CXTokens.push_back(CXTok);
  previousWasAt = Tok.is(tok::at);
} while (Lex.getBufferLocation() < EffectiveBufferEnd);
6635}

6637void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range,
                  CXToken **Tokens, unsigned *NumTokens) {
LOG_FUNC_SECTIONif (clang::cxindex::LogRef Log = clang::cxindex::Logger::make
(__func__)) {
  *Log << TU << ' ' << Range;
}

if (Tokens)
  *Tokens = nullptr;
if (NumTokens)
  *NumTokens = 0;

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

ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
if (!CXXUnit || !Tokens || !NumTokens)
  return;

ASTUnit::ConcurrencyCheck Check(*CXXUnit);

SourceRange R = cxloc::translateCXSourceRange(Range);
if (R.isInvalid())
  return;

SmallVector<CXToken, 32> CXTokens;
getTokens(CXXUnit, R, CXTokens);

if (CXTokens.empty())
  return;

*Tokens = static_cast<CXToken *>(
    llvm::safe_malloc(sizeof(CXToken) * CXTokens.size()));
memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size());
*NumTokens = CXTokens.size();
6673}

6675void clang_disposeTokens(CXTranslationUnit TU,
                       CXToken *Tokens, unsigned NumTokens) {
free(Tokens);
6678}

6680//===----------------------------------------------------------------------===//
6681// Token annotation APIs.
6682//===----------------------------------------------------------------------===//

6684static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor,
                                                   CXCursor parent,
                                                   CXClientData client_data);
6687static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor,
                                            CXClientData client_data);

6690namespace {
6691class AnnotateTokensWorker {
CXToken *Tokens;
CXCursor *Cursors;
unsigned NumTokens;
unsigned TokIdx;
unsigned PreprocessingTokIdx;
CursorVisitor AnnotateVis;
SourceManager &SrcMgr;
bool HasContextSensitiveKeywords;

struct PostChildrenInfo {
  CXCursor Cursor;
  SourceRange CursorRange;
  unsigned BeforeReachingCursorIdx;
  unsigned BeforeChildrenTokenIdx;
};
SmallVector<PostChildrenInfo, 8> PostChildrenInfos;

CXToken &getTok(unsigned Idx) {
  assert(Idx < NumTokens)(static_cast <bool> (Idx < NumTokens) ? void (0) : __assert_fail
 ("Idx < NumTokens", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 6710, __extension__ __PRETTY_FUNCTION__));
  return Tokens[Idx];
}
const CXToken &getTok(unsigned Idx) const {
  assert(Idx < NumTokens)(static_cast <bool> (Idx < NumTokens) ? void (0) : __assert_fail
 ("Idx < NumTokens", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 6714, __extension__ __PRETTY_FUNCTION__));
  return Tokens[Idx];
}
bool MoreTokens() const { return TokIdx < NumTokens; }
unsigned NextToken() const { return TokIdx; }
void AdvanceToken() { ++TokIdx; }
SourceLocation GetTokenLoc(unsigned tokI) {
  return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[1]);
}
bool isFunctionMacroToken(unsigned tokI) const {
  return getTok(tokI).int_data[3] != 0;
}
SourceLocation getFunctionMacroTokenLoc(unsigned tokI) const {
  return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[3]);
}

void annotateAndAdvanceTokens(CXCursor, RangeComparisonResult, SourceRange);
bool annotateAndAdvanceFunctionMacroTokens(CXCursor, RangeComparisonResult,
                                           SourceRange);

6734public:
AnnotateTokensWorker(CXToken *tokens, CXCursor *cursors, unsigned numTokens,
                     CXTranslationUnit TU, SourceRange RegionOfInterest)
  : Tokens(tokens), Cursors(cursors),
    NumTokens(numTokens), TokIdx(0), PreprocessingTokIdx(0),
    AnnotateVis(TU,
                AnnotateTokensVisitor, this,
                /*VisitPreprocessorLast=*/true,
                /*VisitIncludedEntities=*/false,
                RegionOfInterest,
                /*VisitDeclsOnly=*/false,
                AnnotateTokensPostChildrenVisitor),
    SrcMgr(cxtu::getASTUnit(TU)->getSourceManager()),
    HasContextSensitiveKeywords(false) { }

void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); }
enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent);
bool postVisitChildren(CXCursor cursor);
void AnnotateTokens();

/// \brief Determine whether the annotator saw any cursors that have 
/// context-sensitive keywords.
bool hasContextSensitiveKeywords() const {
  return HasContextSensitiveKeywords;
}

~AnnotateTokensWorker() {
  assert(PostChildrenInfos.empty())(static_cast <bool> (PostChildrenInfos.empty()) ? void (
0) : __assert_fail ("PostChildrenInfos.empty()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 6761, __extension__ __PRETTY_FUNCTION__));
}
6763};
6764}

6766void AnnotateTokensWorker::AnnotateTokens() {
// Walk the AST within the region of interest, annotating tokens
// along the way.
AnnotateVis.visitFileRegion();
6770}

6772static inline void updateCursorAnnotation(CXCursor &Cursor,
                                        const CXCursor &updateC) {
if (clang_isInvalid(updateC.kind) || !clang_isInvalid(Cursor.kind))
  return;
Cursor = updateC;
6777}

6779/// \brief It annotates and advances tokens with a cursor until the comparison
6780//// between the cursor location and the source range is the same as
6781/// \arg compResult.
6782///
6783/// Pass RangeBefore to annotate tokens with a cursor until a range is reached.
6784/// Pass RangeOverlap to annotate tokens inside a range.
6785void AnnotateTokensWorker::annotateAndAdvanceTokens(CXCursor updateC,
                                             RangeComparisonResult compResult,
                                             SourceRange range) {
while (MoreTokens()) {
  const unsigned I = NextToken();
  if (isFunctionMacroToken(I))
    if (!annotateAndAdvanceFunctionMacroTokens(updateC, compResult, range))
      return;

  SourceLocation TokLoc = GetTokenLoc(I);
  if (LocationCompare(SrcMgr, TokLoc, range) == compResult) {
    updateCursorAnnotation(Cursors[I], updateC);
    AdvanceToken();
    continue;
  }
  break;
}
6802}

6804/// \brief Special annotation handling for macro argument tokens.
6805/// \returns true if it advanced beyond all macro tokens, false otherwise.
6806bool AnnotateTokensWorker::annotateAndAdvanceFunctionMacroTokens(
                                             CXCursor updateC,
                                             RangeComparisonResult compResult,
                                             SourceRange range) {
assert(MoreTokens())(static_cast <bool> (MoreTokens()) ? void (0) : __assert_fail
 ("MoreTokens()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 6810, __extension__ __PRETTY_FUNCTION__));
assert(isFunctionMacroToken(NextToken()) &&(static_cast <bool> (isFunctionMacroToken(NextToken()) &&
 "Should be called only for macro arg tokens") ? void (0) : __assert_fail
 ("isFunctionMacroToken(NextToken()) && \"Should be called only for macro arg tokens\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 6812, __extension__ __PRETTY_FUNCTION__))
       "Should be called only for macro arg tokens")(static_cast <bool> (isFunctionMacroToken(NextToken()) &&
 "Should be called only for macro arg tokens") ? void (0) : __assert_fail
 ("isFunctionMacroToken(NextToken()) && \"Should be called only for macro arg tokens\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 6812, __extension__ __PRETTY_FUNCTION__));

// This works differently than annotateAndAdvanceTokens; because expanded
// macro arguments can have arbitrary translation-unit source order, we do not
// advance the token index one by one until a token fails the range test.
// We only advance once past all of the macro arg tokens if all of them
// pass the range test. If one of them fails we keep the token index pointing
// at the start of the macro arg tokens so that the failing token will be
// annotated by a subsequent annotation try.

bool atLeastOneCompFail = false;

unsigned I = NextToken();
for (; I < NumTokens && isFunctionMacroToken(I); ++I) {
  SourceLocation TokLoc = getFunctionMacroTokenLoc(I);
  if (TokLoc.isFileID())
    continue; // not macro arg token, it's parens or comma.
  if (LocationCompare(SrcMgr, TokLoc, range) == compResult) {
    if (clang_isInvalid(clang_getCursorKind(Cursors[I])))
      Cursors[I] = updateC;
  } else
    atLeastOneCompFail = true;
}

if (atLeastOneCompFail)
  return false;

TokIdx = I; // All of the tokens were handled, advance beyond all of them.
return true;
6841}

6843enum CXChildVisitResult
6844AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) {  
SourceRange cursorRange = getRawCursorExtent(cursor);
if (cursorRange.isInvalid())
  return CXChildVisit_Recurse;
    
if (!HasContextSensitiveKeywords) {
  // Objective-C properties can have context-sensitive keywords.
  if (cursor.kind == CXCursor_ObjCPropertyDecl) {
    if (const ObjCPropertyDecl *Property
                = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(cursor)))
      HasContextSensitiveKeywords = Property->getPropertyAttributesAsWritten() != 0;
  }
  // Objective-C methods can have context-sensitive keywords.
  else if (cursor.kind == CXCursor_ObjCInstanceMethodDecl ||
           cursor.kind == CXCursor_ObjCClassMethodDecl) {
    if (const ObjCMethodDecl *Method
          = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) {
      if (Method->getObjCDeclQualifier())
        HasContextSensitiveKeywords = true;
      else {
        for (const auto *P : Method->parameters()) {
          if (P->getObjCDeclQualifier()) {
            HasContextSensitiveKeywords = true;
            break;
          }
        }
      }
    }
  }    
  // C++ methods can have context-sensitive keywords.
  else if (cursor.kind == CXCursor_CXXMethod) {
    if (const CXXMethodDecl *Method
                = dyn_cast_or_null<CXXMethodDecl>(getCursorDecl(cursor))) {
      if (Method->hasAttr<FinalAttr>() || Method->hasAttr<OverrideAttr>())
        HasContextSensitiveKeywords = true;
    }
  }
  // C++ classes can have context-sensitive keywords.
  else if (cursor.kind == CXCursor_StructDecl ||
           cursor.kind == CXCursor_ClassDecl ||
           cursor.kind == CXCursor_ClassTemplate ||
           cursor.kind == CXCursor_ClassTemplatePartialSpecialization) {
    if (const Decl *D = getCursorDecl(cursor))
      if (D->hasAttr<FinalAttr>())
        HasContextSensitiveKeywords = true;
  }
}

// Don't override a property annotation with its getter/setter method.
if (cursor.kind == CXCursor_ObjCInstanceMethodDecl &&
    parent.kind == CXCursor_ObjCPropertyDecl)
  return CXChildVisit_Continue;

if (clang_isPreprocessing(cursor.kind)) {    
  // Items in the preprocessing record are kept separate from items in
  // declarations, so we keep a separate token index.
  unsigned SavedTokIdx = TokIdx;
  TokIdx = PreprocessingTokIdx;

  // Skip tokens up until we catch up to the beginning of the preprocessing
  // entry.
  while (MoreTokens()) {
    const unsigned I = NextToken();
    SourceLocation TokLoc = GetTokenLoc(I);
    switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) {
    case RangeBefore:
      AdvanceToken();
      continue;
    case RangeAfter:
    case RangeOverlap:
      break;
    }
    break;
  }
  
  // Look at all of the tokens within this range.
  while (MoreTokens()) {
    const unsigned I = NextToken();
    SourceLocation TokLoc = GetTokenLoc(I);
    switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) {
    case RangeBefore:
      llvm_unreachable("Infeasible")::llvm::llvm_unreachable_internal("Infeasible", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 6925);
    case RangeAfter:
      break;
    case RangeOverlap:
      // For macro expansions, just note where the beginning of the macro
      // expansion occurs.
      if (cursor.kind == CXCursor_MacroExpansion) {
        if (TokLoc == cursorRange.getBegin())
          Cursors[I] = cursor;
        AdvanceToken();
        break;
      }
      // We may have already annotated macro names inside macro definitions.
      if (Cursors[I].kind != CXCursor_MacroExpansion)
        Cursors[I] = cursor;
      AdvanceToken();
      continue;
    }
    break;
  }

  // Save the preprocessing token index; restore the non-preprocessing
  // token index.
  PreprocessingTokIdx = TokIdx;
  TokIdx = SavedTokIdx;
  return CXChildVisit_Recurse;
}

if (cursorRange.isInvalid())
  return CXChildVisit_Continue;

unsigned BeforeReachingCursorIdx = NextToken();
const enum CXCursorKind cursorK = clang_getCursorKind(cursor);
const enum CXCursorKind K = clang_getCursorKind(parent);
const CXCursor updateC =
  (clang_isInvalid(K) || K == CXCursor_TranslationUnit ||
   // Attributes are annotated out-of-order, skip tokens until we reach it.
   clang_isAttribute(cursor.kind))
   ? clang_getNullCursor() : parent;

annotateAndAdvanceTokens(updateC, RangeBefore, cursorRange);

// Avoid having the cursor of an expression "overwrite" the annotation of the
// variable declaration that it belongs to.
// This can happen for C++ constructor expressions whose range generally
// include the variable declaration, e.g.:
//  MyCXXClass foo; // Make sure we don't annotate 'foo' as a CallExpr cursor.
if (clang_isExpression(cursorK) && MoreTokens()) {
  const Expr *E = getCursorExpr(cursor);
  if (const Decl *D = getCursorParentDecl(cursor)) {
    const unsigned I = NextToken();
    if (E->getLocStart().isValid() && D->getLocation().isValid() &&
        E->getLocStart() == D->getLocation() &&
        E->getLocStart() == GetTokenLoc(I)) {
      updateCursorAnnotation(Cursors[I], updateC);
      AdvanceToken();
    }
  }
}

// Before recursing into the children keep some state that we are going
// to use in the AnnotateTokensWorker::postVisitChildren callback to do some
// extra work after the child nodes are visited.
// Note that we don't call VisitChildren here to avoid traversing statements
// code-recursively which can blow the stack.

PostChildrenInfo Info;
Info.Cursor = cursor;
Info.CursorRange = cursorRange;
Info.BeforeReachingCursorIdx = BeforeReachingCursorIdx;
Info.BeforeChildrenTokenIdx = NextToken();
PostChildrenInfos.push_back(Info);

return CXChildVisit_Recurse;
6999}

7001bool AnnotateTokensWorker::postVisitChildren(CXCursor cursor) {
if (PostChildrenInfos.empty())
  return false;
const PostChildrenInfo &Info = PostChildrenInfos.back();
if (!clang_equalCursors(Info.Cursor, cursor))
  return false;

const unsigned BeforeChildren = Info.BeforeChildrenTokenIdx;
const unsigned AfterChildren = NextToken();
SourceRange cursorRange = Info.CursorRange;

// Scan the tokens that are at the end of the cursor, but are not captured
// but the child cursors.
annotateAndAdvanceTokens(cursor, RangeOverlap, cursorRange);

// Scan the tokens that are at the beginning of the cursor, but are not
// capture by the child cursors.
for (unsigned I = BeforeChildren; I != AfterChildren; ++I) {
  if (!clang_isInvalid(clang_getCursorKind(Cursors[I])))
    break;

  Cursors[I] = cursor;
}

// Attributes are annotated out-of-order, rewind TokIdx to when we first
// encountered the attribute cursor.
if (clang_isAttribute(cursor.kind))
  TokIdx = Info.BeforeReachingCursorIdx;

PostChildrenInfos.pop_back();
return false;
7032}

7034static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor,
                                                   CXCursor parent,
                                                   CXClientData client_data) {
return static_cast<AnnotateTokensWorker*>(client_data)->Visit(cursor, parent);
7038}

7040static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor,
                                            CXClientData client_data) {
return static_cast<AnnotateTokensWorker*>(client_data)->
                                                    postVisitChildren(cursor);
7044}

7046namespace {

7048/// \brief Uses the macro expansions in the preprocessing record to find
7049/// and mark tokens that are macro arguments. This info is used by the
7050/// AnnotateTokensWorker.
7051class MarkMacroArgTokensVisitor {
SourceManager &SM;
CXToken *Tokens;
unsigned NumTokens;
unsigned CurIdx;

7057public:
MarkMacroArgTokensVisitor(SourceManager &SM,
                          CXToken *tokens, unsigned numTokens)
  : SM(SM), Tokens(tokens), NumTokens(numTokens), CurIdx(0) { }

CXChildVisitResult visit(CXCursor cursor, CXCursor parent) {
  if (cursor.kind != CXCursor_MacroExpansion)
    return CXChildVisit_Continue;

  SourceRange macroRange = getCursorMacroExpansion(cursor).getSourceRange();
  if (macroRange.getBegin() == macroRange.getEnd())
    return CXChildVisit_Continue; // it's not a function macro.

  for (; CurIdx < NumTokens; ++CurIdx) {
    if (!SM.isBeforeInTranslationUnit(getTokenLoc(CurIdx),
                                      macroRange.getBegin()))
      break;
  }
  
  if (CurIdx == NumTokens)
    return CXChildVisit_Break;

  for (; CurIdx < NumTokens; ++CurIdx) {
    SourceLocation tokLoc = getTokenLoc(CurIdx);
    if (!SM.isBeforeInTranslationUnit(tokLoc, macroRange.getEnd()))
      break;

    setFunctionMacroTokenLoc(CurIdx, SM.getMacroArgExpandedLocation(tokLoc));
  }

  if (CurIdx == NumTokens)
    return CXChildVisit_Break;

  return CXChildVisit_Continue;
}

7093private:
CXToken &getTok(unsigned Idx) {
  assert(Idx < NumTokens)(static_cast <bool> (Idx < NumTokens) ? void (0) : __assert_fail
 ("Idx < NumTokens", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 7095, __extension__ __PRETTY_FUNCTION__));
  return Tokens[Idx];
}
const CXToken &getTok(unsigned Idx) const {
  assert(Idx < NumTokens)(static_cast <bool> (Idx < NumTokens) ? void (0) : __assert_fail
 ("Idx < NumTokens", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 7099, __extension__ __PRETTY_FUNCTION__));
  return Tokens[Idx];
}

SourceLocation getTokenLoc(unsigned tokI) {
  return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[1]);
}

void setFunctionMacroTokenLoc(unsigned tokI, SourceLocation loc) {
  // The third field is reserved and currently not used. Use it here
  // to mark macro arg expanded tokens with their expanded locations.
  getTok(tokI).int_data[3] = loc.getRawEncoding();
}
7112};

7114} // end anonymous namespace

7116static CXChildVisitResult
7117MarkMacroArgTokensVisitorDelegate(CXCursor cursor, CXCursor parent,
                                CXClientData client_data) {
return static_cast<MarkMacroArgTokensVisitor*>(client_data)->visit(cursor,
                                                                   parent);
7121}

7123/// \brief Used by \c annotatePreprocessorTokens.
7124/// \returns true if lexing was finished, false otherwise.
7125static bool lexNext(Lexer &Lex, Token &Tok,
                 unsigned &NextIdx, unsigned NumTokens) {
if (NextIdx >= NumTokens)
  return true;

++NextIdx;
Lex.LexFromRawLexer(Tok);
return Tok.is(tok::eof);
7133}

7135static void annotatePreprocessorTokens(CXTranslationUnit TU,
                                     SourceRange RegionOfInterest,
                                     CXCursor *Cursors,
                                     CXToken *Tokens,
                                     unsigned NumTokens) {
ASTUnit *CXXUnit = cxtu::getASTUnit(TU);

Preprocessor &PP = CXXUnit->getPreprocessor();
SourceManager &SourceMgr = CXXUnit->getSourceManager();
std::pair<FileID, unsigned> BeginLocInfo
  = SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getBegin());
std::pair<FileID, unsigned> EndLocInfo
  = SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getEnd());

if (BeginLocInfo.first != EndLocInfo.first)
  return;

StringRef Buffer;
bool Invalid = false;
Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid);
if (Buffer.empty() || Invalid)
  return;

Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
          CXXUnit->getASTContext().getLangOpts(),
          Buffer.begin(), Buffer.data() + BeginLocInfo.second,
          Buffer.end());
Lex.SetCommentRetentionState(true);

unsigned NextIdx = 0;
// Lex tokens in raw mode until we hit the end of the range, to avoid
// entering #includes or expanding macros.
while (true) {
  Token Tok;
  if (lexNext(Lex, Tok, NextIdx, NumTokens))
    break;
  unsigned TokIdx = NextIdx-1;
  assert(Tok.getLocation() ==(static_cast <bool> (Tok.getLocation() == SourceLocation
::getFromRawEncoding(Tokens[TokIdx].int_data[1])) ? void (0) :
 __assert_fail ("Tok.getLocation() == SourceLocation::getFromRawEncoding(Tokens[TokIdx].int_data[1])"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 7173, __extension__ __PRETTY_FUNCTION__))
           SourceLocation::getFromRawEncoding(Tokens[TokIdx].int_data[1]))(static_cast <bool> (Tok.getLocation() == SourceLocation
::getFromRawEncoding(Tokens[TokIdx].int_data[1])) ? void (0) :
 __assert_fail ("Tok.getLocation() == SourceLocation::getFromRawEncoding(Tokens[TokIdx].int_data[1])"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 7173, __extension__ __PRETTY_FUNCTION__));
  
reprocess:
  if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) {
    // We have found a preprocessing directive. Annotate the tokens
    // appropriately.
    //
    // FIXME: Some simple tests here could identify macro definitions and
    // #undefs, to provide specific cursor kinds for those.

    SourceLocation BeginLoc = Tok.getLocation();
    if (lexNext(Lex, Tok, NextIdx, NumTokens))
      break;

    MacroInfo *MI = nullptr;
    if (Tok.is(tok::raw_identifier) && Tok.getRawIdentifier() == "define") {
      if (lexNext(Lex, Tok, NextIdx, NumTokens))
        break;

      if (Tok.is(tok::raw_identifier)) {
        IdentifierInfo &II =
            PP.getIdentifierTable().get(Tok.getRawIdentifier());
        SourceLocation MappedTokLoc =
            CXXUnit->mapLocationToPreamble(Tok.getLocation());
        MI = getMacroInfo(II, MappedTokLoc, TU);
      }
    }

    bool finished = false;
    do {
      if (lexNext(Lex, Tok, NextIdx, NumTokens)) {
        finished = true;
        break;
      }
      // If we are in a macro definition, check if the token was ever a
      // macro name and annotate it if that's the case.
      if (MI) {
        SourceLocation SaveLoc = Tok.getLocation();
        Tok.setLocation(CXXUnit->mapLocationToPreamble(SaveLoc));
        MacroDefinitionRecord *MacroDef =
            checkForMacroInMacroDefinition(MI, Tok, TU);
        Tok.setLocation(SaveLoc);
        if (MacroDef)
          Cursors[NextIdx - 1] =
              MakeMacroExpansionCursor(MacroDef, Tok.getLocation(), TU);
      }
    } while (!Tok.isAtStartOfLine());

    unsigned LastIdx = finished ? NextIdx-1 : NextIdx-2;
    assert(TokIdx <= LastIdx)(static_cast <bool> (TokIdx <= LastIdx) ? void (0) :
 __assert_fail ("TokIdx <= LastIdx", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 7222, __extension__ __PRETTY_FUNCTION__));
    SourceLocation EndLoc =
        SourceLocation::getFromRawEncoding(Tokens[LastIdx].int_data[1]);
    CXCursor Cursor =
        MakePreprocessingDirectiveCursor(SourceRange(BeginLoc, EndLoc), TU);

    for (; TokIdx <= LastIdx; ++TokIdx)
      updateCursorAnnotation(Cursors[TokIdx], Cursor);
    
    if (finished)
      break;
    goto reprocess;
  }
}
7236}

7238// This gets run a separate thread to avoid stack blowout.
7239static void clang_annotateTokensImpl(CXTranslationUnit TU, ASTUnit *CXXUnit,
                                   CXToken *Tokens, unsigned NumTokens,
                                   CXCursor *Cursors) {
CIndexer *CXXIdx = TU->CIdx;
if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
  setThreadBackgroundPriority();

// Determine the region of interest, which contains all of the tokens.
SourceRange RegionOfInterest;
RegionOfInterest.setBegin(
  cxloc::translateSourceLocation(clang_getTokenLocation(TU, Tokens[0])));
RegionOfInterest.setEnd(
  cxloc::translateSourceLocation(clang_getTokenLocation(TU,
                                                       Tokens[NumTokens-1])));

// Relex the tokens within the source range to look for preprocessing
// directives.
annotatePreprocessorTokens(TU, RegionOfInterest, Cursors, Tokens, NumTokens);

// If begin location points inside a macro argument, set it to the expansion
// location so we can have the full context when annotating semantically.
{
  SourceManager &SM = CXXUnit->getSourceManager();
  SourceLocation Loc =
      SM.getMacroArgExpandedLocation(RegionOfInterest.getBegin());
  if (Loc.isMacroID())
    RegionOfInterest.setBegin(SM.getExpansionLoc(Loc));
}

if (CXXUnit->getPreprocessor().getPreprocessingRecord()) {
  // Search and mark tokens that are macro argument expansions.
  MarkMacroArgTokensVisitor Visitor(CXXUnit->getSourceManager(),
                                    Tokens, NumTokens);
  CursorVisitor MacroArgMarker(TU,
                               MarkMacroArgTokensVisitorDelegate, &Visitor,
                               /*VisitPreprocessorLast=*/true,
                               /*VisitIncludedEntities=*/false,
                               RegionOfInterest);
  MacroArgMarker.visitPreprocessedEntitiesInRegion();
}

// Annotate all of the source locations in the region of interest that map to
// a specific cursor.
AnnotateTokensWorker W(Tokens, Cursors, NumTokens, TU, RegionOfInterest);

// FIXME: We use a ridiculous stack size here because the data-recursion
// algorithm uses a large stack frame than the non-data recursive version,
// and AnnotationTokensWorker currently transforms the data-recursion
// algorithm back into a traditional recursion by explicitly calling
// VisitChildren().  We will need to remove this explicit recursive call.
W.AnnotateTokens();

// If we ran into any entities that involve context-sensitive keywords,
// take another pass through the tokens to mark them as such.
if (W.hasContextSensitiveKeywords()) {
  for (unsigned I = 0; I != NumTokens; ++I) {
    if (clang_getTokenKind(Tokens[I]) != CXToken_Identifier)
      continue;
    
    if (Cursors[I].kind == CXCursor_ObjCPropertyDecl) {
      IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data);
      if (const ObjCPropertyDecl *Property
          = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(Cursors[I]))) {
        if (Property->getPropertyAttributesAsWritten() != 0 &&
            llvm::StringSwitch<bool>(II->getName())
            .Case("readonly", true)
            .Case("assign", true)
            .Case("unsafe_unretained", true)
            .Case("readwrite", true)
            .Case("retain", true)
            .Case("copy", true)
            .Case("nonatomic", true)
            .Case("atomic", true)
            .Case("getter", true)
            .Case("setter", true)
            .Case("strong", true)
            .Case("weak", true)
            .Case("class", true)
            .Default(false))
          Tokens[I].int_data[0] = CXToken_Keyword;
      }
      continue;
    }
    
    if (Cursors[I].kind == CXCursor_ObjCInstanceMethodDecl ||
        Cursors[I].kind == CXCursor_ObjCClassMethodDecl) {
      IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data);
      if (llvm::StringSwitch<bool>(II->getName())
          .Case("in", true)
          .Case("out", true)
          .Case("inout", true)
          .Case("oneway", true)
          .Case("bycopy", true)
          .Case("byref", true)
          .Default(false))
        Tokens[I].int_data[0] = CXToken_Keyword;
      continue;
    }

    if (Cursors[I].kind == CXCursor_CXXFinalAttr ||
        Cursors[I].kind == CXCursor_CXXOverrideAttr) {
      Tokens[I].int_data[0] = CXToken_Keyword;
      continue;
    }
  }
}
7345}

7347void clang_annotateTokens(CXTranslationUnit TU,
                        CXToken *Tokens, unsigned NumTokens,
                        CXCursor *Cursors) {
if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return;
}
if (NumTokens == 0 || !Tokens || !Cursors) {
  LOG_FUNC_SECTIONif (clang::cxindex::LogRef Log = clang::cxindex::Logger::make
(__func__)) { *Log << "<null input>"; }
  return;
}

LOG_FUNC_SECTIONif (clang::cxindex::LogRef Log = clang::cxindex::Logger::make
(__func__)) {
  *Log << TU << ' ';
  CXSourceLocation bloc = clang_getTokenLocation(TU, Tokens[0]);
  CXSourceLocation eloc = clang_getTokenLocation(TU, Tokens[NumTokens-1]);
  *Log << clang_getRange(bloc, eloc);
}

// Any token we don't specifically annotate will have a NULL cursor.
CXCursor C = clang_getNullCursor();
for (unsigned I = 0; I != NumTokens; ++I)
  Cursors[I] = C;

ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
if (!CXXUnit)
  return;

ASTUnit::ConcurrencyCheck Check(*CXXUnit);

auto AnnotateTokensImpl = [=]() {
  clang_annotateTokensImpl(TU, CXXUnit, Tokens, NumTokens, Cursors);
};
llvm::CrashRecoveryContext CRC;
if (!RunSafely(CRC, AnnotateTokensImpl, GetSafetyThreadStackSize() * 2)) {
  fprintf(stderrstderr, "libclang: crash detected while annotating tokens\n");
}
7384}

7386//===----------------------------------------------------------------------===//
7387// Operations for querying linkage of a cursor.
7388//===----------------------------------------------------------------------===//

7390CXLinkageKind clang_getCursorLinkage(CXCursor cursor) {
if (!clang_isDeclaration(cursor.kind))
  return CXLinkage_Invalid;

const Decl *D = cxcursor::getCursorDecl(cursor);
if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D))
  switch (ND->getLinkageInternal()) {
    case NoLinkage:
    case VisibleNoLinkage: return CXLinkage_NoLinkage;
    case ModuleInternalLinkage:
    case InternalLinkage: return CXLinkage_Internal;
    case UniqueExternalLinkage: return CXLinkage_UniqueExternal;
    case ModuleLinkage:
    case ExternalLinkage: return CXLinkage_External;
  };

return CXLinkage_Invalid;
7407}

7409//===----------------------------------------------------------------------===//
7410// Operations for querying visibility of a cursor.
7411//===----------------------------------------------------------------------===//

7413CXVisibilityKind clang_getCursorVisibility(CXCursor cursor) {
if (!clang_isDeclaration(cursor.kind))
  return CXVisibility_Invalid;

const Decl *D = cxcursor::getCursorDecl(cursor);
if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D))
  switch (ND->getVisibility()) {
    case HiddenVisibility: return CXVisibility_Hidden;
    case ProtectedVisibility: return CXVisibility_Protected;
    case DefaultVisibility: return CXVisibility_Default;
  };

return CXVisibility_Invalid;
7426}

7428//===----------------------------------------------------------------------===//
7429// Operations for querying language of a cursor.
7430//===----------------------------------------------------------------------===//

7432static CXLanguageKind getDeclLanguage(const Decl *D) {
if (!D)
  return CXLanguage_C;

switch (D->getKind()) {
  default:
    break;
  case Decl::ImplicitParam:
  case Decl::ObjCAtDefsField:
  case Decl::ObjCCategory:
  case Decl::ObjCCategoryImpl:
  case Decl::ObjCCompatibleAlias:
  case Decl::ObjCImplementation:
  case Decl::ObjCInterface:
  case Decl::ObjCIvar:
  case Decl::ObjCMethod:
  case Decl::ObjCProperty:
  case Decl::ObjCPropertyImpl:
  case Decl::ObjCProtocol:
  case Decl::ObjCTypeParam:
    return CXLanguage_ObjC;
  case Decl::CXXConstructor:
  case Decl::CXXConversion:
  case Decl::CXXDestructor:
  case Decl::CXXMethod:
  case Decl::CXXRecord:
  case Decl::ClassTemplate:
  case Decl::ClassTemplatePartialSpecialization:
  case Decl::ClassTemplateSpecialization:
  case Decl::Friend:
  case Decl::FriendTemplate:
  case Decl::FunctionTemplate:
  case Decl::LinkageSpec:
  case Decl::Namespace:
  case Decl::NamespaceAlias:
  case Decl::NonTypeTemplateParm:
  case Decl::StaticAssert:
  case Decl::TemplateTemplateParm:
  case Decl::TemplateTypeParm:
  case Decl::UnresolvedUsingTypename:
  case Decl::UnresolvedUsingValue:
  case Decl::Using:
  case Decl::UsingDirective:
  case Decl::UsingShadow:
    return CXLanguage_CPlusPlus;
}

return CXLanguage_C;
7480}

7482static CXAvailabilityKind getCursorAvailabilityForDecl(const Decl *D) {
if (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isDeleted())
  return CXAvailability_NotAvailable;

switch (D->getAvailability()) {
case AR_Available:
case AR_NotYetIntroduced:
  if (const EnumConstantDecl *EnumConst = dyn_cast<EnumConstantDecl>(D))
    return getCursorAvailabilityForDecl(
        cast<Decl>(EnumConst->getDeclContext()));
  return CXAvailability_Available;

case AR_Deprecated:
  return CXAvailability_Deprecated;

case AR_Unavailable:
  return CXAvailability_NotAvailable;
}

llvm_unreachable("Unknown availability kind!")::llvm::llvm_unreachable_internal("Unknown availability kind!"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 7501);
7502}

7504enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor) {
if (clang_isDeclaration(cursor.kind))
  if (const Decl *D = cxcursor::getCursorDecl(cursor))
    return getCursorAvailabilityForDecl(D);

return CXAvailability_Available;
7510}

7512static CXVersion convertVersion(VersionTuple In) {
CXVersion Out = { -1, -1, -1 };
if (In.empty())
  return Out;

Out.Major = In.getMajor();

Optional<unsigned> Minor = In.getMinor();
if (Minor.hasValue())
  Out.Minor = *Minor;
else
  return Out;

Optional<unsigned> Subminor = In.getSubminor();
if (Subminor.hasValue())
  Out.Subminor = *Subminor;

return Out;
7530}

7532static void getCursorPlatformAvailabilityForDecl(
  const Decl *D, int *always_deprecated, CXString *deprecated_message,
  int *always_unavailable, CXString *unavailable_message,
  SmallVectorImpl<AvailabilityAttr *> &AvailabilityAttrs) {
bool HadAvailAttr = false;
for (auto A : D->attrs()) {
  if (DeprecatedAttr *Deprecated = dyn_cast<DeprecatedAttr>(A)) {
    HadAvailAttr = true;
    if (always_deprecated)
      *always_deprecated = 1;
    if (deprecated_message) {
      clang_disposeString(*deprecated_message);
      *deprecated_message = cxstring::createDup(Deprecated->getMessage());
    }
    continue;
  }

  if (UnavailableAttr *Unavailable = dyn_cast<UnavailableAttr>(A)) {
    HadAvailAttr = true;
    if (always_unavailable)
      *always_unavailable = 1;
    if (unavailable_message) {
      clang_disposeString(*unavailable_message);
      *unavailable_message = cxstring::createDup(Unavailable->getMessage());
    }
    continue;
  }

  if (AvailabilityAttr *Avail = dyn_cast<AvailabilityAttr>(A)) {
    AvailabilityAttrs.push_back(Avail);
    HadAvailAttr = true;
  }
}

if (!HadAvailAttr)
  if (const EnumConstantDecl *EnumConst = dyn_cast<EnumConstantDecl>(D))
    return getCursorPlatformAvailabilityForDecl(
        cast<Decl>(EnumConst->getDeclContext()), always_deprecated,
        deprecated_message, always_unavailable, unavailable_message,
        AvailabilityAttrs);

if (AvailabilityAttrs.empty())
  return;

std::sort(AvailabilityAttrs.begin(), AvailabilityAttrs.end(),
          [](AvailabilityAttr *LHS, AvailabilityAttr *RHS) {
            return LHS->getPlatform()->getName() <
                   RHS->getPlatform()->getName();
          });
ASTContext &Ctx = D->getASTContext();
auto It = std::unique(
    AvailabilityAttrs.begin(), AvailabilityAttrs.end(),
    [&Ctx](AvailabilityAttr *LHS, AvailabilityAttr *RHS) {
      if (LHS->getPlatform() != RHS->getPlatform())
1
Assuming the condition is false→
2
←
Taking false branch→
        return false;

      if (LHS->getIntroduced() == RHS->getIntroduced() &&
3
←
Taking false branch→
          LHS->getDeprecated() == RHS->getDeprecated() &&
          LHS->getObsoleted() == RHS->getObsoleted() &&
          LHS->getMessage() == RHS->getMessage() &&
          LHS->getReplacement() == RHS->getReplacement())
        return true;

      if ((!LHS->getIntroduced().empty() && !RHS->getIntroduced().empty()) ||
4
←
Taking false branch→
          (!LHS->getDeprecated().empty() && !RHS->getDeprecated().empty()) ||
          (!LHS->getObsoleted().empty() && !RHS->getObsoleted().empty()))
        return false;

      if (LHS->getIntroduced().empty() && !RHS->getIntroduced().empty())
5
←
Taking false branch→
        LHS->setIntroduced(Ctx, RHS->getIntroduced());

      if (LHS->getDeprecated().empty() && !RHS->getDeprecated().empty()) {
6
←
Taking false branch→
        LHS->setDeprecated(Ctx, RHS->getDeprecated());
        if (LHS->getMessage().empty())
          LHS->setMessage(Ctx, RHS->getMessage());
        if (LHS->getReplacement().empty())
          LHS->setReplacement(Ctx, RHS->getReplacement());
      }

      if (LHS->getObsoleted().empty() && !RHS->getObsoleted().empty()) {
7
←
Taking true branch→
        LHS->setObsoleted(Ctx, RHS->getObsoleted());
        if (LHS->getMessage().empty())
8
←
Assuming the condition is true→
9
←
Taking true branch→
          LHS->setMessage(Ctx, RHS->getMessage());
10
←
Calling 'AvailabilityAttr::setMessage'→
        if (LHS->getReplacement().empty())
          LHS->setReplacement(Ctx, RHS->getReplacement());
      }

      return true;
    });
AvailabilityAttrs.erase(It, AvailabilityAttrs.end());
7622}

7624int clang_getCursorPlatformAvailability(CXCursor cursor, int *always_deprecated,
                                      CXString *deprecated_message,
                                      int *always_unavailable,
                                      CXString *unavailable_message,
                                      CXPlatformAvailability *availability,
                                      int availability_size) {
if (always_deprecated)
  *always_deprecated = 0;
if (deprecated_message)
  *deprecated_message = cxstring::createEmpty();
if (always_unavailable)
  *always_unavailable = 0;
if (unavailable_message)
  *unavailable_message = cxstring::createEmpty();

if (!clang_isDeclaration(cursor.kind))
  return 0;

const Decl *D = cxcursor::getCursorDecl(cursor);
if (!D)
  return 0;

SmallVector<AvailabilityAttr *, 8> AvailabilityAttrs;
getCursorPlatformAvailabilityForDecl(D, always_deprecated, deprecated_message,
                                     always_unavailable, unavailable_message,
                                     AvailabilityAttrs);
for (const auto &Avail :
     llvm::enumerate(llvm::makeArrayRef(AvailabilityAttrs)
                         .take_front(availability_size))) {
  availability[Avail.index()].Platform =
      cxstring::createDup(Avail.value()->getPlatform()->getName());
  availability[Avail.index()].Introduced =
      convertVersion(Avail.value()->getIntroduced());
  availability[Avail.index()].Deprecated =
      convertVersion(Avail.value()->getDeprecated());
  availability[Avail.index()].Obsoleted =
      convertVersion(Avail.value()->getObsoleted());
  availability[Avail.index()].Unavailable = Avail.value()->getUnavailable();
  availability[Avail.index()].Message =
      cxstring::createDup(Avail.value()->getMessage());
}

return AvailabilityAttrs.size();
7667}

7669void clang_disposeCXPlatformAvailability(CXPlatformAvailability *availability) {
clang_disposeString(availability->Platform);
clang_disposeString(availability->Message);
7672}

7674CXLanguageKind clang_getCursorLanguage(CXCursor cursor) {
if (clang_isDeclaration(cursor.kind))
  return getDeclLanguage(cxcursor::getCursorDecl(cursor));

return CXLanguage_Invalid;
7679}

7681CXTLSKind clang_getCursorTLSKind(CXCursor cursor) {
const Decl *D = cxcursor::getCursorDecl(cursor);
if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
  switch (VD->getTLSKind()) {
  case VarDecl::TLS_None:
    return CXTLS_None;
  case VarDecl::TLS_Dynamic:
    return CXTLS_Dynamic;
  case VarDecl::TLS_Static:
    return CXTLS_Static;
  }
}

return CXTLS_None;
7695}

/// \brief If the given cursor is the "templated" declaration
/// descibing a class or function template, return the class or
/// function template.
7700static const Decl *maybeGetTemplateCursor(const Decl *D) {
if (!D)
  return nullptr;

if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
  if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate())
    return FunTmpl;

if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
  if (ClassTemplateDecl *ClassTmpl = RD->getDescribedClassTemplate())
    return ClassTmpl;

return D;
7713}


7716enum CX_StorageClass clang_Cursor_getStorageClass(CXCursor C) {
StorageClass sc = SC_None;
const Decl *D = getCursorDecl(C);
if (D) {
  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
    sc = FD->getStorageClass();
  } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
    sc = VD->getStorageClass();
  } else {
    return CX_SC_Invalid;
  }
} else {
  return CX_SC_Invalid;
}
switch (sc) {
case SC_None:
  return CX_SC_None;
case SC_Extern:
  return CX_SC_Extern;
case SC_Static:
  return CX_SC_Static;
case SC_PrivateExtern:
  return CX_SC_PrivateExtern;
case SC_Auto:
  return CX_SC_Auto;
case SC_Register:
  return CX_SC_Register;
}
llvm_unreachable("Unhandled storage class!")::llvm::llvm_unreachable_internal("Unhandled storage class!",
 "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/tools/libclang/CIndex.cpp"
, 7744);
7745}

7747CXCursor clang_getCursorSemanticParent(CXCursor cursor) {
if (clang_isDeclaration(cursor.kind)) {
  if (const Decl *D = getCursorDecl(cursor)) {
    const DeclContext *DC = D->getDeclContext();
    if (!DC)
      return clang_getNullCursor();

    return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 
                        getCursorTU(cursor));
  }
}

if (clang_isStatement(cursor.kind) || clang_isExpression(cursor.kind)) {
  if (const Decl *D = getCursorDecl(cursor))
    return MakeCXCursor(D, getCursorTU(cursor));
}

return clang_getNullCursor();
7765}

7767CXCursor clang_getCursorLexicalParent(CXCursor cursor) {
if (clang_isDeclaration(cursor.kind)) {
  if (const Decl *D = getCursorDecl(cursor)) {
    const DeclContext *DC = D->getLexicalDeclContext();
    if (!DC)
      return clang_getNullCursor();

    return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 
                        getCursorTU(cursor));
  }
}

// FIXME: Note that we can't easily compute the lexical context of a 
// statement or expression, so we return nothing.
return clang_getNullCursor();
7782}

7784CXFile clang_getIncludedFile(CXCursor cursor) {
if (cursor.kind != CXCursor_InclusionDirective)
  return nullptr;

const InclusionDirective *ID = getCursorInclusionDirective(cursor);
return const_cast<FileEntry *>(ID->getFile());
7790}

7792unsigned clang_Cursor_getObjCPropertyAttributes(CXCursor C, unsigned reserved) {
if (C.kind != CXCursor_ObjCPropertyDecl)
  return CXObjCPropertyAttr_noattr;

unsigned Result = CXObjCPropertyAttr_noattr;
const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(getCursorDecl(C));
ObjCPropertyDecl::PropertyAttributeKind Attr =
    PD->getPropertyAttributesAsWritten();

7801#define SET_CXOBJCPROP_ATTR(A) \
if (Attr & ObjCPropertyDecl::OBJC_PR_##A) \
  Result |= CXObjCPropertyAttr_##A
SET_CXOBJCPROP_ATTR(readonly);
SET_CXOBJCPROP_ATTR(getter);
SET_CXOBJCPROP_ATTR(assign);
SET_CXOBJCPROP_ATTR(readwrite);
SET_CXOBJCPROP_ATTR(retain);
SET_CXOBJCPROP_ATTR(copy);
SET_CXOBJCPROP_ATTR(nonatomic);
SET_CXOBJCPROP_ATTR(setter);
SET_CXOBJCPROP_ATTR(atomic);
SET_CXOBJCPROP_ATTR(weak);
SET_CXOBJCPROP_ATTR(strong);
SET_CXOBJCPROP_ATTR(unsafe_unretained);
SET_CXOBJCPROP_ATTR(class);
7817#undef SET_CXOBJCPROP_ATTR

return Result;
7820}

7822unsigned clang_Cursor_getObjCDeclQualifiers(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return CXObjCDeclQualifier_None;

Decl::ObjCDeclQualifier QT = Decl::OBJC_TQ_None;
const Decl *D = getCursorDecl(C);
if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
  QT = MD->getObjCDeclQualifier();
else if (const ParmVarDecl *PD = dyn_cast<ParmVarDecl>(D))
  QT = PD->getObjCDeclQualifier();
if (QT == Decl::OBJC_TQ_None)
  return CXObjCDeclQualifier_None;

unsigned Result = CXObjCDeclQualifier_None;
if (QT & Decl::OBJC_TQ_In) Result |= CXObjCDeclQualifier_In;
if (QT & Decl::OBJC_TQ_Inout) Result |= CXObjCDeclQualifier_Inout;
if (QT & Decl::OBJC_TQ_Out) Result |= CXObjCDeclQualifier_Out;
if (QT & Decl::OBJC_TQ_Bycopy) Result |= CXObjCDeclQualifier_Bycopy;
if (QT & Decl::OBJC_TQ_Byref) Result |= CXObjCDeclQualifier_Byref;
if (QT & Decl::OBJC_TQ_Oneway) Result |= CXObjCDeclQualifier_Oneway;

return Result;
7844}

7846unsigned clang_Cursor_isObjCOptional(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

const Decl *D = getCursorDecl(C);
if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
  return PD->getPropertyImplementation() == ObjCPropertyDecl::Optional;
if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
  return MD->getImplementationControl() == ObjCMethodDecl::Optional;

return 0;
7857}

7859unsigned clang_Cursor_isVariadic(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

const Decl *D = getCursorDecl(C);
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
  return FD->isVariadic();
if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
  return MD->isVariadic();

return 0;
7870}

7872unsigned clang_Cursor_isExternalSymbol(CXCursor C,
                                   CXString *language, CXString *definedIn,
                                   unsigned *isGenerated) {
if (!clang_isDeclaration(C.kind))
  return 0;

const Decl *D = getCursorDecl(C);

if (auto *attr = D->getExternalSourceSymbolAttr()) {
  if (language)
    *language = cxstring::createDup(attr->getLanguage());
  if (definedIn)
    *definedIn = cxstring::createDup(attr->getDefinedIn());
  if (isGenerated)
    *isGenerated = attr->getGeneratedDeclaration();
  return 1;
}
return 0;
7890}

7892CXSourceRange clang_Cursor_getCommentRange(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return clang_getNullRange();

const Decl *D = getCursorDecl(C);
ASTContext &Context = getCursorContext(C);
const RawComment *RC = Context.getRawCommentForAnyRedecl(D);
if (!RC)
  return clang_getNullRange();

return cxloc::translateSourceRange(Context, RC->getSourceRange());
7903}

7905CXString clang_Cursor_getRawCommentText(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return cxstring::createNull();

const Decl *D = getCursorDecl(C);
ASTContext &Context = getCursorContext(C);
const RawComment *RC = Context.getRawCommentForAnyRedecl(D);
StringRef RawText = RC ? RC->getRawText(Context.getSourceManager()) :
                         StringRef();

// Don't duplicate the string because RawText points directly into source
// code.
return cxstring::createRef(RawText);
7918}

7920CXString clang_Cursor_getBriefCommentText(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return cxstring::createNull();

const Decl *D = getCursorDecl(C);
const ASTContext &Context = getCursorContext(C);
const RawComment *RC = Context.getRawCommentForAnyRedecl(D);

if (RC) {
  StringRef BriefText = RC->getBriefText(Context);

  // Don't duplicate the string because RawComment ensures that this memory
  // will not go away.
  return cxstring::createRef(BriefText);
}

return cxstring::createNull();
7937}

7939CXModule clang_Cursor_getModule(CXCursor C) {
if (C.kind == CXCursor_ModuleImportDecl) {
  if (const ImportDecl *ImportD =
          dyn_cast_or_null<ImportDecl>(getCursorDecl(C)))
    return ImportD->getImportedModule();
}

return nullptr;
7947}

7949CXModule clang_getModuleForFile(CXTranslationUnit TU, CXFile File) {
if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return nullptr;
}
if (!File)
  return nullptr;
FileEntry *FE = static_cast<FileEntry *>(File);

ASTUnit &Unit = *cxtu::getASTUnit(TU);
HeaderSearch &HS = Unit.getPreprocessor().getHeaderSearchInfo();
ModuleMap::KnownHeader Header = HS.findModuleForHeader(FE);

return Header.getModule();
7963}

7965CXFile clang_Module_getASTFile(CXModule CXMod) {
if (!CXMod)
  return nullptr;
Module *Mod = static_cast<Module*>(CXMod);
return const_cast<FileEntry *>(Mod->getASTFile());
7970}

7972CXModule clang_Module_getParent(CXModule CXMod) {
if (!CXMod)
  return nullptr;
Module *Mod = static_cast<Module*>(CXMod);
return Mod->Parent;
7977}

7979CXString clang_Module_getName(CXModule CXMod) {
if (!CXMod)
  return cxstring::createEmpty();
Module *Mod = static_cast<Module*>(CXMod);
return cxstring::createDup(Mod->Name);
7984}

7986CXString clang_Module_getFullName(CXModule CXMod) {
if (!CXMod)
  return cxstring::createEmpty();
Module *Mod = static_cast<Module*>(CXMod);
return cxstring::createDup(Mod->getFullModuleName());
7991}

7993int clang_Module_isSystem(CXModule CXMod) {
if (!CXMod)
  return 0;
Module *Mod = static_cast<Module*>(CXMod);
return Mod->IsSystem;
7998}

8000unsigned clang_Module_getNumTopLevelHeaders(CXTranslationUnit TU,
                                          CXModule CXMod) {
if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return 0;
}
if (!CXMod)
  return 0;
Module *Mod = static_cast<Module*>(CXMod);
FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager();
ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr);
return TopHeaders.size();
8012}

8014CXFile clang_Module_getTopLevelHeader(CXTranslationUnit TU,
                                    CXModule CXMod, unsigned Index) {
if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return nullptr;
}
if (!CXMod)
  return nullptr;
Module *Mod = static_cast<Module*>(CXMod);
FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager();

ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr);
if (Index < TopHeaders.size())
  return const_cast<FileEntry *>(TopHeaders[Index]);

return nullptr;
8030}

8032//===----------------------------------------------------------------------===//
8033// C++ AST instrospection.
8034//===----------------------------------------------------------------------===//

8036unsigned clang_CXXConstructor_isDefaultConstructor(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

const Decl *D = cxcursor::getCursorDecl(C);
const CXXConstructorDecl *Constructor =
    D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
return (Constructor && Constructor->isDefaultConstructor()) ? 1 : 0;
8044}

8046unsigned clang_CXXConstructor_isCopyConstructor(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

const Decl *D = cxcursor::getCursorDecl(C);
const CXXConstructorDecl *Constructor =
    D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
return (Constructor && Constructor->isCopyConstructor()) ? 1 : 0;
8054}

8056unsigned clang_CXXConstructor_isMoveConstructor(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

const Decl *D = cxcursor::getCursorDecl(C);
const CXXConstructorDecl *Constructor =
    D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
return (Constructor && Constructor->isMoveConstructor()) ? 1 : 0;
8064}

8066unsigned clang_CXXConstructor_isConvertingConstructor(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

const Decl *D = cxcursor::getCursorDecl(C);
const CXXConstructorDecl *Constructor =
    D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
// Passing 'false' excludes constructors marked 'explicit'.
return (Constructor && Constructor->isConvertingConstructor(false)) ? 1 : 0;
8075}

8077unsigned clang_CXXField_isMutable(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

if (const auto D = cxcursor::getCursorDecl(C))
  if (const auto FD = dyn_cast_or_null<FieldDecl>(D))
    return FD->isMutable() ? 1 : 0;
return 0;
8085}

8087unsigned clang_CXXMethod_isPureVirtual(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

const Decl *D = cxcursor::getCursorDecl(C);
const CXXMethodDecl *Method =
    D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
return (Method && Method->isVirtual() && Method->isPure()) ? 1 : 0;
8095}

8097unsigned clang_CXXMethod_isConst(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

const Decl *D = cxcursor::getCursorDecl(C);
const CXXMethodDecl *Method =
    D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
return (Method && (Method->getTypeQualifiers() & Qualifiers::Const)) ? 1 : 0;
8105}

8107unsigned clang_CXXMethod_isDefaulted(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

const Decl *D = cxcursor::getCursorDecl(C);
const CXXMethodDecl *Method =
    D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
return (Method && Method->isDefaulted()) ? 1 : 0;
8115}

8117unsigned clang_CXXMethod_isStatic(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

const Decl *D = cxcursor::getCursorDecl(C);
const CXXMethodDecl *Method =
    D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
return (Method && Method->isStatic()) ? 1 : 0;
8125}

8127unsigned clang_CXXMethod_isVirtual(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

const Decl *D = cxcursor::getCursorDecl(C);
const CXXMethodDecl *Method =
    D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
return (Method && Method->isVirtual()) ? 1 : 0;
8135}

8137unsigned clang_CXXRecord_isAbstract(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

const auto *D = cxcursor::getCursorDecl(C);
const auto *RD = dyn_cast_or_null<CXXRecordDecl>(D);
if (RD)
  RD = RD->getDefinition();
return (RD && RD->isAbstract()) ? 1 : 0;
8146}

8148unsigned clang_EnumDecl_isScoped(CXCursor C) {
if (!clang_isDeclaration(C.kind))
  return 0;

const Decl *D = cxcursor::getCursorDecl(C);
auto *Enum = dyn_cast_or_null<EnumDecl>(D);
return (Enum && Enum->isScoped()) ? 1 : 0;
8155}

8157//===----------------------------------------------------------------------===//
8158// Attribute introspection.
8159//===----------------------------------------------------------------------===//

8161CXType clang_getIBOutletCollectionType(CXCursor C) {
if (C.kind != CXCursor_IBOutletCollectionAttr)
  return cxtype::MakeCXType(QualType(), cxcursor::getCursorTU(C));

const IBOutletCollectionAttr *A =
  cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(C));

return cxtype::MakeCXType(A->getInterface(), cxcursor::getCursorTU(C));  
8169}

8171//===----------------------------------------------------------------------===//
8172// Inspecting memory usage.
8173//===----------------------------------------------------------------------===//

8175typedef std::vector<CXTUResourceUsageEntry> MemUsageEntries;

8177static inline void createCXTUResourceUsageEntry(MemUsageEntries &entries,
                                            enum CXTUResourceUsageKind k,
                                            unsigned long amount) {
CXTUResourceUsageEntry entry = { k, amount };
entries.push_back(entry);
8182}

8184const char *clang_getTUResourceUsageName(CXTUResourceUsageKind kind) {
const char *str = "";
switch (kind) {
  case CXTUResourceUsage_AST:
    str = "ASTContext: expressions, declarations, and types"; 
    break;
  case CXTUResourceUsage_Identifiers:
    str = "ASTContext: identifiers";
    break;
  case CXTUResourceUsage_Selectors:
    str = "ASTContext: selectors";
    break;
  case CXTUResourceUsage_GlobalCompletionResults:
    str = "Code completion: cached global results";
    break;
  case CXTUResourceUsage_SourceManagerContentCache:
    str = "SourceManager: content cache allocator";
    break;
  case CXTUResourceUsage_AST_SideTables:
    str = "ASTContext: side tables";
    break;
  case CXTUResourceUsage_SourceManager_Membuffer_Malloc:
    str = "SourceManager: malloc'ed memory buffers";
    break;
  case CXTUResourceUsage_SourceManager_Membuffer_MMap:
    str = "SourceManager: mmap'ed memory buffers";
    break;
  case CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc:
    str = "ExternalASTSource: malloc'ed memory buffers";
    break;
  case CXTUResourceUsage_ExternalASTSource_Membuffer_MMap:
    str = "ExternalASTSource: mmap'ed memory buffers";
    break;
  case CXTUResourceUsage_Preprocessor:
    str = "Preprocessor: malloc'ed memory";
    break;
  case CXTUResourceUsage_PreprocessingRecord:
    str = "Preprocessor: PreprocessingRecord";
    break;
  case CXTUResourceUsage_SourceManager_DataStructures:
    str = "SourceManager: data structures and tables";
    break;
  case CXTUResourceUsage_Preprocessor_HeaderSearch:
    str = "Preprocessor: header search tables";
    break;
}
return str;
8231}

8233CXTUResourceUsage clang_getCXTUResourceUsage(CXTranslationUnit TU) {
if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  CXTUResourceUsage usage = { (void*) nullptr, 0, nullptr };
  return usage;
}

ASTUnit *astUnit = cxtu::getASTUnit(TU);
std::unique_ptr<MemUsageEntries> entries(new MemUsageEntries());
ASTContext &astContext = astUnit->getASTContext();

// How much memory is used by AST nodes and types?
createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST,
  (unsigned long) astContext.getASTAllocatedMemory());

// How much memory is used by identifiers?
createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Identifiers,
  (unsigned long) astContext.Idents.getAllocator().getTotalMemory());

// How much memory is used for selectors?
createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Selectors,
  (unsigned long) astContext.Selectors.getTotalMemory());

// How much memory is used by ASTContext's side tables?
createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST_SideTables,
  (unsigned long) astContext.getSideTableAllocatedMemory());

// How much memory is used for caching global code completion results?
unsigned long completionBytes = 0;
if (GlobalCodeCompletionAllocator *completionAllocator =
    astUnit->getCachedCompletionAllocator().get()) {
  completionBytes = completionAllocator->getTotalMemory();
}
createCXTUResourceUsageEntry(*entries,
                             CXTUResourceUsage_GlobalCompletionResults,
                             completionBytes);

// How much memory is being used by SourceManager's content cache?
createCXTUResourceUsageEntry(*entries,
        CXTUResourceUsage_SourceManagerContentCache,
        (unsigned long) astContext.getSourceManager().getContentCacheSize());

// How much memory is being used by the MemoryBuffer's in SourceManager?
const SourceManager::MemoryBufferSizes &srcBufs =
  astUnit->getSourceManager().getMemoryBufferSizes();

createCXTUResourceUsageEntry(*entries,
                             CXTUResourceUsage_SourceManager_Membuffer_Malloc,
                             (unsigned long) srcBufs.malloc_bytes);
createCXTUResourceUsageEntry(*entries,
                             CXTUResourceUsage_SourceManager_Membuffer_MMap,
                             (unsigned long) srcBufs.mmap_bytes);
createCXTUResourceUsageEntry(*entries,
                             CXTUResourceUsage_SourceManager_DataStructures,
                             (unsigned long) astContext.getSourceManager()
                              .getDataStructureSizes());

// How much memory is being used by the ExternalASTSource?
if (ExternalASTSource *esrc = astContext.getExternalSource()) {
  const ExternalASTSource::MemoryBufferSizes &sizes =
    esrc->getMemoryBufferSizes();
  
  createCXTUResourceUsageEntry(*entries,
    CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc,
                               (unsigned long) sizes.malloc_bytes);
  createCXTUResourceUsageEntry(*entries,
    CXTUResourceUsage_ExternalASTSource_Membuffer_MMap,
                               (unsigned long) sizes.mmap_bytes);
}

// How much memory is being used by the Preprocessor?
Preprocessor &pp = astUnit->getPreprocessor();
createCXTUResourceUsageEntry(*entries,
                             CXTUResourceUsage_Preprocessor,
                             pp.getTotalMemory());

if (PreprocessingRecord *pRec = pp.getPreprocessingRecord()) {
  createCXTUResourceUsageEntry(*entries,
                               CXTUResourceUsage_PreprocessingRecord,
                               pRec->getTotalMemory());    
}

createCXTUResourceUsageEntry(*entries,
                             CXTUResourceUsage_Preprocessor_HeaderSearch,
                             pp.getHeaderSearchInfo().getTotalMemory());

CXTUResourceUsage usage = { (void*) entries.get(),
                          (unsigned) entries->size(),
                          !entries->empty() ? &(*entries)[0] : nullptr };
(void)entries.release();
return usage;
8324}

8326void clang_disposeCXTUResourceUsage(CXTUResourceUsage usage) {
if (usage.data)
  delete (MemUsageEntries*) usage.data;
8329}

8331CXSourceRangeList *clang_getSkippedRanges(CXTranslationUnit TU, CXFile file) {
CXSourceRangeList *skipped = new CXSourceRangeList;
skipped->count = 0;
skipped->ranges = nullptr;

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

if (!file)
  return skipped;

ASTUnit *astUnit = cxtu::getASTUnit(TU);
PreprocessingRecord *ppRec = astUnit->getPreprocessor().getPreprocessingRecord();
if (!ppRec)
  return skipped;

ASTContext &Ctx = astUnit->getASTContext();
SourceManager &sm = Ctx.getSourceManager();
FileEntry *fileEntry = static_cast<FileEntry *>(file);
FileID wantedFileID = sm.translateFile(fileEntry);
bool isMainFile = wantedFileID == sm.getMainFileID();

const std::vector<SourceRange> &SkippedRanges = ppRec->getSkippedRanges();
std::vector<SourceRange> wantedRanges;
for (std::vector<SourceRange>::const_iterator i = SkippedRanges.begin(), ei = SkippedRanges.end();
     i != ei; ++i) {
  if (sm.getFileID(i->getBegin()) == wantedFileID || sm.getFileID(i->getEnd()) == wantedFileID)
    wantedRanges.push_back(*i);
  else if (isMainFile && (astUnit->isInPreambleFileID(i->getBegin()) || astUnit->isInPreambleFileID(i->getEnd())))
    wantedRanges.push_back(*i);
}

skipped->count = wantedRanges.size();
skipped->ranges = new CXSourceRange[skipped->count];
for (unsigned i = 0, ei = skipped->count; i != ei; ++i)
  skipped->ranges[i] = cxloc::translateSourceRange(Ctx, wantedRanges[i]);

return skipped;
8371}

8373CXSourceRangeList *clang_getAllSkippedRanges(CXTranslationUnit TU) {
CXSourceRangeList *skipped = new CXSourceRangeList;
skipped->count = 0;
skipped->ranges = nullptr;

if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return skipped;
}
  
ASTUnit *astUnit = cxtu::getASTUnit(TU);
PreprocessingRecord *ppRec = astUnit->getPreprocessor().getPreprocessingRecord();
if (!ppRec)
  return skipped;

ASTContext &Ctx = astUnit->getASTContext();

const std::vector<SourceRange> &SkippedRanges = ppRec->getSkippedRanges();

skipped->count = SkippedRanges.size();
skipped->ranges = new CXSourceRange[skipped->count];
for (unsigned i = 0, ei = skipped->count; i != ei; ++i)
  skipped->ranges[i] = cxloc::translateSourceRange(Ctx, SkippedRanges[i]);

return skipped;
8398}

8400void clang_disposeSourceRangeList(CXSourceRangeList *ranges) {
if (ranges) {
  delete[] ranges->ranges;
  delete ranges;
}
8405}

8407void clang::PrintLibclangResourceUsage(CXTranslationUnit TU) {
CXTUResourceUsage Usage = clang_getCXTUResourceUsage(TU);
for (unsigned I = 0; I != Usage.numEntries; ++I)
  fprintf(stderrstderr, "  %s: %lu\n", 
          clang_getTUResourceUsageName(Usage.entries[I].kind),
          Usage.entries[I].amount);

clang_disposeCXTUResourceUsage(Usage);
8415}

8417//===----------------------------------------------------------------------===//
8418// Misc. utility functions.
8419//===----------------------------------------------------------------------===//

8421/// Default to using an 8 MB stack size on "safety" threads.
8422static unsigned SafetyStackThreadSize = 8 << 20;

8424namespace clang {

8426bool RunSafely(llvm::CrashRecoveryContext &CRC, llvm::function_ref<void()> Fn,
             unsigned Size) {
if (!Size)
  Size = GetSafetyThreadStackSize();
if (Size && !getenv("LIBCLANG_NOTHREADS"))
  return CRC.RunSafelyOnThread(Fn, Size);
return CRC.RunSafely(Fn);
8433}

8435unsigned GetSafetyThreadStackSize() {
return SafetyStackThreadSize;
8437}

8439void SetSafetyThreadStackSize(unsigned Value) {
SafetyStackThreadSize = Value;
8441}

8443}

8445void clang::setThreadBackgroundPriority() {
if (getenv("LIBCLANG_BGPRIO_DISABLE"))
  return;

8449#ifdef USE_DARWIN_THREADS
setpriority(PRIO_DARWIN_THREAD, 0, PRIO_DARWIN_BG);
8451#endif
8452}

8454void cxindex::printDiagsToStderr(ASTUnit *Unit) {
if (!Unit)
  return;

for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(), 
                                DEnd = Unit->stored_diag_end();
     D != DEnd; ++D) {
  CXStoredDiagnostic Diag(*D, Unit->getLangOpts());
  CXString Msg = clang_formatDiagnostic(&Diag,
                              clang_defaultDiagnosticDisplayOptions());
  fprintf(stderrstderr, "%s\n", clang_getCString(Msg));
  clang_disposeString(Msg);
}
8467#ifdef LLVM_ON_WIN32
// On Windows, force a flush, since there may be multiple copies of
// stderr and stdout in the file system, all with different buffers
// but writing to the same device.
fflush(stderrstderr);
8472#endif
8473}

8475MacroInfo *cxindex::getMacroInfo(const IdentifierInfo &II,
                               SourceLocation MacroDefLoc,
                               CXTranslationUnit TU){
if (MacroDefLoc.isInvalid() || !TU)
  return nullptr;
if (!II.hadMacroDefinition())
  return nullptr;

ASTUnit *Unit = cxtu::getASTUnit(TU);
Preprocessor &PP = Unit->getPreprocessor();
MacroDirective *MD = PP.getLocalMacroDirectiveHistory(&II);
if (MD) {
  for (MacroDirective::DefInfo
         Def = MD->getDefinition(); Def; Def = Def.getPreviousDefinition()) {
    if (MacroDefLoc == Def.getMacroInfo()->getDefinitionLoc())
      return Def.getMacroInfo();
  }
}

return nullptr;
8495}

8497const MacroInfo *cxindex::getMacroInfo(const MacroDefinitionRecord *MacroDef,
                                     CXTranslationUnit TU) {
if (!MacroDef || !TU)
  return nullptr;
const IdentifierInfo *II = MacroDef->getName();
if (!II)
  return nullptr;

return getMacroInfo(*II, MacroDef->getLocation(), TU);
8506}

8508MacroDefinitionRecord *
8509cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI, const Token &Tok,
                                      CXTranslationUnit TU) {
if (!MI || !TU)
  return nullptr;
if (Tok.isNot(tok::raw_identifier))
  return nullptr;

if (MI->getNumTokens() == 0)
  return nullptr;
SourceRange DefRange(MI->getReplacementToken(0).getLocation(),
                     MI->getDefinitionEndLoc());
ASTUnit *Unit = cxtu::getASTUnit(TU);

// Check that the token is inside the definition and not its argument list.
SourceManager &SM = Unit->getSourceManager();
if (SM.isBeforeInTranslationUnit(Tok.getLocation(), DefRange.getBegin()))
  return nullptr;
if (SM.isBeforeInTranslationUnit(DefRange.getEnd(), Tok.getLocation()))
  return nullptr;

Preprocessor &PP = Unit->getPreprocessor();
PreprocessingRecord *PPRec = PP.getPreprocessingRecord();
if (!PPRec)
  return nullptr;

IdentifierInfo &II = PP.getIdentifierTable().get(Tok.getRawIdentifier());
if (!II.hadMacroDefinition())
  return nullptr;

// Check that the identifier is not one of the macro arguments.
if (std::find(MI->param_begin(), MI->param_end(), &II) != MI->param_end())
  return nullptr;

MacroDirective *InnerMD = PP.getLocalMacroDirectiveHistory(&II);
if (!InnerMD)
  return nullptr;

return PPRec->findMacroDefinition(InnerMD->getMacroInfo());
8547}

8549MacroDefinitionRecord *
8550cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI, SourceLocation Loc,
                                      CXTranslationUnit TU) {
if (Loc.isInvalid() || !MI || !TU)
  return nullptr;

if (MI->getNumTokens() == 0)
  return nullptr;
ASTUnit *Unit = cxtu::getASTUnit(TU);
Preprocessor &PP = Unit->getPreprocessor();
if (!PP.getPreprocessingRecord())
  return nullptr;
Loc = Unit->getSourceManager().getSpellingLoc(Loc);
Token Tok;
if (PP.getRawToken(Loc, Tok))
  return nullptr;

return checkForMacroInMacroDefinition(MI, Tok, TU);
8567}

8569CXString clang_getClangVersion() {
return cxstring::createDup(getClangFullVersion());
8571}

8573Logger &cxindex::Logger::operator<<(CXTranslationUnit TU) {
if (TU) {
  if (ASTUnit *Unit = cxtu::getASTUnit(TU)) {
    LogOS << '<' << Unit->getMainFileName() << '>';
    if (Unit->isMainFileAST())
      LogOS << " (" << Unit->getASTFileName() << ')';
    return *this;
  }
} else {
  LogOS << "<NULL TU>";
}
return *this;
8585}

8587Logger &cxindex::Logger::operator<<(const FileEntry *FE) {
*this << FE->getName();
return *this;
8590}

8592Logger &cxindex::Logger::operator<<(CXCursor cursor) {
CXString cursorName = clang_getCursorDisplayName(cursor);
*this << cursorName << "@" << clang_getCursorLocation(cursor);
clang_disposeString(cursorName);
return *this;
8597}

8599Logger &cxindex::Logger::operator<<(CXSourceLocation Loc) {
CXFile File;
unsigned Line, Column;
clang_getFileLocation(Loc, &File, &Line, &Column, nullptr);
CXString FileName = clang_getFileName(File);
*this << llvm::format("(%s:%d:%d)", clang_getCString(FileName), Line, Column);
clang_disposeString(FileName);
return *this;
8607}

8609Logger &cxindex::Logger::operator<<(CXSourceRange range) {
CXSourceLocation BLoc = clang_getRangeStart(range);
CXSourceLocation ELoc = clang_getRangeEnd(range);

CXFile BFile;
unsigned BLine, BColumn;
clang_getFileLocation(BLoc, &BFile, &BLine, &BColumn, nullptr);

CXFile EFile;
unsigned ELine, EColumn;
clang_getFileLocation(ELoc, &EFile, &ELine, &EColumn, nullptr);

CXString BFileName = clang_getFileName(BFile);
if (BFile == EFile) {
  *this << llvm::format("[%s %d:%d-%d:%d]", clang_getCString(BFileName),
                       BLine, BColumn, ELine, EColumn);
} else {
  CXString EFileName = clang_getFileName(EFile);
  *this << llvm::format("[%s:%d:%d - ", clang_getCString(BFileName),
                        BLine, BColumn)
        << llvm::format("%s:%d:%d]", clang_getCString(EFileName),
                        ELine, EColumn);
  clang_disposeString(EFileName);
}
clang_disposeString(BFileName);
return *this;
8635}

8637Logger &cxindex::Logger::operator<<(CXString Str) {
*this << clang_getCString(Str);
return *this;
8640}

8642Logger &cxindex::Logger::operator<<(const llvm::format_object_base &Fmt) {
LogOS << Fmt;
return *this;
8645}

8647static llvm::ManagedStatic<llvm::sys::Mutex> LoggingMutex;

8649cxindex::Logger::~Logger() {
llvm::sys::ScopedLock L(*LoggingMutex);

static llvm::TimeRecord sBeginTR = llvm::TimeRecord::getCurrentTime();

raw_ostream &OS = llvm::errs();
OS << "[libclang:" << Name << ':';

8657#ifdef USE_DARWIN_THREADS
// TODO: Portability.
mach_port_t tid = pthread_mach_thread_np(pthread_self());
OS << tid << ':';
8661#endif

llvm::TimeRecord TR = llvm::TimeRecord::getCurrentTime();
OS << llvm::format("%7.4f] ", TR.getWallTime() - sBeginTR.getWallTime());
OS << Msg << '\n';

if (Trace) {
  llvm::sys::PrintStackTrace(OS);
  OS << "--------------------------------------------------\n";
}
8671}

8673#ifdef CLANG_TOOL_EXTRA_BUILD1
8674// This anchor is used to force the linker to link the clang-tidy plugin.
8675extern volatile int ClangTidyPluginAnchorSource;
8676static int LLVM_ATTRIBUTE_UNUSED__attribute__((__unused__)) ClangTidyPluginAnchorDestination =
  ClangTidyPluginAnchorSource;

8679// This anchor is used to force the linker to link the clang-include-fixer
8680// plugin.
8681extern volatile int ClangIncludeFixerPluginAnchorSource;
8682static int LLVM_ATTRIBUTE_UNUSED__attribute__((__unused__)) ClangIncludeFixerPluginAnchorDestination =
  ClangIncludeFixerPluginAnchorSource;
8684#endif

←

/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc

1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
*                                                                            *|
* Attribute classes' definitions                                             *|
*                                                                            *|
* Automatically generated file, do not edit!                                 *|
*                                                                            *|
7\*===----------------------------------------------------------------------===*/

9#ifndef LLVM_CLANG_ATTR_CLASSES_INC
10#define LLVM_CLANG_ATTR_CLASSES_INC

12class AMDGPUFlatWorkGroupSizeAttr : public InheritableAttr {
13unsigned min;

15unsigned max;

17public:
static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned Min, unsigned Max, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AMDGPUFlatWorkGroupSizeAttr(Loc, Ctx, Min, Max, 0);
  A->setImplicit(true);
  return A;
}

AMDGPUFlatWorkGroupSizeAttr(SourceRange R, ASTContext &Ctx
            , unsigned Min
            , unsigned Max
            , unsigned SI
           )
  : InheritableAttr(attr::AMDGPUFlatWorkGroupSize, R, SI, false, false)
            , min(Min)
            , max(Max)
{
}

AMDGPUFlatWorkGroupSizeAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getMin() const {
  return min;
}

unsigned getMax() const {
  return max;
}



static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUFlatWorkGroupSize; }
50};

52class AMDGPUNumSGPRAttr : public InheritableAttr {
53unsigned numSGPR;

55public:
static AMDGPUNumSGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumSGPR, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AMDGPUNumSGPRAttr(Loc, Ctx, NumSGPR, 0);
  A->setImplicit(true);
  return A;
}

AMDGPUNumSGPRAttr(SourceRange R, ASTContext &Ctx
            , unsigned NumSGPR
            , unsigned SI
           )
  : InheritableAttr(attr::AMDGPUNumSGPR, R, SI, false, false)
            , numSGPR(NumSGPR)
{
}

AMDGPUNumSGPRAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getNumSGPR() const {
  return numSGPR;
}



static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumSGPR; }
82};

84class AMDGPUNumVGPRAttr : public InheritableAttr {
85unsigned numVGPR;

87public:
static AMDGPUNumVGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumVGPR, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AMDGPUNumVGPRAttr(Loc, Ctx, NumVGPR, 0);
  A->setImplicit(true);
  return A;
}

AMDGPUNumVGPRAttr(SourceRange R, ASTContext &Ctx
            , unsigned NumVGPR
            , unsigned SI
           )
  : InheritableAttr(attr::AMDGPUNumVGPR, R, SI, false, false)
            , numVGPR(NumVGPR)
{
}

AMDGPUNumVGPRAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getNumVGPR() const {
  return numVGPR;
}



static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumVGPR; }
114};

116class AMDGPUWavesPerEUAttr : public InheritableAttr {
117unsigned min;

119unsigned max;

121public:
static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, unsigned Min, unsigned Max, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AMDGPUWavesPerEUAttr(Loc, Ctx, Min, Max, 0);
  A->setImplicit(true);
  return A;
}

AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx
            , unsigned Min
            , unsigned Max
            , unsigned SI
           )
  : InheritableAttr(attr::AMDGPUWavesPerEU, R, SI, false, false)
            , min(Min)
            , max(Max)
{
}

AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx
            , unsigned Min
            , unsigned SI
           )
  : InheritableAttr(attr::AMDGPUWavesPerEU, R, SI, false, false)
            , min(Min)
            , max()
{
}

AMDGPUWavesPerEUAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getMin() const {
  return min;
}

unsigned getMax() const {
  return max;
}



static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUWavesPerEU; }
164};

166class ARMInterruptAttr : public InheritableAttr {
167public:
enum InterruptType {
  IRQ,
  FIQ,
  SWI,
  ABORT,
  UNDEF,
  Generic
};
176private:
InterruptType interrupt;

179public:
static ARMInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ARMInterruptAttr(Loc, Ctx, Interrupt, 0);
  A->setImplicit(true);
  return A;
}

ARMInterruptAttr(SourceRange R, ASTContext &Ctx
            , InterruptType Interrupt
            , unsigned SI
           )
  : InheritableAttr(attr::ARMInterrupt, R, SI, false, false)
            , interrupt(Interrupt)
{
}

ARMInterruptAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ARMInterrupt, R, SI, false, false)
            , interrupt(InterruptType(0))
{
}

ARMInterruptAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
InterruptType getInterrupt() const {
  return interrupt;
}

static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out) {
  Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val)
    .Case("IRQ", ARMInterruptAttr::IRQ)
    .Case("FIQ", ARMInterruptAttr::FIQ)
    .Case("SWI", ARMInterruptAttr::SWI)
    .Case("ABORT", ARMInterruptAttr::ABORT)
    .Case("UNDEF", ARMInterruptAttr::UNDEF)
    .Case("", ARMInterruptAttr::Generic)
    .Default(Optional<InterruptType>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertInterruptTypeToStr(InterruptType Val) {
  switch(Val) {
  case ARMInterruptAttr::IRQ: return "IRQ";
  case ARMInterruptAttr::FIQ: return "FIQ";
  case ARMInterruptAttr::SWI: return "SWI";
  case ARMInterruptAttr::ABORT: return "ABORT";
  case ARMInterruptAttr::UNDEF: return "UNDEF";
  case ARMInterruptAttr::Generic: return "";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 236);
}


static bool classof(const Attr *A) { return A->getKind() == attr::ARMInterrupt; }
241};

243class AVRInterruptAttr : public InheritableAttr {
244public:
static AVRInterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AVRInterruptAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

AVRInterruptAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AVRInterrupt, R, SI, false, false)
{
}

AVRInterruptAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::AVRInterrupt; }
265};

267class AVRSignalAttr : public InheritableAttr {
268public:
static AVRSignalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AVRSignalAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

AVRSignalAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AVRSignal, R, SI, false, false)
{
}

AVRSignalAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::AVRSignal; }
289};

291class AbiTagAttr : public Attr {
unsigned tags_Size;
StringRef *tags_;

295public:
static AbiTagAttr *CreateImplicit(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AbiTagAttr(Loc, Ctx, Tags, TagsSize, 0);
  A->setImplicit(true);
  return A;
}

AbiTagAttr(SourceRange R, ASTContext &Ctx
            , StringRef *Tags, unsigned TagsSize
            , unsigned SI
           )
  : Attr(attr::AbiTag, R, SI, false)
            , tags_Size(TagsSize), tags_(new (Ctx, 16) StringRef[tags_Size])
{
  for (size_t I = 0, E = tags_Size; I != E;
       ++I) {
    StringRef Ref = Tags[I];
    if (!Ref.empty()) {
      char *Mem = new (Ctx, 1) char[Ref.size()];
      std::memcpy(Mem, Ref.data(), Ref.size());
      tags_[I] = StringRef(Mem, Ref.size());
    }
  }
}

AbiTagAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : Attr(attr::AbiTag, R, SI, false)
            , tags_Size(0), tags_(nullptr)
{
}

AbiTagAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef StringRef* tags_iterator;
tags_iterator tags_begin() const { return tags_; }
tags_iterator tags_end() const { return tags_ + tags_Size; }
unsigned tags_size() const { return tags_Size; }
llvm::iterator_range<tags_iterator> tags() const { return llvm::make_range(tags_begin(), tags_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::AbiTag; }
342};

344class AcquireCapabilityAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

348public:
enum Spelling {
  GNU_acquire_capability = 0,
  CXX11_clang_acquire_capability = 1,
  GNU_acquire_shared_capability = 2,
  CXX11_clang_acquire_shared_capability = 3,
  GNU_exclusive_lock_function = 4,
  GNU_shared_lock_function = 5
};

static AcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AcquireCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
  A->setImplicit(true);
  return A;
}

AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
            , Expr * *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::AcquireCapability, R, SI, true, true)
            , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AcquireCapability, R, SI, true, true)
            , args_Size(0), args_(nullptr)
{
}

AcquireCapabilityAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 388);
  case 0: return GNU_acquire_capability;
  case 1: return CXX11_clang_acquire_capability;
  case 2: return GNU_acquire_shared_capability;
  case 3: return CXX11_clang_acquire_shared_capability;
  case 4: return GNU_exclusive_lock_function;
  case 5: return GNU_shared_lock_function;
}
}
bool isShared() const { return SpellingListIndex == 2 ||
  SpellingListIndex == 3 ||
  SpellingListIndex == 5; }
typedef Expr ** args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::AcquireCapability; }
410};

412class AcquiredAfterAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

416public:
static AcquiredAfterAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AcquiredAfterAttr(Loc, Ctx, Args, ArgsSize, 0);
  A->setImplicit(true);
  return A;
}

AcquiredAfterAttr(SourceRange R, ASTContext &Ctx
            , Expr * *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::AcquiredAfter, R, SI, true, true)
            , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

AcquiredAfterAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AcquiredAfter, R, SI, true, true)
            , args_Size(0), args_(nullptr)
{
}

AcquiredAfterAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef Expr ** args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredAfter; }
455};

457class AcquiredBeforeAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

461public:
static AcquiredBeforeAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AcquiredBeforeAttr(Loc, Ctx, Args, ArgsSize, 0);
  A->setImplicit(true);
  return A;
}

AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx
            , Expr * *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::AcquiredBefore, R, SI, true, true)
            , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AcquiredBefore, R, SI, true, true)
            , args_Size(0), args_(nullptr)
{
}

AcquiredBeforeAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef Expr ** args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredBefore; }
500};

502class AliasAttr : public Attr {
503unsigned aliaseeLength;
504char *aliasee;

506public:
static AliasAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AliasAttr(Loc, Ctx, Aliasee, 0);
  A->setImplicit(true);
  return A;
}

AliasAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Aliasee
            , unsigned SI
           )
  : Attr(attr::Alias, R, SI, false)
            , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength])
{
    if (!Aliasee.empty())
      std::memcpy(aliasee, Aliasee.data(), aliaseeLength);
}

AliasAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getAliasee() const {
  return llvm::StringRef(aliasee, aliaseeLength);
}
unsigned getAliaseeLength() const {
  return aliaseeLength;
}
void setAliasee(ASTContext &C, llvm::StringRef S) {
  aliaseeLength = S.size();
  this->aliasee = new (C, 1) char [aliaseeLength];
  if (!S.empty())
    std::memcpy(this->aliasee, S.data(), aliaseeLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::Alias; }
544};

546class AlignMac68kAttr : public InheritableAttr {
547public:
static AlignMac68kAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AlignMac68kAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

AlignMac68kAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AlignMac68k, R, SI, false, false)
{
}

AlignMac68kAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::AlignMac68k; }
568};

570class AlignValueAttr : public Attr {
571Expr * alignment;

573public:
static AlignValueAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AlignValueAttr(Loc, Ctx, Alignment, 0);
  A->setImplicit(true);
  return A;
}

AlignValueAttr(SourceRange R, ASTContext &Ctx
            , Expr * Alignment
            , unsigned SI
           )
  : Attr(attr::AlignValue, R, SI, false)
            , alignment(Alignment)
{
}

AlignValueAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Expr * getAlignment() const {
  return alignment;
}



static bool classof(const Attr *A) { return A->getKind() == attr::AlignValue; }
600};

602class AlignedAttr : public InheritableAttr {
603bool isalignmentExpr;
604union {
605Expr *alignmentExpr;
606TypeSourceInfo *alignmentType;
607};

609public:
enum Spelling {
  GNU_aligned = 0,
  CXX11_gnu_aligned = 1,
  Declspec_align = 2,
  Keyword_alignas = 3,
  Keyword_Alignas = 4
};

static AlignedAttr *CreateImplicit(ASTContext &Ctx, Spelling S, bool IsAlignmentExpr, void *Alignment, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AlignedAttr(Loc, Ctx, IsAlignmentExpr, Alignment, S);
  A->setImplicit(true);
  return A;
}

AlignedAttr(SourceRange R, ASTContext &Ctx
            , bool IsAlignmentExpr, void *Alignment
            , unsigned SI
           )
  : InheritableAttr(attr::Aligned, R, SI, false, false)
            , isalignmentExpr(IsAlignmentExpr)
{
  if (isalignmentExpr)
     alignmentExpr = reinterpret_cast<Expr *>(Alignment);
  else
     alignmentType = reinterpret_cast<TypeSourceInfo *>(Alignment);
}

AlignedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Aligned, R, SI, false, false)
            , isalignmentExpr(false)
{
}

AlignedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 651);
  case 0: return GNU_aligned;
  case 1: return CXX11_gnu_aligned;
  case 2: return Declspec_align;
  case 3: return Keyword_alignas;
  case 4: return Keyword_Alignas;
}
}
bool isGNU() const { return SpellingListIndex == 0 ||
  SpellingListIndex == 1; }
bool isC11() const { return SpellingListIndex == 4; }
bool isAlignas() const { return SpellingListIndex == 3 ||
  SpellingListIndex == 4; }
bool isDeclspec() const { return SpellingListIndex == 2; }
bool isAlignmentDependent() const;
unsigned getAlignment(ASTContext &Ctx) const;
bool isAlignmentExpr() const {
  return isalignmentExpr;
}
Expr *getAlignmentExpr() const {
  assert(isalignmentExpr)(static_cast <bool> (isalignmentExpr) ? void (0) : __assert_fail
 ("isalignmentExpr", "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 671, __extension__ __PRETTY_FUNCTION__));
  return alignmentExpr;
}
TypeSourceInfo *getAlignmentType() const {
  assert(!isalignmentExpr)(static_cast <bool> (!isalignmentExpr) ? void (0) : __assert_fail
 ("!isalignmentExpr", "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 675, __extension__ __PRETTY_FUNCTION__));
  return alignmentType;
}



static bool classof(const Attr *A) { return A->getKind() == attr::Aligned; }
682};

684class AllocAlignAttr : public InheritableAttr {
685int paramIndex;

687public:
static AllocAlignAttr *CreateImplicit(ASTContext &Ctx, int ParamIndex, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AllocAlignAttr(Loc, Ctx, ParamIndex, 0);
  A->setImplicit(true);
  return A;
}

AllocAlignAttr(SourceRange R, ASTContext &Ctx
            , int ParamIndex
            , unsigned SI
           )
  : InheritableAttr(attr::AllocAlign, R, SI, false, false)
            , paramIndex(ParamIndex)
{
}

AllocAlignAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
int getParamIndex() const {
  return paramIndex;
}



static bool classof(const Attr *A) { return A->getKind() == attr::AllocAlign; }
714};

716class AllocSizeAttr : public InheritableAttr {
717int elemSizeParam;

719int numElemsParam;

721public:
static AllocSizeAttr *CreateImplicit(ASTContext &Ctx, int ElemSizeParam, int NumElemsParam, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AllocSizeAttr(Loc, Ctx, ElemSizeParam, NumElemsParam, 0);
  A->setImplicit(true);
  return A;
}

AllocSizeAttr(SourceRange R, ASTContext &Ctx
            , int ElemSizeParam
            , int NumElemsParam
            , unsigned SI
           )
  : InheritableAttr(attr::AllocSize, R, SI, false, false)
            , elemSizeParam(ElemSizeParam)
            , numElemsParam(NumElemsParam)
{
}

AllocSizeAttr(SourceRange R, ASTContext &Ctx
            , int ElemSizeParam
            , unsigned SI
           )
  : InheritableAttr(attr::AllocSize, R, SI, false, false)
            , elemSizeParam(ElemSizeParam)
            , numElemsParam()
{
}

AllocSizeAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
int getElemSizeParam() const {
  return elemSizeParam;
}

int getNumElemsParam() const {
  return numElemsParam;
}



static bool classof(const Attr *A) { return A->getKind() == attr::AllocSize; }
764};

766class AlwaysInlineAttr : public InheritableAttr {
767public:
enum Spelling {
  GNU_always_inline = 0,
  CXX11_gnu_always_inline = 1,
  Keyword_forceinline = 2
};

static AlwaysInlineAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AlwaysInlineAttr(Loc, Ctx, S);
  A->setImplicit(true);
  return A;
}

AlwaysInlineAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AlwaysInline, R, SI, false, false)
{
}

AlwaysInlineAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 793);
  case 0: return GNU_always_inline;
  case 1: return CXX11_gnu_always_inline;
  case 2: return Keyword_forceinline;
}
}


static bool classof(const Attr *A) { return A->getKind() == attr::AlwaysInline; }
802};

804class AnalyzerNoReturnAttr : public InheritableAttr {
805public:
static AnalyzerNoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AnalyzerNoReturnAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

AnalyzerNoReturnAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AnalyzerNoReturn, R, SI, false, false)
{
}

AnalyzerNoReturnAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::AnalyzerNoReturn; }
826};

828class AnnotateAttr : public InheritableParamAttr {
829unsigned annotationLength;
830char *annotation;

832public:
static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AnnotateAttr(Loc, Ctx, Annotation, 0);
  A->setImplicit(true);
  return A;
}

AnnotateAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Annotation
            , unsigned SI
           )
  : InheritableParamAttr(attr::Annotate, R, SI, false, false)
            , annotationLength(Annotation.size()),annotation(new (Ctx, 1) char[annotationLength])
{
    if (!Annotation.empty())
      std::memcpy(annotation, Annotation.data(), annotationLength);
}

AnnotateAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getAnnotation() const {
  return llvm::StringRef(annotation, annotationLength);
}
unsigned getAnnotationLength() const {
  return annotationLength;
}
void setAnnotation(ASTContext &C, llvm::StringRef S) {
  annotationLength = S.size();
  this->annotation = new (C, 1) char [annotationLength];
  if (!S.empty())
    std::memcpy(this->annotation, S.data(), annotationLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::Annotate; }
870};

872class AnyX86InterruptAttr : public InheritableAttr {
873public:
static AnyX86InterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AnyX86InterruptAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

AnyX86InterruptAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AnyX86Interrupt, R, SI, false, false)
{
}

AnyX86InterruptAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86Interrupt; }
894};

896class AnyX86NoCallerSavedRegistersAttr : public InheritableAttr {
897public:
static AnyX86NoCallerSavedRegistersAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AnyX86NoCallerSavedRegistersAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

AnyX86NoCallerSavedRegistersAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AnyX86NoCallerSavedRegisters, R, SI, false, false)
{
}

AnyX86NoCallerSavedRegistersAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCallerSavedRegisters; }
918};

920class ArcWeakrefUnavailableAttr : public InheritableAttr {
921public:
static ArcWeakrefUnavailableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ArcWeakrefUnavailableAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ArcWeakrefUnavailableAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ArcWeakrefUnavailable, R, SI, false, false)
{
}

ArcWeakrefUnavailableAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ArcWeakrefUnavailable; }
942};

944class ArgumentWithTypeTagAttr : public InheritableAttr {
945IdentifierInfo * argumentKind;

947unsigned argumentIdx;

949unsigned typeTagIdx;

951bool isPointer;

953public:
enum Spelling {
  GNU_argument_with_type_tag = 0,
  CXX11_clang_argument_with_type_tag = 1,
  C2x_clang_argument_with_type_tag = 2,
  GNU_pointer_with_type_tag = 3,
  CXX11_clang_pointer_with_type_tag = 4,
  C2x_clang_pointer_with_type_tag = 5
};

static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * ArgumentKind, unsigned ArgumentIdx, unsigned TypeTagIdx, bool IsPointer, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ArgumentWithTypeTagAttr(Loc, Ctx, ArgumentKind, ArgumentIdx, TypeTagIdx, IsPointer, S);
  A->setImplicit(true);
  return A;
}

static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * ArgumentKind, unsigned ArgumentIdx, unsigned TypeTagIdx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ArgumentWithTypeTagAttr(Loc, Ctx, ArgumentKind, ArgumentIdx, TypeTagIdx, S);
  A->setImplicit(true);
  return A;
}

ArgumentWithTypeTagAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * ArgumentKind
            , unsigned ArgumentIdx
            , unsigned TypeTagIdx
            , bool IsPointer
            , unsigned SI
           )
  : InheritableAttr(attr::ArgumentWithTypeTag, R, SI, false, false)
            , argumentKind(ArgumentKind)
            , argumentIdx(ArgumentIdx)
            , typeTagIdx(TypeTagIdx)
            , isPointer(IsPointer)
{
}

ArgumentWithTypeTagAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * ArgumentKind
            , unsigned ArgumentIdx
            , unsigned TypeTagIdx
            , unsigned SI
           )
  : InheritableAttr(attr::ArgumentWithTypeTag, R, SI, false, false)
            , argumentKind(ArgumentKind)
            , argumentIdx(ArgumentIdx)
            , typeTagIdx(TypeTagIdx)
            , isPointer()
{
}

ArgumentWithTypeTagAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1010);
  case 0: return GNU_argument_with_type_tag;
  case 1: return CXX11_clang_argument_with_type_tag;
  case 2: return C2x_clang_argument_with_type_tag;
  case 3: return GNU_pointer_with_type_tag;
  case 4: return CXX11_clang_pointer_with_type_tag;
  case 5: return C2x_clang_pointer_with_type_tag;
}
}
IdentifierInfo * getArgumentKind() const {
  return argumentKind;
}

unsigned getArgumentIdx() const {
  return argumentIdx;
}

unsigned getTypeTagIdx() const {
  return typeTagIdx;
}

bool getIsPointer() const {
  return isPointer;
}



static bool classof(const Attr *A) { return A->getKind() == attr::ArgumentWithTypeTag; }
1038};

1040class ArtificialAttr : public InheritableAttr {
1041public:
static ArtificialAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ArtificialAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ArtificialAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Artificial, R, SI, false, false)
{
}

ArtificialAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Artificial; }
1062};

1064class AsmLabelAttr : public InheritableAttr {
1065unsigned labelLength;
1066char *label;

1068public:
static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AsmLabelAttr(Loc, Ctx, Label, 0);
  A->setImplicit(true);
  return A;
}

AsmLabelAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Label
            , unsigned SI
           )
  : InheritableAttr(attr::AsmLabel, R, SI, false, false)
            , labelLength(Label.size()),label(new (Ctx, 1) char[labelLength])
{
    if (!Label.empty())
      std::memcpy(label, Label.data(), labelLength);
}

AsmLabelAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getLabel() const {
  return llvm::StringRef(label, labelLength);
}
unsigned getLabelLength() const {
  return labelLength;
}
void setLabel(ASTContext &C, llvm::StringRef S) {
  labelLength = S.size();
  this->label = new (C, 1) char [labelLength];
  if (!S.empty())
    std::memcpy(this->label, S.data(), labelLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::AsmLabel; }
1106};

1108class AssertCapabilityAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

1112public:
enum Spelling {
  GNU_assert_capability = 0,
  CXX11_clang_assert_capability = 1,
  GNU_assert_shared_capability = 2,
  CXX11_clang_assert_shared_capability = 3
};

static AssertCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AssertCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
  A->setImplicit(true);
  return A;
}

AssertCapabilityAttr(SourceRange R, ASTContext &Ctx
            , Expr * *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::AssertCapability, R, SI, true, true)
            , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

AssertCapabilityAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AssertCapability, R, SI, true, true)
            , args_Size(0), args_(nullptr)
{
}

AssertCapabilityAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1150);
  case 0: return GNU_assert_capability;
  case 1: return CXX11_clang_assert_capability;
  case 2: return GNU_assert_shared_capability;
  case 3: return CXX11_clang_assert_shared_capability;
}
}
bool isShared() const { return SpellingListIndex == 2 ||
  SpellingListIndex == 3; }
typedef Expr ** args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::AssertCapability; }
1169};

1171class AssertExclusiveLockAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

1175public:
static AssertExclusiveLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AssertExclusiveLockAttr(Loc, Ctx, Args, ArgsSize, 0);
  A->setImplicit(true);
  return A;
}

AssertExclusiveLockAttr(SourceRange R, ASTContext &Ctx
            , Expr * *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::AssertExclusiveLock, R, SI, true, true)
            , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

AssertExclusiveLockAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AssertExclusiveLock, R, SI, true, true)
            , args_Size(0), args_(nullptr)
{
}

AssertExclusiveLockAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef Expr ** args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::AssertExclusiveLock; }
1214};

1216class AssertSharedLockAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

1220public:
static AssertSharedLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AssertSharedLockAttr(Loc, Ctx, Args, ArgsSize, 0);
  A->setImplicit(true);
  return A;
}

AssertSharedLockAttr(SourceRange R, ASTContext &Ctx
            , Expr * *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::AssertSharedLock, R, SI, true, true)
            , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

AssertSharedLockAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AssertSharedLock, R, SI, true, true)
            , args_Size(0), args_(nullptr)
{
}

AssertSharedLockAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef Expr ** args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::AssertSharedLock; }
1259};

1261class AssumeAlignedAttr : public InheritableAttr {
1262Expr * alignment;

1264Expr * offset;

1266public:
static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AssumeAlignedAttr(Loc, Ctx, Alignment, Offset, 0);
  A->setImplicit(true);
  return A;
}

AssumeAlignedAttr(SourceRange R, ASTContext &Ctx
            , Expr * Alignment
            , Expr * Offset
            , unsigned SI
           )
  : InheritableAttr(attr::AssumeAligned, R, SI, false, false)
            , alignment(Alignment)
            , offset(Offset)
{
}

AssumeAlignedAttr(SourceRange R, ASTContext &Ctx
            , Expr * Alignment
            , unsigned SI
           )
  : InheritableAttr(attr::AssumeAligned, R, SI, false, false)
            , alignment(Alignment)
            , offset()
{
}

AssumeAlignedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Expr * getAlignment() const {
  return alignment;
}

Expr * getOffset() const {
  return offset;
}



static bool classof(const Attr *A) { return A->getKind() == attr::AssumeAligned; }
1309};

1311class AvailabilityAttr : public InheritableAttr {
1312IdentifierInfo * platform;

1314VersionTuple introduced;


1317VersionTuple deprecated;


1320VersionTuple obsoleted;


1323bool unavailable;

1325unsigned messageLength;
1326char *message;

1328bool strict;

1330unsigned replacementLength;
1331char *replacement;

1333public:
static AvailabilityAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AvailabilityAttr(Loc, Ctx, Platform, Introduced, Deprecated, Obsoleted, Unavailable, Message, Strict, Replacement, 0);
  A->setImplicit(true);
  return A;
}

AvailabilityAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * Platform
            , VersionTuple Introduced
            , VersionTuple Deprecated
            , VersionTuple Obsoleted
            , bool Unavailable
            , llvm::StringRef Message
            , bool Strict
            , llvm::StringRef Replacement
            , unsigned SI
           )
  : InheritableAttr(attr::Availability, R, SI, false, true)
            , platform(Platform)
            , introduced(Introduced)
            , deprecated(Deprecated)
            , obsoleted(Obsoleted)
            , unavailable(Unavailable)
            , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
            , strict(Strict)
            , replacementLength(Replacement.size()),replacement(new (Ctx, 1) char[replacementLength])
{
    if (!Message.empty())
      std::memcpy(message, Message.data(), messageLength);
    if (!Replacement.empty())
      std::memcpy(replacement, Replacement.data(), replacementLength);
}

AvailabilityAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
IdentifierInfo * getPlatform() const {
  return platform;
}

VersionTuple getIntroduced() const {
  return introduced;
}
void setIntroduced(ASTContext &C, VersionTuple V) {
  introduced = V;
}

VersionTuple getDeprecated() const {
  return deprecated;
}
void setDeprecated(ASTContext &C, VersionTuple V) {
  deprecated = V;
}

VersionTuple getObsoleted() const {
  return obsoleted;
}
void setObsoleted(ASTContext &C, VersionTuple V) {
  obsoleted = V;
}

bool getUnavailable() const {
  return unavailable;
}

llvm::StringRef getMessage() const {
  return llvm::StringRef(message, messageLength);
}
unsigned getMessageLength() const {
  return messageLength;
}
void setMessage(ASTContext &C, llvm::StringRef S) {
  messageLength = S.size();
  this->message = new (C, 1) char [messageLength];
11
←
Null pointer value stored to field 'message'→
  if (!S.empty())
12
←
Assuming the condition is true→
13
←
Taking true branch→
    std::memcpy(this->message, S.data(), messageLength);
14
←
Null pointer passed as an argument to a 'nonnull' parameter
}

bool getStrict() const {
  return strict;
}

llvm::StringRef getReplacement() const {
  return llvm::StringRef(replacement, replacementLength);
}
unsigned getReplacementLength() const {
  return replacementLength;
}
void setReplacement(ASTContext &C, llvm::StringRef S) {
  replacementLength = S.size();
  this->replacement = new (C, 1) char [replacementLength];
  if (!S.empty())
    std::memcpy(this->replacement, S.data(), replacementLength);
}

1430static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) {
  return llvm::StringSwitch<llvm::StringRef>(Platform)
           .Case("android", "Android")
           .Case("ios", "iOS")
           .Case("macos", "macOS")
           .Case("tvos", "tvOS")
           .Case("watchos", "watchOS")
           .Case("ios_app_extension", "iOS (App Extension)")
           .Case("macos_app_extension", "macOS (App Extension)")
           .Case("tvos_app_extension", "tvOS (App Extension)")
           .Case("watchos_app_extension", "watchOS (App Extension)")
           .Default(llvm::StringRef());
1442}
1443static llvm::StringRef getPlatformNameSourceSpelling(llvm::StringRef Platform) {
  return llvm::StringSwitch<llvm::StringRef>(Platform)
           .Case("ios", "iOS")
           .Case("macos", "macOS")
           .Case("tvos", "tvOS")
           .Case("watchos", "watchOS")
           .Case("ios_app_extension", "iOSApplicationExtension")
           .Case("macos_app_extension", "macOSApplicationExtension")
           .Case("tvos_app_extension", "tvOSApplicationExtension")
           .Case("watchos_app_extension", "watchOSApplicationExtension")
           .Default(Platform);
1454}
1455static llvm::StringRef canonicalizePlatformName(llvm::StringRef Platform) {
  return llvm::StringSwitch<llvm::StringRef>(Platform)
           .Case("iOS", "ios")
           .Case("macOS", "macos")
           .Case("tvOS", "tvos")
           .Case("watchOS", "watchos")
           .Case("iOSApplicationExtension", "ios_app_extension")
           .Case("macOSApplicationExtension", "macos_app_extension")
           .Case("tvOSApplicationExtension", "tvos_app_extension")
           .Case("watchOSApplicationExtension", "watchos_app_extension")
           .Default(Platform);
1466} 

static bool classof(const Attr *A) { return A->getKind() == attr::Availability; }
1469};

1471class BlocksAttr : public InheritableAttr {
1472public:
enum BlockType {
  ByRef
};
1476private:
BlockType type;

1479public:
static BlocksAttr *CreateImplicit(ASTContext &Ctx, BlockType Type, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) BlocksAttr(Loc, Ctx, Type, 0);
  A->setImplicit(true);
  return A;
}

BlocksAttr(SourceRange R, ASTContext &Ctx
            , BlockType Type
            , unsigned SI
           )
  : InheritableAttr(attr::Blocks, R, SI, false, false)
            , type(Type)
{
}

BlocksAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
BlockType getType() const {
  return type;
}

static bool ConvertStrToBlockType(StringRef Val, BlockType &Out) {
  Optional<BlockType> R = llvm::StringSwitch<Optional<BlockType>>(Val)
    .Case("byref", BlocksAttr::ByRef)
    .Default(Optional<BlockType>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertBlockTypeToStr(BlockType Val) {
  switch(Val) {
  case BlocksAttr::ByRef: return "byref";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1518);
}


static bool classof(const Attr *A) { return A->getKind() == attr::Blocks; }
1523};

1525class C11NoReturnAttr : public InheritableAttr {
1526public:
static C11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) C11NoReturnAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

C11NoReturnAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::C11NoReturn, R, SI, false, false)
{
}

C11NoReturnAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::C11NoReturn; }
1547};

1549class CDeclAttr : public InheritableAttr {
1550public:
static CDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CDeclAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CDeclAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CDecl, R, SI, false, false)
{
}

CDeclAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CDecl; }
1571};

1573class CFAuditedTransferAttr : public InheritableAttr {
1574public:
static CFAuditedTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CFAuditedTransferAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CFAuditedTransferAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CFAuditedTransfer, R, SI, false, false)
{
}

CFAuditedTransferAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CFAuditedTransfer; }
1595};

1597class CFConsumedAttr : public InheritableParamAttr {
1598public:
static CFConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CFConsumedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CFConsumedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableParamAttr(attr::CFConsumed, R, SI, false, false)
{
}

CFConsumedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CFConsumed; }
1619};

1621class CFReturnsNotRetainedAttr : public InheritableAttr {
1622public:
static CFReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CFReturnsNotRetainedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CFReturnsNotRetainedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CFReturnsNotRetained, R, SI, false, false)
{
}

CFReturnsNotRetainedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsNotRetained; }
1643};

1645class CFReturnsRetainedAttr : public InheritableAttr {
1646public:
static CFReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CFReturnsRetainedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CFReturnsRetainedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CFReturnsRetained, R, SI, false, false)
{
}

CFReturnsRetainedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsRetained; }
1667};

1669class CFUnknownTransferAttr : public InheritableAttr {
1670public:
static CFUnknownTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CFUnknownTransferAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CFUnknownTransferAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CFUnknownTransfer, R, SI, false, false)
{
}

CFUnknownTransferAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CFUnknownTransfer; }
1691};

1693class CUDAConstantAttr : public InheritableAttr {
1694public:
static CUDAConstantAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CUDAConstantAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CUDAConstantAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CUDAConstant, R, SI, false, false)
{
}

CUDAConstantAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CUDAConstant; }
1715};

1717class CUDADeviceAttr : public InheritableAttr {
1718public:
static CUDADeviceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CUDADeviceAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CUDADeviceAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CUDADevice, R, SI, false, false)
{
}

CUDADeviceAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CUDADevice; }
1739};

1741class CUDAGlobalAttr : public InheritableAttr {
1742public:
static CUDAGlobalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CUDAGlobalAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CUDAGlobalAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CUDAGlobal, R, SI, false, false)
{
}

CUDAGlobalAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CUDAGlobal; }
1763};

1765class CUDAHostAttr : public InheritableAttr {
1766public:
static CUDAHostAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CUDAHostAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CUDAHostAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CUDAHost, R, SI, false, false)
{
}

CUDAHostAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CUDAHost; }
1787};

1789class CUDAInvalidTargetAttr : public InheritableAttr {
1790public:
static CUDAInvalidTargetAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CUDAInvalidTargetAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CUDAInvalidTargetAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CUDAInvalidTarget, R, SI, false, false)
{
}

CUDAInvalidTargetAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CUDAInvalidTarget; }
1811};

1813class CUDALaunchBoundsAttr : public InheritableAttr {
1814Expr * maxThreads;

1816Expr * minBlocks;

1818public:
static CUDALaunchBoundsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CUDALaunchBoundsAttr(Loc, Ctx, MaxThreads, MinBlocks, 0);
  A->setImplicit(true);
  return A;
}

CUDALaunchBoundsAttr(SourceRange R, ASTContext &Ctx
            , Expr * MaxThreads
            , Expr * MinBlocks
            , unsigned SI
           )
  : InheritableAttr(attr::CUDALaunchBounds, R, SI, false, false)
            , maxThreads(MaxThreads)
            , minBlocks(MinBlocks)
{
}

CUDALaunchBoundsAttr(SourceRange R, ASTContext &Ctx
            , Expr * MaxThreads
            , unsigned SI
           )
  : InheritableAttr(attr::CUDALaunchBounds, R, SI, false, false)
            , maxThreads(MaxThreads)
            , minBlocks()
{
}

CUDALaunchBoundsAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Expr * getMaxThreads() const {
  return maxThreads;
}

Expr * getMinBlocks() const {
  return minBlocks;
}



static bool classof(const Attr *A) { return A->getKind() == attr::CUDALaunchBounds; }
1861};

1863class CUDASharedAttr : public InheritableAttr {
1864public:
static CUDASharedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CUDASharedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CUDASharedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CUDAShared, R, SI, false, false)
{
}

CUDASharedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CUDAShared; }
1885};

1887class CXX11NoReturnAttr : public InheritableAttr {
1888public:
static CXX11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CXX11NoReturnAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CXX11NoReturnAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CXX11NoReturn, R, SI, false, false)
{
}

CXX11NoReturnAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CXX11NoReturn; }
1909};

1911class CallableWhenAttr : public InheritableAttr {
1912public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
1918private:
unsigned callableStates_Size;
ConsumedState *callableStates_;

1922public:
static CallableWhenAttr *CreateImplicit(ASTContext &Ctx, ConsumedState *CallableStates, unsigned CallableStatesSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CallableWhenAttr(Loc, Ctx, CallableStates, CallableStatesSize, 0);
  A->setImplicit(true);
  return A;
}

CallableWhenAttr(SourceRange R, ASTContext &Ctx
            , ConsumedState *CallableStates, unsigned CallableStatesSize
            , unsigned SI
           )
  : InheritableAttr(attr::CallableWhen, R, SI, false, false)
            , callableStates_Size(CallableStatesSize), callableStates_(new (Ctx, 16) ConsumedState[callableStates_Size])
{
  std::copy(CallableStates, CallableStates + callableStates_Size, callableStates_);
}

CallableWhenAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CallableWhen, R, SI, false, false)
            , callableStates_Size(0), callableStates_(nullptr)
{
}

CallableWhenAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef ConsumedState* callableStates_iterator;
callableStates_iterator callableStates_begin() const { return callableStates_; }
callableStates_iterator callableStates_end() const { return callableStates_ + callableStates_Size; }
unsigned callableStates_size() const { return callableStates_Size; }
llvm::iterator_range<callableStates_iterator> callableStates() const { return llvm::make_range(callableStates_begin(), callableStates_end()); }


static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
  Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
    .Case("unknown", CallableWhenAttr::Unknown)
    .Case("consumed", CallableWhenAttr::Consumed)
    .Case("unconsumed", CallableWhenAttr::Unconsumed)
    .Default(Optional<ConsumedState>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertConsumedStateToStr(ConsumedState Val) {
  switch(Val) {
  case CallableWhenAttr::Unknown: return "unknown";
  case CallableWhenAttr::Consumed: return "consumed";
  case CallableWhenAttr::Unconsumed: return "unconsumed";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1977);
}


static bool classof(const Attr *A) { return A->getKind() == attr::CallableWhen; }
1982};

1984class CapabilityAttr : public InheritableAttr {
1985unsigned nameLength;
1986char *name;

1988public:
enum Spelling {
  GNU_capability = 0,
  CXX11_clang_capability = 1,
  GNU_shared_capability = 2,
  CXX11_clang_shared_capability = 3
};

static CapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CapabilityAttr(Loc, Ctx, Name, S);
  A->setImplicit(true);
  return A;
}

CapabilityAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Name
            , unsigned SI
           )
  : InheritableAttr(attr::Capability, R, SI, false, false)
            , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
{
    if (!Name.empty())
      std::memcpy(name, Name.data(), nameLength);
}

CapabilityAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2019);
  case 0: return GNU_capability;
  case 1: return CXX11_clang_capability;
  case 2: return GNU_shared_capability;
  case 3: return CXX11_clang_shared_capability;
}
}
bool isShared() const { return SpellingListIndex == 2 ||
  SpellingListIndex == 3; }
llvm::StringRef getName() const {
  return llvm::StringRef(name, nameLength);
}
unsigned getNameLength() const {
  return nameLength;
}
void setName(ASTContext &C, llvm::StringRef S) {
  nameLength = S.size();
  this->name = new (C, 1) char [nameLength];
  if (!S.empty())
    std::memcpy(this->name, S.data(), nameLength);
}


  bool isMutex() const { return getName().equals_lower("mutex"); }
  bool isRole() const { return getName().equals_lower("role"); }


static bool classof(const Attr *A) { return A->getKind() == attr::Capability; }
2047};

2049class CapturedRecordAttr : public InheritableAttr {
2050public:
static CapturedRecordAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CapturedRecordAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CapturedRecordAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CapturedRecord, R, SI, false, false)
{
}

CapturedRecordAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CapturedRecord; }
2071};

2073class CarriesDependencyAttr : public InheritableParamAttr {
2074public:
static CarriesDependencyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CarriesDependencyAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CarriesDependencyAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableParamAttr(attr::CarriesDependency, R, SI, false, false)
{
}

CarriesDependencyAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::CarriesDependency; }
2095};

2097class CleanupAttr : public InheritableAttr {
2098FunctionDecl * functionDecl;

2100public:
static CleanupAttr *CreateImplicit(ASTContext &Ctx, FunctionDecl * FunctionDecl, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CleanupAttr(Loc, Ctx, FunctionDecl, 0);
  A->setImplicit(true);
  return A;
}

CleanupAttr(SourceRange R, ASTContext &Ctx
            , FunctionDecl * FunctionDecl
            , unsigned SI
           )
  : InheritableAttr(attr::Cleanup, R, SI, false, false)
            , functionDecl(FunctionDecl)
{
}

CleanupAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
FunctionDecl * getFunctionDecl() const {
  return functionDecl;
}



static bool classof(const Attr *A) { return A->getKind() == attr::Cleanup; }
2127};

2129class ColdAttr : public InheritableAttr {
2130public:
static ColdAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ColdAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ColdAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Cold, R, SI, false, false)
{
}

ColdAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Cold; }
2151};

2153class CommonAttr : public InheritableAttr {
2154public:
static CommonAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CommonAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

CommonAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Common, R, SI, false, false)
{
}

CommonAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Common; }
2175};

2177class ConstAttr : public InheritableAttr {
2178public:
static ConstAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ConstAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ConstAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Const, R, SI, false, false)
{
}

ConstAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Const; }
2199};

2201class ConstructorAttr : public InheritableAttr {
2202int priority;

2204public:
static ConstructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ConstructorAttr(Loc, Ctx, Priority, 0);
  A->setImplicit(true);
  return A;
}

ConstructorAttr(SourceRange R, ASTContext &Ctx
            , int Priority
            , unsigned SI
           )
  : InheritableAttr(attr::Constructor, R, SI, false, false)
            , priority(Priority)
{
}

ConstructorAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Constructor, R, SI, false, false)
            , priority()
{
}

ConstructorAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
int getPriority() const {
  return priority;
}

static const int DefaultPriority = 65535;



static bool classof(const Attr *A) { return A->getKind() == attr::Constructor; }
2241};

2243class ConsumableAttr : public InheritableAttr {
2244public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
2250private:
ConsumedState defaultState;

2253public:
static ConsumableAttr *CreateImplicit(ASTContext &Ctx, ConsumedState DefaultState, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ConsumableAttr(Loc, Ctx, DefaultState, 0);
  A->setImplicit(true);
  return A;
}

ConsumableAttr(SourceRange R, ASTContext &Ctx
            , ConsumedState DefaultState
            , unsigned SI
           )
  : InheritableAttr(attr::Consumable, R, SI, false, false)
            , defaultState(DefaultState)
{
}

ConsumableAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
ConsumedState getDefaultState() const {
  return defaultState;
}

static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
  Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
    .Case("unknown", ConsumableAttr::Unknown)
    .Case("consumed", ConsumableAttr::Consumed)
    .Case("unconsumed", ConsumableAttr::Unconsumed)
    .Default(Optional<ConsumedState>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertConsumedStateToStr(ConsumedState Val) {
  switch(Val) {
  case ConsumableAttr::Unknown: return "unknown";
  case ConsumableAttr::Consumed: return "consumed";
  case ConsumableAttr::Unconsumed: return "unconsumed";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2296);
}


static bool classof(const Attr *A) { return A->getKind() == attr::Consumable; }
2301};

2303class ConsumableAutoCastAttr : public InheritableAttr {
2304public:
static ConsumableAutoCastAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ConsumableAutoCastAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ConsumableAutoCastAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ConsumableAutoCast, R, SI, false, false)
{
}

ConsumableAutoCastAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ConsumableAutoCast; }
2325};

2327class ConsumableSetOnReadAttr : public InheritableAttr {
2328public:
static ConsumableSetOnReadAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ConsumableSetOnReadAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ConsumableSetOnReadAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ConsumableSetOnRead, R, SI, false, false)
{
}

ConsumableSetOnReadAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ConsumableSetOnRead; }
2349};

2351class ConvergentAttr : public InheritableAttr {
2352public:
static ConvergentAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ConvergentAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ConvergentAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Convergent, R, SI, false, false)
{
}

ConvergentAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Convergent; }
2373};

2375class DLLExportAttr : public InheritableAttr {
2376public:
static DLLExportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) DLLExportAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

DLLExportAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::DLLExport, R, SI, false, false)
{
}

DLLExportAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::DLLExport; }
2397};

2399class DLLImportAttr : public InheritableAttr {
2400public:
static DLLImportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) DLLImportAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

DLLImportAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::DLLImport, R, SI, false, false)
{
}

DLLImportAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::DLLImport; }
2421};

2423class DeprecatedAttr : public InheritableAttr {
2424unsigned messageLength;
2425char *message;

2427unsigned replacementLength;
2428char *replacement;

2430public:
static DeprecatedAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, llvm::StringRef Replacement, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) DeprecatedAttr(Loc, Ctx, Message, Replacement, 0);
  A->setImplicit(true);
  return A;
}

DeprecatedAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Message
            , llvm::StringRef Replacement
            , unsigned SI
           )
  : InheritableAttr(attr::Deprecated, R, SI, false, false)
            , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
            , replacementLength(Replacement.size()),replacement(new (Ctx, 1) char[replacementLength])
{
    if (!Message.empty())
      std::memcpy(message, Message.data(), messageLength);
    if (!Replacement.empty())
      std::memcpy(replacement, Replacement.data(), replacementLength);
}

DeprecatedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Deprecated, R, SI, false, false)
            , messageLength(0),message(nullptr)
            , replacementLength(0),replacement(nullptr)
{
}

DeprecatedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getMessage() const {
  return llvm::StringRef(message, messageLength);
}
unsigned getMessageLength() const {
  return messageLength;
}
void setMessage(ASTContext &C, llvm::StringRef S) {
  messageLength = S.size();
  this->message = new (C, 1) char [messageLength];
  if (!S.empty())
    std::memcpy(this->message, S.data(), messageLength);
}

llvm::StringRef getReplacement() const {
  return llvm::StringRef(replacement, replacementLength);
}
unsigned getReplacementLength() const {
  return replacementLength;
}
void setReplacement(ASTContext &C, llvm::StringRef S) {
  replacementLength = S.size();
  this->replacement = new (C, 1) char [replacementLength];
  if (!S.empty())
    std::memcpy(this->replacement, S.data(), replacementLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::Deprecated; }
2494};

2496class DestructorAttr : public InheritableAttr {
2497int priority;

2499public:
static DestructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) DestructorAttr(Loc, Ctx, Priority, 0);
  A->setImplicit(true);
  return A;
}

DestructorAttr(SourceRange R, ASTContext &Ctx
            , int Priority
            , unsigned SI
           )
  : InheritableAttr(attr::Destructor, R, SI, false, false)
            , priority(Priority)
{
}

DestructorAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Destructor, R, SI, false, false)
            , priority()
{
}

DestructorAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
int getPriority() const {
  return priority;
}

static const int DefaultPriority = 65535;



static bool classof(const Attr *A) { return A->getKind() == attr::Destructor; }
2536};

2538class DiagnoseIfAttr : public InheritableAttr {
2539Expr * cond;

2541unsigned messageLength;
2542char *message;

2544public:
enum DiagnosticType {
  DT_Error,
  DT_Warning
};
2549private:
DiagnosticType diagnosticType;

2552bool argDependent;

2554NamedDecl * parent;

2556public:
static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, bool ArgDependent, NamedDecl * Parent, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) DiagnoseIfAttr(Loc, Ctx, Cond, Message, DiagnosticType, ArgDependent, Parent, 0);
  A->setImplicit(true);
  return A;
}

static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) DiagnoseIfAttr(Loc, Ctx, Cond, Message, DiagnosticType, 0);
  A->setImplicit(true);
  return A;
}

DiagnoseIfAttr(SourceRange R, ASTContext &Ctx
            , Expr * Cond
            , llvm::StringRef Message
            , DiagnosticType DiagnosticType
            , bool ArgDependent
            , NamedDecl * Parent
            , unsigned SI
           )
  : InheritableAttr(attr::DiagnoseIf, R, SI, true, true)
            , cond(Cond)
            , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
            , diagnosticType(DiagnosticType)
            , argDependent(ArgDependent)
            , parent(Parent)
{
    if (!Message.empty())
      std::memcpy(message, Message.data(), messageLength);
}

DiagnoseIfAttr(SourceRange R, ASTContext &Ctx
            , Expr * Cond
            , llvm::StringRef Message
            , DiagnosticType DiagnosticType
            , unsigned SI
           )
  : InheritableAttr(attr::DiagnoseIf, R, SI, true, true)
            , cond(Cond)
            , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
            , diagnosticType(DiagnosticType)
            , argDependent()
            , parent()
{
    if (!Message.empty())
      std::memcpy(message, Message.data(), messageLength);
}

DiagnoseIfAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Expr * getCond() const {
  return cond;
}

llvm::StringRef getMessage() const {
  return llvm::StringRef(message, messageLength);
}
unsigned getMessageLength() const {
  return messageLength;
}
void setMessage(ASTContext &C, llvm::StringRef S) {
  messageLength = S.size();
  this->message = new (C, 1) char [messageLength];
  if (!S.empty())
    std::memcpy(this->message, S.data(), messageLength);
}

DiagnosticType getDiagnosticType() const {
  return diagnosticType;
}

static bool ConvertStrToDiagnosticType(StringRef Val, DiagnosticType &Out) {
  Optional<DiagnosticType> R = llvm::StringSwitch<Optional<DiagnosticType>>(Val)
    .Case("error", DiagnoseIfAttr::DT_Error)
    .Case("warning", DiagnoseIfAttr::DT_Warning)
    .Default(Optional<DiagnosticType>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertDiagnosticTypeToStr(DiagnosticType Val) {
  switch(Val) {
  case DiagnoseIfAttr::DT_Error: return "error";
  case DiagnoseIfAttr::DT_Warning: return "warning";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2647);
}
bool getArgDependent() const {
  return argDependent;
}

NamedDecl * getParent() const {
  return parent;
}


  bool isError() const { return diagnosticType == DT_Error; }
  bool isWarning() const { return diagnosticType == DT_Warning; }


static bool classof(const Attr *A) { return A->getKind() == attr::DiagnoseIf; }
2663};

2665class DisableTailCallsAttr : public InheritableAttr {
2666public:
static DisableTailCallsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) DisableTailCallsAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

DisableTailCallsAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::DisableTailCalls, R, SI, false, false)
{
}

DisableTailCallsAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::DisableTailCalls; }
2687};

2689class EmptyBasesAttr : public InheritableAttr {
2690public:
static EmptyBasesAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) EmptyBasesAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

EmptyBasesAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::EmptyBases, R, SI, false, false)
{
}

EmptyBasesAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::EmptyBases; }
2711};

2713class EnableIfAttr : public InheritableAttr {
2714Expr * cond;

2716unsigned messageLength;
2717char *message;

2719public:
static EnableIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) EnableIfAttr(Loc, Ctx, Cond, Message, 0);
  A->setImplicit(true);
  return A;
}

EnableIfAttr(SourceRange R, ASTContext &Ctx
            , Expr * Cond
            , llvm::StringRef Message
            , unsigned SI
           )
  : InheritableAttr(attr::EnableIf, R, SI, false, false)
            , cond(Cond)
            , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
{
    if (!Message.empty())
      std::memcpy(message, Message.data(), messageLength);
}

EnableIfAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Expr * getCond() const {
  return cond;
}

llvm::StringRef getMessage() const {
  return llvm::StringRef(message, messageLength);
}
unsigned getMessageLength() const {
  return messageLength;
}
void setMessage(ASTContext &C, llvm::StringRef S) {
  messageLength = S.size();
  this->message = new (C, 1) char [messageLength];
  if (!S.empty())
    std::memcpy(this->message, S.data(), messageLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::EnableIf; }
2763};

2765class EnumExtensibilityAttr : public InheritableAttr {
2766public:
enum Kind {
  Closed,
  Open
};
2771private:
Kind extensibility;

2774public:
static EnumExtensibilityAttr *CreateImplicit(ASTContext &Ctx, Kind Extensibility, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) EnumExtensibilityAttr(Loc, Ctx, Extensibility, 0);
  A->setImplicit(true);
  return A;
}

EnumExtensibilityAttr(SourceRange R, ASTContext &Ctx
            , Kind Extensibility
            , unsigned SI
           )
  : InheritableAttr(attr::EnumExtensibility, R, SI, false, false)
            , extensibility(Extensibility)
{
}

EnumExtensibilityAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Kind getExtensibility() const {
  return extensibility;
}

static bool ConvertStrToKind(StringRef Val, Kind &Out) {
  Optional<Kind> R = llvm::StringSwitch<Optional<Kind>>(Val)
    .Case("closed", EnumExtensibilityAttr::Closed)
    .Case("open", EnumExtensibilityAttr::Open)
    .Default(Optional<Kind>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertKindToStr(Kind Val) {
  switch(Val) {
  case EnumExtensibilityAttr::Closed: return "closed";
  case EnumExtensibilityAttr::Open: return "open";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2815);
}


static bool classof(const Attr *A) { return A->getKind() == attr::EnumExtensibility; }
2820};

2822class ExclusiveTrylockFunctionAttr : public InheritableAttr {
2823Expr * successValue;

unsigned args_Size;
Expr * *args_;

2828public:
static ExclusiveTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ExclusiveTrylockFunctionAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, 0);
  A->setImplicit(true);
  return A;
}

ExclusiveTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
            , Expr * SuccessValue
            , Expr * *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::ExclusiveTrylockFunction, R, SI, true, true)
            , successValue(SuccessValue)
            , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

ExclusiveTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
            , Expr * SuccessValue
            , unsigned SI
           )
  : InheritableAttr(attr::ExclusiveTrylockFunction, R, SI, true, true)
            , successValue(SuccessValue)
            , args_Size(0), args_(nullptr)
{
}

ExclusiveTrylockFunctionAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Expr * getSuccessValue() const {
  return successValue;
}

typedef Expr ** args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::ExclusiveTrylockFunction; }
2875};

2877class ExternalSourceSymbolAttr : public InheritableAttr {
2878unsigned languageLength;
2879char *language;

2881unsigned definedInLength;
2882char *definedIn;

2884bool generatedDeclaration;

2886public:
static ExternalSourceSymbolAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Language, llvm::StringRef DefinedIn, bool GeneratedDeclaration, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ExternalSourceSymbolAttr(Loc, Ctx, Language, DefinedIn, GeneratedDeclaration, 0);
  A->setImplicit(true);
  return A;
}

ExternalSourceSymbolAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Language
            , llvm::StringRef DefinedIn
            , bool GeneratedDeclaration
            , unsigned SI
           )
  : InheritableAttr(attr::ExternalSourceSymbol, R, SI, false, false)
            , languageLength(Language.size()),language(new (Ctx, 1) char[languageLength])
            , definedInLength(DefinedIn.size()),definedIn(new (Ctx, 1) char[definedInLength])
            , generatedDeclaration(GeneratedDeclaration)
{
    if (!Language.empty())
      std::memcpy(language, Language.data(), languageLength);
    if (!DefinedIn.empty())
      std::memcpy(definedIn, DefinedIn.data(), definedInLength);
}

ExternalSourceSymbolAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ExternalSourceSymbol, R, SI, false, false)
            , languageLength(0),language(nullptr)
            , definedInLength(0),definedIn(nullptr)
            , generatedDeclaration()
{
}

ExternalSourceSymbolAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getLanguage() const {
  return llvm::StringRef(language, languageLength);
}
unsigned getLanguageLength() const {
  return languageLength;
}
void setLanguage(ASTContext &C, llvm::StringRef S) {
  languageLength = S.size();
  this->language = new (C, 1) char [languageLength];
  if (!S.empty())
    std::memcpy(this->language, S.data(), languageLength);
}

llvm::StringRef getDefinedIn() const {
  return llvm::StringRef(definedIn, definedInLength);
}
unsigned getDefinedInLength() const {
  return definedInLength;
}
void setDefinedIn(ASTContext &C, llvm::StringRef S) {
  definedInLength = S.size();
  this->definedIn = new (C, 1) char [definedInLength];
  if (!S.empty())
    std::memcpy(this->definedIn, S.data(), definedInLength);
}

bool getGeneratedDeclaration() const {
  return generatedDeclaration;
}



static bool classof(const Attr *A) { return A->getKind() == attr::ExternalSourceSymbol; }
2957};

2959class FallThroughAttr : public StmtAttr {
2960public:
static FallThroughAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) FallThroughAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

FallThroughAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : StmtAttr(attr::FallThrough, R, SI, false)
{
}

FallThroughAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::FallThrough; }
2981};

2983class FastCallAttr : public InheritableAttr {
2984public:
static FastCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) FastCallAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

FastCallAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::FastCall, R, SI, false, false)
{
}

FastCallAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::FastCall; }
3005};

3007class FinalAttr : public InheritableAttr {
3008public:
enum Spelling {
  Keyword_final = 0,
  Keyword_sealed = 1
};

static FinalAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) FinalAttr(Loc, Ctx, S);
  A->setImplicit(true);
  return A;
}

FinalAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Final, R, SI, false, false)
{
}

FinalAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3033);
  case 0: return Keyword_final;
  case 1: return Keyword_sealed;
}
}
bool isSpelledAsSealed() const { return SpellingListIndex == 1; }


static bool classof(const Attr *A) { return A->getKind() == attr::Final; }
3042};

3044class FlagEnumAttr : public InheritableAttr {
3045public:
static FlagEnumAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) FlagEnumAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

FlagEnumAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::FlagEnum, R, SI, false, false)
{
}

FlagEnumAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::FlagEnum; }
3066};

3068class FlattenAttr : public InheritableAttr {
3069public:
static FlattenAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) FlattenAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

FlattenAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Flatten, R, SI, false, false)
{
}

FlattenAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Flatten; }
3090};

3092class FormatAttr : public InheritableAttr {
3093IdentifierInfo * type;

3095int formatIdx;

3097int firstArg;

3099public:
static FormatAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Type, int FormatIdx, int FirstArg, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) FormatAttr(Loc, Ctx, Type, FormatIdx, FirstArg, 0);
  A->setImplicit(true);
  return A;
}

FormatAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * Type
            , int FormatIdx
            , int FirstArg
            , unsigned SI
           )
  : InheritableAttr(attr::Format, R, SI, false, false)
            , type(Type)
            , formatIdx(FormatIdx)
            , firstArg(FirstArg)
{
}

FormatAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
IdentifierInfo * getType() const {
  return type;
}

int getFormatIdx() const {
  return formatIdx;
}

int getFirstArg() const {
  return firstArg;
}



static bool classof(const Attr *A) { return A->getKind() == attr::Format; }
3138};

3140class FormatArgAttr : public InheritableAttr {
3141int formatIdx;

3143public:
static FormatArgAttr *CreateImplicit(ASTContext &Ctx, int FormatIdx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) FormatArgAttr(Loc, Ctx, FormatIdx, 0);
  A->setImplicit(true);
  return A;
}

FormatArgAttr(SourceRange R, ASTContext &Ctx
            , int FormatIdx
            , unsigned SI
           )
  : InheritableAttr(attr::FormatArg, R, SI, false, false)
            , formatIdx(FormatIdx)
{
}

FormatArgAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
int getFormatIdx() const {
  return formatIdx;
}



static bool classof(const Attr *A) { return A->getKind() == attr::FormatArg; }
3170};

3172class GNUInlineAttr : public InheritableAttr {
3173public:
static GNUInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) GNUInlineAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

GNUInlineAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::GNUInline, R, SI, false, false)
{
}

GNUInlineAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::GNUInline; }
3194};

3196class GuardedByAttr : public InheritableAttr {
3197Expr * arg;

3199public:
static GuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) GuardedByAttr(Loc, Ctx, Arg, 0);
  A->setImplicit(true);
  return A;
}

GuardedByAttr(SourceRange R, ASTContext &Ctx
            , Expr * Arg
            , unsigned SI
           )
  : InheritableAttr(attr::GuardedBy, R, SI, true, true)
            , arg(Arg)
{
}

GuardedByAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Expr * getArg() const {
  return arg;
}



static bool classof(const Attr *A) { return A->getKind() == attr::GuardedBy; }
3226};

3228class GuardedVarAttr : public InheritableAttr {
3229public:
static GuardedVarAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) GuardedVarAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

GuardedVarAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::GuardedVar, R, SI, false, false)
{
}

GuardedVarAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::GuardedVar; }
3250};

3252class HotAttr : public InheritableAttr {
3253public:
static HotAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) HotAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

HotAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Hot, R, SI, false, false)
{
}

HotAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Hot; }
3274};

3276class IBActionAttr : public InheritableAttr {
3277public:
static IBActionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) IBActionAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

IBActionAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::IBAction, R, SI, false, false)
{
}

IBActionAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::IBAction; }
3298};

3300class IBOutletAttr : public InheritableAttr {
3301public:
static IBOutletAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) IBOutletAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

IBOutletAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::IBOutlet, R, SI, false, false)
{
}

IBOutletAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::IBOutlet; }
3322};

3324class IBOutletCollectionAttr : public InheritableAttr {
3325TypeSourceInfo * interface_;

3327public:
static IBOutletCollectionAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * Interface, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) IBOutletCollectionAttr(Loc, Ctx, Interface, 0);
  A->setImplicit(true);
  return A;
}

IBOutletCollectionAttr(SourceRange R, ASTContext &Ctx
            , TypeSourceInfo * Interface
            , unsigned SI
           )
  : InheritableAttr(attr::IBOutletCollection, R, SI, false, false)
            , interface_(Interface)
{
}

IBOutletCollectionAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::IBOutletCollection, R, SI, false, false)
            , interface_()
{
}

IBOutletCollectionAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
QualType getInterface() const {
  return interface_->getType();
}  TypeSourceInfo * getInterfaceLoc() const {
  return interface_;
}



static bool classof(const Attr *A) { return A->getKind() == attr::IBOutletCollection; }
3364};

3366class IFuncAttr : public Attr {
3367unsigned resolverLength;
3368char *resolver;

3370public:
static IFuncAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Resolver, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) IFuncAttr(Loc, Ctx, Resolver, 0);
  A->setImplicit(true);
  return A;
}

IFuncAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Resolver
            , unsigned SI
           )
  : Attr(attr::IFunc, R, SI, false)
            , resolverLength(Resolver.size()),resolver(new (Ctx, 1) char[resolverLength])
{
    if (!Resolver.empty())
      std::memcpy(resolver, Resolver.data(), resolverLength);
}

IFuncAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getResolver() const {
  return llvm::StringRef(resolver, resolverLength);
}
unsigned getResolverLength() const {
  return resolverLength;
}
void setResolver(ASTContext &C, llvm::StringRef S) {
  resolverLength = S.size();
  this->resolver = new (C, 1) char [resolverLength];
  if (!S.empty())
    std::memcpy(this->resolver, S.data(), resolverLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::IFunc; }
3408};

3410class InitPriorityAttr : public InheritableAttr {
3411unsigned priority;

3413public:
static InitPriorityAttr *CreateImplicit(ASTContext &Ctx, unsigned Priority, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) InitPriorityAttr(Loc, Ctx, Priority, 0);
  A->setImplicit(true);
  return A;
}

InitPriorityAttr(SourceRange R, ASTContext &Ctx
            , unsigned Priority
            , unsigned SI
           )
  : InheritableAttr(attr::InitPriority, R, SI, false, false)
            , priority(Priority)
{
}

InitPriorityAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getPriority() const {
  return priority;
}



static bool classof(const Attr *A) { return A->getKind() == attr::InitPriority; }
3440};

3442class InitSegAttr : public Attr {
3443unsigned sectionLength;
3444char *section;

3446public:
static InitSegAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Section, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) InitSegAttr(Loc, Ctx, Section, 0);
  A->setImplicit(true);
  return A;
}

InitSegAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Section
            , unsigned SI
           )
  : Attr(attr::InitSeg, R, SI, false)
            , sectionLength(Section.size()),section(new (Ctx, 1) char[sectionLength])
{
    if (!Section.empty())
      std::memcpy(section, Section.data(), sectionLength);
}

InitSegAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getSection() const {
  return llvm::StringRef(section, sectionLength);
}
unsigned getSectionLength() const {
  return sectionLength;
}
void setSection(ASTContext &C, llvm::StringRef S) {
  sectionLength = S.size();
  this->section = new (C, 1) char [sectionLength];
  if (!S.empty())
    std::memcpy(this->section, S.data(), sectionLength);
}


void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
  OS << " (" << getSection() << ')';
}


static bool classof(const Attr *A) { return A->getKind() == attr::InitSeg; }
3488};

3490class IntelOclBiccAttr : public InheritableAttr {
3491public:
static IntelOclBiccAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) IntelOclBiccAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

IntelOclBiccAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::IntelOclBicc, R, SI, false, false)
{
}

IntelOclBiccAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::IntelOclBicc; }
3512};

3514class InternalLinkageAttr : public InheritableAttr {
3515public:
static InternalLinkageAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) InternalLinkageAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

InternalLinkageAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::InternalLinkage, R, SI, false, false)
{
}

InternalLinkageAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::InternalLinkage; }
3536};

3538class LTOVisibilityPublicAttr : public InheritableAttr {
3539public:
static LTOVisibilityPublicAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) LTOVisibilityPublicAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

LTOVisibilityPublicAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::LTOVisibilityPublic, R, SI, false, false)
{
}

LTOVisibilityPublicAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::LTOVisibilityPublic; }
3560};

3562class LayoutVersionAttr : public InheritableAttr {
3563unsigned version;

3565public:
static LayoutVersionAttr *CreateImplicit(ASTContext &Ctx, unsigned Version, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) LayoutVersionAttr(Loc, Ctx, Version, 0);
  A->setImplicit(true);
  return A;
}

LayoutVersionAttr(SourceRange R, ASTContext &Ctx
            , unsigned Version
            , unsigned SI
           )
  : InheritableAttr(attr::LayoutVersion, R, SI, false, false)
            , version(Version)
{
}

LayoutVersionAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getVersion() const {
  return version;
}



static bool classof(const Attr *A) { return A->getKind() == attr::LayoutVersion; }
3592};

3594class LockReturnedAttr : public InheritableAttr {
3595Expr * arg;

3597public:
static LockReturnedAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) LockReturnedAttr(Loc, Ctx, Arg, 0);
  A->setImplicit(true);
  return A;
}

LockReturnedAttr(SourceRange R, ASTContext &Ctx
            , Expr * Arg
            , unsigned SI
           )
  : InheritableAttr(attr::LockReturned, R, SI, true, false)
            , arg(Arg)
{
}

LockReturnedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Expr * getArg() const {
  return arg;
}



static bool classof(const Attr *A) { return A->getKind() == attr::LockReturned; }
3624};

3626class LocksExcludedAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

3630public:
static LocksExcludedAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) LocksExcludedAttr(Loc, Ctx, Args, ArgsSize, 0);
  A->setImplicit(true);
  return A;
}

LocksExcludedAttr(SourceRange R, ASTContext &Ctx
            , Expr * *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::LocksExcluded, R, SI, true, true)
            , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

LocksExcludedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::LocksExcluded, R, SI, true, true)
            , args_Size(0), args_(nullptr)
{
}

LocksExcludedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef Expr ** args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::LocksExcluded; }
3669};

3671class LoopHintAttr : public Attr {
3672public:
enum OptionType {
  Vectorize,
  VectorizeWidth,
  Interleave,
  InterleaveCount,
  Unroll,
  UnrollCount,
  Distribute
};
3682private:
OptionType option;

3685public:
enum LoopHintState {
  Enable,
  Disable,
  Numeric,
  AssumeSafety,
  Full
};
3693private:
LoopHintState state;

3696Expr * value;

3698public:
enum Spelling {
  Pragma_clang_loop = 0,
  Pragma_unroll = 1,
  Pragma_nounroll = 2
};

static LoopHintAttr *CreateImplicit(ASTContext &Ctx, Spelling S, OptionType Option, LoopHintState State, Expr * Value, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) LoopHintAttr(Loc, Ctx, Option, State, Value, S);
  A->setImplicit(true);
  return A;
}

LoopHintAttr(SourceRange R, ASTContext &Ctx
            , OptionType Option
            , LoopHintState State
            , Expr * Value
            , unsigned SI
           )
  : Attr(attr::LoopHint, R, SI, false)
            , option(Option)
            , state(State)
            , value(Value)
{
}

LoopHintAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3730);
  case 0: return Pragma_clang_loop;
  case 1: return Pragma_unroll;
  case 2: return Pragma_nounroll;
}
}
OptionType getOption() const {
  return option;
}

static bool ConvertStrToOptionType(StringRef Val, OptionType &Out) {
  Optional<OptionType> R = llvm::StringSwitch<Optional<OptionType>>(Val)
    .Case("vectorize", LoopHintAttr::Vectorize)
    .Case("vectorize_width", LoopHintAttr::VectorizeWidth)
    .Case("interleave", LoopHintAttr::Interleave)
    .Case("interleave_count", LoopHintAttr::InterleaveCount)
    .Case("unroll", LoopHintAttr::Unroll)
    .Case("unroll_count", LoopHintAttr::UnrollCount)
    .Case("distribute", LoopHintAttr::Distribute)
    .Default(Optional<OptionType>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertOptionTypeToStr(OptionType Val) {
  switch(Val) {
  case LoopHintAttr::Vectorize: return "vectorize";
  case LoopHintAttr::VectorizeWidth: return "vectorize_width";
  case LoopHintAttr::Interleave: return "interleave";
  case LoopHintAttr::InterleaveCount: return "interleave_count";
  case LoopHintAttr::Unroll: return "unroll";
  case LoopHintAttr::UnrollCount: return "unroll_count";
  case LoopHintAttr::Distribute: return "distribute";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3767);
}
LoopHintState getState() const {
  return state;
}

static bool ConvertStrToLoopHintState(StringRef Val, LoopHintState &Out) {
  Optional<LoopHintState> R = llvm::StringSwitch<Optional<LoopHintState>>(Val)
    .Case("enable", LoopHintAttr::Enable)
    .Case("disable", LoopHintAttr::Disable)
    .Case("numeric", LoopHintAttr::Numeric)
    .Case("assume_safety", LoopHintAttr::AssumeSafety)
    .Case("full", LoopHintAttr::Full)
    .Default(Optional<LoopHintState>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertLoopHintStateToStr(LoopHintState Val) {
  switch(Val) {
  case LoopHintAttr::Enable: return "enable";
  case LoopHintAttr::Disable: return "disable";
  case LoopHintAttr::Numeric: return "numeric";
  case LoopHintAttr::AssumeSafety: return "assume_safety";
  case LoopHintAttr::Full: return "full";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3796);
}
Expr * getValue() const {
  return value;
}


static const char *getOptionName(int Option) {
  switch(Option) {
  case Vectorize: return "vectorize";
  case VectorizeWidth: return "vectorize_width";
  case Interleave: return "interleave";
  case InterleaveCount: return "interleave_count";
  case Unroll: return "unroll";
  case UnrollCount: return "unroll_count";
  case Distribute: return "distribute";
  }
  llvm_unreachable("Unhandled LoopHint option.")::llvm::llvm_unreachable_internal("Unhandled LoopHint option."
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3813);
}

void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
  unsigned SpellingIndex = getSpellingListIndex();
  // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
  // "nounroll" is already emitted as the pragma name.
  if (SpellingIndex == Pragma_nounroll)
    return;
  else if (SpellingIndex == Pragma_unroll) {
    OS << ' ' << getValueString(Policy);
    return;
  }

  assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling")(static_cast <bool> (SpellingIndex == Pragma_clang_loop
 && "Unexpected spelling") ? void (0) : __assert_fail
 ("SpellingIndex == Pragma_clang_loop && \"Unexpected spelling\""
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3827, __extension__ __PRETTY_FUNCTION__));
  OS << ' ' << getOptionName(option) << getValueString(Policy);
}

// Return a string containing the loop hint argument including the
// enclosing parentheses.
std::string getValueString(const PrintingPolicy &Policy) const {
  std::string ValueName;
  llvm::raw_string_ostream OS(ValueName);
  OS << "(";
  if (state == Numeric)
    value->printPretty(OS, nullptr, Policy);
  else if (state == Enable)
    OS << "enable";
  else if (state == Full)
    OS << "full";
  else if (state == AssumeSafety)
    OS << "assume_safety";
  else
    OS << "disable";
  OS << ")";
  return OS.str();
}

// Return a string suitable for identifying this attribute in diagnostics.
std::string getDiagnosticName(const PrintingPolicy &Policy) const {
  unsigned SpellingIndex = getSpellingListIndex();
  if (SpellingIndex == Pragma_nounroll)
    return "#pragma nounroll";
  else if (SpellingIndex == Pragma_unroll)
    return "#pragma unroll" + (option == UnrollCount ? getValueString(Policy) : "");

  assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling")(static_cast <bool> (SpellingIndex == Pragma_clang_loop
 && "Unexpected spelling") ? void (0) : __assert_fail
 ("SpellingIndex == Pragma_clang_loop && \"Unexpected spelling\""
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3859, __extension__ __PRETTY_FUNCTION__));
  return getOptionName(option) + getValueString(Policy);
}


static bool classof(const Attr *A) { return A->getKind() == attr::LoopHint; }
3865};

3867class MSABIAttr : public InheritableAttr {
3868public:
static MSABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MSABIAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

MSABIAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::MSABI, R, SI, false, false)
{
}

MSABIAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::MSABI; }
3889};

3891class MSInheritanceAttr : public InheritableAttr {
3892bool bestCase;

3894public:
enum Spelling {
  Keyword_single_inheritance = 0,
  Keyword_multiple_inheritance = 1,
  Keyword_virtual_inheritance = 2,
  Keyword_unspecified_inheritance = 3
};

static MSInheritanceAttr *CreateImplicit(ASTContext &Ctx, Spelling S, bool BestCase, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MSInheritanceAttr(Loc, Ctx, BestCase, S);
  A->setImplicit(true);
  return A;
}

MSInheritanceAttr(SourceRange R, ASTContext &Ctx
            , bool BestCase
            , unsigned SI
           )
  : InheritableAttr(attr::MSInheritance, R, SI, false, false)
            , bestCase(BestCase)
{
}

MSInheritanceAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::MSInheritance, R, SI, false, false)
            , bestCase()
{
}

MSInheritanceAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3931);
  case 0: return Keyword_single_inheritance;
  case 1: return Keyword_multiple_inheritance;
  case 2: return Keyword_virtual_inheritance;
  case 3: return Keyword_unspecified_inheritance;
}
}
bool getBestCase() const {
  return bestCase;
}

static const bool DefaultBestCase = true;


static bool hasVBPtrOffsetField(Spelling Inheritance) {
  return Inheritance == Keyword_unspecified_inheritance;
}

// Only member pointers to functions need a this adjustment, since it can be
// combined with the field offset for data pointers.
static bool hasNVOffsetField(bool IsMemberFunction, Spelling Inheritance) {
  return IsMemberFunction && Inheritance >= Keyword_multiple_inheritance;
}

static bool hasVBTableOffsetField(Spelling Inheritance) {
  return Inheritance >= Keyword_virtual_inheritance;
}

static bool hasOnlyOneField(bool IsMemberFunction,
                            Spelling Inheritance) {
  if (IsMemberFunction)
    return Inheritance <= Keyword_single_inheritance;
  return Inheritance <= Keyword_multiple_inheritance;
}


static bool classof(const Attr *A) { return A->getKind() == attr::MSInheritance; }
3968};

3970class MSNoVTableAttr : public InheritableAttr {
3971public:
static MSNoVTableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MSNoVTableAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

MSNoVTableAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::MSNoVTable, R, SI, false, false)
{
}

MSNoVTableAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::MSNoVTable; }
3992};

3994class MSP430InterruptAttr : public InheritableAttr {
3995unsigned number;

3997public:
static MSP430InterruptAttr *CreateImplicit(ASTContext &Ctx, unsigned Number, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MSP430InterruptAttr(Loc, Ctx, Number, 0);
  A->setImplicit(true);
  return A;
}

MSP430InterruptAttr(SourceRange R, ASTContext &Ctx
            , unsigned Number
            , unsigned SI
           )
  : InheritableAttr(attr::MSP430Interrupt, R, SI, false, false)
            , number(Number)
{
}

MSP430InterruptAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getNumber() const {
  return number;
}



static bool classof(const Attr *A) { return A->getKind() == attr::MSP430Interrupt; }
4024};

4026class MSStructAttr : public InheritableAttr {
4027public:
static MSStructAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MSStructAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

MSStructAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::MSStruct, R, SI, false, false)
{
}

MSStructAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::MSStruct; }
4048};

4050class MSVtorDispAttr : public InheritableAttr {
4051unsigned vdm;

4053public:
static MSVtorDispAttr *CreateImplicit(ASTContext &Ctx, unsigned Vdm, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MSVtorDispAttr(Loc, Ctx, Vdm, 0);
  A->setImplicit(true);
  return A;
}

MSVtorDispAttr(SourceRange R, ASTContext &Ctx
            , unsigned Vdm
            , unsigned SI
           )
  : InheritableAttr(attr::MSVtorDisp, R, SI, false, false)
            , vdm(Vdm)
{
}

MSVtorDispAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getVdm() const {
  return vdm;
}


enum Mode {
  Never,
  ForVBaseOverride,
  ForVFTable
};

Mode getVtorDispMode() const { return Mode(vdm); }


static bool classof(const Attr *A) { return A->getKind() == attr::MSVtorDisp; }
4088};

4090class MaxFieldAlignmentAttr : public InheritableAttr {
4091unsigned alignment;

4093public:
static MaxFieldAlignmentAttr *CreateImplicit(ASTContext &Ctx, unsigned Alignment, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MaxFieldAlignmentAttr(Loc, Ctx, Alignment, 0);
  A->setImplicit(true);
  return A;
}

MaxFieldAlignmentAttr(SourceRange R, ASTContext &Ctx
            , unsigned Alignment
            , unsigned SI
           )
  : InheritableAttr(attr::MaxFieldAlignment, R, SI, false, false)
            , alignment(Alignment)
{
}

MaxFieldAlignmentAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getAlignment() const {
  return alignment;
}



static bool classof(const Attr *A) { return A->getKind() == attr::MaxFieldAlignment; }
4120};

4122class MayAliasAttr : public InheritableAttr {
4123public:
static MayAliasAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MayAliasAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

MayAliasAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::MayAlias, R, SI, false, false)
{
}

MayAliasAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::MayAlias; }
4144};

4146class MicroMipsAttr : public InheritableAttr {
4147public:
static MicroMipsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MicroMipsAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

MicroMipsAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::MicroMips, R, SI, false, false)
{
}

MicroMipsAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::MicroMips; }
4168};

4170class MinSizeAttr : public InheritableAttr {
4171public:
static MinSizeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MinSizeAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

MinSizeAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::MinSize, R, SI, false, false)
{
}

MinSizeAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::MinSize; }
4192};

4194class Mips16Attr : public InheritableAttr {
4195public:
static Mips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) Mips16Attr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

Mips16Attr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Mips16, R, SI, false, false)
{
}

Mips16Attr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Mips16; }
4216};

4218class MipsInterruptAttr : public InheritableAttr {
4219public:
enum InterruptType {
  sw0,
  sw1,
  hw0,
  hw1,
  hw2,
  hw3,
  hw4,
  hw5,
  eic
};
4231private:
InterruptType interrupt;

4234public:
static MipsInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MipsInterruptAttr(Loc, Ctx, Interrupt, 0);
  A->setImplicit(true);
  return A;
}

MipsInterruptAttr(SourceRange R, ASTContext &Ctx
            , InterruptType Interrupt
            , unsigned SI
           )
  : InheritableAttr(attr::MipsInterrupt, R, SI, false, false)
            , interrupt(Interrupt)
{
}

MipsInterruptAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
InterruptType getInterrupt() const {
  return interrupt;
}

static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out) {
  Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val)
    .Case("vector=sw0", MipsInterruptAttr::sw0)
    .Case("vector=sw1", MipsInterruptAttr::sw1)
    .Case("vector=hw0", MipsInterruptAttr::hw0)
    .Case("vector=hw1", MipsInterruptAttr::hw1)
    .Case("vector=hw2", MipsInterruptAttr::hw2)
    .Case("vector=hw3", MipsInterruptAttr::hw3)
    .Case("vector=hw4", MipsInterruptAttr::hw4)
    .Case("vector=hw5", MipsInterruptAttr::hw5)
    .Case("eic", MipsInterruptAttr::eic)
    .Case("", MipsInterruptAttr::eic)
    .Default(Optional<InterruptType>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertInterruptTypeToStr(InterruptType Val) {
  switch(Val) {
  case MipsInterruptAttr::sw0: return "vector=sw0";
  case MipsInterruptAttr::sw1: return "vector=sw1";
  case MipsInterruptAttr::hw0: return "vector=hw0";
  case MipsInterruptAttr::hw1: return "vector=hw1";
  case MipsInterruptAttr::hw2: return "vector=hw2";
  case MipsInterruptAttr::hw3: return "vector=hw3";
  case MipsInterruptAttr::hw4: return "vector=hw4";
  case MipsInterruptAttr::hw5: return "vector=hw5";
  case MipsInterruptAttr::eic: return "eic";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4290);
}


static bool classof(const Attr *A) { return A->getKind() == attr::MipsInterrupt; }
4295};

4297class MipsLongCallAttr : public InheritableAttr {
4298public:
enum Spelling {
  GNU_long_call = 0,
  CXX11_gnu_long_call = 1,
  GNU_far = 2,
  CXX11_gnu_far = 3
};

static MipsLongCallAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MipsLongCallAttr(Loc, Ctx, S);
  A->setImplicit(true);
  return A;
}

MipsLongCallAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::MipsLongCall, R, SI, false, false)
{
}

MipsLongCallAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4325);
  case 0: return GNU_long_call;
  case 1: return CXX11_gnu_long_call;
  case 2: return GNU_far;
  case 3: return CXX11_gnu_far;
}
}


static bool classof(const Attr *A) { return A->getKind() == attr::MipsLongCall; }
4335};

4337class MipsShortCallAttr : public InheritableAttr {
4338public:
enum Spelling {
  GNU_short_call = 0,
  CXX11_gnu_short_call = 1,
  GNU_near = 2,
  CXX11_gnu_near = 3
};

static MipsShortCallAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MipsShortCallAttr(Loc, Ctx, S);
  A->setImplicit(true);
  return A;
}

MipsShortCallAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::MipsShortCall, R, SI, false, false)
{
}

MipsShortCallAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4365);
  case 0: return GNU_short_call;
  case 1: return CXX11_gnu_short_call;
  case 2: return GNU_near;
  case 3: return CXX11_gnu_near;
}
}


static bool classof(const Attr *A) { return A->getKind() == attr::MipsShortCall; }
4375};

4377class ModeAttr : public Attr {
4378IdentifierInfo * mode;

4380public:
static ModeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Mode, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ModeAttr(Loc, Ctx, Mode, 0);
  A->setImplicit(true);
  return A;
}

ModeAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * Mode
            , unsigned SI
           )
  : Attr(attr::Mode, R, SI, false)
            , mode(Mode)
{
}

ModeAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
IdentifierInfo * getMode() const {
  return mode;
}



static bool classof(const Attr *A) { return A->getKind() == attr::Mode; }
4407};

4409class NSConsumedAttr : public InheritableParamAttr {
4410public:
static NSConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NSConsumedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NSConsumedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableParamAttr(attr::NSConsumed, R, SI, false, false)
{
}

NSConsumedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumed; }
4431};

4433class NSConsumesSelfAttr : public InheritableAttr {
4434public:
static NSConsumesSelfAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NSConsumesSelfAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NSConsumesSelfAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NSConsumesSelf, R, SI, false, false)
{
}

NSConsumesSelfAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumesSelf; }
4455};

4457class NSReturnsAutoreleasedAttr : public InheritableAttr {
4458public:
static NSReturnsAutoreleasedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NSReturnsAutoreleasedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NSReturnsAutoreleasedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NSReturnsAutoreleased, R, SI, false, false)
{
}

NSReturnsAutoreleasedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsAutoreleased; }
4479};

4481class NSReturnsNotRetainedAttr : public InheritableAttr {
4482public:
static NSReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NSReturnsNotRetainedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NSReturnsNotRetainedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NSReturnsNotRetained, R, SI, false, false)
{
}

NSReturnsNotRetainedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsNotRetained; }
4503};

4505class NSReturnsRetainedAttr : public InheritableAttr {
4506public:
static NSReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NSReturnsRetainedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NSReturnsRetainedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NSReturnsRetained, R, SI, false, false)
{
}

NSReturnsRetainedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsRetained; }
4527};

4529class NakedAttr : public InheritableAttr {
4530public:
static NakedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NakedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NakedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Naked, R, SI, false, false)
{
}

NakedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Naked; }
4551};

4553class NoAliasAttr : public InheritableAttr {
4554public:
static NoAliasAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoAliasAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoAliasAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoAlias, R, SI, false, false)
{
}

NoAliasAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NoAlias; }
4575};

4577class NoCommonAttr : public InheritableAttr {
4578public:
static NoCommonAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoCommonAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoCommonAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoCommon, R, SI, false, false)
{
}

NoCommonAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NoCommon; }
4599};

4601class NoDebugAttr : public InheritableAttr {
4602public:
static NoDebugAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoDebugAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoDebugAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoDebug, R, SI, false, false)
{
}

NoDebugAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NoDebug; }
4623};

4625class NoDuplicateAttr : public InheritableAttr {
4626public:
static NoDuplicateAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoDuplicateAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoDuplicateAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoDuplicate, R, SI, false, false)
{
}

NoDuplicateAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NoDuplicate; }
4647};

4649class NoEscapeAttr : public Attr {
4650public:
static NoEscapeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoEscapeAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoEscapeAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : Attr(attr::NoEscape, R, SI, false)
{
}

NoEscapeAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NoEscape; }
4671};

4673class NoInlineAttr : public InheritableAttr {
4674public:
static NoInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoInlineAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoInlineAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoInline, R, SI, false, false)
{
}

NoInlineAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NoInline; }
4695};

4697class NoInstrumentFunctionAttr : public InheritableAttr {
4698public:
static NoInstrumentFunctionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoInstrumentFunctionAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoInstrumentFunctionAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoInstrumentFunction, R, SI, false, false)
{
}

NoInstrumentFunctionAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NoInstrumentFunction; }
4719};

4721class NoMicroMipsAttr : public InheritableAttr {
4722public:
static NoMicroMipsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoMicroMipsAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoMicroMipsAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoMicroMips, R, SI, false, false)
{
}

NoMicroMipsAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NoMicroMips; }
4743};

4745class NoMips16Attr : public InheritableAttr {
4746public:
static NoMips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoMips16Attr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoMips16Attr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoMips16, R, SI, false, false)
{
}

NoMips16Attr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NoMips16; }
4767};

4769class NoReturnAttr : public InheritableAttr {
4770public:
static NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoReturnAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoReturnAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoReturn, R, SI, false, false)
{
}

NoReturnAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NoReturn; }
4791};

4793class NoSanitizeAttr : public InheritableAttr {
unsigned sanitizers_Size;
StringRef *sanitizers_;

4797public:
static NoSanitizeAttr *CreateImplicit(ASTContext &Ctx, StringRef *Sanitizers, unsigned SanitizersSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoSanitizeAttr(Loc, Ctx, Sanitizers, SanitizersSize, 0);
  A->setImplicit(true);
  return A;
}

NoSanitizeAttr(SourceRange R, ASTContext &Ctx
            , StringRef *Sanitizers, unsigned SanitizersSize
            , unsigned SI
           )
  : InheritableAttr(attr::NoSanitize, R, SI, false, false)
            , sanitizers_Size(SanitizersSize), sanitizers_(new (Ctx, 16) StringRef[sanitizers_Size])
{
  for (size_t I = 0, E = sanitizers_Size; I != E;
       ++I) {
    StringRef Ref = Sanitizers[I];
    if (!Ref.empty()) {
      char *Mem = new (Ctx, 1) char[Ref.size()];
      std::memcpy(Mem, Ref.data(), Ref.size());
      sanitizers_[I] = StringRef(Mem, Ref.size());
    }
  }
}

NoSanitizeAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoSanitize, R, SI, false, false)
            , sanitizers_Size(0), sanitizers_(nullptr)
{
}

NoSanitizeAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef StringRef* sanitizers_iterator;
sanitizers_iterator sanitizers_begin() const { return sanitizers_; }
sanitizers_iterator sanitizers_end() const { return sanitizers_ + sanitizers_Size; }
unsigned sanitizers_size() const { return sanitizers_Size; }
llvm::iterator_range<sanitizers_iterator> sanitizers() const { return llvm::make_range(sanitizers_begin(), sanitizers_end()); }



  SanitizerMask getMask() const {
    SanitizerMask Mask = 0;
    for (auto SanitizerName : sanitizers()) {
      SanitizerMask ParsedMask =
          parseSanitizerValue(SanitizerName, /*AllowGroups=*/true);
      Mask |= expandSanitizerGroups(ParsedMask);
    }
    return Mask;
  }


static bool classof(const Attr *A) { return A->getKind() == attr::NoSanitize; }
4854};

4856class NoSplitStackAttr : public InheritableAttr {
4857public:
static NoSplitStackAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoSplitStackAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoSplitStackAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoSplitStack, R, SI, false, false)
{
}

NoSplitStackAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NoSplitStack; }
4878};

4880class NoThreadSafetyAnalysisAttr : public InheritableAttr {
4881public:
static NoThreadSafetyAnalysisAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoThreadSafetyAnalysisAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoThreadSafetyAnalysisAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoThreadSafetyAnalysis, R, SI, false, false)
{
}

NoThreadSafetyAnalysisAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NoThreadSafetyAnalysis; }
4902};

4904class NoThrowAttr : public InheritableAttr {
4905public:
static NoThrowAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoThrowAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoThrowAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoThrow, R, SI, false, false)
{
}

NoThrowAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NoThrow; }
4926};

4928class NonNullAttr : public InheritableParamAttr {
unsigned args_Size;
unsigned *args_;

4932public:
static NonNullAttr *CreateImplicit(ASTContext &Ctx, unsigned *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NonNullAttr(Loc, Ctx, Args, ArgsSize, 0);
  A->setImplicit(true);
  return A;
}

NonNullAttr(SourceRange R, ASTContext &Ctx
            , unsigned *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableParamAttr(attr::NonNull, R, SI, false, true)
            , args_Size(ArgsSize), args_(new (Ctx, 16) unsigned[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

NonNullAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableParamAttr(attr::NonNull, R, SI, false, true)
            , args_Size(0), args_(nullptr)
{
}

NonNullAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef unsigned* args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }


4968bool isNonNull(unsigned idx) const {
  if (!args_size())
    return true;
  for (const auto &V : args())
    if (V == idx)
      return true;
  return false;
} 

static bool classof(const Attr *A) { return A->getKind() == attr::NonNull; }
4978};

4980class NotTailCalledAttr : public InheritableAttr {
4981public:
static NotTailCalledAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NotTailCalledAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NotTailCalledAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NotTailCalled, R, SI, false, false)
{
}

NotTailCalledAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::NotTailCalled; }
5002};

5004class OMPCaptureKindAttr : public Attr {
5005unsigned captureKind;

5007public:
static OMPCaptureKindAttr *CreateImplicit(ASTContext &Ctx, unsigned CaptureKind, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OMPCaptureKindAttr(Loc, Ctx, CaptureKind, 0);
  A->setImplicit(true);
  return A;
}

OMPCaptureKindAttr(SourceRange R, ASTContext &Ctx
            , unsigned CaptureKind
            , unsigned SI
           )
  : Attr(attr::OMPCaptureKind, R, SI, false)
            , captureKind(CaptureKind)
{
}

OMPCaptureKindAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getCaptureKind() const {
  return captureKind;
}



static bool classof(const Attr *A) { return A->getKind() == attr::OMPCaptureKind; }
5034};

5036class OMPCaptureNoInitAttr : public InheritableAttr {
5037public:
static OMPCaptureNoInitAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OMPCaptureNoInitAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

OMPCaptureNoInitAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::OMPCaptureNoInit, R, SI, false, false)
{
}

OMPCaptureNoInitAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::OMPCaptureNoInit; }
5058};

5060class OMPDeclareSimdDeclAttr : public Attr {
5061public:
enum BranchStateTy {
  BS_Undefined,
  BS_Inbranch,
  BS_Notinbranch
};
5067private:
BranchStateTy branchState;

5070Expr * simdlen;

unsigned uniforms_Size;
Expr * *uniforms_;

unsigned aligneds_Size;
Expr * *aligneds_;

unsigned alignments_Size;
Expr * *alignments_;

unsigned linears_Size;
Expr * *linears_;

unsigned modifiers_Size;
unsigned *modifiers_;

unsigned steps_Size;
Expr * *steps_;

5090public:
static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OMPDeclareSimdDeclAttr(Loc, Ctx, BranchState, Simdlen, Uniforms, UniformsSize, Aligneds, AlignedsSize, Alignments, AlignmentsSize, Linears, LinearsSize, Modifiers, ModifiersSize, Steps, StepsSize, 0);
  A->setImplicit(true);
  return A;
}

OMPDeclareSimdDeclAttr(SourceRange R, ASTContext &Ctx
            , BranchStateTy BranchState
            , Expr * Simdlen
            , Expr * *Uniforms, unsigned UniformsSize
            , Expr * *Aligneds, unsigned AlignedsSize
            , Expr * *Alignments, unsigned AlignmentsSize
            , Expr * *Linears, unsigned LinearsSize
            , unsigned *Modifiers, unsigned ModifiersSize
            , Expr * *Steps, unsigned StepsSize
            , unsigned SI
           )
  : Attr(attr::OMPDeclareSimdDecl, R, SI, false)
            , branchState(BranchState)
            , simdlen(Simdlen)
            , uniforms_Size(UniformsSize), uniforms_(new (Ctx, 16) Expr *[uniforms_Size])
            , aligneds_Size(AlignedsSize), aligneds_(new (Ctx, 16) Expr *[aligneds_Size])
            , alignments_Size(AlignmentsSize), alignments_(new (Ctx, 16) Expr *[alignments_Size])
            , linears_Size(LinearsSize), linears_(new (Ctx, 16) Expr *[linears_Size])
            , modifiers_Size(ModifiersSize), modifiers_(new (Ctx, 16) unsigned[modifiers_Size])
            , steps_Size(StepsSize), steps_(new (Ctx, 16) Expr *[steps_Size])
{
  std::copy(Uniforms, Uniforms + uniforms_Size, uniforms_);
  std::copy(Aligneds, Aligneds + aligneds_Size, aligneds_);
  std::copy(Alignments, Alignments + alignments_Size, alignments_);
  std::copy(Linears, Linears + linears_Size, linears_);
  std::copy(Modifiers, Modifiers + modifiers_Size, modifiers_);
  std::copy(Steps, Steps + steps_Size, steps_);
}

OMPDeclareSimdDeclAttr(SourceRange R, ASTContext &Ctx
            , BranchStateTy BranchState
            , Expr * Simdlen
            , unsigned SI
           )
  : Attr(attr::OMPDeclareSimdDecl, R, SI, false)
            , branchState(BranchState)
            , simdlen(Simdlen)
            , uniforms_Size(0), uniforms_(nullptr)
            , aligneds_Size(0), aligneds_(nullptr)
            , alignments_Size(0), alignments_(nullptr)
            , linears_Size(0), linears_(nullptr)
            , modifiers_Size(0), modifiers_(nullptr)
            , steps_Size(0), steps_(nullptr)
{
}

OMPDeclareSimdDeclAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
BranchStateTy getBranchState() const {
  return branchState;
}

static bool ConvertStrToBranchStateTy(StringRef Val, BranchStateTy &Out) {
  Optional<BranchStateTy> R = llvm::StringSwitch<Optional<BranchStateTy>>(Val)
    .Case("", OMPDeclareSimdDeclAttr::BS_Undefined)
    .Case("inbranch", OMPDeclareSimdDeclAttr::BS_Inbranch)
    .Case("notinbranch", OMPDeclareSimdDeclAttr::BS_Notinbranch)
    .Default(Optional<BranchStateTy>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertBranchStateTyToStr(BranchStateTy Val) {
  switch(Val) {
  case OMPDeclareSimdDeclAttr::BS_Undefined: return "";
  case OMPDeclareSimdDeclAttr::BS_Inbranch: return "inbranch";
  case OMPDeclareSimdDeclAttr::BS_Notinbranch: return "notinbranch";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 5170);
}
Expr * getSimdlen() const {
  return simdlen;
}

typedef Expr ** uniforms_iterator;
uniforms_iterator uniforms_begin() const { return uniforms_; }
uniforms_iterator uniforms_end() const { return uniforms_ + uniforms_Size; }
unsigned uniforms_size() const { return uniforms_Size; }
llvm::iterator_range<uniforms_iterator> uniforms() const { return llvm::make_range(uniforms_begin(), uniforms_end()); }


typedef Expr ** aligneds_iterator;
aligneds_iterator aligneds_begin() const { return aligneds_; }
aligneds_iterator aligneds_end() const { return aligneds_ + aligneds_Size; }
unsigned aligneds_size() const { return aligneds_Size; }
llvm::iterator_range<aligneds_iterator> aligneds() const { return llvm::make_range(aligneds_begin(), aligneds_end()); }


typedef Expr ** alignments_iterator;
alignments_iterator alignments_begin() const { return alignments_; }
alignments_iterator alignments_end() const { return alignments_ + alignments_Size; }
unsigned alignments_size() const { return alignments_Size; }
llvm::iterator_range<alignments_iterator> alignments() const { return llvm::make_range(alignments_begin(), alignments_end()); }


typedef Expr ** linears_iterator;
linears_iterator linears_begin() const { return linears_; }
linears_iterator linears_end() const { return linears_ + linears_Size; }
unsigned linears_size() const { return linears_Size; }
llvm::iterator_range<linears_iterator> linears() const { return llvm::make_range(linears_begin(), linears_end()); }


typedef unsigned* modifiers_iterator;
modifiers_iterator modifiers_begin() const { return modifiers_; }
modifiers_iterator modifiers_end() const { return modifiers_ + modifiers_Size; }
unsigned modifiers_size() const { return modifiers_Size; }
llvm::iterator_range<modifiers_iterator> modifiers() const { return llvm::make_range(modifiers_begin(), modifiers_end()); }


typedef Expr ** steps_iterator;
steps_iterator steps_begin() const { return steps_; }
steps_iterator steps_end() const { return steps_ + steps_Size; }
unsigned steps_size() const { return steps_Size; }
llvm::iterator_range<steps_iterator> steps() const { return llvm::make_range(steps_begin(), steps_end()); }



  void printPrettyPragma(raw_ostream & OS, const PrintingPolicy &Policy)
      const {
    if (getBranchState() != BS_Undefined)
      OS << ' ' << ConvertBranchStateTyToStr(getBranchState());
    if (auto *E = getSimdlen()) {
      OS << " simdlen(";
      E->printPretty(OS, nullptr, Policy);
      OS << ")";
    }
    if (uniforms_size() > 0) {
      OS << " uniform";
      StringRef Sep = "(";
      for (auto *E : uniforms()) {
        OS << Sep;
        E->printPretty(OS, nullptr, Policy);
        Sep = ", ";
      }
      OS << ")";
    }
    alignments_iterator NI = alignments_begin();
    for (auto *E : aligneds()) {
      OS << " aligned(";
      E->printPretty(OS, nullptr, Policy);
      if (*NI) {
        OS << ": ";
        (*NI)->printPretty(OS, nullptr, Policy);
      }
      OS << ")";
      ++NI;
    }
    steps_iterator I = steps_begin();
    modifiers_iterator MI = modifiers_begin();
    for (auto *E : linears()) {
      OS << " linear(";
      if (*MI != OMPC_LINEAR_unknown)
        OS << getOpenMPSimpleClauseTypeName(OMPC_linear, *MI) << "(";
      E->printPretty(OS, nullptr, Policy);
      if (*MI != OMPC_LINEAR_unknown)
        OS << ")";
      if (*I) {
        OS << ": ";
        (*I)->printPretty(OS, nullptr, Policy);
      }
      OS << ")";
      ++I;
      ++MI;
    }
  }


static bool classof(const Attr *A) { return A->getKind() == attr::OMPDeclareSimdDecl; }
5270};

5272class OMPDeclareTargetDeclAttr : public Attr {
5273public:
enum MapTypeTy {
  MT_To,
  MT_Link
};
5278private:
MapTypeTy mapType;

5281public:
static OMPDeclareTargetDeclAttr *CreateImplicit(ASTContext &Ctx, MapTypeTy MapType, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OMPDeclareTargetDeclAttr(Loc, Ctx, MapType, 0);
  A->setImplicit(true);
  return A;
}

OMPDeclareTargetDeclAttr(SourceRange R, ASTContext &Ctx
            , MapTypeTy MapType
            , unsigned SI
           )
  : Attr(attr::OMPDeclareTargetDecl, R, SI, false)
            , mapType(MapType)
{
}

OMPDeclareTargetDeclAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
MapTypeTy getMapType() const {
  return mapType;
}

static bool ConvertStrToMapTypeTy(StringRef Val, MapTypeTy &Out) {
  Optional<MapTypeTy> R = llvm::StringSwitch<Optional<MapTypeTy>>(Val)
    .Case("to", OMPDeclareTargetDeclAttr::MT_To)
    .Case("link", OMPDeclareTargetDeclAttr::MT_Link)
    .Default(Optional<MapTypeTy>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertMapTypeTyToStr(MapTypeTy Val) {
  switch(Val) {
  case OMPDeclareTargetDeclAttr::MT_To: return "to";
  case OMPDeclareTargetDeclAttr::MT_Link: return "link";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 5322);
}

  void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
    // Use fake syntax because it is for testing and debugging purpose only.
    if (getMapType() != MT_To)
      OS << ' ' << ConvertMapTypeTyToStr(getMapType());
  }


static bool classof(const Attr *A) { return A->getKind() == attr::OMPDeclareTargetDecl; }
5333};

5335class OMPThreadPrivateDeclAttr : public InheritableAttr {
5336public:
static OMPThreadPrivateDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OMPThreadPrivateDeclAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

OMPThreadPrivateDeclAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::OMPThreadPrivateDecl, R, SI, false, false)
{
}

OMPThreadPrivateDeclAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::OMPThreadPrivateDecl; }
5357};

5359class ObjCBoxableAttr : public Attr {
5360public:
static ObjCBoxableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCBoxableAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCBoxableAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : Attr(attr::ObjCBoxable, R, SI, false)
{
}

ObjCBoxableAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBoxable; }
5381};

5383class ObjCBridgeAttr : public InheritableAttr {
5384IdentifierInfo * bridgedType;

5386public:
static ObjCBridgeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCBridgeAttr(Loc, Ctx, BridgedType, 0);
  A->setImplicit(true);
  return A;
}

ObjCBridgeAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * BridgedType
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCBridge, R, SI, false, false)
            , bridgedType(BridgedType)
{
}

ObjCBridgeAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
IdentifierInfo * getBridgedType() const {
  return bridgedType;
}



static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridge; }
5413};

5415class ObjCBridgeMutableAttr : public InheritableAttr {
5416IdentifierInfo * bridgedType;

5418public:
static ObjCBridgeMutableAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCBridgeMutableAttr(Loc, Ctx, BridgedType, 0);
  A->setImplicit(true);
  return A;
}

ObjCBridgeMutableAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * BridgedType
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCBridgeMutable, R, SI, false, false)
            , bridgedType(BridgedType)
{
}

ObjCBridgeMutableAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
IdentifierInfo * getBridgedType() const {
  return bridgedType;
}



static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridgeMutable; }
5445};

5447class ObjCBridgeRelatedAttr : public InheritableAttr {
5448IdentifierInfo * relatedClass;

5450IdentifierInfo * classMethod;

5452IdentifierInfo * instanceMethod;

5454public:
static ObjCBridgeRelatedAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * RelatedClass, IdentifierInfo * ClassMethod, IdentifierInfo * InstanceMethod, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCBridgeRelatedAttr(Loc, Ctx, RelatedClass, ClassMethod, InstanceMethod, 0);
  A->setImplicit(true);
  return A;
}

ObjCBridgeRelatedAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * RelatedClass
            , IdentifierInfo * ClassMethod
            , IdentifierInfo * InstanceMethod
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCBridgeRelated, R, SI, false, false)
            , relatedClass(RelatedClass)
            , classMethod(ClassMethod)
            , instanceMethod(InstanceMethod)
{
}

ObjCBridgeRelatedAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * RelatedClass
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCBridgeRelated, R, SI, false, false)
            , relatedClass(RelatedClass)
            , classMethod()
            , instanceMethod()
{
}

ObjCBridgeRelatedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
IdentifierInfo * getRelatedClass() const {
  return relatedClass;
}

IdentifierInfo * getClassMethod() const {
  return classMethod;
}

IdentifierInfo * getInstanceMethod() const {
  return instanceMethod;
}



static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridgeRelated; }
5504};

5506class ObjCDesignatedInitializerAttr : public Attr {
5507public:
static ObjCDesignatedInitializerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCDesignatedInitializerAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCDesignatedInitializerAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : Attr(attr::ObjCDesignatedInitializer, R, SI, false)
{
}

ObjCDesignatedInitializerAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCDesignatedInitializer; }
5528};

5530class ObjCExceptionAttr : public InheritableAttr {
5531public:
static ObjCExceptionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCExceptionAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCExceptionAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCException, R, SI, false, false)
{
}

ObjCExceptionAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCException; }
5552};

5554class ObjCExplicitProtocolImplAttr : public InheritableAttr {
5555public:
static ObjCExplicitProtocolImplAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCExplicitProtocolImplAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCExplicitProtocolImplAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCExplicitProtocolImpl, R, SI, false, false)
{
}

ObjCExplicitProtocolImplAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCExplicitProtocolImpl; }
5576};

5578class ObjCIndependentClassAttr : public InheritableAttr {
5579public:
static ObjCIndependentClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCIndependentClassAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCIndependentClassAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCIndependentClass, R, SI, false, false)
{
}

ObjCIndependentClassAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCIndependentClass; }
5600};

5602class ObjCMethodFamilyAttr : public InheritableAttr {
5603public:
enum FamilyKind {
  OMF_None,
  OMF_alloc,
  OMF_copy,
  OMF_init,
  OMF_mutableCopy,
  OMF_new
};
5612private:
FamilyKind family;

5615public:
static ObjCMethodFamilyAttr *CreateImplicit(ASTContext &Ctx, FamilyKind Family, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCMethodFamilyAttr(Loc, Ctx, Family, 0);
  A->setImplicit(true);
  return A;
}

ObjCMethodFamilyAttr(SourceRange R, ASTContext &Ctx
            , FamilyKind Family
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCMethodFamily, R, SI, false, false)
            , family(Family)
{
}

ObjCMethodFamilyAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
FamilyKind getFamily() const {
  return family;
}

static bool ConvertStrToFamilyKind(StringRef Val, FamilyKind &Out) {
  Optional<FamilyKind> R = llvm::StringSwitch<Optional<FamilyKind>>(Val)
    .Case("none", ObjCMethodFamilyAttr::OMF_None)
    .Case("alloc", ObjCMethodFamilyAttr::OMF_alloc)
    .Case("copy", ObjCMethodFamilyAttr::OMF_copy)
    .Case("init", ObjCMethodFamilyAttr::OMF_init)
    .Case("mutableCopy", ObjCMethodFamilyAttr::OMF_mutableCopy)
    .Case("new", ObjCMethodFamilyAttr::OMF_new)
    .Default(Optional<FamilyKind>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertFamilyKindToStr(FamilyKind Val) {
  switch(Val) {
  case ObjCMethodFamilyAttr::OMF_None: return "none";
  case ObjCMethodFamilyAttr::OMF_alloc: return "alloc";
  case ObjCMethodFamilyAttr::OMF_copy: return "copy";
  case ObjCMethodFamilyAttr::OMF_init: return "init";
  case ObjCMethodFamilyAttr::OMF_mutableCopy: return "mutableCopy";
  case ObjCMethodFamilyAttr::OMF_new: return "new";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 5664);
}


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCMethodFamily; }
5669};

5671class ObjCNSObjectAttr : public InheritableAttr {
5672public:
static ObjCNSObjectAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCNSObjectAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCNSObjectAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCNSObject, R, SI, false, false)
{
}

ObjCNSObjectAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCNSObject; }
5693};

5695class ObjCPreciseLifetimeAttr : public InheritableAttr {
5696public:
static ObjCPreciseLifetimeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCPreciseLifetimeAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCPreciseLifetimeAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCPreciseLifetime, R, SI, false, false)
{
}

ObjCPreciseLifetimeAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCPreciseLifetime; }
5717};

5719class ObjCRequiresPropertyDefsAttr : public InheritableAttr {
5720public:
static ObjCRequiresPropertyDefsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCRequiresPropertyDefsAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCRequiresPropertyDefsAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCRequiresPropertyDefs, R, SI, false, false)
{
}

ObjCRequiresPropertyDefsAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRequiresPropertyDefs; }
5741};

5743class ObjCRequiresSuperAttr : public InheritableAttr {
5744public:
static ObjCRequiresSuperAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCRequiresSuperAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCRequiresSuperAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCRequiresSuper, R, SI, false, false)
{
}

ObjCRequiresSuperAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRequiresSuper; }
5765};

5767class ObjCReturnsInnerPointerAttr : public InheritableAttr {
5768public:
static ObjCReturnsInnerPointerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCReturnsInnerPointerAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCReturnsInnerPointerAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCReturnsInnerPointer, R, SI, false, false)
{
}

ObjCReturnsInnerPointerAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCReturnsInnerPointer; }
5789};

5791class ObjCRootClassAttr : public InheritableAttr {
5792public:
static ObjCRootClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCRootClassAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCRootClassAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCRootClass, R, SI, false, false)
{
}

ObjCRootClassAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRootClass; }
5813};

5815class ObjCRuntimeNameAttr : public Attr {
5816unsigned metadataNameLength;
5817char *metadataName;

5819public:
static ObjCRuntimeNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef MetadataName, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCRuntimeNameAttr(Loc, Ctx, MetadataName, 0);
  A->setImplicit(true);
  return A;
}

ObjCRuntimeNameAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef MetadataName
            , unsigned SI
           )
  : Attr(attr::ObjCRuntimeName, R, SI, false)
            , metadataNameLength(MetadataName.size()),metadataName(new (Ctx, 1) char[metadataNameLength])
{
    if (!MetadataName.empty())
      std::memcpy(metadataName, MetadataName.data(), metadataNameLength);
}

ObjCRuntimeNameAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getMetadataName() const {
  return llvm::StringRef(metadataName, metadataNameLength);
}
unsigned getMetadataNameLength() const {
  return metadataNameLength;
}
void setMetadataName(ASTContext &C, llvm::StringRef S) {
  metadataNameLength = S.size();
  this->metadataName = new (C, 1) char [metadataNameLength];
  if (!S.empty())
    std::memcpy(this->metadataName, S.data(), metadataNameLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRuntimeName; }
5857};

5859class ObjCRuntimeVisibleAttr : public Attr {
5860public:
static ObjCRuntimeVisibleAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCRuntimeVisibleAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCRuntimeVisibleAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : Attr(attr::ObjCRuntimeVisible, R, SI, false)
{
}

ObjCRuntimeVisibleAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRuntimeVisible; }
5881};

5883class ObjCSubclassingRestrictedAttr : public InheritableAttr {
5884public:
static ObjCSubclassingRestrictedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCSubclassingRestrictedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCSubclassingRestrictedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCSubclassingRestricted, R, SI, false, false)
{
}

ObjCSubclassingRestrictedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCSubclassingRestricted; }
5905};

5907class OpenCLAccessAttr : public Attr {
5908public:
enum Spelling {
  Keyword_read_only = 0,
  Keyword_write_only = 2,
  Keyword_read_write = 4
};

static OpenCLAccessAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OpenCLAccessAttr(Loc, Ctx, S);
  A->setImplicit(true);
  return A;
}

OpenCLAccessAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : Attr(attr::OpenCLAccess, R, SI, false)
{
}

OpenCLAccessAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 5934);
  case 0: return Keyword_read_only;
  case 1: return Keyword_read_only;
  case 2: return Keyword_write_only;
  case 3: return Keyword_write_only;
  case 4: return Keyword_read_write;
  case 5: return Keyword_read_write;
}
}
bool isReadOnly() const { return SpellingListIndex == 0 ||
  SpellingListIndex == 1; }
bool isReadWrite() const { return SpellingListIndex == 4 ||
  SpellingListIndex == 5; }
bool isWriteOnly() const { return SpellingListIndex == 2 ||
  SpellingListIndex == 3; }


static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLAccess; }
5952};

5954class OpenCLIntelReqdSubGroupSizeAttr : public InheritableAttr {
5955unsigned subGroupSize;

5957public:
static OpenCLIntelReqdSubGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned SubGroupSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OpenCLIntelReqdSubGroupSizeAttr(Loc, Ctx, SubGroupSize, 0);
  A->setImplicit(true);
  return A;
}

OpenCLIntelReqdSubGroupSizeAttr(SourceRange R, ASTContext &Ctx
            , unsigned SubGroupSize
            , unsigned SI
           )
  : InheritableAttr(attr::OpenCLIntelReqdSubGroupSize, R, SI, false, false)
            , subGroupSize(SubGroupSize)
{
}

OpenCLIntelReqdSubGroupSizeAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getSubGroupSize() const {
  return subGroupSize;
}



static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLIntelReqdSubGroupSize; }
5984};

5986class OpenCLKernelAttr : public InheritableAttr {
5987public:
static OpenCLKernelAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OpenCLKernelAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

OpenCLKernelAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::OpenCLKernel, R, SI, false, false)
{
}

OpenCLKernelAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLKernel; }
6008};

6010class OpenCLUnrollHintAttr : public InheritableAttr {
6011unsigned unrollHint;

6013public:
static OpenCLUnrollHintAttr *CreateImplicit(ASTContext &Ctx, unsigned UnrollHint, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OpenCLUnrollHintAttr(Loc, Ctx, UnrollHint, 0);
  A->setImplicit(true);
  return A;
}

OpenCLUnrollHintAttr(SourceRange R, ASTContext &Ctx
            , unsigned UnrollHint
            , unsigned SI
           )
  : InheritableAttr(attr::OpenCLUnrollHint, R, SI, false, false)
            , unrollHint(UnrollHint)
{
}

OpenCLUnrollHintAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getUnrollHint() const {
  return unrollHint;
}



static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLUnrollHint; }
6040};

6042class OptimizeNoneAttr : public InheritableAttr {
6043public:
static OptimizeNoneAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OptimizeNoneAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

OptimizeNoneAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::OptimizeNone, R, SI, false, false)
{
}

OptimizeNoneAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::OptimizeNone; }
6064};

6066class OverloadableAttr : public Attr {
6067public:
static OverloadableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OverloadableAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

OverloadableAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : Attr(attr::Overloadable, R, SI, false)
{
}

OverloadableAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Overloadable; }
6088};

6090class OverrideAttr : public InheritableAttr {
6091public:
static OverrideAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OverrideAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

OverrideAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Override, R, SI, false, false)
{
}

OverrideAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Override; }
6112};

6114class OwnershipAttr : public InheritableAttr {
6115IdentifierInfo * module;

unsigned args_Size;
unsigned *args_;

6120public:
enum Spelling {
  GNU_ownership_holds = 0,
  CXX11_clang_ownership_holds = 1,
  C2x_clang_ownership_holds = 2,
  GNU_ownership_returns = 3,
  CXX11_clang_ownership_returns = 4,
  C2x_clang_ownership_returns = 5,
  GNU_ownership_takes = 6,
  CXX11_clang_ownership_takes = 7,
  C2x_clang_ownership_takes = 8
};

static OwnershipAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * Module, unsigned *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OwnershipAttr(Loc, Ctx, Module, Args, ArgsSize, S);
  A->setImplicit(true);
  return A;
}

OwnershipAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * Module
            , unsigned *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::Ownership, R, SI, false, false)
            , module(Module)
            , args_Size(ArgsSize), args_(new (Ctx, 16) unsigned[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

OwnershipAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * Module
            , unsigned SI
           )
  : InheritableAttr(attr::Ownership, R, SI, false, false)
            , module(Module)
            , args_Size(0), args_(nullptr)
{
}

OwnershipAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6167);
  case 0: return GNU_ownership_holds;
  case 1: return CXX11_clang_ownership_holds;
  case 2: return C2x_clang_ownership_holds;
  case 3: return GNU_ownership_returns;
  case 4: return CXX11_clang_ownership_returns;
  case 5: return C2x_clang_ownership_returns;
  case 6: return GNU_ownership_takes;
  case 7: return CXX11_clang_ownership_takes;
  case 8: return C2x_clang_ownership_takes;
}
}
bool isHolds() const { return SpellingListIndex == 0 ||
  SpellingListIndex == 1 ||
  SpellingListIndex == 2; }
bool isReturns() const { return SpellingListIndex == 3 ||
  SpellingListIndex == 4 ||
  SpellingListIndex == 5; }
bool isTakes() const { return SpellingListIndex == 6 ||
  SpellingListIndex == 7 ||
  SpellingListIndex == 8; }
IdentifierInfo * getModule() const {
  return module;
}

typedef unsigned* args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }



  enum OwnershipKind { Holds, Returns, Takes };
  OwnershipKind getOwnKind() const {
    return isHolds() ? Holds :
           isTakes() ? Takes :
           Returns;
  }


static bool classof(const Attr *A) { return A->getKind() == attr::Ownership; }
6209};

6211class PackedAttr : public InheritableAttr {
6212public:
static PackedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PackedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

PackedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Packed, R, SI, false, false)
{
}

PackedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Packed; }
6233};

6235class ParamTypestateAttr : public InheritableAttr {
6236public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
6242private:
ConsumedState paramState;

6245public:
static ParamTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState ParamState, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ParamTypestateAttr(Loc, Ctx, ParamState, 0);
  A->setImplicit(true);
  return A;
}

ParamTypestateAttr(SourceRange R, ASTContext &Ctx
            , ConsumedState ParamState
            , unsigned SI
           )
  : InheritableAttr(attr::ParamTypestate, R, SI, false, false)
            , paramState(ParamState)
{
}

ParamTypestateAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
ConsumedState getParamState() const {
  return paramState;
}

static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
  Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
    .Case("unknown", ParamTypestateAttr::Unknown)
    .Case("consumed", ParamTypestateAttr::Consumed)
    .Case("unconsumed", ParamTypestateAttr::Unconsumed)
    .Default(Optional<ConsumedState>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertConsumedStateToStr(ConsumedState Val) {
  switch(Val) {
  case ParamTypestateAttr::Unknown: return "unknown";
  case ParamTypestateAttr::Consumed: return "consumed";
  case ParamTypestateAttr::Unconsumed: return "unconsumed";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6288);
}


static bool classof(const Attr *A) { return A->getKind() == attr::ParamTypestate; }
6293};

6295class PascalAttr : public InheritableAttr {
6296public:
static PascalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PascalAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

PascalAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Pascal, R, SI, false, false)
{
}

PascalAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Pascal; }
6317};

6319class PassObjectSizeAttr : public InheritableParamAttr {
6320int type;

6322public:
static PassObjectSizeAttr *CreateImplicit(ASTContext &Ctx, int Type, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PassObjectSizeAttr(Loc, Ctx, Type, 0);
  A->setImplicit(true);
  return A;
}

PassObjectSizeAttr(SourceRange R, ASTContext &Ctx
            , int Type
            , unsigned SI
           )
  : InheritableParamAttr(attr::PassObjectSize, R, SI, false, false)
            , type(Type)
{
}

PassObjectSizeAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
int getType() const {
  return type;
}



static bool classof(const Attr *A) { return A->getKind() == attr::PassObjectSize; }
6349};

6351class PcsAttr : public InheritableAttr {
6352public:
enum PCSType {
  AAPCS,
  AAPCS_VFP
};
6357private:
PCSType pCS;

6360public:
static PcsAttr *CreateImplicit(ASTContext &Ctx, PCSType PCS, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PcsAttr(Loc, Ctx, PCS, 0);
  A->setImplicit(true);
  return A;
}

PcsAttr(SourceRange R, ASTContext &Ctx
            , PCSType PCS
            , unsigned SI
           )
  : InheritableAttr(attr::Pcs, R, SI, false, false)
            , pCS(PCS)
{
}

PcsAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
PCSType getPCS() const {
  return pCS;
}

static bool ConvertStrToPCSType(StringRef Val, PCSType &Out) {
  Optional<PCSType> R = llvm::StringSwitch<Optional<PCSType>>(Val)
    .Case("aapcs", PcsAttr::AAPCS)
    .Case("aapcs-vfp", PcsAttr::AAPCS_VFP)
    .Default(Optional<PCSType>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertPCSTypeToStr(PCSType Val) {
  switch(Val) {
  case PcsAttr::AAPCS: return "aapcs";
  case PcsAttr::AAPCS_VFP: return "aapcs-vfp";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6401);
}


static bool classof(const Attr *A) { return A->getKind() == attr::Pcs; }
6406};

6408class PragmaClangBSSSectionAttr : public InheritableAttr {
6409unsigned nameLength;
6410char *name;

6412public:
static PragmaClangBSSSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PragmaClangBSSSectionAttr(Loc, Ctx, Name, 0);
  A->setImplicit(true);
  return A;
}

PragmaClangBSSSectionAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Name
            , unsigned SI
           )
  : InheritableAttr(attr::PragmaClangBSSSection, R, SI, false, false)
            , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
{
    if (!Name.empty())
      std::memcpy(name, Name.data(), nameLength);
}

PragmaClangBSSSectionAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getName() const {
  return llvm::StringRef(name, nameLength);
}
unsigned getNameLength() const {
  return nameLength;
}
void setName(ASTContext &C, llvm::StringRef S) {
  nameLength = S.size();
  this->name = new (C, 1) char [nameLength];
  if (!S.empty())
    std::memcpy(this->name, S.data(), nameLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangBSSSection; }
6450};

6452class PragmaClangDataSectionAttr : public InheritableAttr {
6453unsigned nameLength;
6454char *name;

6456public:
static PragmaClangDataSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PragmaClangDataSectionAttr(Loc, Ctx, Name, 0);
  A->setImplicit(true);
  return A;
}

PragmaClangDataSectionAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Name
            , unsigned SI
           )
  : InheritableAttr(attr::PragmaClangDataSection, R, SI, false, false)
            , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
{
    if (!Name.empty())
      std::memcpy(name, Name.data(), nameLength);
}

PragmaClangDataSectionAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getName() const {
  return llvm::StringRef(name, nameLength);
}
unsigned getNameLength() const {
  return nameLength;
}
void setName(ASTContext &C, llvm::StringRef S) {
  nameLength = S.size();
  this->name = new (C, 1) char [nameLength];
  if (!S.empty())
    std::memcpy(this->name, S.data(), nameLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangDataSection; }
6494};

6496class PragmaClangRodataSectionAttr : public InheritableAttr {
6497unsigned nameLength;
6498char *name;

6500public:
static PragmaClangRodataSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PragmaClangRodataSectionAttr(Loc, Ctx, Name, 0);
  A->setImplicit(true);
  return A;
}

PragmaClangRodataSectionAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Name
            , unsigned SI
           )
  : InheritableAttr(attr::PragmaClangRodataSection, R, SI, false, false)
            , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
{
    if (!Name.empty())
      std::memcpy(name, Name.data(), nameLength);
}

PragmaClangRodataSectionAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getName() const {
  return llvm::StringRef(name, nameLength);
}
unsigned getNameLength() const {
  return nameLength;
}
void setName(ASTContext &C, llvm::StringRef S) {
  nameLength = S.size();
  this->name = new (C, 1) char [nameLength];
  if (!S.empty())
    std::memcpy(this->name, S.data(), nameLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangRodataSection; }
6538};

6540class PragmaClangTextSectionAttr : public InheritableAttr {
6541unsigned nameLength;
6542char *name;

6544public:
static PragmaClangTextSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PragmaClangTextSectionAttr(Loc, Ctx, Name, 0);
  A->setImplicit(true);
  return A;
}

PragmaClangTextSectionAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Name
            , unsigned SI
           )
  : InheritableAttr(attr::PragmaClangTextSection, R, SI, false, false)
            , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
{
    if (!Name.empty())
      std::memcpy(name, Name.data(), nameLength);
}

PragmaClangTextSectionAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getName() const {
  return llvm::StringRef(name, nameLength);
}
unsigned getNameLength() const {
  return nameLength;
}
void setName(ASTContext &C, llvm::StringRef S) {
  nameLength = S.size();
  this->name = new (C, 1) char [nameLength];
  if (!S.empty())
    std::memcpy(this->name, S.data(), nameLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangTextSection; }
6582};

6584class PreserveAllAttr : public InheritableAttr {
6585public:
static PreserveAllAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PreserveAllAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

PreserveAllAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::PreserveAll, R, SI, false, false)
{
}

PreserveAllAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::PreserveAll; }
6606};

6608class PreserveMostAttr : public InheritableAttr {
6609public:
static PreserveMostAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PreserveMostAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

PreserveMostAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::PreserveMost, R, SI, false, false)
{
}

PreserveMostAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::PreserveMost; }
6630};

6632class PtGuardedByAttr : public InheritableAttr {
6633Expr * arg;

6635public:
static PtGuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PtGuardedByAttr(Loc, Ctx, Arg, 0);
  A->setImplicit(true);
  return A;
}

PtGuardedByAttr(SourceRange R, ASTContext &Ctx
            , Expr * Arg
            , unsigned SI
           )
  : InheritableAttr(attr::PtGuardedBy, R, SI, true, true)
            , arg(Arg)
{
}

PtGuardedByAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Expr * getArg() const {
  return arg;
}



static bool classof(const Attr *A) { return A->getKind() == attr::PtGuardedBy; }
6662};

6664class PtGuardedVarAttr : public InheritableAttr {
6665public:
static PtGuardedVarAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PtGuardedVarAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

PtGuardedVarAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::PtGuardedVar, R, SI, false, false)
{
}

PtGuardedVarAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::PtGuardedVar; }
6686};

6688class PureAttr : public InheritableAttr {
6689public:
static PureAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PureAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

PureAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Pure, R, SI, false, false)
{
}

PureAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Pure; }
6710};

6712class RegCallAttr : public InheritableAttr {
6713public:
static RegCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) RegCallAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

RegCallAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::RegCall, R, SI, false, false)
{
}

RegCallAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::RegCall; }
6734};

6736class ReleaseCapabilityAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

6740public:
enum Spelling {
  GNU_release_capability = 0,
  CXX11_clang_release_capability = 1,
  GNU_release_shared_capability = 2,
  CXX11_clang_release_shared_capability = 3,
  GNU_release_generic_capability = 4,
  CXX11_clang_release_generic_capability = 5,
  GNU_unlock_function = 6,
  CXX11_clang_unlock_function = 7
};

static ReleaseCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ReleaseCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
  A->setImplicit(true);
  return A;
}

ReleaseCapabilityAttr(SourceRange R, ASTContext &Ctx
            , Expr * *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::ReleaseCapability, R, SI, true, true)
            , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

ReleaseCapabilityAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ReleaseCapability, R, SI, true, true)
            , args_Size(0), args_(nullptr)
{
}

ReleaseCapabilityAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6782);
  case 0: return GNU_release_capability;
  case 1: return CXX11_clang_release_capability;
  case 2: return GNU_release_shared_capability;
  case 3: return CXX11_clang_release_shared_capability;
  case 4: return GNU_release_generic_capability;
  case 5: return CXX11_clang_release_generic_capability;
  case 6: return GNU_unlock_function;
  case 7: return CXX11_clang_unlock_function;
}
}
bool isShared() const { return SpellingListIndex == 2 ||
  SpellingListIndex == 3; }
bool isGeneric() const { return SpellingListIndex == 4 ||
  SpellingListIndex == 5 ||
  SpellingListIndex == 6 ||
  SpellingListIndex == 7; }
typedef Expr ** args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::ReleaseCapability; }
6809};

6811class RenderScriptKernelAttr : public Attr {
6812public:
static RenderScriptKernelAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) RenderScriptKernelAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

RenderScriptKernelAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : Attr(attr::RenderScriptKernel, R, SI, false)
{
}

RenderScriptKernelAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::RenderScriptKernel; }
6833};

6835class ReqdWorkGroupSizeAttr : public InheritableAttr {
6836unsigned xDim;

6838unsigned yDim;

6840unsigned zDim;

6842public:
static ReqdWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ReqdWorkGroupSizeAttr(Loc, Ctx, XDim, YDim, ZDim, 0);
  A->setImplicit(true);
  return A;
}

ReqdWorkGroupSizeAttr(SourceRange R, ASTContext &Ctx
            , unsigned XDim
            , unsigned YDim
            , unsigned ZDim
            , unsigned SI
           )
  : InheritableAttr(attr::ReqdWorkGroupSize, R, SI, false, false)
            , xDim(XDim)
            , yDim(YDim)
            , zDim(ZDim)
{
}

ReqdWorkGroupSizeAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getXDim() const {
  return xDim;
}

unsigned getYDim() const {
  return yDim;
}

unsigned getZDim() const {
  return zDim;
}



static bool classof(const Attr *A) { return A->getKind() == attr::ReqdWorkGroupSize; }
6881};

6883class RequireConstantInitAttr : public InheritableAttr {
6884public:
static RequireConstantInitAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) RequireConstantInitAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

RequireConstantInitAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::RequireConstantInit, R, SI, false, false)
{
}

RequireConstantInitAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::RequireConstantInit; }
6905};

6907class RequiresCapabilityAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

6911public:
enum Spelling {
  GNU_requires_capability = 0,
  CXX11_clang_requires_capability = 1,
  GNU_exclusive_locks_required = 2,
  CXX11_clang_exclusive_locks_required = 3,
  GNU_requires_shared_capability = 4,
  CXX11_clang_requires_shared_capability = 5,
  GNU_shared_locks_required = 6,
  CXX11_clang_shared_locks_required = 7
};

static RequiresCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) RequiresCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
  A->setImplicit(true);
  return A;
}

RequiresCapabilityAttr(SourceRange R, ASTContext &Ctx
            , Expr * *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::RequiresCapability, R, SI, true, true)
            , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

RequiresCapabilityAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::RequiresCapability, R, SI, true, true)
            , args_Size(0), args_(nullptr)
{
}

RequiresCapabilityAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6953);
  case 0: return GNU_requires_capability;
  case 1: return CXX11_clang_requires_capability;
  case 2: return GNU_exclusive_locks_required;
  case 3: return CXX11_clang_exclusive_locks_required;
  case 4: return GNU_requires_shared_capability;
  case 5: return CXX11_clang_requires_shared_capability;
  case 6: return GNU_shared_locks_required;
  case 7: return CXX11_clang_shared_locks_required;
}
}
bool isShared() const { return SpellingListIndex == 4 ||
  SpellingListIndex == 5 ||
  SpellingListIndex == 6 ||
  SpellingListIndex == 7; }
typedef Expr ** args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::RequiresCapability; }
6978};

6980class RestrictAttr : public InheritableAttr {
6981public:
enum Spelling {
  Declspec_restrict = 0,
  GNU_malloc = 1,
  CXX11_gnu_malloc = 2
};

static RestrictAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) RestrictAttr(Loc, Ctx, S);
  A->setImplicit(true);
  return A;
}

RestrictAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Restrict, R, SI, false, false)
{
}

RestrictAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7007);
  case 0: return Declspec_restrict;
  case 1: return GNU_malloc;
  case 2: return CXX11_gnu_malloc;
}
}


static bool classof(const Attr *A) { return A->getKind() == attr::Restrict; }
7016};

7018class ReturnTypestateAttr : public InheritableAttr {
7019public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
7025private:
ConsumedState state;

7028public:
static ReturnTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState State, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ReturnTypestateAttr(Loc, Ctx, State, 0);
  A->setImplicit(true);
  return A;
}

ReturnTypestateAttr(SourceRange R, ASTContext &Ctx
            , ConsumedState State
            , unsigned SI
           )
  : InheritableAttr(attr::ReturnTypestate, R, SI, false, false)
            , state(State)
{
}

ReturnTypestateAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
ConsumedState getState() const {
  return state;
}

static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
  Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
    .Case("unknown", ReturnTypestateAttr::Unknown)
    .Case("consumed", ReturnTypestateAttr::Consumed)
    .Case("unconsumed", ReturnTypestateAttr::Unconsumed)
    .Default(Optional<ConsumedState>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertConsumedStateToStr(ConsumedState Val) {
  switch(Val) {
  case ReturnTypestateAttr::Unknown: return "unknown";
  case ReturnTypestateAttr::Consumed: return "consumed";
  case ReturnTypestateAttr::Unconsumed: return "unconsumed";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7071);
}


static bool classof(const Attr *A) { return A->getKind() == attr::ReturnTypestate; }
7076};

7078class ReturnsNonNullAttr : public InheritableAttr {
7079public:
static ReturnsNonNullAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ReturnsNonNullAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ReturnsNonNullAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ReturnsNonNull, R, SI, false, false)
{
}

ReturnsNonNullAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ReturnsNonNull; }
7100};

7102class ReturnsTwiceAttr : public InheritableAttr {
7103public:
static ReturnsTwiceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ReturnsTwiceAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ReturnsTwiceAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ReturnsTwice, R, SI, false, false)
{
}

ReturnsTwiceAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ReturnsTwice; }
7124};

7126class ScopedLockableAttr : public InheritableAttr {
7127public:
static ScopedLockableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ScopedLockableAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ScopedLockableAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ScopedLockable, R, SI, false, false)
{
}

ScopedLockableAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ScopedLockable; }
7148};

7150class SectionAttr : public InheritableAttr {
7151unsigned nameLength;
7152char *name;

7154public:
enum Spelling {
  GNU_section = 0,
  CXX11_gnu_section = 1,
  Declspec_allocate = 2
};

static SectionAttr *CreateImplicit(ASTContext &Ctx, Spelling S, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) SectionAttr(Loc, Ctx, Name, S);
  A->setImplicit(true);
  return A;
}

SectionAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Name
            , unsigned SI
           )
  : InheritableAttr(attr::Section, R, SI, false, false)
            , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
{
    if (!Name.empty())
      std::memcpy(name, Name.data(), nameLength);
}

SectionAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7184);
  case 0: return GNU_section;
  case 1: return CXX11_gnu_section;
  case 2: return Declspec_allocate;
}
}
llvm::StringRef getName() const {
  return llvm::StringRef(name, nameLength);
}
unsigned getNameLength() const {
  return nameLength;
}
void setName(ASTContext &C, llvm::StringRef S) {
  nameLength = S.size();
  this->name = new (C, 1) char [nameLength];
  if (!S.empty())
    std::memcpy(this->name, S.data(), nameLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::Section; }
7206};

7208class SelectAnyAttr : public InheritableAttr {
7209public:
static SelectAnyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) SelectAnyAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

SelectAnyAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::SelectAny, R, SI, false, false)
{
}

SelectAnyAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::SelectAny; }
7230};

7232class SentinelAttr : public InheritableAttr {
7233int sentinel;

7235int nullPos;

7237public:
static SentinelAttr *CreateImplicit(ASTContext &Ctx, int Sentinel, int NullPos, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) SentinelAttr(Loc, Ctx, Sentinel, NullPos, 0);
  A->setImplicit(true);
  return A;
}

SentinelAttr(SourceRange R, ASTContext &Ctx
            , int Sentinel
            , int NullPos
            , unsigned SI
           )
  : InheritableAttr(attr::Sentinel, R, SI, false, false)
            , sentinel(Sentinel)
            , nullPos(NullPos)
{
}

SentinelAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Sentinel, R, SI, false, false)
            , sentinel()
            , nullPos()
{
}

SentinelAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
int getSentinel() const {
  return sentinel;
}

static const int DefaultSentinel = 0;

int getNullPos() const {
  return nullPos;
}

static const int DefaultNullPos = 0;



static bool classof(const Attr *A) { return A->getKind() == attr::Sentinel; }
7283};

7285class SetTypestateAttr : public InheritableAttr {
7286public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
7292private:
ConsumedState newState;

7295public:
static SetTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState NewState, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) SetTypestateAttr(Loc, Ctx, NewState, 0);
  A->setImplicit(true);
  return A;
}

SetTypestateAttr(SourceRange R, ASTContext &Ctx
            , ConsumedState NewState
            , unsigned SI
           )
  : InheritableAttr(attr::SetTypestate, R, SI, false, false)
            , newState(NewState)
{
}

SetTypestateAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
ConsumedState getNewState() const {
  return newState;
}

static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
  Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
    .Case("unknown", SetTypestateAttr::Unknown)
    .Case("consumed", SetTypestateAttr::Consumed)
    .Case("unconsumed", SetTypestateAttr::Unconsumed)
    .Default(Optional<ConsumedState>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertConsumedStateToStr(ConsumedState Val) {
  switch(Val) {
  case SetTypestateAttr::Unknown: return "unknown";
  case SetTypestateAttr::Consumed: return "consumed";
  case SetTypestateAttr::Unconsumed: return "unconsumed";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7338);
}


static bool classof(const Attr *A) { return A->getKind() == attr::SetTypestate; }
7343};

7345class SharedTrylockFunctionAttr : public InheritableAttr {
7346Expr * successValue;

unsigned args_Size;
Expr * *args_;

7351public:
static SharedTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) SharedTrylockFunctionAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, 0);
  A->setImplicit(true);
  return A;
}

SharedTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
            , Expr * SuccessValue
            , Expr * *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::SharedTrylockFunction, R, SI, true, true)
            , successValue(SuccessValue)
            , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

SharedTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
            , Expr * SuccessValue
            , unsigned SI
           )
  : InheritableAttr(attr::SharedTrylockFunction, R, SI, true, true)
            , successValue(SuccessValue)
            , args_Size(0), args_(nullptr)
{
}

SharedTrylockFunctionAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Expr * getSuccessValue() const {
  return successValue;
}

typedef Expr ** args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::SharedTrylockFunction; }
7398};

7400class StdCallAttr : public InheritableAttr {
7401public:
static StdCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) StdCallAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

StdCallAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::StdCall, R, SI, false, false)
{
}

StdCallAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::StdCall; }
7422};

7424class SuppressAttr : public StmtAttr {
unsigned diagnosticIdentifiers_Size;
StringRef *diagnosticIdentifiers_;

7428public:
static SuppressAttr *CreateImplicit(ASTContext &Ctx, StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) SuppressAttr(Loc, Ctx, DiagnosticIdentifiers, DiagnosticIdentifiersSize, 0);
  A->setImplicit(true);
  return A;
}

SuppressAttr(SourceRange R, ASTContext &Ctx
            , StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize
            , unsigned SI
           )
  : StmtAttr(attr::Suppress, R, SI, false)
            , diagnosticIdentifiers_Size(DiagnosticIdentifiersSize), diagnosticIdentifiers_(new (Ctx, 16) StringRef[diagnosticIdentifiers_Size])
{
  for (size_t I = 0, E = diagnosticIdentifiers_Size; I != E;
       ++I) {
    StringRef Ref = DiagnosticIdentifiers[I];
    if (!Ref.empty()) {
      char *Mem = new (Ctx, 1) char[Ref.size()];
      std::memcpy(Mem, Ref.data(), Ref.size());
      diagnosticIdentifiers_[I] = StringRef(Mem, Ref.size());
    }
  }
}

SuppressAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : StmtAttr(attr::Suppress, R, SI, false)
            , diagnosticIdentifiers_Size(0), diagnosticIdentifiers_(nullptr)
{
}

SuppressAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef StringRef* diagnosticIdentifiers_iterator;
diagnosticIdentifiers_iterator diagnosticIdentifiers_begin() const { return diagnosticIdentifiers_; }
diagnosticIdentifiers_iterator diagnosticIdentifiers_end() const { return diagnosticIdentifiers_ + diagnosticIdentifiers_Size; }
unsigned diagnosticIdentifiers_size() const { return diagnosticIdentifiers_Size; }
llvm::iterator_range<diagnosticIdentifiers_iterator> diagnosticIdentifiers() const { return llvm::make_range(diagnosticIdentifiers_begin(), diagnosticIdentifiers_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::Suppress; }
7475};

7477class SwiftCallAttr : public InheritableAttr {
7478public:
static SwiftCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) SwiftCallAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

SwiftCallAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::SwiftCall, R, SI, false, false)
{
}

SwiftCallAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::SwiftCall; }
7499};

7501class SwiftContextAttr : public ParameterABIAttr {
7502public:
static SwiftContextAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) SwiftContextAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

SwiftContextAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : ParameterABIAttr(attr::SwiftContext, R, SI, false, false)
{
}

SwiftContextAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::SwiftContext; }
7523};

7525class SwiftErrorResultAttr : public ParameterABIAttr {
7526public:
static SwiftErrorResultAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) SwiftErrorResultAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

SwiftErrorResultAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : ParameterABIAttr(attr::SwiftErrorResult, R, SI, false, false)
{
}

SwiftErrorResultAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::SwiftErrorResult; }
7547};

7549class SwiftIndirectResultAttr : public ParameterABIAttr {
7550public:
static SwiftIndirectResultAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) SwiftIndirectResultAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

SwiftIndirectResultAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : ParameterABIAttr(attr::SwiftIndirectResult, R, SI, false, false)
{
}

SwiftIndirectResultAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::SwiftIndirectResult; }
7571};

7573class SysVABIAttr : public InheritableAttr {
7574public:
static SysVABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) SysVABIAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

SysVABIAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::SysVABI, R, SI, false, false)
{
}

SysVABIAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::SysVABI; }
7595};

7597class TLSModelAttr : public InheritableAttr {
7598unsigned modelLength;
7599char *model;

7601public:
static TLSModelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Model, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) TLSModelAttr(Loc, Ctx, Model, 0);
  A->setImplicit(true);
  return A;
}

TLSModelAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Model
            , unsigned SI
           )
  : InheritableAttr(attr::TLSModel, R, SI, false, false)
            , modelLength(Model.size()),model(new (Ctx, 1) char[modelLength])
{
    if (!Model.empty())
      std::memcpy(model, Model.data(), modelLength);
}

TLSModelAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getModel() const {
  return llvm::StringRef(model, modelLength);
}
unsigned getModelLength() const {
  return modelLength;
}
void setModel(ASTContext &C, llvm::StringRef S) {
  modelLength = S.size();
  this->model = new (C, 1) char [modelLength];
  if (!S.empty())
    std::memcpy(this->model, S.data(), modelLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::TLSModel; }
7639};

7641class TargetAttr : public InheritableAttr {
7642unsigned featuresStrLength;
7643char *featuresStr;

7645public:
static TargetAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef FeaturesStr, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) TargetAttr(Loc, Ctx, FeaturesStr, 0);
  A->setImplicit(true);
  return A;
}

TargetAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef FeaturesStr
            , unsigned SI
           )
  : InheritableAttr(attr::Target, R, SI, false, false)
            , featuresStrLength(FeaturesStr.size()),featuresStr(new (Ctx, 1) char[featuresStrLength])
{
    if (!FeaturesStr.empty())
      std::memcpy(featuresStr, FeaturesStr.data(), featuresStrLength);
}

TargetAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getFeaturesStr() const {
  return llvm::StringRef(featuresStr, featuresStrLength);
}
unsigned getFeaturesStrLength() const {
  return featuresStrLength;
}
void setFeaturesStr(ASTContext &C, llvm::StringRef S) {
  featuresStrLength = S.size();
  this->featuresStr = new (C, 1) char [featuresStrLength];
  if (!S.empty())
    std::memcpy(this->featuresStr, S.data(), featuresStrLength);
}


  struct ParsedTargetAttr {
    std::vector<std::string> Features;
    StringRef Architecture;
    bool DuplicateArchitecture = false;
    bool operator ==(const ParsedTargetAttr &Other) const {
      return DuplicateArchitecture == Other.DuplicateArchitecture &&
             Architecture == Other.Architecture && Features == Other.Features;
    }
  };
  ParsedTargetAttr parse() const {
    return parse(getFeaturesStr());
  }

  template<class Compare>
  ParsedTargetAttr parse(Compare cmp) const {
    ParsedTargetAttr Attrs = parse();
    std::sort(std::begin(Attrs.Features), std::end(Attrs.Features), cmp);
    return Attrs;
  }

  bool isDefaultVersion() const { return getFeaturesStr() == "default"; }

  static ParsedTargetAttr parse(StringRef Features) {
    ParsedTargetAttr Ret;
    if (Features == "default") return Ret;
    SmallVector<StringRef, 1> AttrFeatures;
    Features.split(AttrFeatures, ",");

    // Grab the various features and prepend a "+" to turn on the feature to
    // the backend and add them to our existing set of features.
    for (auto &Feature : AttrFeatures) {
      // Go ahead and trim whitespace rather than either erroring or
      // accepting it weirdly.
      Feature = Feature.trim();

      // We don't support cpu tuning this way currently.
      // TODO: Support the fpmath option. It will require checking
      // overall feature validity for the function with the rest of the
      // attributes on the function.
      if (Feature.startswith("fpmath=") || Feature.startswith("tune="))
 continue;

      // While we're here iterating check for a different target cpu.
      if (Feature.startswith("arch=")) {
        if (!Ret.Architecture.empty())
          Ret.DuplicateArchitecture = true;
        else
          Ret.Architecture = Feature.split("=").second.trim();
      } else if (Feature.startswith("no-"))
        Ret.Features.push_back("-" + Feature.split("-").second.str());
      else
        Ret.Features.push_back("+" + Feature.str());
    }
    return Ret;
  }


static bool classof(const Attr *A) { return A->getKind() == attr::Target; }
7739};

7741class TestTypestateAttr : public InheritableAttr {
7742public:
enum ConsumedState {
  Consumed,
  Unconsumed
};
7747private:
ConsumedState testState;

7750public:
static TestTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState TestState, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) TestTypestateAttr(Loc, Ctx, TestState, 0);
  A->setImplicit(true);
  return A;
}

TestTypestateAttr(SourceRange R, ASTContext &Ctx
            , ConsumedState TestState
            , unsigned SI
           )
  : InheritableAttr(attr::TestTypestate, R, SI, false, false)
            , testState(TestState)
{
}

TestTypestateAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
ConsumedState getTestState() const {
  return testState;
}

static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
  Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
    .Case("consumed", TestTypestateAttr::Consumed)
    .Case("unconsumed", TestTypestateAttr::Unconsumed)
    .Default(Optional<ConsumedState>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertConsumedStateToStr(ConsumedState Val) {
  switch(Val) {
  case TestTypestateAttr::Consumed: return "consumed";
  case TestTypestateAttr::Unconsumed: return "unconsumed";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7791);
}


static bool classof(const Attr *A) { return A->getKind() == attr::TestTypestate; }
7796};

7798class ThisCallAttr : public InheritableAttr {
7799public:
static ThisCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ThisCallAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ThisCallAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::ThisCall, R, SI, false, false)
{
}

ThisCallAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::ThisCall; }
7820};

7822class ThreadAttr : public Attr {
7823public:
static ThreadAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ThreadAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ThreadAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : Attr(attr::Thread, R, SI, false)
{
}

ThreadAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Thread; }
7844};

7846class TransparentUnionAttr : public InheritableAttr {
7847public:
static TransparentUnionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) TransparentUnionAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

TransparentUnionAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::TransparentUnion, R, SI, false, false)
{
}

TransparentUnionAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::TransparentUnion; }
7868};

7870class TrivialABIAttr : public InheritableAttr {
7871public:
static TrivialABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) TrivialABIAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

TrivialABIAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::TrivialABI, R, SI, false, false)
{
}

TrivialABIAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::TrivialABI; }
7892};

7894class TryAcquireCapabilityAttr : public InheritableAttr {
7895Expr * successValue;

unsigned args_Size;
Expr * *args_;

7900public:
enum Spelling {
  GNU_try_acquire_capability = 0,
  CXX11_clang_try_acquire_capability = 1,
  GNU_try_acquire_shared_capability = 2,
  CXX11_clang_try_acquire_shared_capability = 3
};

static TryAcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) TryAcquireCapabilityAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, S);
  A->setImplicit(true);
  return A;
}

TryAcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
            , Expr * SuccessValue
            , Expr * *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::TryAcquireCapability, R, SI, true, true)
            , successValue(SuccessValue)
            , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
{
  std::copy(Args, Args + args_Size, args_);
}

TryAcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
            , Expr * SuccessValue
            , unsigned SI
           )
  : InheritableAttr(attr::TryAcquireCapability, R, SI, true, true)
            , successValue(SuccessValue)
            , args_Size(0), args_(nullptr)
{
}

TryAcquireCapabilityAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7942);
  case 0: return GNU_try_acquire_capability;
  case 1: return CXX11_clang_try_acquire_capability;
  case 2: return GNU_try_acquire_shared_capability;
  case 3: return CXX11_clang_try_acquire_shared_capability;
}
}
bool isShared() const { return SpellingListIndex == 2 ||
  SpellingListIndex == 3; }
Expr * getSuccessValue() const {
  return successValue;
}

typedef Expr ** args_iterator;
args_iterator args_begin() const { return args_; }
args_iterator args_end() const { return args_ + args_Size; }
unsigned args_size() const { return args_Size; }
llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::TryAcquireCapability; }
7965};

7967class TypeTagForDatatypeAttr : public InheritableAttr {
7968IdentifierInfo * argumentKind;

7970TypeSourceInfo * matchingCType;

7972bool layoutCompatible;

7974bool mustBeNull;

7976public:
static TypeTagForDatatypeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, TypeSourceInfo * MatchingCType, bool LayoutCompatible, bool MustBeNull, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) TypeTagForDatatypeAttr(Loc, Ctx, ArgumentKind, MatchingCType, LayoutCompatible, MustBeNull, 0);
  A->setImplicit(true);
  return A;
}

TypeTagForDatatypeAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * ArgumentKind
            , TypeSourceInfo * MatchingCType
            , bool LayoutCompatible
            , bool MustBeNull
            , unsigned SI
           )
  : InheritableAttr(attr::TypeTagForDatatype, R, SI, false, false)
            , argumentKind(ArgumentKind)
            , matchingCType(MatchingCType)
            , layoutCompatible(LayoutCompatible)
            , mustBeNull(MustBeNull)
{
}

TypeTagForDatatypeAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
IdentifierInfo * getArgumentKind() const {
  return argumentKind;
}

QualType getMatchingCType() const {
  return matchingCType->getType();
}  TypeSourceInfo * getMatchingCTypeLoc() const {
  return matchingCType;
}

bool getLayoutCompatible() const {
  return layoutCompatible;
}

bool getMustBeNull() const {
  return mustBeNull;
}



static bool classof(const Attr *A) { return A->getKind() == attr::TypeTagForDatatype; }
8023};

8025class TypeVisibilityAttr : public InheritableAttr {
8026public:
enum VisibilityType {
  Default,
  Hidden,
  Protected
};
8032private:
VisibilityType visibility;

8035public:
static TypeVisibilityAttr *CreateImplicit(ASTContext &Ctx, VisibilityType Visibility, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) TypeVisibilityAttr(Loc, Ctx, Visibility, 0);
  A->setImplicit(true);
  return A;
}

TypeVisibilityAttr(SourceRange R, ASTContext &Ctx
            , VisibilityType Visibility
            , unsigned SI
           )
  : InheritableAttr(attr::TypeVisibility, R, SI, false, false)
            , visibility(Visibility)
{
}

TypeVisibilityAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
VisibilityType getVisibility() const {
  return visibility;
}

static bool ConvertStrToVisibilityType(StringRef Val, VisibilityType &Out) {
  Optional<VisibilityType> R = llvm::StringSwitch<Optional<VisibilityType>>(Val)
    .Case("default", TypeVisibilityAttr::Default)
    .Case("hidden", TypeVisibilityAttr::Hidden)
    .Case("internal", TypeVisibilityAttr::Hidden)
    .Case("protected", TypeVisibilityAttr::Protected)
    .Default(Optional<VisibilityType>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertVisibilityTypeToStr(VisibilityType Val) {
  switch(Val) {
  case TypeVisibilityAttr::Default: return "default";
  case TypeVisibilityAttr::Hidden: return "hidden";
  case TypeVisibilityAttr::Protected: return "protected";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8079);
}


static bool classof(const Attr *A) { return A->getKind() == attr::TypeVisibility; }
8084};

8086class UnavailableAttr : public InheritableAttr {
8087unsigned messageLength;
8088char *message;

8090public:
enum ImplicitReason {
  IR_None,
  IR_ARCForbiddenType,
  IR_ForbiddenWeak,
  IR_ARCForbiddenConversion,
  IR_ARCInitReturnsUnrelated,
  IR_ARCFieldWithOwnership
};
8099private:
ImplicitReason implicitReason;

8102public:
static UnavailableAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, ImplicitReason ImplicitReason, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) UnavailableAttr(Loc, Ctx, Message, ImplicitReason, 0);
  A->setImplicit(true);
  return A;
}

static UnavailableAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) UnavailableAttr(Loc, Ctx, Message, 0);
  A->setImplicit(true);
  return A;
}

UnavailableAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Message
            , ImplicitReason ImplicitReason
            , unsigned SI
           )
  : InheritableAttr(attr::Unavailable, R, SI, false, false)
            , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
            , implicitReason(ImplicitReason)
{
    if (!Message.empty())
      std::memcpy(message, Message.data(), messageLength);
}

UnavailableAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Message
            , unsigned SI
           )
  : InheritableAttr(attr::Unavailable, R, SI, false, false)
            , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
            , implicitReason(ImplicitReason(0))
{
    if (!Message.empty())
      std::memcpy(message, Message.data(), messageLength);
}

UnavailableAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Unavailable, R, SI, false, false)
            , messageLength(0),message(nullptr)
            , implicitReason(ImplicitReason(0))
{
}

UnavailableAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getMessage() const {
  return llvm::StringRef(message, messageLength);
}
unsigned getMessageLength() const {
  return messageLength;
}
void setMessage(ASTContext &C, llvm::StringRef S) {
  messageLength = S.size();
  this->message = new (C, 1) char [messageLength];
  if (!S.empty())
    std::memcpy(this->message, S.data(), messageLength);
}

ImplicitReason getImplicitReason() const {
  return implicitReason;
}



static bool classof(const Attr *A) { return A->getKind() == attr::Unavailable; }
8173};

8175class UnusedAttr : public InheritableAttr {
8176public:
enum Spelling {
  CXX11_maybe_unused = 0,
  GNU_unused = 1,
  CXX11_gnu_unused = 2,
  C2x_maybe_unused = 3
};

static UnusedAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) UnusedAttr(Loc, Ctx, S);
  A->setImplicit(true);
  return A;
}

UnusedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Unused, R, SI, false, false)
{
}

UnusedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8203);
  case 0: return CXX11_maybe_unused;
  case 1: return GNU_unused;
  case 2: return CXX11_gnu_unused;
  case 3: return C2x_maybe_unused;
}
}


static bool classof(const Attr *A) { return A->getKind() == attr::Unused; }
8213};

8215class UsedAttr : public InheritableAttr {
8216public:
static UsedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) UsedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

UsedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Used, R, SI, false, false)
{
}

UsedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Used; }
8237};

8239class UuidAttr : public InheritableAttr {
8240unsigned guidLength;
8241char *guid;

8243public:
static UuidAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Guid, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) UuidAttr(Loc, Ctx, Guid, 0);
  A->setImplicit(true);
  return A;
}

UuidAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Guid
            , unsigned SI
           )
  : InheritableAttr(attr::Uuid, R, SI, false, false)
            , guidLength(Guid.size()),guid(new (Ctx, 1) char[guidLength])
{
    if (!Guid.empty())
      std::memcpy(guid, Guid.data(), guidLength);
}

UuidAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getGuid() const {
  return llvm::StringRef(guid, guidLength);
}
unsigned getGuidLength() const {
  return guidLength;
}
void setGuid(ASTContext &C, llvm::StringRef S) {
  guidLength = S.size();
  this->guid = new (C, 1) char [guidLength];
  if (!S.empty())
    std::memcpy(this->guid, S.data(), guidLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::Uuid; }
8281};

8283class VecReturnAttr : public InheritableAttr {
8284public:
static VecReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) VecReturnAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

VecReturnAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::VecReturn, R, SI, false, false)
{
}

VecReturnAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::VecReturn; }
8305};

8307class VecTypeHintAttr : public InheritableAttr {
8308TypeSourceInfo * typeHint;

8310public:
static VecTypeHintAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * TypeHint, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) VecTypeHintAttr(Loc, Ctx, TypeHint, 0);
  A->setImplicit(true);
  return A;
}

VecTypeHintAttr(SourceRange R, ASTContext &Ctx
            , TypeSourceInfo * TypeHint
            , unsigned SI
           )
  : InheritableAttr(attr::VecTypeHint, R, SI, false, false)
            , typeHint(TypeHint)
{
}

VecTypeHintAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
QualType getTypeHint() const {
  return typeHint->getType();
}  TypeSourceInfo * getTypeHintLoc() const {
  return typeHint;
}



static bool classof(const Attr *A) { return A->getKind() == attr::VecTypeHint; }
8339};

8341class VectorCallAttr : public InheritableAttr {
8342public:
static VectorCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) VectorCallAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

VectorCallAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::VectorCall, R, SI, false, false)
{
}

VectorCallAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::VectorCall; }
8363};

8365class VisibilityAttr : public InheritableAttr {
8366public:
enum VisibilityType {
  Default,
  Hidden,
  Protected
};
8372private:
VisibilityType visibility;

8375public:
static VisibilityAttr *CreateImplicit(ASTContext &Ctx, VisibilityType Visibility, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) VisibilityAttr(Loc, Ctx, Visibility, 0);
  A->setImplicit(true);
  return A;
}

VisibilityAttr(SourceRange R, ASTContext &Ctx
            , VisibilityType Visibility
            , unsigned SI
           )
  : InheritableAttr(attr::Visibility, R, SI, false, false)
            , visibility(Visibility)
{
}

VisibilityAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
VisibilityType getVisibility() const {
  return visibility;
}

static bool ConvertStrToVisibilityType(StringRef Val, VisibilityType &Out) {
  Optional<VisibilityType> R = llvm::StringSwitch<Optional<VisibilityType>>(Val)
    .Case("default", VisibilityAttr::Default)
    .Case("hidden", VisibilityAttr::Hidden)
    .Case("internal", VisibilityAttr::Hidden)
    .Case("protected", VisibilityAttr::Protected)
    .Default(Optional<VisibilityType>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertVisibilityTypeToStr(VisibilityType Val) {
  switch(Val) {
  case VisibilityAttr::Default: return "default";
  case VisibilityAttr::Hidden: return "hidden";
  case VisibilityAttr::Protected: return "protected";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8419);
}


static bool classof(const Attr *A) { return A->getKind() == attr::Visibility; }
8424};

8426class WarnUnusedAttr : public InheritableAttr {
8427public:
static WarnUnusedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) WarnUnusedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

WarnUnusedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::WarnUnused, R, SI, false, false)
{
}

WarnUnusedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::WarnUnused; }
8448};

8450class WarnUnusedResultAttr : public InheritableAttr {
8451public:
enum Spelling {
  CXX11_nodiscard = 0,
  C2x_nodiscard = 1,
  CXX11_clang_warn_unused_result = 2,
  GNU_warn_unused_result = 3,
  CXX11_gnu_warn_unused_result = 4
};

static WarnUnusedResultAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) WarnUnusedResultAttr(Loc, Ctx, S);
  A->setImplicit(true);
  return A;
}

WarnUnusedResultAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::WarnUnusedResult, R, SI, false, false)
{
}

WarnUnusedResultAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8479);
  case 0: return CXX11_nodiscard;
  case 1: return C2x_nodiscard;
  case 2: return CXX11_clang_warn_unused_result;
  case 3: return GNU_warn_unused_result;
  case 4: return CXX11_gnu_warn_unused_result;
}
}


static bool classof(const Attr *A) { return A->getKind() == attr::WarnUnusedResult; }
8490};

8492class WeakAttr : public InheritableAttr {
8493public:
static WeakAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) WeakAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

WeakAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Weak, R, SI, false, false)
{
}

WeakAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::Weak; }
8514};

8516class WeakImportAttr : public InheritableAttr {
8517public:
static WeakImportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) WeakImportAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

WeakImportAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::WeakImport, R, SI, false, false)
{
}

WeakImportAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::WeakImport; }
8538};

8540class WeakRefAttr : public InheritableAttr {
8541unsigned aliaseeLength;
8542char *aliasee;

8544public:
static WeakRefAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) WeakRefAttr(Loc, Ctx, Aliasee, 0);
  A->setImplicit(true);
  return A;
}

WeakRefAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Aliasee
            , unsigned SI
           )
  : InheritableAttr(attr::WeakRef, R, SI, false, false)
            , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength])
{
    if (!Aliasee.empty())
      std::memcpy(aliasee, Aliasee.data(), aliaseeLength);
}

WeakRefAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::WeakRef, R, SI, false, false)
            , aliaseeLength(0),aliasee(nullptr)
{
}

WeakRefAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getAliasee() const {
  return llvm::StringRef(aliasee, aliaseeLength);
}
unsigned getAliaseeLength() const {
  return aliaseeLength;
}
void setAliasee(ASTContext &C, llvm::StringRef S) {
  aliaseeLength = S.size();
  this->aliasee = new (C, 1) char [aliaseeLength];
  if (!S.empty())
    std::memcpy(this->aliasee, S.data(), aliaseeLength);
}



static bool classof(const Attr *A) { return A->getKind() == attr::WeakRef; }
8590};

8592class WorkGroupSizeHintAttr : public InheritableAttr {
8593unsigned xDim;

8595unsigned yDim;

8597unsigned zDim;

8599public:
static WorkGroupSizeHintAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) WorkGroupSizeHintAttr(Loc, Ctx, XDim, YDim, ZDim, 0);
  A->setImplicit(true);
  return A;
}

WorkGroupSizeHintAttr(SourceRange R, ASTContext &Ctx
            , unsigned XDim
            , unsigned YDim
            , unsigned ZDim
            , unsigned SI
           )
  : InheritableAttr(attr::WorkGroupSizeHint, R, SI, false, false)
            , xDim(XDim)
            , yDim(YDim)
            , zDim(ZDim)
{
}

WorkGroupSizeHintAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getXDim() const {
  return xDim;
}

unsigned getYDim() const {
  return yDim;
}

unsigned getZDim() const {
  return zDim;
}



static bool classof(const Attr *A) { return A->getKind() == attr::WorkGroupSizeHint; }
8638};

8640class X86ForceAlignArgPointerAttr : public InheritableAttr {
8641public:
static X86ForceAlignArgPointerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) X86ForceAlignArgPointerAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

X86ForceAlignArgPointerAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::X86ForceAlignArgPointer, R, SI, false, false)
{
}

X86ForceAlignArgPointerAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


static bool classof(const Attr *A) { return A->getKind() == attr::X86ForceAlignArgPointer; }
8662};

8664class XRayInstrumentAttr : public InheritableAttr {
8665public:
enum Spelling {
  GNU_xray_always_instrument = 0,
  CXX11_clang_xray_always_instrument = 1,
  C2x_clang_xray_always_instrument = 2,
  GNU_xray_never_instrument = 3,
  CXX11_clang_xray_never_instrument = 4,
  C2x_clang_xray_never_instrument = 5
};

static XRayInstrumentAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) XRayInstrumentAttr(Loc, Ctx, S);
  A->setImplicit(true);
  return A;
}

XRayInstrumentAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::XRayInstrument, R, SI, false, false)
{
}

XRayInstrumentAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8694);
  case 0: return GNU_xray_always_instrument;
  case 1: return CXX11_clang_xray_always_instrument;
  case 2: return C2x_clang_xray_always_instrument;
  case 3: return GNU_xray_never_instrument;
  case 4: return CXX11_clang_xray_never_instrument;
  case 5: return C2x_clang_xray_never_instrument;
}
}
bool alwaysXRayInstrument() const { return SpellingListIndex == 0 ||
  SpellingListIndex == 1 ||
  SpellingListIndex == 2; }
bool neverXRayInstrument() const { return SpellingListIndex == 3 ||
  SpellingListIndex == 4 ||
  SpellingListIndex == 5; }


static bool classof(const Attr *A) { return A->getKind() == attr::XRayInstrument; }
8712};

8714class XRayLogArgsAttr : public InheritableAttr {
8715unsigned argumentCount;

8717public:
static XRayLogArgsAttr *CreateImplicit(ASTContext &Ctx, unsigned ArgumentCount, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) XRayLogArgsAttr(Loc, Ctx, ArgumentCount, 0);
  A->setImplicit(true);
  return A;
}

XRayLogArgsAttr(SourceRange R, ASTContext &Ctx
            , unsigned ArgumentCount
            , unsigned SI
           )
  : InheritableAttr(attr::XRayLogArgs, R, SI, false, false)
            , argumentCount(ArgumentCount)
{
}

XRayLogArgsAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getArgumentCount() const {
  return argumentCount;
}



static bool classof(const Attr *A) { return A->getKind() == attr::XRayLogArgs; }
8744};

8746#endif // LLVM_CLANG_ATTR_CLASSES_INC