/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaStmtAttr.cpp

Bug Summary

File:	tools/clang/lib/Sema/SemaStmtAttr.cpp
Warning:	line 7448, column 9 Called C++ object pointer is null

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 SemaStmtAttr.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 _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/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema -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/lib/Sema -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/lib/Sema/SemaStmtAttr.cpp

/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaStmtAttr.cpp

→

1//===--- SemaStmtAttr.cpp - Statement Attribute Handling ------------------===//
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 stmt-related attribute processing.
11//
12//===----------------------------------------------------------------------===//

14#include "clang/Sema/SemaInternal.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/Basic/SourceManager.h"
17#include "clang/Sema/DelayedDiagnostic.h"
18#include "clang/Sema/Lookup.h"
19#include "clang/Sema/LoopHint.h"
20#include "clang/Sema/ScopeInfo.h"
21#include "llvm/ADT/StringExtras.h"

23using namespace clang;
24using namespace sema;

26static Attr *handleFallThroughAttr(Sema &S, Stmt *St, const AttributeList &A,
                                 SourceRange Range) {
FallThroughAttr Attr(A.getRange(), S.Context,
                     A.getAttributeSpellingListIndex());
if (!isa<NullStmt>(St)) {
  S.Diag(A.getRange().getBegin(), diag::err_fallthrough_attr_wrong_target)
      << Attr.getSpelling() << St->getLocStart();
  if (isa<SwitchCase>(St)) {
    SourceLocation L = S.getLocForEndOfToken(Range.getEnd());
    S.Diag(L, diag::note_fallthrough_insert_semi_fixit)
        << FixItHint::CreateInsertion(L, ";");
  }
  return nullptr;
}
auto *FnScope = S.getCurFunction();
if (FnScope->SwitchStack.empty()) {
  S.Diag(A.getRange().getBegin(), diag::err_fallthrough_attr_outside_switch);
  return nullptr;
}

// If this is spelled as the standard C++17 attribute, but not in C++17, warn
// about using it as an extension.
if (!S.getLangOpts().CPlusPlus17 && A.isCXX11Attribute() &&
    !A.getScopeName())
  S.Diag(A.getLoc(), diag::ext_cxx17_attr) << A.getName();

FnScope->setHasFallthroughStmt();
return ::new (S.Context) auto(Attr);
54}

56static Attr *handleSuppressAttr(Sema &S, Stmt *St, const AttributeList &A,
                              SourceRange Range) {
if (A.getNumArgs() < 1) {
3
←
Assuming the condition is false→
4
←
Taking false branch→
  S.Diag(A.getLoc(), diag::err_attribute_too_few_arguments)
      << A.getName() << 1;
  return nullptr;
}

std::vector<StringRef> DiagnosticIdentifiers;
for (unsigned I = 0, E = A.getNumArgs(); I != E; ++I) {
5
←
Loop condition is true.  Entering loop body→
8
←
Assuming 'I' is equal to 'E'→
9
←
Loop condition is false. Execution jumps to the end of the function→
  StringRef RuleName;

  if (!S.checkStringLiteralArgumentAttr(A, I, RuleName, nullptr))
6
←
Assuming the condition is false→
7
←
Taking false branch→
    return nullptr;

  // FIXME: Warn if the rule name is unknown. This is tricky because only
  // clang-tidy knows about available rules.
  DiagnosticIdentifiers.push_back(RuleName);
}

return ::new (S.Context) SuppressAttr(
10
←
Calling constructor for 'SuppressAttr'→
    A.getRange(), S.Context, DiagnosticIdentifiers.data(),
    DiagnosticIdentifiers.size(), A.getAttributeSpellingListIndex());
79}

81static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const AttributeList &A,
                              SourceRange) {
IdentifierLoc *PragmaNameLoc = A.getArgAsIdent(0);
IdentifierLoc *OptionLoc = A.getArgAsIdent(1);
IdentifierLoc *StateLoc = A.getArgAsIdent(2);
Expr *ValueExpr = A.getArgAsExpr(3);

bool PragmaUnroll = PragmaNameLoc->Ident->getName() == "unroll";
bool PragmaNoUnroll = PragmaNameLoc->Ident->getName() == "nounroll";
if (St->getStmtClass() != Stmt::DoStmtClass &&
    St->getStmtClass() != Stmt::ForStmtClass &&
    St->getStmtClass() != Stmt::CXXForRangeStmtClass &&
    St->getStmtClass() != Stmt::WhileStmtClass) {
  const char *Pragma =
      llvm::StringSwitch<const char *>(PragmaNameLoc->Ident->getName())
          .Case("unroll", "#pragma unroll")
          .Case("nounroll", "#pragma nounroll")
          .Default("#pragma clang loop");
  S.Diag(St->getLocStart(), diag::err_pragma_loop_precedes_nonloop) << Pragma;
  return nullptr;
}

LoopHintAttr::Spelling Spelling =
    LoopHintAttr::Spelling(A.getAttributeSpellingListIndex());
LoopHintAttr::OptionType Option;
LoopHintAttr::LoopHintState State;
if (PragmaNoUnroll) {
  // #pragma nounroll
  Option = LoopHintAttr::Unroll;
  State = LoopHintAttr::Disable;
} else if (PragmaUnroll) {
  if (ValueExpr) {
    // #pragma unroll N
    Option = LoopHintAttr::UnrollCount;
    State = LoopHintAttr::Numeric;
  } else {
    // #pragma unroll
    Option = LoopHintAttr::Unroll;
    State = LoopHintAttr::Enable;
  }
} else {
  // #pragma clang loop ...
  assert(OptionLoc && OptionLoc->Ident &&(static_cast <bool> (OptionLoc && OptionLoc->
Ident && "Attribute must have valid option info.") ? void
 (0) : __assert_fail ("OptionLoc && OptionLoc->Ident && \"Attribute must have valid option info.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaStmtAttr.cpp"
, 124, __extension__ __PRETTY_FUNCTION__))
         "Attribute must have valid option info.")(static_cast <bool> (OptionLoc && OptionLoc->
Ident && "Attribute must have valid option info.") ? void
 (0) : __assert_fail ("OptionLoc && OptionLoc->Ident && \"Attribute must have valid option info.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaStmtAttr.cpp"
, 124, __extension__ __PRETTY_FUNCTION__));
  Option = llvm::StringSwitch<LoopHintAttr::OptionType>(
               OptionLoc->Ident->getName())
               .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(LoopHintAttr::Vectorize);
  if (Option == LoopHintAttr::VectorizeWidth ||
      Option == LoopHintAttr::InterleaveCount ||
      Option == LoopHintAttr::UnrollCount) {
    assert(ValueExpr && "Attribute must have a valid value expression.")(static_cast <bool> (ValueExpr && "Attribute must have a valid value expression."
) ? void (0) : __assert_fail ("ValueExpr && \"Attribute must have a valid value expression.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaStmtAttr.cpp"
, 138, __extension__ __PRETTY_FUNCTION__));
    if (S.CheckLoopHintExpr(ValueExpr, St->getLocStart()))
      return nullptr;
    State = LoopHintAttr::Numeric;
  } else if (Option == LoopHintAttr::Vectorize ||
             Option == LoopHintAttr::Interleave ||
             Option == LoopHintAttr::Unroll ||
             Option == LoopHintAttr::Distribute) {
    assert(StateLoc && StateLoc->Ident && "Loop hint must have an argument")(static_cast <bool> (StateLoc && StateLoc->Ident
 && "Loop hint must have an argument") ? void (0) : __assert_fail
 ("StateLoc && StateLoc->Ident && \"Loop hint must have an argument\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaStmtAttr.cpp"
, 146, __extension__ __PRETTY_FUNCTION__));
    if (StateLoc->Ident->isStr("disable"))
      State = LoopHintAttr::Disable;
    else if (StateLoc->Ident->isStr("assume_safety"))
      State = LoopHintAttr::AssumeSafety;
    else if (StateLoc->Ident->isStr("full"))
      State = LoopHintAttr::Full;
    else if (StateLoc->Ident->isStr("enable"))
      State = LoopHintAttr::Enable;
    else
      llvm_unreachable("bad loop hint argument")::llvm::llvm_unreachable_internal("bad loop hint argument", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaStmtAttr.cpp"
, 156);
  } else
    llvm_unreachable("bad loop hint")::llvm::llvm_unreachable_internal("bad loop hint", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaStmtAttr.cpp"
, 158);
}

return LoopHintAttr::CreateImplicit(S.Context, Spelling, Option, State,
                                    ValueExpr, A.getRange());
163}

165static void
166CheckForIncompatibleAttributes(Sema &S,
                             const SmallVectorImpl<const Attr *> &Attrs) {
// There are 4 categories of loop hints attributes: vectorize, interleave,
// unroll and distribute. Except for distribute they come in two variants: a
// state form and a numeric form.  The state form selectively
// defaults/enables/disables the transformation for the loop (for unroll,
// default indicates full unrolling rather than enabling the transformation).
// The numeric form form provides an integer hint (for example, unroll count)
// to the transformer. The following array accumulates the hints encountered
// while iterating through the attributes to check for compatibility.
struct {
  const LoopHintAttr *StateAttr;
  const LoopHintAttr *NumericAttr;
} HintAttrs[] = {{nullptr, nullptr},
                 {nullptr, nullptr},
                 {nullptr, nullptr},
                 {nullptr, nullptr}};

for (const auto *I : Attrs) {
  const LoopHintAttr *LH = dyn_cast<LoopHintAttr>(I);

  // Skip non loop hint attributes
  if (!LH)
    continue;

  LoopHintAttr::OptionType Option = LH->getOption();
  enum { Vectorize, Interleave, Unroll, Distribute } Category;
  switch (Option) {
  case LoopHintAttr::Vectorize:
  case LoopHintAttr::VectorizeWidth:
    Category = Vectorize;
    break;
  case LoopHintAttr::Interleave:
  case LoopHintAttr::InterleaveCount:
    Category = Interleave;
    break;
  case LoopHintAttr::Unroll:
  case LoopHintAttr::UnrollCount:
    Category = Unroll;
    break;
  case LoopHintAttr::Distribute:
    // Perform the check for duplicated 'distribute' hints.
    Category = Distribute;
    break;
  };

  auto &CategoryState = HintAttrs[Category];
  const LoopHintAttr *PrevAttr;
  if (Option == LoopHintAttr::Vectorize ||
      Option == LoopHintAttr::Interleave || Option == LoopHintAttr::Unroll ||
      Option == LoopHintAttr::Distribute) {
    // Enable|Disable|AssumeSafety hint.  For example, vectorize(enable).
    PrevAttr = CategoryState.StateAttr;
    CategoryState.StateAttr = LH;
  } else {
    // Numeric hint.  For example, vectorize_width(8).
    PrevAttr = CategoryState.NumericAttr;
    CategoryState.NumericAttr = LH;
  }

  PrintingPolicy Policy(S.Context.getLangOpts());
  SourceLocation OptionLoc = LH->getRange().getBegin();
  if (PrevAttr)
    // Cannot specify same type of attribute twice.
    S.Diag(OptionLoc, diag::err_pragma_loop_compatibility)
        << /*Duplicate=*/true << PrevAttr->getDiagnosticName(Policy)
        << LH->getDiagnosticName(Policy);

  if (CategoryState.StateAttr && CategoryState.NumericAttr &&
      (Category == Unroll ||
       CategoryState.StateAttr->getState() == LoopHintAttr::Disable)) {
    // Disable hints are not compatible with numeric hints of the same
    // category.  As a special case, numeric unroll hints are also not
    // compatible with enable or full form of the unroll pragma because these
    // directives indicate full unrolling.
    S.Diag(OptionLoc, diag::err_pragma_loop_compatibility)
        << /*Duplicate=*/false
        << CategoryState.StateAttr->getDiagnosticName(Policy)
        << CategoryState.NumericAttr->getDiagnosticName(Policy);
  }
}
247}

249static Attr *handleOpenCLUnrollHint(Sema &S, Stmt *St, const AttributeList &A,
                                  SourceRange Range) {
// Although the feature was introduced only in OpenCL C v2.0 s6.11.5, it's
// useful for OpenCL 1.x too and doesn't require HW support.
// opencl_unroll_hint can have 0 arguments (compiler
// determines unrolling factor) or 1 argument (the unroll factor provided
// by the user).

unsigned NumArgs = A.getNumArgs();

if (NumArgs > 1) {
  S.Diag(A.getLoc(), diag::err_attribute_too_many_arguments) << A.getName()
                                                             << 1;
  return nullptr;
}

unsigned UnrollFactor = 0;

if (NumArgs == 1) {
  Expr *E = A.getArgAsExpr(0);
  llvm::APSInt ArgVal(32);

  if (!E->isIntegerConstantExpr(ArgVal, S.Context)) {
    S.Diag(A.getLoc(), diag::err_attribute_argument_type)
        << A.getName() << AANT_ArgumentIntegerConstant << E->getSourceRange();
    return nullptr;
  }

  int Val = ArgVal.getSExtValue();

  if (Val <= 0) {
    S.Diag(A.getRange().getBegin(),
           diag::err_attribute_requires_positive_integer)
        << A.getName();
    return nullptr;
  }
  UnrollFactor = Val;
}

return OpenCLUnrollHintAttr::CreateImplicit(S.Context, UnrollFactor);
289}

291static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const AttributeList &A,
                                SourceRange Range) {
switch (A.getKind()) {
1
Control jumps to 'case AT_Suppress:'  at line 305→
case AttributeList::UnknownAttribute:
  S.Diag(A.getLoc(), A.isDeclspecAttribute() ?
         diag::warn_unhandled_ms_attribute_ignored :
         diag::warn_unknown_attribute_ignored) << A.getName();
  return nullptr;
case AttributeList::AT_FallThrough:
  return handleFallThroughAttr(S, St, A, Range);
case AttributeList::AT_LoopHint:
  return handleLoopHintAttr(S, St, A, Range);
case AttributeList::AT_OpenCLUnrollHint:
  return handleOpenCLUnrollHint(S, St, A, Range);
case AttributeList::AT_Suppress:
  return handleSuppressAttr(S, St, A, Range);
2
←
Calling 'handleSuppressAttr'→
default:
  // if we're here, then we parsed a known attribute, but didn't recognize
  // it as a statement attribute => it is declaration attribute
  S.Diag(A.getRange().getBegin(), diag::err_decl_attribute_invalid_on_stmt)
      << A.getName() << St->getLocStart();
  return nullptr;
}
314}

316StmtResult Sema::ProcessStmtAttributes(Stmt *S, AttributeList *AttrList,
                                     SourceRange Range) {
SmallVector<const Attr*, 8> Attrs;
for (const AttributeList* l = AttrList; l; l = l->getNext()) {
  if (Attr *a = ProcessStmtAttribute(*this, S, *l, Range))
    Attrs.push_back(a);
}

CheckForIncompatibleAttributes(*this, Attrs);

if (Attrs.empty())
  return S;

return ActOnAttributedStmt(Range.getBegin(), Attrs, S);
330}

←

/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];
  if (!S.empty())
    std::memcpy(this->message, S.data(), messageLength);
}

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])
11
←
Null pointer value stored to field 'diagnosticIdentifiers_'→
{
  for (size_t I = 0, E = diagnosticIdentifiers_Size; I != E;
12
←
Assuming 'I' is not equal to 'E'→
13
←
Loop condition is true.  Entering loop body→
       ++I) {
    StringRef Ref = DiagnosticIdentifiers[I];
    if (!Ref.empty()) {
14
←
Assuming the condition is true→
15
←
Taking true branch→
      char *Mem = new (Ctx, 1) char[Ref.size()];
      std::memcpy(Mem, Ref.data(), Ref.size());
      diagnosticIdentifiers_[I] = StringRef(Mem, Ref.size());
16
←
Called C++ object pointer is null
    }
  }
}

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